1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
25 #include "expression.h"
30 #include "gdb_string.h"
32 #include "breakpoint.h"
33 #include "tracepoint.h"
36 #include "completer.h"
38 #include "dictionary.h"
40 #include "user-regs.h"
44 #include "filenames.h"
45 #include "gdbthread.h"
53 #include "exceptions.h"
54 #include "cli/cli-utils.h"
57 #include "completer.h"
59 /* readline include files */
60 #include "readline/readline.h"
61 #include "readline/history.h"
63 /* readline defines this. */
74 /* Maximum length of an agent aexpression.
75 This accounts for the fact that packets are limited to 400 bytes
76 (which includes everything -- including the checksum), and assumes
77 the worst case of maximum length for each of the pieces of a
80 NOTE: expressions get mem2hex'ed otherwise this would be twice as
81 large. (400 - 31)/2 == 184 */
82 #define MAX_AGENT_EXPR_LEN 184
86 /* A hook used to notify the UI of tracepoint operations. */
88 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
89 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
91 extern void (*deprecated_readline_begin_hook
) (char *, ...);
92 extern char *(*deprecated_readline_hook
) (char *);
93 extern void (*deprecated_readline_end_hook
) (void);
98 This module defines the following debugger commands:
99 trace : set a tracepoint on a function, line, or address.
100 info trace : list all debugger-defined tracepoints.
101 delete trace : delete one or more tracepoints.
102 enable trace : enable one or more tracepoints.
103 disable trace : disable one or more tracepoints.
104 actions : specify actions to be taken at a tracepoint.
105 passcount : specify a pass count for a tracepoint.
106 tstart : start a trace experiment.
107 tstop : stop a trace experiment.
108 tstatus : query the status of a trace experiment.
109 tfind : find a trace frame in the trace buffer.
110 tdump : print everything collected at the current tracepoint.
111 save-tracepoints : write tracepoint setup into a file.
113 This module defines the following user-visible debugger variables:
114 $trace_frame : sequence number of trace frame currently being debugged.
115 $trace_line : source line of trace frame currently being debugged.
116 $trace_file : source file of trace frame currently being debugged.
117 $tracepoint : tracepoint number of trace frame currently being debugged.
121 /* ======= Important global variables: ======= */
123 /* The list of all trace state variables. We don't retain pointers to
124 any of these for any reason - API is by name or number only - so it
125 works to have a vector of objects. */
127 typedef struct trace_state_variable tsv_s
;
130 static VEC(tsv_s
) *tvariables
;
132 /* The next integer to assign to a variable. */
134 static int next_tsv_number
= 1;
136 /* Number of last traceframe collected. */
137 static int traceframe_number
;
139 /* Tracepoint for last traceframe collected. */
140 static int tracepoint_number
;
142 /* Symbol for function for last traceframe collected. */
143 static struct symbol
*traceframe_fun
;
145 /* Symtab and line for last traceframe collected. */
146 static struct symtab_and_line traceframe_sal
;
148 /* The traceframe info of the current traceframe. NULL if we haven't
149 yet attempted to fetch it, or if the target does not support
150 fetching this object, or if we're not inspecting a traceframe
152 static struct traceframe_info
*traceframe_info
;
154 /* Tracing command lists. */
155 static struct cmd_list_element
*tfindlist
;
157 /* List of expressions to collect by default at each tracepoint hit. */
158 char *default_collect
= "";
160 static int disconnected_tracing
;
162 /* This variable controls whether we ask the target for a linear or
163 circular trace buffer. */
165 static int circular_trace_buffer
;
167 /* This variable is the requested trace buffer size, or -1 to indicate
168 that we don't care and leave it up to the target to set a size. */
170 static int trace_buffer_size
= -1;
172 /* Textual notes applying to the current and/or future trace runs. */
174 char *trace_user
= NULL
;
176 /* Textual notes applying to the current and/or future trace runs. */
178 char *trace_notes
= NULL
;
180 /* Textual notes applying to the stopping of a trace. */
182 char *trace_stop_notes
= NULL
;
184 /* ======= Important command functions: ======= */
185 static void trace_actions_command (char *, int);
186 static void trace_start_command (char *, int);
187 static void trace_stop_command (char *, int);
188 static void trace_status_command (char *, int);
189 static void trace_find_command (char *, int);
190 static void trace_find_pc_command (char *, int);
191 static void trace_find_tracepoint_command (char *, int);
192 static void trace_find_line_command (char *, int);
193 static void trace_find_range_command (char *, int);
194 static void trace_find_outside_command (char *, int);
195 static void trace_dump_command (char *, int);
197 /* support routines */
199 struct collection_list
;
200 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
201 static char *mem2hex (gdb_byte
*, char *, int);
202 static void add_register (struct collection_list
*collection
,
205 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
206 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
209 extern void _initialize_tracepoint (void);
211 static struct trace_status trace_status
;
213 char *stop_reason_names
[] = {
223 struct trace_status
*
224 current_trace_status (void)
226 return &trace_status
;
232 free_traceframe_info (struct traceframe_info
*info
)
236 VEC_free (mem_range_s
, info
->memory
);
242 /* Free and clear the traceframe info cache of the current
246 clear_traceframe_info (void)
248 free_traceframe_info (traceframe_info
);
249 traceframe_info
= NULL
;
252 /* Set traceframe number to NUM. */
254 set_traceframe_num (int num
)
256 traceframe_number
= num
;
257 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
260 /* Set tracepoint number to NUM. */
262 set_tracepoint_num (int num
)
264 tracepoint_number
= num
;
265 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
268 /* Set externally visible debug variables for querying/printing
269 the traceframe context (line, function, file). */
272 set_traceframe_context (struct frame_info
*trace_frame
)
276 /* Save as globals for internal use. */
277 if (trace_frame
!= NULL
278 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
280 traceframe_sal
= find_pc_line (trace_pc
, 0);
281 traceframe_fun
= find_pc_function (trace_pc
);
283 /* Save linenumber as "$trace_line", a debugger variable visible to
285 set_internalvar_integer (lookup_internalvar ("trace_line"),
286 traceframe_sal
.line
);
290 init_sal (&traceframe_sal
);
291 traceframe_fun
= NULL
;
292 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
295 /* Save func name as "$trace_func", a debugger variable visible to
297 if (traceframe_fun
== NULL
298 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
299 clear_internalvar (lookup_internalvar ("trace_func"));
301 set_internalvar_string (lookup_internalvar ("trace_func"),
302 SYMBOL_LINKAGE_NAME (traceframe_fun
));
304 /* Save file name as "$trace_file", a debugger variable visible to
306 if (traceframe_sal
.symtab
== NULL
)
307 clear_internalvar (lookup_internalvar ("trace_file"));
309 set_internalvar_string (lookup_internalvar ("trace_file"),
310 symtab_to_filename_for_display (traceframe_sal
.symtab
));
313 /* Create a new trace state variable with the given name. */
315 struct trace_state_variable
*
316 create_trace_state_variable (const char *name
)
318 struct trace_state_variable tsv
;
320 memset (&tsv
, 0, sizeof (tsv
));
321 tsv
.name
= xstrdup (name
);
322 tsv
.number
= next_tsv_number
++;
323 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
326 /* Look for a trace state variable of the given name. */
328 struct trace_state_variable
*
329 find_trace_state_variable (const char *name
)
331 struct trace_state_variable
*tsv
;
334 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
335 if (strcmp (name
, tsv
->name
) == 0)
342 delete_trace_state_variable (const char *name
)
344 struct trace_state_variable
*tsv
;
347 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
348 if (strcmp (name
, tsv
->name
) == 0)
350 observer_notify_tsv_deleted (tsv
);
352 xfree ((void *)tsv
->name
);
353 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
358 warning (_("No trace variable named \"$%s\", not deleting"), name
);
361 /* Throws an error if NAME is not valid syntax for a trace state
365 validate_trace_state_variable_name (const char *name
)
370 error (_("Must supply a non-empty variable name"));
372 /* All digits in the name is reserved for value history
374 for (p
= name
; isdigit (*p
); p
++)
377 error (_("$%s is not a valid trace state variable name"), name
);
379 for (p
= name
; isalnum (*p
) || *p
== '_'; p
++)
382 error (_("$%s is not a valid trace state variable name"), name
);
385 /* The 'tvariable' command collects a name and optional expression to
386 evaluate into an initial value. */
389 trace_variable_command (char *args
, int from_tty
)
391 struct cleanup
*old_chain
;
393 struct trace_state_variable
*tsv
;
397 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
399 /* Only allow two syntaxes; "$name" and "$name=value". */
400 p
= skip_spaces (args
);
403 error (_("Name of trace variable should start with '$'"));
406 while (isalnum (*p
) || *p
== '_')
408 name
= savestring (name
, p
- name
);
409 old_chain
= make_cleanup (xfree
, name
);
412 if (*p
!= '=' && *p
!= '\0')
413 error (_("Syntax must be $NAME [ = EXPR ]"));
415 validate_trace_state_variable_name (name
);
418 initval
= value_as_long (parse_and_eval (++p
));
420 /* If the variable already exists, just change its initial value. */
421 tsv
= find_trace_state_variable (name
);
424 if (tsv
->initial_value
!= initval
)
426 tsv
->initial_value
= initval
;
427 observer_notify_tsv_modified (tsv
);
429 printf_filtered (_("Trace state variable $%s "
430 "now has initial value %s.\n"),
431 tsv
->name
, plongest (tsv
->initial_value
));
432 do_cleanups (old_chain
);
436 /* Create a new variable. */
437 tsv
= create_trace_state_variable (name
);
438 tsv
->initial_value
= initval
;
440 observer_notify_tsv_created (tsv
);
442 printf_filtered (_("Trace state variable $%s "
443 "created, with initial value %s.\n"),
444 tsv
->name
, plongest (tsv
->initial_value
));
446 do_cleanups (old_chain
);
450 delete_trace_variable_command (char *args
, int from_tty
)
454 struct cleanup
*back_to
;
458 if (query (_("Delete all trace state variables? ")))
459 VEC_free (tsv_s
, tvariables
);
461 observer_notify_tsv_deleted (NULL
);
465 argv
= gdb_buildargv (args
);
466 back_to
= make_cleanup_freeargv (argv
);
468 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
470 if (*argv
[ix
] == '$')
471 delete_trace_state_variable (argv
[ix
] + 1);
473 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
476 do_cleanups (back_to
);
482 tvariables_info_1 (void)
484 struct trace_state_variable
*tsv
;
487 struct cleanup
*back_to
;
488 struct ui_out
*uiout
= current_uiout
;
490 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
492 printf_filtered (_("No trace state variables.\n"));
496 /* Try to acquire values from the target. */
497 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
498 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
501 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
502 count
, "trace-variables");
503 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
504 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
505 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
507 ui_out_table_body (uiout
);
509 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
511 struct cleanup
*back_to2
;
515 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
517 name
= concat ("$", tsv
->name
, (char *) NULL
);
518 make_cleanup (xfree
, name
);
519 ui_out_field_string (uiout
, "name", name
);
520 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
522 if (tsv
->value_known
)
523 c
= plongest (tsv
->value
);
524 else if (ui_out_is_mi_like_p (uiout
))
525 /* For MI, we prefer not to use magic string constants, but rather
526 omit the field completely. The difference between unknown and
527 undefined does not seem important enough to represent. */
529 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
530 /* The value is/was defined, but we don't have it. */
533 /* It is not meaningful to ask about the value. */
536 ui_out_field_string (uiout
, "current", c
);
537 ui_out_text (uiout
, "\n");
539 do_cleanups (back_to2
);
542 do_cleanups (back_to
);
545 /* List all the trace state variables. */
548 tvariables_info (char *args
, int from_tty
)
550 tvariables_info_1 ();
553 /* Stash definitions of tsvs into the given file. */
556 save_trace_state_variables (struct ui_file
*fp
)
558 struct trace_state_variable
*tsv
;
561 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
563 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
564 if (tsv
->initial_value
)
565 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
566 fprintf_unfiltered (fp
, "\n");
570 /* ACTIONS functions: */
572 /* The three functions:
573 collect_pseudocommand,
574 while_stepping_pseudocommand, and
575 end_actions_pseudocommand
576 are placeholders for "commands" that are actually ONLY to be used
577 within a tracepoint action list. If the actual function is ever called,
578 it means that somebody issued the "command" at the top level,
579 which is always an error. */
582 end_actions_pseudocommand (char *args
, int from_tty
)
584 error (_("This command cannot be used at the top level."));
588 while_stepping_pseudocommand (char *args
, int from_tty
)
590 error (_("This command can only be used in a tracepoint actions list."));
594 collect_pseudocommand (char *args
, int from_tty
)
596 error (_("This command can only be used in a tracepoint actions list."));
600 teval_pseudocommand (char *args
, int from_tty
)
602 error (_("This command can only be used in a tracepoint actions list."));
605 /* Parse any collection options, such as /s for strings. */
608 decode_agent_options (const char *exp
, int *trace_string
)
610 struct value_print_options opts
;
617 /* Call this to borrow the print elements default for collection
619 get_user_print_options (&opts
);
624 if (target_supports_string_tracing ())
626 /* Allow an optional decimal number giving an explicit maximum
627 string length, defaulting it to the "print elements" value;
628 so "collect/s80 mystr" gets at most 80 bytes of string. */
629 *trace_string
= opts
.print_max
;
631 if (*exp
>= '0' && *exp
<= '9')
632 *trace_string
= atoi (exp
);
633 while (*exp
>= '0' && *exp
<= '9')
637 error (_("Target does not support \"/s\" option for string tracing."));
640 error (_("Undefined collection format \"%c\"."), *exp
);
642 exp
= skip_spaces_const (exp
);
647 /* Enter a list of actions for a tracepoint. */
649 trace_actions_command (char *args
, int from_tty
)
651 struct tracepoint
*t
;
652 struct command_line
*l
;
654 t
= get_tracepoint_by_number (&args
, NULL
, 1);
658 xstrprintf ("Enter actions for tracepoint %d, one per line.",
660 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
662 l
= read_command_lines (tmpbuf
, from_tty
, 1,
663 check_tracepoint_command
, t
);
664 do_cleanups (cleanups
);
665 breakpoint_set_commands (&t
->base
, l
);
667 /* else just return */
670 /* Report the results of checking the agent expression, as errors or
674 report_agent_reqs_errors (struct agent_expr
*aexpr
)
676 /* All of the "flaws" are serious bytecode generation issues that
677 should never occur. */
678 if (aexpr
->flaw
!= agent_flaw_none
)
679 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
681 /* If analysis shows a stack underflow, GDB must have done something
682 badly wrong in its bytecode generation. */
683 if (aexpr
->min_height
< 0)
684 internal_error (__FILE__
, __LINE__
,
685 _("expression has min height < 0"));
687 /* Issue this error if the stack is predicted to get too deep. The
688 limit is rather arbitrary; a better scheme might be for the
689 target to report how much stack it will have available. The
690 depth roughly corresponds to parenthesization, so a limit of 20
691 amounts to 20 levels of expression nesting, which is actually
692 a pretty big hairy expression. */
693 if (aexpr
->max_height
> 20)
694 error (_("Expression is too complicated."));
697 /* worker function */
699 validate_actionline (const char *line
, struct breakpoint
*b
)
701 struct cmd_list_element
*c
;
702 struct expression
*exp
= NULL
;
703 struct cleanup
*old_chain
= NULL
;
706 struct bp_location
*loc
;
707 struct agent_expr
*aexpr
;
708 struct tracepoint
*t
= (struct tracepoint
*) b
;
710 /* If EOF is typed, *line is NULL. */
714 p
= skip_spaces_const (line
);
716 /* Symbol lookup etc. */
717 if (*p
== '\0') /* empty line: just prompt for another line. */
720 if (*p
== '#') /* comment line */
723 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
725 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
727 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
729 int trace_string
= 0;
732 p
= decode_agent_options (p
, &trace_string
);
735 { /* Repeat over a comma-separated list. */
736 QUIT
; /* Allow user to bail out with ^C. */
737 p
= skip_spaces_const (p
);
739 if (*p
== '$') /* Look for special pseudo-symbols. */
741 if (0 == strncasecmp ("reg", p
+ 1, 3)
742 || 0 == strncasecmp ("arg", p
+ 1, 3)
743 || 0 == strncasecmp ("loc", p
+ 1, 3)
744 || 0 == strncasecmp ("_ret", p
+ 1, 4)
745 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
750 /* else fall thru, treat p as an expression and parse it! */
753 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
756 exp
= parse_exp_1 (&p
, loc
->address
,
757 block_for_pc (loc
->address
), 1);
758 old_chain
= make_cleanup (free_current_contents
, &exp
);
760 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
762 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
764 error (_("constant `%s' (value %s) "
765 "will not be collected."),
766 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
767 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
769 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
770 == LOC_OPTIMIZED_OUT
)
772 error (_("`%s' is optimized away "
773 "and cannot be collected."),
774 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
778 /* We have something to collect, make sure that the expr to
779 bytecode translator can handle it and that it's not too
781 aexpr
= gen_trace_for_expr (loc
->address
, exp
, trace_string
);
782 make_cleanup_free_agent_expr (aexpr
);
784 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
785 error (_("Expression is too complicated."));
789 report_agent_reqs_errors (aexpr
);
791 do_cleanups (old_chain
);
794 while (p
&& *p
++ == ',');
797 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
800 { /* Repeat over a comma-separated list. */
801 QUIT
; /* Allow user to bail out with ^C. */
802 p
= skip_spaces_const (p
);
805 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
809 /* Only expressions are allowed for this action. */
810 exp
= parse_exp_1 (&p
, loc
->address
,
811 block_for_pc (loc
->address
), 1);
812 old_chain
= make_cleanup (free_current_contents
, &exp
);
814 /* We have something to evaluate, make sure that the expr to
815 bytecode translator can handle it and that it's not too
817 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
818 make_cleanup_free_agent_expr (aexpr
);
820 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
821 error (_("Expression is too complicated."));
824 report_agent_reqs_errors (aexpr
);
826 do_cleanups (old_chain
);
829 while (p
&& *p
++ == ',');
832 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
836 p
= skip_spaces_const (p
);
837 t
->step_count
= strtol (p
, &endp
, 0);
838 if (endp
== p
|| t
->step_count
== 0)
839 error (_("while-stepping step count `%s' is malformed."), line
);
843 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
847 error (_("`%s' is not a supported tracepoint action."), line
);
851 memrange_absolute
= -1
856 int type
; /* memrange_absolute for absolute memory range,
857 else basereg number. */
858 bfd_signed_vma start
;
862 struct collection_list
864 unsigned char regs_mask
[32]; /* room for up to 256 regs */
867 struct memrange
*list
;
868 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
870 struct agent_expr
**aexpr_list
;
872 /* True is the user requested a collection of "$_sdata", "static
876 tracepoint_list
, stepping_list
;
878 /* MEMRANGE functions: */
880 static int memrange_cmp (const void *, const void *);
882 /* Compare memranges for qsort. */
884 memrange_cmp (const void *va
, const void *vb
)
886 const struct memrange
*a
= va
, *b
= vb
;
888 if (a
->type
< b
->type
)
890 if (a
->type
> b
->type
)
892 if (a
->type
== memrange_absolute
)
894 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
896 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
901 if (a
->start
< b
->start
)
903 if (a
->start
> b
->start
)
909 /* Sort the memrange list using qsort, and merge adjacent memranges. */
911 memrange_sortmerge (struct collection_list
*memranges
)
915 qsort (memranges
->list
, memranges
->next_memrange
,
916 sizeof (struct memrange
), memrange_cmp
);
917 if (memranges
->next_memrange
> 0)
919 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
921 /* If memrange b overlaps or is adjacent to memrange a,
923 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
924 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
926 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
927 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
928 continue; /* next b, same a */
932 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
933 sizeof (struct memrange
));
935 memranges
->next_memrange
= a
+ 1;
939 /* Add a register to a collection list. */
941 add_register (struct collection_list
*collection
, unsigned int regno
)
944 printf_filtered ("collect register %d\n", regno
);
945 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
946 error (_("Internal: register number %d too large for tracepoint"),
948 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
951 /* Add a memrange to a collection list. */
953 add_memrange (struct collection_list
*memranges
,
954 int type
, bfd_signed_vma base
,
959 printf_filtered ("(%d,", type
);
961 printf_filtered (",%ld)\n", len
);
964 /* type: memrange_absolute == memory, other n == basereg */
965 memranges
->list
[memranges
->next_memrange
].type
= type
;
966 /* base: addr if memory, offset if reg relative. */
967 memranges
->list
[memranges
->next_memrange
].start
= base
;
968 /* len: we actually save end (base + len) for convenience */
969 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
970 memranges
->next_memrange
++;
971 if (memranges
->next_memrange
>= memranges
->listsize
)
973 memranges
->listsize
*= 2;
974 memranges
->list
= xrealloc (memranges
->list
,
975 memranges
->listsize
);
978 if (type
!= memrange_absolute
) /* Better collect the base register! */
979 add_register (memranges
, type
);
982 /* Add a symbol to a collection list. */
984 collect_symbol (struct collection_list
*collect
,
986 struct gdbarch
*gdbarch
,
987 long frame_regno
, long frame_offset
,
993 bfd_signed_vma offset
;
994 int treat_as_expr
= 0;
996 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
997 switch (SYMBOL_CLASS (sym
))
1000 printf_filtered ("%s: don't know symbol class %d\n",
1001 SYMBOL_PRINT_NAME (sym
),
1002 SYMBOL_CLASS (sym
));
1005 printf_filtered ("constant %s (value %s) will not be collected.\n",
1006 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
1009 offset
= SYMBOL_VALUE_ADDRESS (sym
);
1014 sprintf_vma (tmp
, offset
);
1015 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1016 SYMBOL_PRINT_NAME (sym
), len
,
1019 /* A struct may be a C++ class with static fields, go to general
1020 expression handling. */
1021 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
1024 add_memrange (collect
, memrange_absolute
, offset
, len
);
1027 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1029 printf_filtered ("LOC_REG[parm] %s: ",
1030 SYMBOL_PRINT_NAME (sym
));
1031 add_register (collect
, reg
);
1032 /* Check for doubles stored in two registers. */
1033 /* FIXME: how about larger types stored in 3 or more regs? */
1034 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1035 len
> register_size (gdbarch
, reg
))
1036 add_register (collect
, reg
+ 1);
1039 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1040 printf_filtered (" (will not collect %s)\n",
1041 SYMBOL_PRINT_NAME (sym
));
1045 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1048 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1049 SYMBOL_PRINT_NAME (sym
), len
);
1050 printf_vma (offset
);
1051 printf_filtered (" from frame ptr reg %d\n", reg
);
1053 add_memrange (collect
, reg
, offset
, len
);
1055 case LOC_REGPARM_ADDR
:
1056 reg
= SYMBOL_VALUE (sym
);
1060 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1061 SYMBOL_PRINT_NAME (sym
), len
);
1062 printf_vma (offset
);
1063 printf_filtered (" from reg %d\n", reg
);
1065 add_memrange (collect
, reg
, offset
, len
);
1069 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1072 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1073 SYMBOL_PRINT_NAME (sym
), len
);
1074 printf_vma (offset
);
1075 printf_filtered (" from frame ptr reg %d\n", reg
);
1077 add_memrange (collect
, reg
, offset
, len
);
1080 case LOC_UNRESOLVED
:
1084 case LOC_OPTIMIZED_OUT
:
1085 printf_filtered ("%s has been optimized out of existence.\n",
1086 SYMBOL_PRINT_NAME (sym
));
1094 /* Expressions are the most general case. */
1097 struct agent_expr
*aexpr
;
1098 struct cleanup
*old_chain1
= NULL
;
1100 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
, trace_string
);
1102 /* It can happen that the symbol is recorded as a computed
1103 location, but it's been optimized away and doesn't actually
1104 have a location expression. */
1107 printf_filtered ("%s has been optimized out of existence.\n",
1108 SYMBOL_PRINT_NAME (sym
));
1112 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1116 report_agent_reqs_errors (aexpr
);
1118 discard_cleanups (old_chain1
);
1119 add_aexpr (collect
, aexpr
);
1121 /* Take care of the registers. */
1122 if (aexpr
->reg_mask_len
> 0)
1126 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1128 QUIT
; /* Allow user to bail out with ^C. */
1129 if (aexpr
->reg_mask
[ndx1
] != 0)
1131 /* Assume chars have 8 bits. */
1132 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1133 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1134 /* It's used -- record it. */
1135 add_register (collect
, ndx1
* 8 + ndx2
);
1142 /* Data to be passed around in the calls to the locals and args
1145 struct add_local_symbols_data
1147 struct collection_list
*collect
;
1148 struct gdbarch
*gdbarch
;
1156 /* The callback for the locals and args iterators. */
1159 do_collect_symbol (const char *print_name
,
1163 struct add_local_symbols_data
*p
= cb_data
;
1165 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1166 p
->frame_offset
, p
->pc
, p
->trace_string
);
1170 /* Add all locals (or args) symbols to collection list. */
1172 add_local_symbols (struct collection_list
*collect
,
1173 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1174 long frame_regno
, long frame_offset
, int type
,
1177 struct block
*block
;
1178 struct add_local_symbols_data cb_data
;
1180 cb_data
.collect
= collect
;
1181 cb_data
.gdbarch
= gdbarch
;
1183 cb_data
.frame_regno
= frame_regno
;
1184 cb_data
.frame_offset
= frame_offset
;
1186 cb_data
.trace_string
= trace_string
;
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 int trace_string
= 0;
1396 if (*action_exp
== '/')
1397 action_exp
= decode_agent_options (action_exp
, &trace_string
);
1400 { /* Repeat over a comma-separated list. */
1401 QUIT
; /* Allow user to bail out with ^C. */
1402 action_exp
= skip_spaces_const (action_exp
);
1404 if (0 == strncasecmp ("$reg", action_exp
, 4))
1406 for (i
= 0; i
< gdbarch_num_regs (tloc
->gdbarch
); i
++)
1407 add_register (collect
, i
);
1408 action_exp
= strchr (action_exp
, ','); /* more? */
1410 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1412 add_local_symbols (collect
,
1419 action_exp
= strchr (action_exp
, ','); /* more? */
1421 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1423 add_local_symbols (collect
,
1430 action_exp
= strchr (action_exp
, ','); /* more? */
1432 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1434 struct cleanup
*old_chain1
= NULL
;
1436 aexpr
= gen_trace_for_return_address (tloc
->address
,
1440 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1443 report_agent_reqs_errors (aexpr
);
1445 discard_cleanups (old_chain1
);
1446 add_aexpr (collect
, aexpr
);
1448 /* take care of the registers */
1449 if (aexpr
->reg_mask_len
> 0)
1453 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1455 QUIT
; /* allow user to bail out with ^C */
1456 if (aexpr
->reg_mask
[ndx1
] != 0)
1458 /* assume chars have 8 bits */
1459 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1460 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1461 /* it's used -- record it */
1462 add_register (collect
,
1468 action_exp
= strchr (action_exp
, ','); /* more? */
1470 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1472 add_static_trace_data (collect
);
1473 action_exp
= strchr (action_exp
, ','); /* more? */
1478 struct cleanup
*old_chain
= NULL
;
1479 struct cleanup
*old_chain1
= NULL
;
1481 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1482 block_for_pc (tloc
->address
), 1);
1483 old_chain
= make_cleanup (free_current_contents
, &exp
);
1485 switch (exp
->elts
[0].opcode
)
1489 const char *name
= &exp
->elts
[2].string
;
1491 i
= user_reg_map_name_to_regnum (tloc
->gdbarch
,
1492 name
, strlen (name
));
1494 internal_error (__FILE__
, __LINE__
,
1495 _("Register $%s not available"),
1498 printf_filtered ("OP_REGISTER: ");
1499 add_register (collect
, i
);
1504 /* Safe because we know it's a simple expression. */
1505 tempval
= evaluate_expression (exp
);
1506 addr
= value_address (tempval
);
1507 /* Initialize the TYPE_LENGTH if it is a typedef. */
1508 check_typedef (exp
->elts
[1].type
);
1509 add_memrange (collect
, memrange_absolute
, addr
,
1510 TYPE_LENGTH (exp
->elts
[1].type
));
1514 collect_symbol (collect
,
1515 exp
->elts
[2].symbol
,
1523 default: /* Full-fledged expression. */
1524 aexpr
= gen_trace_for_expr (tloc
->address
, exp
,
1527 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1531 report_agent_reqs_errors (aexpr
);
1533 discard_cleanups (old_chain1
);
1534 add_aexpr (collect
, aexpr
);
1536 /* Take care of the registers. */
1537 if (aexpr
->reg_mask_len
> 0)
1542 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1544 QUIT
; /* Allow user to bail out with ^C. */
1545 if (aexpr
->reg_mask
[ndx1
] != 0)
1547 /* Assume chars have 8 bits. */
1548 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1549 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1550 /* It's used -- record it. */
1551 add_register (collect
,
1558 do_cleanups (old_chain
);
1561 while (action_exp
&& *action_exp
++ == ',');
1563 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1566 { /* Repeat over a comma-separated list. */
1567 QUIT
; /* Allow user to bail out with ^C. */
1568 action_exp
= skip_spaces_const (action_exp
);
1571 struct cleanup
*old_chain
= NULL
;
1572 struct cleanup
*old_chain1
= NULL
;
1574 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1575 block_for_pc (tloc
->address
), 1);
1576 old_chain
= make_cleanup (free_current_contents
, &exp
);
1578 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1579 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1582 report_agent_reqs_errors (aexpr
);
1584 discard_cleanups (old_chain1
);
1585 /* Even though we're not officially collecting, add
1586 to the collect list anyway. */
1587 add_aexpr (collect
, aexpr
);
1589 do_cleanups (old_chain
);
1592 while (action_exp
&& *action_exp
++ == ',');
1594 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1596 /* We check against nested while-stepping when setting
1597 breakpoint action, so no way to run into nested
1599 gdb_assert (stepping_list
);
1601 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
,
1602 frame_offset
, stepping_list
, NULL
);
1605 error (_("Invalid tracepoint command '%s'"), action
->line
);
1609 /* Render all actions into gdb protocol. */
1612 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1613 char ***tdp_actions
, char ***stepping_actions
)
1615 static char tdp_buff
[2048], step_buff
[2048];
1616 char *default_collect_line
= NULL
;
1617 struct command_line
*actions
;
1618 struct command_line
*default_collect_action
= NULL
;
1620 LONGEST frame_offset
;
1621 struct cleanup
*back_to
;
1623 back_to
= make_cleanup (null_cleanup
, NULL
);
1625 clear_collection_list (&tracepoint_list
);
1626 clear_collection_list (&stepping_list
);
1628 *tdp_actions
= NULL
;
1629 *stepping_actions
= NULL
;
1631 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1632 tloc
->address
, &frame_reg
, &frame_offset
);
1634 actions
= breakpoint_commands (t
);
1636 /* If there are default expressions to collect, make up a collect
1637 action and prepend to the action list to encode. Note that since
1638 validation is per-tracepoint (local var "xyz" might be valid for
1639 one tracepoint and not another, etc), we make up the action on
1640 the fly, and don't cache it. */
1641 if (*default_collect
)
1643 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1644 make_cleanup (xfree
, default_collect_line
);
1646 validate_actionline (default_collect_line
, t
);
1648 default_collect_action
= xmalloc (sizeof (struct command_line
));
1649 make_cleanup (xfree
, default_collect_action
);
1650 default_collect_action
->next
= actions
;
1651 default_collect_action
->line
= default_collect_line
;
1652 actions
= default_collect_action
;
1654 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1655 &tracepoint_list
, &stepping_list
);
1657 memrange_sortmerge (&tracepoint_list
);
1658 memrange_sortmerge (&stepping_list
);
1660 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1662 *stepping_actions
= stringify_collection_list (&stepping_list
,
1665 do_cleanups (back_to
);
1669 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1671 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1673 collect
->aexpr_list
=
1674 xrealloc (collect
->aexpr_list
,
1675 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1676 collect
->aexpr_listsize
*= 2;
1678 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1679 collect
->next_aexpr_elt
++;
1683 process_tracepoint_on_disconnect (void)
1685 VEC(breakpoint_p
) *tp_vec
= NULL
;
1687 struct breakpoint
*b
;
1688 int has_pending_p
= 0;
1690 /* Check whether we still have pending tracepoint. If we have, warn the
1691 user that pending tracepoint will no longer work. */
1692 tp_vec
= all_tracepoints ();
1693 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1702 struct bp_location
*loc1
;
1704 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1706 if (loc1
->shlib_disabled
)
1717 VEC_free (breakpoint_p
, tp_vec
);
1720 warning (_("Pending tracepoints will not be resolved while"
1721 " GDB is disconnected\n"));
1726 start_tracing (char *notes
)
1728 VEC(breakpoint_p
) *tp_vec
= NULL
;
1730 struct breakpoint
*b
;
1731 struct trace_state_variable
*tsv
;
1732 int any_enabled
= 0, num_to_download
= 0;
1735 tp_vec
= all_tracepoints ();
1737 /* No point in tracing without any tracepoints... */
1738 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1740 VEC_free (breakpoint_p
, tp_vec
);
1741 error (_("No tracepoints defined, not starting trace"));
1744 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1746 struct tracepoint
*t
= (struct tracepoint
*) b
;
1747 struct bp_location
*loc
;
1749 if (b
->enable_state
== bp_enabled
)
1752 if ((b
->type
== bp_fast_tracepoint
1753 ? may_insert_fast_tracepoints
1754 : may_insert_tracepoints
))
1757 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1758 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1763 if (target_supports_enable_disable_tracepoint ())
1764 warning (_("No tracepoints enabled"));
1767 /* No point in tracing with only disabled tracepoints that
1768 cannot be re-enabled. */
1769 VEC_free (breakpoint_p
, tp_vec
);
1770 error (_("No tracepoints enabled, not starting trace"));
1774 if (num_to_download
<= 0)
1776 VEC_free (breakpoint_p
, tp_vec
);
1777 error (_("No tracepoints that may be downloaded, not starting trace"));
1780 target_trace_init ();
1782 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1784 struct tracepoint
*t
= (struct tracepoint
*) b
;
1785 struct bp_location
*loc
;
1786 int bp_location_downloaded
= 0;
1788 /* Clear `inserted' flag. */
1789 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1792 if ((b
->type
== bp_fast_tracepoint
1793 ? !may_insert_fast_tracepoints
1794 : !may_insert_tracepoints
))
1797 t
->number_on_target
= 0;
1799 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1801 /* Since tracepoint locations are never duplicated, `inserted'
1802 flag should be zero. */
1803 gdb_assert (!loc
->inserted
);
1805 target_download_tracepoint (loc
);
1808 bp_location_downloaded
= 1;
1811 t
->number_on_target
= b
->number
;
1813 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1814 if (loc
->probe
!= NULL
)
1815 loc
->probe
->pops
->set_semaphore (loc
->probe
, loc
->gdbarch
);
1817 if (bp_location_downloaded
)
1818 observer_notify_breakpoint_modified (b
);
1820 VEC_free (breakpoint_p
, tp_vec
);
1822 /* Send down all the trace state variables too. */
1823 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1825 target_download_trace_state_variable (tsv
);
1828 /* Tell target to treat text-like sections as transparent. */
1829 target_trace_set_readonly_regions ();
1830 /* Set some mode flags. */
1831 target_set_disconnected_tracing (disconnected_tracing
);
1832 target_set_circular_trace_buffer (circular_trace_buffer
);
1833 target_set_trace_buffer_size (trace_buffer_size
);
1836 notes
= trace_notes
;
1837 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1839 if (!ret
&& (trace_user
|| notes
))
1840 warning (_("Target does not support trace user/notes, info ignored"));
1842 /* Now insert traps and begin collecting data. */
1843 target_trace_start ();
1845 /* Reset our local state. */
1846 set_traceframe_num (-1);
1847 set_tracepoint_num (-1);
1848 set_traceframe_context (NULL
);
1849 current_trace_status()->running
= 1;
1850 clear_traceframe_info ();
1853 /* The tstart command requests the target to start a new trace run.
1854 The command passes any arguments it has to the target verbatim, as
1855 an optional "trace note". This is useful as for instance a warning
1856 to other users if the trace runs disconnected, and you don't want
1857 anybody else messing with the target. */
1860 trace_start_command (char *args
, int from_tty
)
1862 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1864 if (current_trace_status ()->running
)
1867 && !query (_("A trace is running already. Start a new run? ")))
1868 error (_("New trace run not started."));
1871 start_tracing (args
);
1874 /* The tstop command stops the tracing run. The command passes any
1875 supplied arguments to the target verbatim as a "stop note"; if the
1876 target supports trace notes, then it will be reported back as part
1877 of the trace run's status. */
1880 trace_stop_command (char *args
, int from_tty
)
1882 if (!current_trace_status ()->running
)
1883 error (_("Trace is not running."));
1885 stop_tracing (args
);
1889 stop_tracing (char *note
)
1892 VEC(breakpoint_p
) *tp_vec
= NULL
;
1894 struct breakpoint
*t
;
1896 target_trace_stop ();
1898 tp_vec
= all_tracepoints ();
1899 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1901 struct bp_location
*loc
;
1903 if ((t
->type
== bp_fast_tracepoint
1904 ? !may_insert_fast_tracepoints
1905 : !may_insert_tracepoints
))
1908 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1910 /* GDB can be totally absent in some disconnected trace scenarios,
1911 but we don't really care if this semaphore goes out of sync.
1912 That's why we are decrementing it here, but not taking care
1914 if (loc
->probe
!= NULL
)
1915 loc
->probe
->pops
->clear_semaphore (loc
->probe
, loc
->gdbarch
);
1919 VEC_free (breakpoint_p
, tp_vec
);
1922 note
= trace_stop_notes
;
1923 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1926 warning (_("Target does not support trace notes, note ignored"));
1928 /* Should change in response to reply? */
1929 current_trace_status ()->running
= 0;
1932 /* tstatus command */
1934 trace_status_command (char *args
, int from_tty
)
1936 struct trace_status
*ts
= current_trace_status ();
1938 VEC(breakpoint_p
) *tp_vec
= NULL
;
1939 struct breakpoint
*t
;
1941 status
= target_get_trace_status (ts
);
1945 if (ts
->filename
!= NULL
)
1946 printf_filtered (_("Using a trace file.\n"));
1949 printf_filtered (_("Trace can not be run on this target.\n"));
1954 if (!ts
->running_known
)
1956 printf_filtered (_("Run/stop status is unknown.\n"));
1958 else if (ts
->running
)
1960 printf_filtered (_("Trace is running on the target.\n"));
1964 switch (ts
->stop_reason
)
1966 case trace_never_run
:
1967 printf_filtered (_("No trace has been run on the target.\n"));
1971 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1974 printf_filtered (_("Trace stopped by a tstop command.\n"));
1976 case trace_buffer_full
:
1977 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1979 case trace_disconnected
:
1980 printf_filtered (_("Trace stopped because of disconnection.\n"));
1982 case tracepoint_passcount
:
1983 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1984 ts
->stopping_tracepoint
);
1986 case tracepoint_error
:
1987 if (ts
->stopping_tracepoint
)
1988 printf_filtered (_("Trace stopped by an "
1989 "error (%s, tracepoint %d).\n"),
1990 ts
->stop_desc
, ts
->stopping_tracepoint
);
1992 printf_filtered (_("Trace stopped by an error (%s).\n"),
1995 case trace_stop_reason_unknown
:
1996 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1999 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
2005 if (ts
->traceframes_created
>= 0
2006 && ts
->traceframe_count
!= ts
->traceframes_created
)
2008 printf_filtered (_("Buffer contains %d trace "
2009 "frames (of %d created total).\n"),
2010 ts
->traceframe_count
, ts
->traceframes_created
);
2012 else if (ts
->traceframe_count
>= 0)
2014 printf_filtered (_("Collected %d trace frames.\n"),
2015 ts
->traceframe_count
);
2018 if (ts
->buffer_free
>= 0)
2020 if (ts
->buffer_size
>= 0)
2022 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2023 ts
->buffer_free
, ts
->buffer_size
);
2024 if (ts
->buffer_size
> 0)
2025 printf_filtered (_(" (%d%% full)"),
2026 ((int) ((((long long) (ts
->buffer_size
2027 - ts
->buffer_free
)) * 100)
2028 / ts
->buffer_size
)));
2029 printf_filtered (_(".\n"));
2032 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2036 if (ts
->disconnected_tracing
)
2037 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2039 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2041 if (ts
->circular_buffer
)
2042 printf_filtered (_("Trace buffer is circular.\n"));
2044 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
2045 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
2047 if (ts
->notes
&& strlen (ts
->notes
) > 0)
2048 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
2050 /* Now report on what we're doing with tfind. */
2051 if (traceframe_number
>= 0)
2052 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2053 traceframe_number
, tracepoint_number
);
2055 printf_filtered (_("Not looking at any trace frame.\n"));
2057 /* Report start/stop times if supplied. */
2062 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
2064 /* Reporting a run time is more readable than two long numbers. */
2065 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2066 (long int) ts
->start_time
/ 1000000,
2067 (long int) ts
->start_time
% 1000000,
2068 (long int) run_time
/ 1000000,
2069 (long int) run_time
% 1000000);
2072 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2073 (long int) ts
->start_time
/ 1000000,
2074 (long int) ts
->start_time
% 1000000);
2076 else if (ts
->stop_time
)
2077 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2078 (long int) ts
->stop_time
/ 1000000,
2079 (long int) ts
->stop_time
% 1000000);
2081 /* Now report any per-tracepoint status available. */
2082 tp_vec
= all_tracepoints ();
2084 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2085 target_get_tracepoint_status (t
, NULL
);
2087 VEC_free (breakpoint_p
, tp_vec
);
2090 /* Report the trace status to uiout, in a way suitable for MI, and not
2091 suitable for CLI. If ON_STOP is true, suppress a few fields that
2092 are not meaningful in the -trace-stop response.
2094 The implementation is essentially parallel to trace_status_command, but
2095 merging them will result in unreadable code. */
2097 trace_status_mi (int on_stop
)
2099 struct ui_out
*uiout
= current_uiout
;
2100 struct trace_status
*ts
= current_trace_status ();
2103 status
= target_get_trace_status (ts
);
2105 if (status
== -1 && ts
->filename
== NULL
)
2107 ui_out_field_string (uiout
, "supported", "0");
2111 if (ts
->filename
!= NULL
)
2112 ui_out_field_string (uiout
, "supported", "file");
2114 ui_out_field_string (uiout
, "supported", "1");
2116 if (ts
->filename
!= NULL
)
2117 ui_out_field_string (uiout
, "trace-file", ts
->filename
);
2119 gdb_assert (ts
->running_known
);
2123 ui_out_field_string (uiout
, "running", "1");
2125 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2126 Given that the frontend gets the status either on -trace-stop, or from
2127 -trace-status after re-connection, it does not seem like this
2128 information is necessary for anything. It is not necessary for either
2129 figuring the vital state of the target nor for navigation of trace
2130 frames. If the frontend wants to show the current state is some
2131 configure dialog, it can request the value when such dialog is
2132 invoked by the user. */
2136 char *stop_reason
= NULL
;
2137 int stopping_tracepoint
= -1;
2140 ui_out_field_string (uiout
, "running", "0");
2142 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2144 switch (ts
->stop_reason
)
2147 stop_reason
= "request";
2149 case trace_buffer_full
:
2150 stop_reason
= "overflow";
2152 case trace_disconnected
:
2153 stop_reason
= "disconnection";
2155 case tracepoint_passcount
:
2156 stop_reason
= "passcount";
2157 stopping_tracepoint
= ts
->stopping_tracepoint
;
2159 case tracepoint_error
:
2160 stop_reason
= "error";
2161 stopping_tracepoint
= ts
->stopping_tracepoint
;
2167 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2168 if (stopping_tracepoint
!= -1)
2169 ui_out_field_int (uiout
, "stopping-tracepoint",
2170 stopping_tracepoint
);
2171 if (ts
->stop_reason
== tracepoint_error
)
2172 ui_out_field_string (uiout
, "error-description",
2178 if (ts
->traceframe_count
!= -1)
2179 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2180 if (ts
->traceframes_created
!= -1)
2181 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2182 if (ts
->buffer_size
!= -1)
2183 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2184 if (ts
->buffer_free
!= -1)
2185 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2187 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2188 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2190 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2191 ui_out_field_string (uiout
, "notes", ts
->notes
);
2196 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2197 (long int) ts
->start_time
/ 1000000,
2198 (long int) ts
->start_time
% 1000000);
2199 ui_out_field_string (uiout
, "start-time", buf
);
2200 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2201 (long int) ts
->stop_time
/ 1000000,
2202 (long int) ts
->stop_time
% 1000000);
2203 ui_out_field_string (uiout
, "stop-time", buf
);
2207 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2208 user if she really wants to detach. */
2211 query_if_trace_running (int from_tty
)
2216 /* It can happen that the target that was tracing went away on its
2217 own, and we didn't notice. Get a status update, and if the
2218 current target doesn't even do tracing, then assume it's not
2220 if (target_get_trace_status (current_trace_status ()) < 0)
2221 current_trace_status ()->running
= 0;
2223 /* If running interactively, give the user the option to cancel and
2224 then decide what to do differently with the run. Scripts are
2225 just going to disconnect and let the target deal with it,
2226 according to how it's been instructed previously via
2227 disconnected-tracing. */
2228 if (current_trace_status ()->running
)
2230 process_tracepoint_on_disconnect ();
2232 if (current_trace_status ()->disconnected_tracing
)
2234 if (!query (_("Trace is running and will "
2235 "continue after detach; detach anyway? ")))
2236 error (_("Not confirmed."));
2240 if (!query (_("Trace is running but will "
2241 "stop on detach; detach anyway? ")))
2242 error (_("Not confirmed."));
2247 /* This function handles the details of what to do about an ongoing
2248 tracing run if the user has asked to detach or otherwise disconnect
2252 disconnect_tracing (void)
2254 /* Also we want to be out of tfind mode, otherwise things can get
2255 confusing upon reconnection. Just use these calls instead of
2256 full tfind_1 behavior because we're in the middle of detaching,
2257 and there's no point to updating current stack frame etc. */
2258 set_current_traceframe (-1);
2259 set_tracepoint_num (-1);
2260 set_traceframe_context (NULL
);
2263 /* Worker function for the various flavors of the tfind command. */
2265 tfind_1 (enum trace_find_type type
, int num
,
2266 CORE_ADDR addr1
, CORE_ADDR addr2
,
2269 int target_frameno
= -1, target_tracept
= -1;
2270 struct frame_id old_frame_id
= null_frame_id
;
2271 struct tracepoint
*tp
;
2272 struct ui_out
*uiout
= current_uiout
;
2274 /* Only try to get the current stack frame if we have a chance of
2275 succeeding. In particular, if we're trying to get a first trace
2276 frame while all threads are running, it's not going to succeed,
2277 so leave it with a default value and let the frame comparison
2278 below (correctly) decide to print out the source location of the
2280 if (!(type
== tfind_number
&& num
== -1)
2281 && (has_stack_frames () || traceframe_number
>= 0))
2282 old_frame_id
= get_frame_id (get_current_frame ());
2284 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2287 if (type
== tfind_number
2289 && target_frameno
== -1)
2291 /* We told the target to get out of tfind mode, and it did. */
2293 else if (target_frameno
== -1)
2295 /* A request for a non-existent trace frame has failed.
2296 Our response will be different, depending on FROM_TTY:
2298 If FROM_TTY is true, meaning that this command was
2299 typed interactively by the user, then give an error
2300 and DO NOT change the state of traceframe_number etc.
2302 However if FROM_TTY is false, meaning that we're either
2303 in a script, a loop, or a user-defined command, then
2304 DON'T give an error, but DO change the state of
2305 traceframe_number etc. to invalid.
2307 The rationalle is that if you typed the command, you
2308 might just have committed a typo or something, and you'd
2309 like to NOT lose your current debugging state. However
2310 if you're in a user-defined command or especially in a
2311 loop, then you need a way to detect that the command
2312 failed WITHOUT aborting. This allows you to write
2313 scripts that search thru the trace buffer until the end,
2314 and then continue on to do something else. */
2317 error (_("Target failed to find requested trace frame."));
2321 printf_filtered ("End of trace buffer.\n");
2322 #if 0 /* dubious now? */
2323 /* The following will not recurse, since it's
2325 trace_find_command ("-1", from_tty
);
2330 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2332 reinit_frame_cache ();
2333 target_dcache_invalidate ();
2335 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2337 if (target_frameno
!= get_traceframe_number ())
2338 observer_notify_traceframe_changed (target_frameno
, tracepoint_number
);
2340 set_current_traceframe (target_frameno
);
2342 if (target_frameno
== -1)
2343 set_traceframe_context (NULL
);
2345 set_traceframe_context (get_current_frame ());
2347 if (traceframe_number
>= 0)
2349 /* Use different branches for MI and CLI to make CLI messages
2351 if (ui_out_is_mi_like_p (uiout
))
2353 ui_out_field_string (uiout
, "found", "1");
2354 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2355 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2359 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2360 traceframe_number
, tracepoint_number
);
2365 if (ui_out_is_mi_like_p (uiout
))
2366 ui_out_field_string (uiout
, "found", "0");
2367 else if (type
== tfind_number
&& num
== -1)
2368 printf_unfiltered (_("No longer looking at any trace frame\n"));
2369 else /* This case may never occur, check. */
2370 printf_unfiltered (_("No trace frame found\n"));
2373 /* If we're in nonstop mode and getting out of looking at trace
2374 frames, there won't be any current frame to go back to and
2377 && (has_stack_frames () || traceframe_number
>= 0))
2379 enum print_what print_what
;
2381 /* NOTE: in imitation of the step command, try to determine
2382 whether we have made a transition from one function to
2383 another. If so, we'll print the "stack frame" (ie. the new
2384 function and it's arguments) -- otherwise we'll just show the
2387 if (frame_id_eq (old_frame_id
,
2388 get_frame_id (get_current_frame ())))
2389 print_what
= SRC_LINE
;
2391 print_what
= SRC_AND_LOC
;
2393 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2398 /* trace_find_command takes a trace frame number n,
2399 sends "QTFrame:<n>" to the target,
2400 and accepts a reply that may contain several optional pieces
2401 of information: a frame number, a tracepoint number, and an
2402 indication of whether this is a trap frame or a stepping frame.
2404 The minimal response is just "OK" (which indicates that the
2405 target does not give us a frame number or a tracepoint number).
2406 Instead of that, the target may send us a string containing
2408 F<hexnum> (gives the selected frame number)
2409 T<hexnum> (gives the selected tracepoint number)
2414 trace_find_command (char *args
, int from_tty
)
2415 { /* This should only be called with a numeric argument. */
2418 if (current_trace_status ()->running
2419 && current_trace_status ()->filename
== NULL
)
2420 error (_("May not look at trace frames while trace is running."));
2422 if (args
== 0 || *args
== 0)
2423 { /* TFIND with no args means find NEXT trace frame. */
2424 if (traceframe_number
== -1)
2425 frameno
= 0; /* "next" is first one. */
2427 frameno
= traceframe_number
+ 1;
2429 else if (0 == strcmp (args
, "-"))
2431 if (traceframe_number
== -1)
2432 error (_("not debugging trace buffer"));
2433 else if (from_tty
&& traceframe_number
== 0)
2434 error (_("already at start of trace buffer"));
2436 frameno
= traceframe_number
- 1;
2438 /* A hack to work around eval's need for fp to have been collected. */
2439 else if (0 == strcmp (args
, "-1"))
2442 frameno
= parse_and_eval_long (args
);
2445 error (_("invalid input (%d is less than zero)"), frameno
);
2447 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2452 trace_find_end_command (char *args
, int from_tty
)
2454 trace_find_command ("-1", from_tty
);
2459 trace_find_start_command (char *args
, int from_tty
)
2461 trace_find_command ("0", from_tty
);
2464 /* tfind pc command */
2466 trace_find_pc_command (char *args
, int from_tty
)
2470 if (current_trace_status ()->running
2471 && current_trace_status ()->filename
== NULL
)
2472 error (_("May not look at trace frames while trace is running."));
2474 if (args
== 0 || *args
== 0)
2475 pc
= regcache_read_pc (get_current_regcache ());
2477 pc
= parse_and_eval_address (args
);
2479 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2482 /* tfind tracepoint command */
2484 trace_find_tracepoint_command (char *args
, int from_tty
)
2487 struct tracepoint
*tp
;
2489 if (current_trace_status ()->running
2490 && current_trace_status ()->filename
== NULL
)
2491 error (_("May not look at trace frames while trace is running."));
2493 if (args
== 0 || *args
== 0)
2495 if (tracepoint_number
== -1)
2496 error (_("No current tracepoint -- please supply an argument."));
2498 tdp
= tracepoint_number
; /* Default is current TDP. */
2501 tdp
= parse_and_eval_long (args
);
2503 /* If we have the tracepoint on hand, use the number that the
2504 target knows about (which may be different if we disconnected
2505 and reconnected). */
2506 tp
= get_tracepoint (tdp
);
2508 tdp
= tp
->number_on_target
;
2510 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2513 /* TFIND LINE command:
2515 This command will take a sourceline for argument, just like BREAK
2516 or TRACE (ie. anything that "decode_line_1" can handle).
2518 With no argument, this command will find the next trace frame
2519 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2522 trace_find_line_command (char *args
, int from_tty
)
2524 static CORE_ADDR start_pc
, end_pc
;
2525 struct symtabs_and_lines sals
;
2526 struct symtab_and_line sal
;
2527 struct cleanup
*old_chain
;
2529 if (current_trace_status ()->running
2530 && current_trace_status ()->filename
== NULL
)
2531 error (_("May not look at trace frames while trace is running."));
2533 if (args
== 0 || *args
== 0)
2535 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2537 sals
.sals
= (struct symtab_and_line
*)
2538 xmalloc (sizeof (struct symtab_and_line
));
2543 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2547 old_chain
= make_cleanup (xfree
, sals
.sals
);
2548 if (sal
.symtab
== 0)
2549 error (_("No line number information available."));
2551 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2553 if (start_pc
== end_pc
)
2555 printf_filtered ("Line %d of \"%s\"",
2557 symtab_to_filename_for_display (sal
.symtab
));
2559 printf_filtered (" is at address ");
2560 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2562 printf_filtered (" but contains no code.\n");
2563 sal
= find_pc_line (start_pc
, 0);
2565 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2566 && start_pc
!= end_pc
)
2567 printf_filtered ("Attempting to find line %d instead.\n",
2570 error (_("Cannot find a good line."));
2574 /* Is there any case in which we get here, and have an address
2575 which the user would want to see? If we have debugging
2576 symbols and no line numbers? */
2577 error (_("Line number %d is out of range for \"%s\"."),
2578 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2580 /* Find within range of stated line. */
2582 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2584 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2585 do_cleanups (old_chain
);
2588 /* tfind range command */
2590 trace_find_range_command (char *args
, int from_tty
)
2592 static CORE_ADDR start
, stop
;
2595 if (current_trace_status ()->running
2596 && current_trace_status ()->filename
== NULL
)
2597 error (_("May not look at trace frames while trace is running."));
2599 if (args
== 0 || *args
== 0)
2600 { /* XXX FIXME: what should default behavior be? */
2601 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2605 if (0 != (tmp
= strchr (args
, ',')))
2607 *tmp
++ = '\0'; /* Terminate start address. */
2608 tmp
= skip_spaces (tmp
);
2609 start
= parse_and_eval_address (args
);
2610 stop
= parse_and_eval_address (tmp
);
2613 { /* No explicit end address? */
2614 start
= parse_and_eval_address (args
);
2615 stop
= start
+ 1; /* ??? */
2618 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2621 /* tfind outside command */
2623 trace_find_outside_command (char *args
, int from_tty
)
2625 CORE_ADDR start
, stop
;
2628 if (current_trace_status ()->running
2629 && current_trace_status ()->filename
== NULL
)
2630 error (_("May not look at trace frames while trace is running."));
2632 if (args
== 0 || *args
== 0)
2633 { /* XXX FIXME: what should default behavior be? */
2634 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2638 if (0 != (tmp
= strchr (args
, ',')))
2640 *tmp
++ = '\0'; /* Terminate start address. */
2641 tmp
= skip_spaces (tmp
);
2642 start
= parse_and_eval_address (args
);
2643 stop
= parse_and_eval_address (tmp
);
2646 { /* No explicit end address? */
2647 start
= parse_and_eval_address (args
);
2648 stop
= start
+ 1; /* ??? */
2651 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2654 /* info scope command: list the locals for a scope. */
2656 scope_info (char *args
, int from_tty
)
2658 struct symtabs_and_lines sals
;
2660 struct minimal_symbol
*msym
;
2661 struct block
*block
;
2662 const char *symname
;
2663 char *save_args
= args
;
2664 struct block_iterator iter
;
2666 struct gdbarch
*gdbarch
;
2669 if (args
== 0 || *args
== 0)
2670 error (_("requires an argument (function, "
2671 "line or *addr) to define a scope"));
2673 sals
= decode_line_1 (&args
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2674 if (sals
.nelts
== 0)
2675 return; /* Presumably decode_line_1 has already warned. */
2677 /* Resolve line numbers to PC. */
2678 resolve_sal_pc (&sals
.sals
[0]);
2679 block
= block_for_pc (sals
.sals
[0].pc
);
2683 QUIT
; /* Allow user to bail out with ^C. */
2684 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2686 QUIT
; /* Allow user to bail out with ^C. */
2688 printf_filtered ("Scope for %s:\n", save_args
);
2691 symname
= SYMBOL_PRINT_NAME (sym
);
2692 if (symname
== NULL
|| *symname
== '\0')
2693 continue; /* Probably botched, certainly useless. */
2695 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2697 printf_filtered ("Symbol %s is ", symname
);
2699 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
2700 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2701 BLOCK_START (block
),
2705 switch (SYMBOL_CLASS (sym
))
2708 case LOC_UNDEF
: /* Messed up symbol? */
2709 printf_filtered ("a bogus symbol, class %d.\n",
2710 SYMBOL_CLASS (sym
));
2711 count
--; /* Don't count this one. */
2714 printf_filtered ("a constant with value %s (%s)",
2715 plongest (SYMBOL_VALUE (sym
)),
2716 hex_string (SYMBOL_VALUE (sym
)));
2718 case LOC_CONST_BYTES
:
2719 printf_filtered ("constant bytes: ");
2720 if (SYMBOL_TYPE (sym
))
2721 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2722 fprintf_filtered (gdb_stdout
, " %02x",
2723 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2726 printf_filtered ("in static storage at address ");
2727 printf_filtered ("%s", paddress (gdbarch
,
2728 SYMBOL_VALUE_ADDRESS (sym
)));
2731 /* GDBARCH is the architecture associated with the objfile
2732 the symbol is defined in; the target architecture may be
2733 different, and may provide additional registers. However,
2734 we do not know the target architecture at this point.
2735 We assume the objfile architecture will contain all the
2736 standard registers that occur in debug info in that
2738 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2741 if (SYMBOL_IS_ARGUMENT (sym
))
2742 printf_filtered ("an argument in register $%s",
2743 gdbarch_register_name (gdbarch
, regno
));
2745 printf_filtered ("a local variable in register $%s",
2746 gdbarch_register_name (gdbarch
, regno
));
2749 printf_filtered ("an argument at stack/frame offset %s",
2750 plongest (SYMBOL_VALUE (sym
)));
2753 printf_filtered ("a local variable at frame offset %s",
2754 plongest (SYMBOL_VALUE (sym
)));
2757 printf_filtered ("a reference argument at offset %s",
2758 plongest (SYMBOL_VALUE (sym
)));
2760 case LOC_REGPARM_ADDR
:
2761 /* Note comment at LOC_REGISTER. */
2762 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2764 printf_filtered ("the address of an argument, in register $%s",
2765 gdbarch_register_name (gdbarch
, regno
));
2768 printf_filtered ("a typedef.\n");
2771 printf_filtered ("a label at address ");
2772 printf_filtered ("%s", paddress (gdbarch
,
2773 SYMBOL_VALUE_ADDRESS (sym
)));
2776 printf_filtered ("a function at address ");
2777 printf_filtered ("%s",
2778 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2780 case LOC_UNRESOLVED
:
2781 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2784 printf_filtered ("Unresolved Static");
2787 printf_filtered ("static storage at address ");
2788 printf_filtered ("%s",
2790 SYMBOL_VALUE_ADDRESS (msym
)));
2793 case LOC_OPTIMIZED_OUT
:
2794 printf_filtered ("optimized out.\n");
2797 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2800 if (SYMBOL_TYPE (sym
))
2801 printf_filtered (", length %d.\n",
2802 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2804 if (BLOCK_FUNCTION (block
))
2807 block
= BLOCK_SUPERBLOCK (block
);
2810 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2814 /* Helper for trace_dump_command. Dump the action list starting at
2815 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2816 actions of the body of a while-stepping action. STEPPING_FRAME is
2817 set if the current traceframe was determined to be a while-stepping
2821 trace_dump_actions (struct command_line
*action
,
2822 int stepping_actions
, int stepping_frame
,
2825 const char *action_exp
, *next_comma
;
2827 for (; action
!= NULL
; action
= action
->next
)
2829 struct cmd_list_element
*cmd
;
2831 QUIT
; /* Allow user to bail out with ^C. */
2832 action_exp
= action
->line
;
2833 action_exp
= skip_spaces_const (action_exp
);
2835 /* The collection actions to be done while stepping are
2836 bracketed by the commands "while-stepping" and "end". */
2838 if (*action_exp
== '#') /* comment line */
2841 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2843 error (_("Bad action list item: %s"), action_exp
);
2845 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2849 for (i
= 0; i
< action
->body_count
; ++i
)
2850 trace_dump_actions (action
->body_list
[i
],
2851 1, stepping_frame
, from_tty
);
2853 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2855 /* Display the collected data.
2856 For the trap frame, display only what was collected at
2857 the trap. Likewise for stepping frames, display only
2858 what was collected while stepping. This means that the
2859 two boolean variables, STEPPING_FRAME and
2860 STEPPING_ACTIONS should be equal. */
2861 if (stepping_frame
== stepping_actions
)
2864 struct cleanup
*old_chain
2865 = make_cleanup (free_current_contents
, &cmd
);
2866 int trace_string
= 0;
2868 if (*action_exp
== '/')
2869 action_exp
= decode_agent_options (action_exp
, &trace_string
);
2872 { /* Repeat over a comma-separated list. */
2873 QUIT
; /* Allow user to bail out with ^C. */
2874 if (*action_exp
== ',')
2876 action_exp
= skip_spaces_const (action_exp
);
2878 next_comma
= strchr (action_exp
, ',');
2880 if (0 == strncasecmp (action_exp
, "$reg", 4))
2881 registers_info (NULL
, from_tty
);
2882 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2884 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2885 locals_info (NULL
, from_tty
);
2886 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2887 args_info (NULL
, from_tty
);
2890 if (next_comma
!= NULL
)
2892 size_t len
= next_comma
- action_exp
;
2894 cmd
= xrealloc (cmd
, len
+ 1);
2895 memcpy (cmd
, action_exp
, len
);
2900 size_t len
= strlen (action_exp
);
2902 cmd
= xrealloc (cmd
, len
+ 1);
2903 memcpy (cmd
, action_exp
, len
+ 1);
2906 printf_filtered ("%s = ", cmd
);
2907 output_command_const (cmd
, from_tty
);
2908 printf_filtered ("\n");
2910 action_exp
= next_comma
;
2912 while (action_exp
&& *action_exp
== ',');
2914 do_cleanups (old_chain
);
2920 /* The tdump command. */
2923 trace_dump_command (char *args
, int from_tty
)
2925 struct regcache
*regcache
;
2926 struct tracepoint
*t
;
2927 int stepping_frame
= 0;
2928 struct bp_location
*loc
;
2929 char *default_collect_line
= NULL
;
2930 struct command_line
*actions
, *default_collect_action
= NULL
;
2931 struct cleanup
*old_chain
= NULL
;
2933 if (tracepoint_number
== -1)
2935 warning (_("No current trace frame."));
2939 t
= get_tracepoint (tracepoint_number
);
2942 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2945 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2946 tracepoint_number
, traceframe_number
);
2948 /* The current frame is a trap frame if the frame PC is equal
2949 to the tracepoint PC. If not, then the current frame was
2950 collected during single-stepping. */
2952 regcache
= get_current_regcache ();
2954 /* If the traceframe's address matches any of the tracepoint's
2955 locations, assume it is a direct hit rather than a while-stepping
2956 frame. (FIXME this is not reliable, should record each frame's
2959 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
2960 if (loc
->address
== regcache_read_pc (regcache
))
2963 actions
= breakpoint_commands (&t
->base
);
2965 /* If there is a default-collect list, make up a collect command,
2966 prepend to the tracepoint's commands, and pass the whole mess to
2967 the trace dump scanner. We need to validate because
2968 default-collect might have been junked since the trace run. */
2969 if (*default_collect
)
2971 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2972 old_chain
= make_cleanup (xfree
, default_collect_line
);
2973 validate_actionline (default_collect_line
, &t
->base
);
2974 default_collect_action
= xmalloc (sizeof (struct command_line
));
2975 make_cleanup (xfree
, default_collect_action
);
2976 default_collect_action
->next
= actions
;
2977 default_collect_action
->line
= default_collect_line
;
2978 actions
= default_collect_action
;
2981 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2983 if (*default_collect
)
2984 do_cleanups (old_chain
);
2987 /* Encode a piece of a tracepoint's source-level definition in a form
2988 that is suitable for both protocol and saving in files. */
2989 /* This version does not do multiple encodes for long strings; it should
2990 return an offset to the next piece to encode. FIXME */
2993 encode_source_string (int tpnum
, ULONGEST addr
,
2994 char *srctype
, char *src
, char *buf
, int buf_size
)
2996 if (80 + strlen (srctype
) > buf_size
)
2997 error (_("Buffer too small for source encoding"));
2998 sprintf (buf
, "%x:%s:%s:%x:%x:",
2999 tpnum
, phex_nz (addr
, sizeof (addr
)),
3000 srctype
, 0, (int) strlen (src
));
3001 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
3002 error (_("Source string too long for buffer"));
3003 bin2hex ((gdb_byte
*) src
, buf
+ strlen (buf
), 0);
3007 /* Free trace file writer. */
3010 trace_file_writer_xfree (void *arg
)
3012 struct trace_file_writer
*writer
= arg
;
3014 writer
->ops
->dtor (writer
);
3018 /* TFILE trace writer. */
3020 struct tfile_trace_file_writer
3022 struct trace_file_writer base
;
3024 /* File pointer to tfile trace file. */
3026 /* Path name of the tfile trace file. */
3030 /* This is the implementation of trace_file_write_ops method
3031 target_save. We just call the generic target
3032 target_save_trace_data to do target-side saving. */
3035 tfile_target_save (struct trace_file_writer
*self
,
3036 const char *filename
)
3038 int err
= target_save_trace_data (filename
);
3043 /* This is the implementation of trace_file_write_ops method
3047 tfile_dtor (struct trace_file_writer
*self
)
3049 struct tfile_trace_file_writer
*writer
3050 = (struct tfile_trace_file_writer
*) self
;
3052 xfree (writer
->pathname
);
3054 if (writer
->fp
!= NULL
)
3055 fclose (writer
->fp
);
3058 /* This is the implementation of trace_file_write_ops method
3059 start. It creates the trace file FILENAME and registers some
3063 tfile_start (struct trace_file_writer
*self
, const char *filename
)
3065 struct tfile_trace_file_writer
*writer
3066 = (struct tfile_trace_file_writer
*) self
;
3068 writer
->pathname
= tilde_expand (filename
);
3069 writer
->fp
= fopen (writer
->pathname
, "wb");
3070 if (writer
->fp
== NULL
)
3071 error (_("Unable to open file '%s' for saving trace data (%s)"),
3072 filename
, safe_strerror (errno
));
3075 /* This is the implementation of trace_file_write_ops method
3076 write_header. Write the TFILE header. */
3079 tfile_write_header (struct trace_file_writer
*self
)
3081 struct tfile_trace_file_writer
*writer
3082 = (struct tfile_trace_file_writer
*) self
;
3085 /* Write a file header, with a high-bit-set char to indicate a
3086 binary file, plus a hint as what this file is, and a version
3087 number in case of future needs. */
3088 written
= fwrite ("\x7fTRACE0\n", 8, 1, writer
->fp
);
3090 perror_with_name (writer
->pathname
);
3093 /* This is the implementation of trace_file_write_ops method
3094 write_regblock_type. Write the size of register block. */
3097 tfile_write_regblock_type (struct trace_file_writer
*self
, int size
)
3099 struct tfile_trace_file_writer
*writer
3100 = (struct tfile_trace_file_writer
*) self
;
3102 fprintf (writer
->fp
, "R %x\n", size
);
3105 /* This is the implementation of trace_file_write_ops method
3109 tfile_write_status (struct trace_file_writer
*self
,
3110 struct trace_status
*ts
)
3112 struct tfile_trace_file_writer
*writer
3113 = (struct tfile_trace_file_writer
*) self
;
3115 fprintf (writer
->fp
, "status %c;%s",
3116 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
3117 if (ts
->stop_reason
== tracepoint_error
3118 || ts
->stop_reason
== tstop_command
)
3120 char *buf
= (char *) alloca (strlen (ts
->stop_desc
) * 2 + 1);
3122 bin2hex ((gdb_byte
*) ts
->stop_desc
, buf
, 0);
3123 fprintf (writer
->fp
, ":%s", buf
);
3125 fprintf (writer
->fp
, ":%x", ts
->stopping_tracepoint
);
3126 if (ts
->traceframe_count
>= 0)
3127 fprintf (writer
->fp
, ";tframes:%x", ts
->traceframe_count
);
3128 if (ts
->traceframes_created
>= 0)
3129 fprintf (writer
->fp
, ";tcreated:%x", ts
->traceframes_created
);
3130 if (ts
->buffer_free
>= 0)
3131 fprintf (writer
->fp
, ";tfree:%x", ts
->buffer_free
);
3132 if (ts
->buffer_size
>= 0)
3133 fprintf (writer
->fp
, ";tsize:%x", ts
->buffer_size
);
3134 if (ts
->disconnected_tracing
)
3135 fprintf (writer
->fp
, ";disconn:%x", ts
->disconnected_tracing
);
3136 if (ts
->circular_buffer
)
3137 fprintf (writer
->fp
, ";circular:%x", ts
->circular_buffer
);
3138 if (ts
->notes
!= NULL
)
3140 char *buf
= (char *) alloca (strlen (ts
->notes
) * 2 + 1);
3142 bin2hex ((gdb_byte
*) ts
->notes
, buf
, 0);
3143 fprintf (writer
->fp
, ";notes:%s", buf
);
3145 if (ts
->user_name
!= NULL
)
3147 char *buf
= (char *) alloca (strlen (ts
->user_name
) * 2 + 1);
3149 bin2hex ((gdb_byte
*) ts
->user_name
, buf
, 0);
3150 fprintf (writer
->fp
, ";username:%s", buf
);
3152 fprintf (writer
->fp
, "\n");
3155 /* This is the implementation of trace_file_write_ops method
3156 write_uploaded_tsv. */
3159 tfile_write_uploaded_tsv (struct trace_file_writer
*self
,
3160 struct uploaded_tsv
*utsv
)
3163 struct tfile_trace_file_writer
*writer
3164 = (struct tfile_trace_file_writer
*) self
;
3168 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
3169 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
3172 fprintf (writer
->fp
, "tsv %x:%s:%x:%s\n",
3173 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
3174 utsv
->builtin
, buf
);
3180 #define MAX_TRACE_UPLOAD 2000
3182 /* This is the implementation of trace_file_write_ops method
3183 write_uploaded_tp. */
3186 tfile_write_uploaded_tp (struct trace_file_writer
*self
,
3187 struct uploaded_tp
*utp
)
3189 struct tfile_trace_file_writer
*writer
3190 = (struct tfile_trace_file_writer
*) self
;
3193 char buf
[MAX_TRACE_UPLOAD
];
3195 fprintf (writer
->fp
, "tp T%x:%s:%c:%x:%x",
3196 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3197 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
3198 if (utp
->type
== bp_fast_tracepoint
)
3199 fprintf (writer
->fp
, ":F%x", utp
->orig_size
);
3201 fprintf (writer
->fp
,
3202 ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
3204 fprintf (writer
->fp
, "\n");
3205 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
3206 fprintf (writer
->fp
, "tp A%x:%s:%s\n",
3207 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3208 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
3209 fprintf (writer
->fp
, "tp S%x:%s:%s\n",
3210 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3213 encode_source_string (utp
->number
, utp
->addr
,
3214 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
3215 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3217 if (utp
->cond_string
)
3219 encode_source_string (utp
->number
, utp
->addr
,
3220 "cond", utp
->cond_string
,
3221 buf
, MAX_TRACE_UPLOAD
);
3222 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3224 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
3226 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
3227 buf
, MAX_TRACE_UPLOAD
);
3228 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3230 fprintf (writer
->fp
, "tp V%x:%s:%x:%s\n",
3231 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3233 phex_nz (utp
->traceframe_usage
,
3234 sizeof (utp
->traceframe_usage
)));
3237 /* This is the implementation of trace_file_write_ops method
3238 write_definition_end. */
3241 tfile_write_definition_end (struct trace_file_writer
*self
)
3243 struct tfile_trace_file_writer
*writer
3244 = (struct tfile_trace_file_writer
*) self
;
3246 fprintf (writer
->fp
, "\n");
3249 /* This is the implementation of trace_file_write_ops method
3253 tfile_write_raw_data (struct trace_file_writer
*self
, gdb_byte
*buf
,
3256 struct tfile_trace_file_writer
*writer
3257 = (struct tfile_trace_file_writer
*) self
;
3259 if (fwrite (buf
, len
, 1, writer
->fp
) < 1)
3260 perror_with_name (writer
->pathname
);
3263 /* This is the implementation of trace_file_write_ops method
3267 tfile_end (struct trace_file_writer
*self
)
3269 struct tfile_trace_file_writer
*writer
3270 = (struct tfile_trace_file_writer
*) self
;
3271 uint32_t gotten
= 0;
3273 /* Mark the end of trace data. */
3274 if (fwrite (&gotten
, 4, 1, writer
->fp
) < 1)
3275 perror_with_name (writer
->pathname
);
3278 /* Operations to write trace buffers into TFILE format. */
3280 static const struct trace_file_write_ops tfile_write_ops
=
3286 tfile_write_regblock_type
,
3288 tfile_write_uploaded_tsv
,
3289 tfile_write_uploaded_tp
,
3290 tfile_write_definition_end
,
3291 tfile_write_raw_data
,
3296 /* Helper macros. */
3298 #define TRACE_WRITE_R_BLOCK(writer, buf, size) \
3299 writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
3300 #define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
3301 writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
3303 #define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
3304 writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
3306 #define TRACE_WRITE_V_BLOCK(writer, num, val) \
3307 writer->ops->frame_ops->write_v_block ((writer), (num), (val))
3309 /* Save tracepoint data to file named FILENAME through WRITER. WRITER
3310 determines the trace file format. If TARGET_DOES_SAVE is non-zero,
3311 the save is performed on the target, otherwise GDB obtains all trace
3312 data and saves it locally. */
3315 trace_save (const char *filename
, struct trace_file_writer
*writer
,
3316 int target_does_save
)
3318 struct trace_status
*ts
= current_trace_status ();
3320 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
3321 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
3323 ULONGEST offset
= 0;
3324 gdb_byte buf
[MAX_TRACE_UPLOAD
];
3325 #define MAX_TRACE_UPLOAD 2000
3327 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
3329 /* If the target is to save the data to a file on its own, then just
3330 send the command and be done with it. */
3331 if (target_does_save
)
3333 if (!writer
->ops
->target_save (writer
, filename
))
3334 error (_("Target failed to save trace data to '%s'."),
3339 /* Get the trace status first before opening the file, so if the
3340 target is losing, we can get out without touching files. */
3341 status
= target_get_trace_status (ts
);
3343 writer
->ops
->start (writer
, filename
);
3345 writer
->ops
->write_header (writer
);
3347 /* Write descriptive info. */
3349 /* Write out the size of a register block. */
3350 writer
->ops
->write_regblock_type (writer
, trace_regblock_size
);
3352 /* Write out status of the tracing run (aka "tstatus" info). */
3353 writer
->ops
->write_status (writer
, ts
);
3355 /* Note that we want to upload tracepoints and save those, rather
3356 than simply writing out the local ones, because the user may have
3357 changed tracepoints in GDB in preparation for a future tracing
3358 run, or maybe just mass-deleted all types of breakpoints as part
3359 of cleaning up. So as not to contaminate the session, leave the
3360 data in its uploaded form, don't make into real tracepoints. */
3362 /* Get trace state variables first, they may be checked when parsing
3363 uploaded commands. */
3365 target_upload_trace_state_variables (&uploaded_tsvs
);
3367 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3368 writer
->ops
->write_uploaded_tsv (writer
, utsv
);
3370 free_uploaded_tsvs (&uploaded_tsvs
);
3372 target_upload_tracepoints (&uploaded_tps
);
3374 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3375 target_get_tracepoint_status (NULL
, utp
);
3377 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3378 writer
->ops
->write_uploaded_tp (writer
, utp
);
3380 free_uploaded_tps (&uploaded_tps
);
3382 /* Mark the end of the definition section. */
3383 writer
->ops
->write_definition_end (writer
);
3385 /* Get and write the trace data proper. */
3390 /* The writer supports writing the contents of trace buffer
3391 directly to trace file. Don't parse the contents of trace
3393 if (writer
->ops
->write_trace_buffer
!= NULL
)
3395 /* We ask for big blocks, in the hopes of efficiency, but
3396 will take less if the target has packet size limitations
3398 gotten
= target_get_raw_trace_data (buf
, offset
,
3401 error (_("Failure to get requested trace buffer data"));
3402 /* No more data is forthcoming, we're done. */
3406 writer
->ops
->write_trace_buffer (writer
, buf
, gotten
);
3414 /* Parse the trace buffers according to how data are stored
3415 in trace buffer in GDBserver. */
3417 gotten
= target_get_raw_trace_data (buf
, offset
, 6);
3422 /* Read the first six bytes in, which is the tracepoint
3423 number and trace frame size. */
3425 extract_unsigned_integer (&buf
[0], 2, byte_order
);
3427 tf_size
= (uint32_t)
3428 extract_unsigned_integer (&buf
[2], 4, byte_order
);
3430 writer
->ops
->frame_ops
->start (writer
, tp_num
);
3439 for (block
= 0; block
< tf_size
; )
3441 gdb_byte block_type
;
3443 /* We'll fetch one block each time, in order to
3444 handle the extremely large 'M' block. We first
3445 fetch one byte to get the type of the block. */
3446 gotten
= target_get_raw_trace_data (buf
, offset
, 1);
3448 error (_("Failure to get requested trace buffer data"));
3454 block_type
= buf
[0];
3459 = target_get_raw_trace_data (buf
, offset
,
3460 trace_regblock_size
);
3461 if (gotten
< trace_regblock_size
)
3462 error (_("Failure to get requested trace"
3465 TRACE_WRITE_R_BLOCK (writer
, buf
,
3466 trace_regblock_size
);
3470 unsigned short mlen
;
3475 t
= target_get_raw_trace_data (buf
,offset
, 10);
3477 error (_("Failure to get requested trace"
3485 extract_unsigned_integer (buf
, 8,
3487 mlen
= (unsigned short)
3488 extract_unsigned_integer (&buf
[8], 2,
3491 TRACE_WRITE_M_BLOCK_HEADER (writer
, addr
,
3494 /* The memory contents in 'M' block may be
3495 very large. Fetch the data from the target
3496 and write them into file one by one. */
3497 for (j
= 0; j
< mlen
; )
3499 unsigned int read_length
;
3501 if (mlen
- j
> MAX_TRACE_UPLOAD
)
3502 read_length
= MAX_TRACE_UPLOAD
;
3504 read_length
= mlen
- j
;
3506 t
= target_get_raw_trace_data (buf
,
3509 if (t
< read_length
)
3510 error (_("Failure to get requested"
3511 " trace buffer data"));
3513 TRACE_WRITE_M_BLOCK_MEMORY (writer
, buf
,
3517 gotten
+= read_length
;
3528 = target_get_raw_trace_data (buf
, offset
,
3531 error (_("Failure to get requested"
3532 " trace buffer data"));
3534 vnum
= (int) extract_signed_integer (buf
,
3538 = extract_signed_integer (&buf
[4], 8,
3541 TRACE_WRITE_V_BLOCK (writer
, vnum
, val
);
3545 error (_("Unknown block type '%c' (0x%x) in"
3547 block_type
, block_type
);
3557 writer
->ops
->frame_ops
->end (writer
);
3561 writer
->ops
->end (writer
);
3564 /* Return a trace writer for TFILE format. */
3566 static struct trace_file_writer
*
3567 tfile_trace_file_writer_new (void)
3569 struct tfile_trace_file_writer
*writer
3570 = xmalloc (sizeof (struct tfile_trace_file_writer
));
3572 writer
->base
.ops
= &tfile_write_ops
;
3574 writer
->pathname
= NULL
;
3576 return (struct trace_file_writer
*) writer
;
3580 trace_save_command (char *args
, int from_tty
)
3582 int target_does_save
= 0;
3584 char *filename
= NULL
;
3585 struct cleanup
*back_to
;
3586 int generate_ctf
= 0;
3587 struct trace_file_writer
*writer
= NULL
;
3590 error_no_arg (_("file in which to save trace data"));
3592 argv
= gdb_buildargv (args
);
3593 back_to
= make_cleanup_freeargv (argv
);
3595 for (; *argv
; ++argv
)
3597 if (strcmp (*argv
, "-r") == 0)
3598 target_does_save
= 1;
3599 if (strcmp (*argv
, "-ctf") == 0)
3601 else if (**argv
== '-')
3602 error (_("unknown option `%s'"), *argv
);
3608 error_no_arg (_("file in which to save trace data"));
3611 writer
= ctf_trace_file_writer_new ();
3613 writer
= tfile_trace_file_writer_new ();
3615 make_cleanup (trace_file_writer_xfree
, writer
);
3617 trace_save (filename
, writer
, target_does_save
);
3620 printf_filtered (_("Trace data saved to %s '%s'.\n"),
3621 generate_ctf
? "directory" : "file", filename
);
3623 do_cleanups (back_to
);
3626 /* Save the trace data to file FILENAME of tfile format. */
3629 trace_save_tfile (const char *filename
, int target_does_save
)
3631 struct trace_file_writer
*writer
;
3632 struct cleanup
*back_to
;
3634 writer
= tfile_trace_file_writer_new ();
3635 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
3636 trace_save (filename
, writer
, target_does_save
);
3637 do_cleanups (back_to
);
3640 /* Save the trace data to dir DIRNAME of ctf format. */
3643 trace_save_ctf (const char *dirname
, int target_does_save
)
3645 struct trace_file_writer
*writer
;
3646 struct cleanup
*back_to
;
3648 writer
= ctf_trace_file_writer_new ();
3649 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
3651 trace_save (dirname
, writer
, target_does_save
);
3652 do_cleanups (back_to
);
3655 /* Tell the target what to do with an ongoing tracing run if GDB
3656 disconnects for some reason. */
3659 set_disconnected_tracing (char *args
, int from_tty
,
3660 struct cmd_list_element
*c
)
3662 target_set_disconnected_tracing (disconnected_tracing
);
3666 set_circular_trace_buffer (char *args
, int from_tty
,
3667 struct cmd_list_element
*c
)
3669 target_set_circular_trace_buffer (circular_trace_buffer
);
3673 set_trace_buffer_size (char *args
, int from_tty
,
3674 struct cmd_list_element
*c
)
3676 target_set_trace_buffer_size (trace_buffer_size
);
3680 set_trace_user (char *args
, int from_tty
,
3681 struct cmd_list_element
*c
)
3685 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3688 warning (_("Target does not support trace notes, user ignored"));
3692 set_trace_notes (char *args
, int from_tty
,
3693 struct cmd_list_element
*c
)
3697 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3700 warning (_("Target does not support trace notes, note ignored"));
3704 set_trace_stop_notes (char *args
, int from_tty
,
3705 struct cmd_list_element
*c
)
3709 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3712 warning (_("Target does not support trace notes, stop note ignored"));
3715 /* Convert the memory pointed to by mem into hex, placing result in buf.
3716 * Return a pointer to the last char put in buf (null)
3717 * "stolen" from sparc-stub.c
3720 static const char hexchars
[] = "0123456789abcdef";
3723 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3731 *buf
++ = hexchars
[ch
>> 4];
3732 *buf
++ = hexchars
[ch
& 0xf];
3741 get_traceframe_number (void)
3743 return traceframe_number
;
3747 get_tracepoint_number (void)
3749 return tracepoint_number
;
3752 /* Make the traceframe NUM be the current trace frame. Does nothing
3753 if NUM is already current. */
3756 set_current_traceframe (int num
)
3760 if (traceframe_number
== num
)
3762 /* Nothing to do. */
3766 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3769 warning (_("could not change traceframe"));
3771 set_traceframe_num (newnum
);
3773 /* Changing the traceframe changes our view of registers and of the
3775 registers_changed ();
3777 clear_traceframe_info ();
3780 /* Make the traceframe NUM be the current trace frame, and do nothing
3784 set_traceframe_number (int num
)
3786 traceframe_number
= num
;
3789 /* A cleanup used when switching away and back from tfind mode. */
3791 struct current_traceframe_cleanup
3793 /* The traceframe we were inspecting. */
3794 int traceframe_number
;
3798 do_restore_current_traceframe_cleanup (void *arg
)
3800 struct current_traceframe_cleanup
*old
= arg
;
3802 set_current_traceframe (old
->traceframe_number
);
3806 restore_current_traceframe_cleanup_dtor (void *arg
)
3808 struct current_traceframe_cleanup
*old
= arg
;
3814 make_cleanup_restore_current_traceframe (void)
3816 struct current_traceframe_cleanup
*old
;
3818 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3819 old
->traceframe_number
= traceframe_number
;
3821 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3822 restore_current_traceframe_cleanup_dtor
);
3826 make_cleanup_restore_traceframe_number (void)
3828 return make_cleanup_restore_integer (&traceframe_number
);
3831 /* Given a number and address, return an uploaded tracepoint with that
3832 number, creating if necessary. */
3834 struct uploaded_tp
*
3835 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3837 struct uploaded_tp
*utp
;
3839 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3840 if (utp
->number
== num
&& utp
->addr
== addr
)
3842 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3843 memset (utp
, 0, sizeof (struct uploaded_tp
));
3846 utp
->actions
= NULL
;
3847 utp
->step_actions
= NULL
;
3848 utp
->cmd_strings
= NULL
;
3855 free_uploaded_tps (struct uploaded_tp
**utpp
)
3857 struct uploaded_tp
*next_one
;
3861 next_one
= (*utpp
)->next
;
3867 /* Given a number and address, return an uploaded tracepoint with that
3868 number, creating if necessary. */
3870 struct uploaded_tsv
*
3871 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3873 struct uploaded_tsv
*utsv
;
3875 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3876 if (utsv
->number
== num
)
3878 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3879 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3881 utsv
->next
= *utsvp
;
3887 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3889 struct uploaded_tsv
*next_one
;
3893 next_one
= (*utsvp
)->next
;
3899 /* FIXME this function is heuristic and will miss the cases where the
3900 conditional is semantically identical but differs in whitespace,
3901 such as "x == 0" vs "x==0". */
3904 cond_string_is_same (char *str1
, char *str2
)
3906 if (str1
== NULL
|| str2
== NULL
)
3907 return (str1
== str2
);
3909 return (strcmp (str1
, str2
) == 0);
3912 /* Look for an existing tracepoint that seems similar enough to the
3913 uploaded one. Enablement isn't compared, because the user can
3914 toggle that freely, and may have done so in anticipation of the
3915 next trace run. Return the location of matched tracepoint. */
3917 static struct bp_location
*
3918 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3920 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3922 struct breakpoint
*b
;
3923 struct bp_location
*loc
;
3925 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3927 struct tracepoint
*t
= (struct tracepoint
*) b
;
3929 if (b
->type
== utp
->type
3930 && t
->step_count
== utp
->step
3931 && t
->pass_count
== utp
->pass
3932 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3933 /* FIXME also test actions. */
3936 /* Scan the locations for an address match. */
3937 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3939 if (loc
->address
== utp
->addr
)
3947 /* Given a list of tracepoints uploaded from a target, attempt to
3948 match them up with existing tracepoints, and create new ones if not
3952 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3954 struct uploaded_tp
*utp
;
3955 /* A set of tracepoints which are modified. */
3956 VEC(breakpoint_p
) *modified_tp
= NULL
;
3958 struct breakpoint
*b
;
3960 /* Look for GDB tracepoints that match up with our uploaded versions. */
3961 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3963 struct bp_location
*loc
;
3964 struct tracepoint
*t
;
3966 loc
= find_matching_tracepoint_location (utp
);
3971 /* Mark this location as already inserted. */
3973 t
= (struct tracepoint
*) loc
->owner
;
3974 printf_filtered (_("Assuming tracepoint %d is same "
3975 "as target's tracepoint %d at %s.\n"),
3976 loc
->owner
->number
, utp
->number
,
3977 paddress (loc
->gdbarch
, utp
->addr
));
3979 /* The tracepoint LOC->owner was modified (the location LOC
3980 was marked as inserted in the target). Save it in
3981 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3982 observers will be notified later once for each tracepoint
3983 saved in MODIFIED_TP. */
3985 VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
);
3987 if (b
== loc
->owner
)
3993 VEC_safe_push (breakpoint_p
, modified_tp
, loc
->owner
);
3997 t
= create_tracepoint_from_upload (utp
);
3999 printf_filtered (_("Created tracepoint %d for "
4000 "target's tracepoint %d at %s.\n"),
4001 t
->base
.number
, utp
->number
,
4002 paddress (get_current_arch (), utp
->addr
));
4004 printf_filtered (_("Failed to create tracepoint for target's "
4005 "tracepoint %d at %s, skipping it.\n"),
4007 paddress (get_current_arch (), utp
->addr
));
4009 /* Whether found or created, record the number used by the
4010 target, to help with mapping target tracepoints back to their
4011 counterparts here. */
4013 t
->number_on_target
= utp
->number
;
4016 /* Notify 'breakpoint-modified' observer that at least one of B's
4017 locations was changed. */
4018 for (ix
= 0; VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
); ix
++)
4019 observer_notify_breakpoint_modified (b
);
4021 VEC_free (breakpoint_p
, modified_tp
);
4022 free_uploaded_tps (uploaded_tps
);
4025 /* Trace state variables don't have much to identify them beyond their
4026 name, so just use that to detect matches. */
4028 static struct trace_state_variable
*
4029 find_matching_tsv (struct uploaded_tsv
*utsv
)
4034 return find_trace_state_variable (utsv
->name
);
4037 static struct trace_state_variable
*
4038 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
4040 const char *namebase
;
4043 struct trace_state_variable
*tsv
;
4044 struct cleanup
*old_chain
;
4048 namebase
= utsv
->name
;
4049 buf
= xstrprintf ("%s", namebase
);
4054 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
4057 /* Fish for a name that is not in use. */
4058 /* (should check against all internal vars?) */
4059 while (find_trace_state_variable (buf
))
4062 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
4065 old_chain
= make_cleanup (xfree
, buf
);
4067 /* We have an available name, create the variable. */
4068 tsv
= create_trace_state_variable (buf
);
4069 tsv
->initial_value
= utsv
->initial_value
;
4070 tsv
->builtin
= utsv
->builtin
;
4072 observer_notify_tsv_created (tsv
);
4074 do_cleanups (old_chain
);
4079 /* Given a list of uploaded trace state variables, try to match them
4080 up with existing variables, or create additional ones. */
4083 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
4086 struct uploaded_tsv
*utsv
;
4087 struct trace_state_variable
*tsv
;
4090 /* Most likely some numbers will have to be reassigned as part of
4091 the merge, so clear them all in anticipation. */
4092 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4095 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
4097 tsv
= find_matching_tsv (utsv
);
4101 printf_filtered (_("Assuming trace state variable $%s "
4102 "is same as target's variable %d.\n"),
4103 tsv
->name
, utsv
->number
);
4107 tsv
= create_tsv_from_upload (utsv
);
4109 printf_filtered (_("Created trace state variable "
4110 "$%s for target's variable %d.\n"),
4111 tsv
->name
, utsv
->number
);
4113 /* Give precedence to numberings that come from the target. */
4115 tsv
->number
= utsv
->number
;
4118 /* Renumber everything that didn't get a target-assigned number. */
4120 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4121 if (tsv
->number
> highest
)
4122 highest
= tsv
->number
;
4125 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4126 if (tsv
->number
== 0)
4127 tsv
->number
= highest
++;
4129 free_uploaded_tsvs (uploaded_tsvs
);
4132 /* target tfile command */
4134 static struct target_ops tfile_ops
;
4136 /* Fill in tfile_ops with its defined operations and properties. */
4138 #define TRACE_HEADER_SIZE 8
4140 static char *trace_filename
;
4141 static int trace_fd
= -1;
4142 static off_t trace_frames_offset
;
4143 static off_t cur_offset
;
4144 static int cur_data_size
;
4145 int trace_regblock_size
;
4147 static void tfile_interp_line (char *line
,
4148 struct uploaded_tp
**utpp
,
4149 struct uploaded_tsv
**utsvp
);
4151 /* Read SIZE bytes into READBUF from the trace frame, starting at
4152 TRACE_FD's current position. Note that this call `read'
4153 underneath, hence it advances the file's seek position. Throws an
4154 error if the `read' syscall fails, or less than SIZE bytes are
4158 tfile_read (gdb_byte
*readbuf
, int size
)
4162 gotten
= read (trace_fd
, readbuf
, size
);
4164 perror_with_name (trace_filename
);
4165 else if (gotten
< size
)
4166 error (_("Premature end of file while reading trace file"));
4170 tfile_open (char *filename
, int from_tty
)
4172 volatile struct gdb_exception ex
;
4174 struct cleanup
*old_chain
;
4177 char header
[TRACE_HEADER_SIZE
];
4178 char linebuf
[1000]; /* Should be max remote packet size or so. */
4181 struct trace_status
*ts
;
4182 struct uploaded_tp
*uploaded_tps
= NULL
;
4183 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4185 target_preopen (from_tty
);
4187 error (_("No trace file specified."));
4189 filename
= tilde_expand (filename
);
4190 if (!IS_ABSOLUTE_PATH(filename
))
4192 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
4197 old_chain
= make_cleanup (xfree
, filename
);
4199 flags
= O_BINARY
| O_LARGEFILE
;
4201 scratch_chan
= open (filename
, flags
, 0);
4202 if (scratch_chan
< 0)
4203 perror_with_name (filename
);
4205 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
4207 discard_cleanups (old_chain
); /* Don't free filename any more. */
4208 unpush_target (&tfile_ops
);
4210 trace_filename
= xstrdup (filename
);
4211 trace_fd
= scratch_chan
;
4214 /* Read the file header and test for validity. */
4215 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
4217 bytes
+= TRACE_HEADER_SIZE
;
4218 if (!(header
[0] == 0x7f
4219 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
4220 error (_("File is not a valid trace file."));
4222 push_target (&tfile_ops
);
4224 trace_regblock_size
= 0;
4225 ts
= current_trace_status ();
4226 /* We know we're working with a file. Record its name. */
4227 ts
->filename
= trace_filename
;
4228 /* Set defaults in case there is no status line. */
4229 ts
->running_known
= 0;
4230 ts
->stop_reason
= trace_stop_reason_unknown
;
4231 ts
->traceframe_count
= -1;
4232 ts
->buffer_free
= 0;
4233 ts
->disconnected_tracing
= 0;
4234 ts
->circular_buffer
= 0;
4236 TRY_CATCH (ex
, RETURN_MASK_ALL
)
4238 /* Read through a section of newline-terminated lines that
4239 define things like tracepoints. */
4243 tfile_read (&byte
, 1);
4248 /* Empty line marks end of the definition section. */
4253 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
4256 linebuf
[i
++] = byte
;
4258 error (_("Excessively long lines in trace file"));
4261 /* Record the starting offset of the binary trace data. */
4262 trace_frames_offset
= bytes
;
4264 /* If we don't have a blocksize, we can't interpret the
4266 if (trace_regblock_size
== 0)
4267 error (_("No register block size recorded in trace file"));
4271 /* Pop the partially set up target. */
4273 throw_exception (ex
);
4276 inferior_appeared (current_inferior (), TFILE_PID
);
4277 inferior_ptid
= pid_to_ptid (TFILE_PID
);
4278 add_thread_silent (inferior_ptid
);
4280 if (ts
->traceframe_count
<= 0)
4281 warning (_("No traceframes present in this file."));
4283 /* Add the file's tracepoints and variables into the current mix. */
4285 /* Get trace state variables first, they may be checked when parsing
4286 uploaded commands. */
4287 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4289 merge_uploaded_tracepoints (&uploaded_tps
);
4291 post_create_inferior (&tfile_ops
, from_tty
);
4294 /* Interpret the given line from the definitions part of the trace
4298 tfile_interp_line (char *line
, struct uploaded_tp
**utpp
,
4299 struct uploaded_tsv
**utsvp
)
4303 if (strncmp (p
, "R ", strlen ("R ")) == 0)
4306 trace_regblock_size
= strtol (p
, &p
, 16);
4308 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
4310 p
+= strlen ("status ");
4311 parse_trace_status (p
, current_trace_status ());
4313 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
4315 p
+= strlen ("tp ");
4316 parse_tracepoint_definition (p
, utpp
);
4318 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
4320 p
+= strlen ("tsv ");
4321 parse_tsv_definition (p
, utsvp
);
4324 warning (_("Ignoring trace file definition \"%s\""), line
);
4327 /* Parse the part of trace status syntax that is shared between
4328 the remote protocol and the trace file reader. */
4331 parse_trace_status (char *line
, struct trace_status
*ts
)
4333 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
4337 ts
->running_known
= 1;
4338 ts
->running
= (*p
++ == '1');
4339 ts
->stop_reason
= trace_stop_reason_unknown
;
4340 xfree (ts
->stop_desc
);
4341 ts
->stop_desc
= NULL
;
4342 ts
->traceframe_count
= -1;
4343 ts
->traceframes_created
= -1;
4344 ts
->buffer_free
= -1;
4345 ts
->buffer_size
= -1;
4346 ts
->disconnected_tracing
= 0;
4347 ts
->circular_buffer
= 0;
4348 xfree (ts
->user_name
);
4349 ts
->user_name
= NULL
;
4352 ts
->start_time
= ts
->stop_time
= 0;
4356 p1
= strchr (p
, ':');
4358 error (_("Malformed trace status, at %s\n\
4359 Status line: '%s'\n"), p
, line
);
4360 p3
= strchr (p
, ';');
4362 p3
= p
+ strlen (p
);
4363 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
4365 p
= unpack_varlen_hex (++p1
, &val
);
4366 ts
->stop_reason
= trace_buffer_full
;
4368 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
4370 p
= unpack_varlen_hex (++p1
, &val
);
4371 ts
->stop_reason
= trace_never_run
;
4373 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
4376 p
= unpack_varlen_hex (++p1
, &val
);
4377 ts
->stop_reason
= tracepoint_passcount
;
4378 ts
->stopping_tracepoint
= val
;
4380 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
4382 p2
= strchr (++p1
, ':');
4390 ts
->stop_desc
= xmalloc (strlen (line
));
4391 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
4392 ts
->stop_desc
[end
] = '\0';
4395 ts
->stop_desc
= xstrdup ("");
4397 p
= unpack_varlen_hex (++p2
, &val
);
4398 ts
->stop_reason
= tstop_command
;
4400 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
4402 p
= unpack_varlen_hex (++p1
, &val
);
4403 ts
->stop_reason
= trace_disconnected
;
4405 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
4407 p2
= strchr (++p1
, ':');
4410 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
4411 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
4412 ts
->stop_desc
[end
] = '\0';
4415 ts
->stop_desc
= xstrdup ("");
4417 p
= unpack_varlen_hex (++p2
, &val
);
4418 ts
->stopping_tracepoint
= val
;
4419 ts
->stop_reason
= tracepoint_error
;
4421 else if (strncmp (p
, "tframes", p1
- p
) == 0)
4423 p
= unpack_varlen_hex (++p1
, &val
);
4424 ts
->traceframe_count
= val
;
4426 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
4428 p
= unpack_varlen_hex (++p1
, &val
);
4429 ts
->traceframes_created
= val
;
4431 else if (strncmp (p
, "tfree", p1
- p
) == 0)
4433 p
= unpack_varlen_hex (++p1
, &val
);
4434 ts
->buffer_free
= val
;
4436 else if (strncmp (p
, "tsize", p1
- p
) == 0)
4438 p
= unpack_varlen_hex (++p1
, &val
);
4439 ts
->buffer_size
= val
;
4441 else if (strncmp (p
, "disconn", p1
- p
) == 0)
4443 p
= unpack_varlen_hex (++p1
, &val
);
4444 ts
->disconnected_tracing
= val
;
4446 else if (strncmp (p
, "circular", p1
- p
) == 0)
4448 p
= unpack_varlen_hex (++p1
, &val
);
4449 ts
->circular_buffer
= val
;
4451 else if (strncmp (p
, "starttime", p1
- p
) == 0)
4453 p
= unpack_varlen_hex (++p1
, &val
);
4454 ts
->start_time
= val
;
4456 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
4458 p
= unpack_varlen_hex (++p1
, &val
);
4459 ts
->stop_time
= val
;
4461 else if (strncmp (p
, "username", p1
- p
) == 0)
4464 ts
->user_name
= xmalloc (strlen (p
) / 2);
4465 end
= hex2bin (p1
, (gdb_byte
*) ts
->user_name
, (p3
- p1
) / 2);
4466 ts
->user_name
[end
] = '\0';
4469 else if (strncmp (p
, "notes", p1
- p
) == 0)
4472 ts
->notes
= xmalloc (strlen (p
) / 2);
4473 end
= hex2bin (p1
, (gdb_byte
*) ts
->notes
, (p3
- p1
) / 2);
4474 ts
->notes
[end
] = '\0';
4479 /* Silently skip unknown optional info. */
4480 p_temp
= strchr (p1
+ 1, ';');
4484 /* Must be at the end. */
4491 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
4492 struct uploaded_tp
*utp
)
4495 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
4497 p
= unpack_varlen_hex (p
, &uval
);
4499 tp
->base
.hit_count
+= uval
;
4501 utp
->hit_count
+= uval
;
4502 p
= unpack_varlen_hex (p
+ 1, &uval
);
4504 tp
->traceframe_usage
+= uval
;
4506 utp
->traceframe_usage
+= uval
;
4507 /* Ignore any extra, allowing for future extensions. */
4510 /* Given a line of text defining a part of a tracepoint, parse it into
4511 an "uploaded tracepoint". */
4514 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
4518 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
4521 char *cond
, *srctype
, *buf
;
4522 struct uploaded_tp
*utp
= NULL
;
4525 /* Both tracepoint and action definitions start with the same number
4526 and address sequence. */
4528 p
= unpack_varlen_hex (p
, &num
);
4529 p
++; /* skip a colon */
4530 p
= unpack_varlen_hex (p
, &addr
);
4531 p
++; /* skip a colon */
4534 enabled
= (*p
++ == 'E');
4535 p
++; /* skip a colon */
4536 p
= unpack_varlen_hex (p
, &step
);
4537 p
++; /* skip a colon */
4538 p
= unpack_varlen_hex (p
, &pass
);
4539 type
= bp_tracepoint
;
4541 /* Thumb through optional fields. */
4544 p
++; /* skip a colon */
4547 type
= bp_fast_tracepoint
;
4549 p
= unpack_varlen_hex (p
, &orig_size
);
4553 type
= bp_static_tracepoint
;
4559 p
= unpack_varlen_hex (p
, &xlen
);
4560 p
++; /* skip a comma */
4561 cond
= (char *) xmalloc (2 * xlen
+ 1);
4562 strncpy (cond
, p
, 2 * xlen
);
4563 cond
[2 * xlen
] = '\0';
4567 warning (_("Unrecognized char '%c' in tracepoint "
4568 "definition, skipping rest"), *p
);
4570 utp
= get_uploaded_tp (num
, addr
, utpp
);
4572 utp
->enabled
= enabled
;
4577 else if (piece
== 'A')
4579 utp
= get_uploaded_tp (num
, addr
, utpp
);
4580 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
4582 else if (piece
== 'S')
4584 utp
= get_uploaded_tp (num
, addr
, utpp
);
4585 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
4587 else if (piece
== 'Z')
4589 /* Parse a chunk of source form definition. */
4590 utp
= get_uploaded_tp (num
, addr
, utpp
);
4592 p
= strchr (p
, ':');
4593 p
++; /* skip a colon */
4594 p
= unpack_varlen_hex (p
, &start
);
4595 p
++; /* skip a colon */
4596 p
= unpack_varlen_hex (p
, &xlen
);
4597 p
++; /* skip a colon */
4599 buf
= alloca (strlen (line
));
4601 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4604 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
4605 utp
->at_string
= xstrdup (buf
);
4606 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
4607 utp
->cond_string
= xstrdup (buf
);
4608 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
4609 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
4611 else if (piece
== 'V')
4613 utp
= get_uploaded_tp (num
, addr
, utpp
);
4615 parse_tracepoint_status (p
, NULL
, utp
);
4619 /* Don't error out, the target might be sending us optional
4620 info that we don't care about. */
4621 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
4625 /* Convert a textual description of a trace state variable into an
4629 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
4632 ULONGEST num
, initval
, builtin
;
4634 struct uploaded_tsv
*utsv
= NULL
;
4636 buf
= alloca (strlen (line
));
4639 p
= unpack_varlen_hex (p
, &num
);
4640 p
++; /* skip a colon */
4641 p
= unpack_varlen_hex (p
, &initval
);
4642 p
++; /* skip a colon */
4643 p
= unpack_varlen_hex (p
, &builtin
);
4644 p
++; /* skip a colon */
4645 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4648 utsv
= get_uploaded_tsv (num
, utsvp
);
4649 utsv
->initial_value
= initval
;
4650 utsv
->builtin
= builtin
;
4651 utsv
->name
= xstrdup (buf
);
4654 /* Close the trace file and generally clean up. */
4664 pid
= ptid_get_pid (inferior_ptid
);
4665 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff. */
4666 exit_inferior_silent (pid
);
4670 xfree (trace_filename
);
4671 trace_filename
= NULL
;
4675 tfile_files_info (struct target_ops
*t
)
4677 printf_filtered ("\t`%s'\n", trace_filename
);
4680 /* The trace status for a file is that tracing can never be run. */
4683 tfile_get_trace_status (struct trace_status
*ts
)
4685 /* Other bits of trace status were collected as part of opening the
4686 trace files, so nothing to do here. */
4692 tfile_get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
4694 /* Other bits of trace status were collected as part of opening the
4695 trace files, so nothing to do here. */
4698 /* Given the position of a traceframe in the file, figure out what
4699 address the frame was collected at. This would normally be the
4700 value of a collected PC register, but if not available, we
4704 tfile_get_traceframe_address (off_t tframe_offset
)
4708 struct tracepoint
*tp
;
4709 off_t saved_offset
= cur_offset
;
4711 /* FIXME dig pc out of collected registers. */
4713 /* Fall back to using tracepoint address. */
4714 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
4715 tfile_read ((gdb_byte
*) &tpnum
, 2);
4716 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4718 (target_gdbarch ()));
4720 tp
= get_tracepoint_by_number_on_target (tpnum
);
4721 /* FIXME this is a poor heuristic if multiple locations. */
4722 if (tp
&& tp
->base
.loc
)
4723 addr
= tp
->base
.loc
->address
;
4725 /* Restore our seek position. */
4726 cur_offset
= saved_offset
;
4727 lseek (trace_fd
, cur_offset
, SEEK_SET
);
4731 /* Given a type of search and some parameters, scan the collection of
4732 traceframes in the file looking for a match. When found, return
4733 both the traceframe and tracepoint number, otherwise -1 for
4737 tfile_trace_find (enum trace_find_type type
, int num
,
4738 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
)
4741 int tfnum
= 0, found
= 0;
4742 unsigned int data_size
;
4743 struct tracepoint
*tp
;
4744 off_t offset
, tframe_offset
;
4754 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
4755 offset
= trace_frames_offset
;
4758 tframe_offset
= offset
;
4759 tfile_read ((gdb_byte
*) &tpnum
, 2);
4760 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4762 (target_gdbarch ()));
4766 tfile_read ((gdb_byte
*) &data_size
, 4);
4767 data_size
= (unsigned int) extract_unsigned_integer
4768 ((gdb_byte
*) &data_size
, 4,
4769 gdbarch_byte_order (target_gdbarch ()));
4772 if (type
== tfind_number
)
4774 /* Looking for a specific trace frame. */
4780 /* Start from the _next_ trace frame. */
4781 if (tfnum
> traceframe_number
)
4786 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4787 if (tfaddr
== addr1
)
4791 tp
= get_tracepoint (num
);
4792 if (tp
&& tpnum
== tp
->number_on_target
)
4796 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4797 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
4801 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4802 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
4806 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
4815 cur_offset
= offset
;
4816 cur_data_size
= data_size
;
4820 /* Skip past the traceframe's data. */
4821 lseek (trace_fd
, data_size
, SEEK_CUR
);
4822 offset
+= data_size
;
4823 /* Update our own count of traceframes. */
4826 /* Did not find what we were looking for. */
4832 /* Prototype of the callback passed to tframe_walk_blocks. */
4833 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
4835 /* Callback for traceframe_walk_blocks, used to find a given block
4836 type in a traceframe. */
4839 match_blocktype (char blocktype
, void *data
)
4841 char *wantedp
= data
;
4843 if (*wantedp
== blocktype
)
4849 /* Walk over all traceframe block starting at POS offset from
4850 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4851 unmodified. If CALLBACK returns true, this returns the position in
4852 the traceframe where the block is found, relative to the start of
4853 the traceframe (cur_offset). Returns -1 if no callback call
4854 returned true, indicating that all blocks have been walked. */
4857 traceframe_walk_blocks (walk_blocks_callback_func callback
,
4858 int pos
, void *data
)
4860 /* Iterate through a traceframe's blocks, looking for a block of the
4863 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
4864 while (pos
< cur_data_size
)
4866 unsigned short mlen
;
4869 tfile_read ((gdb_byte
*) &block_type
, 1);
4873 if ((*callback
) (block_type
, data
))
4879 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4880 pos
+= trace_regblock_size
;
4883 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4884 tfile_read ((gdb_byte
*) &mlen
, 2);
4885 mlen
= (unsigned short)
4886 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4888 (target_gdbarch ()));
4889 lseek (trace_fd
, mlen
, SEEK_CUR
);
4890 pos
+= (8 + 2 + mlen
);
4893 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
4897 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4898 block_type
, block_type
);
4906 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4907 position offset of a block of type TYPE_WANTED in the current trace
4908 frame, starting at POS. Returns -1 if no such block was found. */
4911 traceframe_find_block_type (char type_wanted
, int pos
)
4913 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
4916 /* Look for a block of saved registers in the traceframe, and get the
4917 requested register from it. */
4920 tfile_fetch_registers (struct target_ops
*ops
,
4921 struct regcache
*regcache
, int regno
)
4923 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4924 int offset
, regn
, regsize
, pc_regno
;
4927 /* An uninitialized reg size says we're not going to be
4928 successful at getting register blocks. */
4929 if (!trace_regblock_size
)
4932 regs
= alloca (trace_regblock_size
);
4934 if (traceframe_find_block_type ('R', 0) >= 0)
4936 tfile_read (regs
, trace_regblock_size
);
4938 /* Assume the block is laid out in GDB register number order,
4939 each register with the size that it has in GDB. */
4941 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4943 regsize
= register_size (gdbarch
, regn
);
4944 /* Make sure we stay within block bounds. */
4945 if (offset
+ regsize
>= trace_regblock_size
)
4947 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
4951 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
4954 else if (regno
== -1)
4956 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
4964 /* We get here if no register data has been found. Mark registers
4966 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4967 regcache_raw_supply (regcache
, regn
, NULL
);
4969 /* We can often usefully guess that the PC is going to be the same
4970 as the address of the tracepoint. */
4971 pc_regno
= gdbarch_pc_regnum (gdbarch
);
4972 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
4974 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
4976 if (tp
&& tp
->base
.loc
)
4978 /* But don't try to guess if tracepoint is multi-location... */
4979 if (tp
->base
.loc
->next
)
4981 warning (_("Tracepoint %d has multiple "
4982 "locations, cannot infer $pc"),
4986 /* ... or does while-stepping. */
4987 if (tp
->step_count
> 0)
4989 warning (_("Tracepoint %d does while-stepping, "
4990 "cannot infer $pc"),
4995 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
4996 gdbarch_byte_order (gdbarch
),
4997 tp
->base
.loc
->address
);
4998 regcache_raw_supply (regcache
, pc_regno
, regs
);
5004 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5005 const char *annex
, gdb_byte
*readbuf
,
5006 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5008 /* We're only doing regular memory for now. */
5009 if (object
!= TARGET_OBJECT_MEMORY
)
5012 if (readbuf
== NULL
)
5013 error (_("tfile_xfer_partial: trace file is read-only"));
5015 if (traceframe_number
!= -1)
5019 /* Iterate through the traceframe's blocks, looking for
5021 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
5023 ULONGEST maddr
, amt
;
5024 unsigned short mlen
;
5025 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
5027 tfile_read ((gdb_byte
*) &maddr
, 8);
5028 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
5030 tfile_read ((gdb_byte
*) &mlen
, 2);
5031 mlen
= (unsigned short)
5032 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
5034 /* If the block includes the first part of the desired
5035 range, return as much it has; GDB will re-request the
5036 remainder, which might be in a different block of this
5038 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
5040 amt
= (maddr
+ mlen
) - offset
;
5044 if (maddr
!= offset
)
5045 lseek (trace_fd
, offset
- maddr
, SEEK_CUR
);
5046 tfile_read (readbuf
, amt
);
5050 /* Skip over this block. */
5051 pos
+= (8 + 2 + mlen
);
5055 /* It's unduly pedantic to refuse to look at the executable for
5056 read-only pieces; so do the equivalent of readonly regions aka
5058 /* FIXME account for relocation at some point. */
5065 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5067 if ((s
->flags
& SEC_LOAD
) == 0
5068 || (s
->flags
& SEC_READONLY
) == 0)
5072 size
= bfd_get_section_size (s
);
5073 if (vma
<= offset
&& offset
< (vma
+ size
))
5077 amt
= (vma
+ size
) - offset
;
5081 amt
= bfd_get_section_contents (exec_bfd
, s
,
5082 readbuf
, offset
- vma
, amt
);
5088 /* Indicate failure to find the requested memory block. */
5092 /* Iterate through the blocks of a trace frame, looking for a 'V'
5093 block with a matching tsv number. */
5096 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
5101 /* Iterate over blocks in current frame and find the last 'V'
5102 block in which tsv number is TSVNUM. In one trace frame, there
5103 may be multiple 'V' blocks created for a given trace variable,
5104 and the last matched 'V' block contains the updated value. */
5106 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
5110 tfile_read ((gdb_byte
*) &vnum
, 4);
5111 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
5113 (target_gdbarch ()));
5116 tfile_read ((gdb_byte
*) val
, 8);
5117 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
5119 (target_gdbarch ()));
5129 tfile_has_all_memory (struct target_ops
*ops
)
5135 tfile_has_memory (struct target_ops
*ops
)
5141 tfile_has_stack (struct target_ops
*ops
)
5143 return traceframe_number
!= -1;
5147 tfile_has_registers (struct target_ops
*ops
)
5149 return traceframe_number
!= -1;
5153 tfile_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
5158 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
5159 object for the tfile target's current traceframe. */
5162 build_traceframe_info (char blocktype
, void *data
)
5164 struct traceframe_info
*info
= data
;
5170 struct mem_range
*r
;
5172 unsigned short mlen
;
5174 tfile_read ((gdb_byte
*) &maddr
, 8);
5175 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
5177 (target_gdbarch ()));
5178 tfile_read ((gdb_byte
*) &mlen
, 2);
5179 mlen
= (unsigned short)
5180 extract_unsigned_integer ((gdb_byte
*) &mlen
,
5181 2, gdbarch_byte_order
5182 (target_gdbarch ()));
5184 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5197 warning (_("Unhandled trace block type (%d) '%c ' "
5198 "while building trace frame info."),
5199 blocktype
, blocktype
);
5206 static struct traceframe_info
*
5207 tfile_traceframe_info (void)
5209 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
5211 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
5216 init_tfile_ops (void)
5218 tfile_ops
.to_shortname
= "tfile";
5219 tfile_ops
.to_longname
= "Local trace dump file";
5221 = "Use a trace file as a target. Specify the filename of the trace file.";
5222 tfile_ops
.to_open
= tfile_open
;
5223 tfile_ops
.to_close
= tfile_close
;
5224 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
5225 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
5226 tfile_ops
.to_files_info
= tfile_files_info
;
5227 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
5228 tfile_ops
.to_get_tracepoint_status
= tfile_get_tracepoint_status
;
5229 tfile_ops
.to_trace_find
= tfile_trace_find
;
5230 tfile_ops
.to_get_trace_state_variable_value
5231 = tfile_get_trace_state_variable_value
;
5232 tfile_ops
.to_stratum
= process_stratum
;
5233 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
5234 tfile_ops
.to_has_memory
= tfile_has_memory
;
5235 tfile_ops
.to_has_stack
= tfile_has_stack
;
5236 tfile_ops
.to_has_registers
= tfile_has_registers
;
5237 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
5238 tfile_ops
.to_thread_alive
= tfile_thread_alive
;
5239 tfile_ops
.to_magic
= OPS_MAGIC
;
5243 free_current_marker (void *arg
)
5245 struct static_tracepoint_marker
**marker_p
= arg
;
5247 if (*marker_p
!= NULL
)
5249 release_static_tracepoint_marker (*marker_p
);
5256 /* Given a line of text defining a static tracepoint marker, parse it
5257 into a "static tracepoint marker" object. Throws an error is
5258 parsing fails. If PP is non-null, it points to one past the end of
5259 the parsed marker definition. */
5262 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
5263 struct static_tracepoint_marker
*marker
)
5270 p
= unpack_varlen_hex (p
, &addr
);
5271 p
++; /* skip a colon */
5273 marker
->gdbarch
= target_gdbarch ();
5274 marker
->address
= (CORE_ADDR
) addr
;
5276 endp
= strchr (p
, ':');
5278 error (_("bad marker definition: %s"), line
);
5280 marker
->str_id
= xmalloc (endp
- p
+ 1);
5281 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
5282 marker
->str_id
[end
] = '\0';
5285 p
++; /* skip a colon */
5287 marker
->extra
= xmalloc (strlen (p
) + 1);
5288 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
5289 marker
->extra
[end
] = '\0';
5295 /* Release a static tracepoint marker's contents. Note that the
5296 object itself isn't released here. There objects are usually on
5300 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
5302 xfree (marker
->str_id
);
5303 marker
->str_id
= NULL
;
5306 /* Print MARKER to gdb_stdout. */
5309 print_one_static_tracepoint_marker (int count
,
5310 struct static_tracepoint_marker
*marker
)
5312 struct command_line
*l
;
5315 char wrap_indent
[80];
5316 char extra_field_indent
[80];
5317 struct ui_out
*uiout
= current_uiout
;
5318 struct cleanup
*bkpt_chain
;
5319 VEC(breakpoint_p
) *tracepoints
;
5321 struct symtab_and_line sal
;
5325 sal
.pc
= marker
->address
;
5327 tracepoints
= static_tracepoints_here (marker
->address
);
5329 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
5331 /* A counter field to help readability. This is not a stable
5333 ui_out_field_int (uiout
, "count", count
);
5335 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
5337 ui_out_field_fmt (uiout
, "enabled", "%c",
5338 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
5339 ui_out_spaces (uiout
, 2);
5341 strcpy (wrap_indent
, " ");
5343 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
5344 strcat (wrap_indent
, " ");
5346 strcat (wrap_indent
, " ");
5348 strcpy (extra_field_indent
, " ");
5350 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
5352 sal
= find_pc_line (marker
->address
, 0);
5353 sym
= find_pc_sect_function (marker
->address
, NULL
);
5356 ui_out_text (uiout
, "in ");
5357 ui_out_field_string (uiout
, "func",
5358 SYMBOL_PRINT_NAME (sym
));
5359 ui_out_wrap_hint (uiout
, wrap_indent
);
5360 ui_out_text (uiout
, " at ");
5363 ui_out_field_skip (uiout
, "func");
5365 if (sal
.symtab
!= NULL
)
5367 ui_out_field_string (uiout
, "file",
5368 symtab_to_filename_for_display (sal
.symtab
));
5369 ui_out_text (uiout
, ":");
5371 if (ui_out_is_mi_like_p (uiout
))
5373 const char *fullname
= symtab_to_fullname (sal
.symtab
);
5375 ui_out_field_string (uiout
, "fullname", fullname
);
5378 ui_out_field_skip (uiout
, "fullname");
5380 ui_out_field_int (uiout
, "line", sal
.line
);
5384 ui_out_field_skip (uiout
, "fullname");
5385 ui_out_field_skip (uiout
, "line");
5388 ui_out_text (uiout
, "\n");
5389 ui_out_text (uiout
, extra_field_indent
);
5390 ui_out_text (uiout
, _("Data: \""));
5391 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
5392 ui_out_text (uiout
, "\"\n");
5394 if (!VEC_empty (breakpoint_p
, tracepoints
))
5396 struct cleanup
*cleanup_chain
;
5398 struct breakpoint
*b
;
5400 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
5403 ui_out_text (uiout
, extra_field_indent
);
5404 ui_out_text (uiout
, _("Probed by static tracepoints: "));
5405 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
5408 ui_out_text (uiout
, ", ");
5409 ui_out_text (uiout
, "#");
5410 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
5413 do_cleanups (cleanup_chain
);
5415 if (ui_out_is_mi_like_p (uiout
))
5416 ui_out_field_int (uiout
, "number-of-tracepoints",
5417 VEC_length(breakpoint_p
, tracepoints
));
5419 ui_out_text (uiout
, "\n");
5421 VEC_free (breakpoint_p
, tracepoints
);
5423 do_cleanups (bkpt_chain
);
5427 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
5429 VEC(static_tracepoint_marker_p
) *markers
;
5430 struct cleanup
*old_chain
;
5431 struct static_tracepoint_marker
*marker
;
5432 struct ui_out
*uiout
= current_uiout
;
5435 /* We don't have to check target_can_use_agent and agent's capability on
5436 static tracepoint here, in order to be compatible with older GDBserver.
5437 We don't check USE_AGENT is true or not, because static tracepoints
5438 don't work without in-process agent, so we don't bother users to type
5439 `set agent on' when to use static tracepoint. */
5442 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
5443 "StaticTracepointMarkersTable");
5445 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
5447 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
5449 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
5450 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
5451 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
5453 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
5454 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
5456 ui_out_table_body (uiout
);
5458 markers
= target_static_tracepoint_markers_by_strid (NULL
);
5459 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
5462 VEC_iterate (static_tracepoint_marker_p
,
5463 markers
, i
, marker
);
5466 print_one_static_tracepoint_marker (i
+ 1, marker
);
5467 release_static_tracepoint_marker (marker
);
5470 do_cleanups (old_chain
);
5473 /* The $_sdata convenience variable is a bit special. We don't know
5474 for sure type of the value until we actually have a chance to fetch
5475 the data --- the size of the object depends on what has been
5476 collected. We solve this by making $_sdata be an internalvar that
5477 creates a new value on access. */
5479 /* Return a new value with the correct type for the sdata object of
5480 the current trace frame. Return a void value if there's no object
5483 static struct value
*
5484 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
5490 /* We need to read the whole object before we know its size. */
5491 size
= target_read_alloc (¤t_target
,
5492 TARGET_OBJECT_STATIC_TRACE_DATA
,
5499 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
5501 v
= allocate_value (type
);
5502 memcpy (value_contents_raw (v
), buf
, size
);
5507 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
5510 #if !defined(HAVE_LIBEXPAT)
5512 struct traceframe_info
*
5513 parse_traceframe_info (const char *tframe_info
)
5515 static int have_warned
;
5520 warning (_("Can not parse XML trace frame info; XML support "
5521 "was disabled at compile time"));
5527 #else /* HAVE_LIBEXPAT */
5529 #include "xml-support.h"
5531 /* Handle the start of a <memory> element. */
5534 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
5535 const struct gdb_xml_element
*element
,
5536 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
5538 struct traceframe_info
*info
= user_data
;
5539 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5540 ULONGEST
*start_p
, *length_p
;
5542 start_p
= xml_find_attribute (attributes
, "start")->value
;
5543 length_p
= xml_find_attribute (attributes
, "length")->value
;
5545 r
->start
= *start_p
;
5546 r
->length
= *length_p
;
5549 /* Discard the constructed trace frame info (if an error occurs). */
5552 free_result (void *p
)
5554 struct traceframe_info
*result
= p
;
5556 free_traceframe_info (result
);
5559 /* The allowed elements and attributes for an XML memory map. */
5561 static const struct gdb_xml_attribute memory_attributes
[] = {
5562 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5563 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5564 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5567 static const struct gdb_xml_element traceframe_info_children
[] = {
5568 { "memory", memory_attributes
, NULL
,
5569 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5570 traceframe_info_start_memory
, NULL
},
5571 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5574 static const struct gdb_xml_element traceframe_info_elements
[] = {
5575 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
5577 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5580 /* Parse a traceframe-info XML document. */
5582 struct traceframe_info
*
5583 parse_traceframe_info (const char *tframe_info
)
5585 struct traceframe_info
*result
;
5586 struct cleanup
*back_to
;
5588 result
= XCNEW (struct traceframe_info
);
5589 back_to
= make_cleanup (free_result
, result
);
5591 if (gdb_xml_parse_quick (_("trace frame info"),
5592 "traceframe-info.dtd", traceframe_info_elements
,
5593 tframe_info
, result
) == 0)
5595 /* Parsed successfully, keep the result. */
5596 discard_cleanups (back_to
);
5601 do_cleanups (back_to
);
5605 #endif /* HAVE_LIBEXPAT */
5607 /* Returns the traceframe_info object for the current traceframe.
5608 This is where we avoid re-fetching the object from the target if we
5609 already have it cached. */
5611 static struct traceframe_info
*
5612 get_traceframe_info (void)
5614 if (traceframe_info
== NULL
)
5615 traceframe_info
= target_traceframe_info ();
5617 return traceframe_info
;
5620 /* If the target supports the query, return in RESULT the set of
5621 collected memory in the current traceframe, found within the LEN
5622 bytes range starting at MEMADDR. Returns true if the target
5623 supports the query, otherwise returns false, and RESULT is left
5627 traceframe_available_memory (VEC(mem_range_s
) **result
,
5628 CORE_ADDR memaddr
, ULONGEST len
)
5630 struct traceframe_info
*info
= get_traceframe_info ();
5634 struct mem_range
*r
;
5639 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
5640 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
5642 ULONGEST lo1
, hi1
, lo2
, hi2
;
5643 struct mem_range
*nr
;
5646 hi1
= memaddr
+ len
;
5649 hi2
= r
->start
+ r
->length
;
5651 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
5653 nr
->start
= max (lo1
, lo2
);
5654 nr
->length
= min (hi1
, hi2
) - nr
->start
;
5657 normalize_mem_ranges (*result
);
5664 /* Implementation of `sdata' variable. */
5666 static const struct internalvar_funcs sdata_funcs
=
5673 /* module initialization */
5675 _initialize_tracepoint (void)
5677 struct cmd_list_element
*c
;
5679 /* Explicitly create without lookup, since that tries to create a
5680 value with a void typed value, and when we get here, gdbarch
5681 isn't initialized yet. At this point, we're quite sure there
5682 isn't another convenience variable of the same name. */
5683 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
5685 traceframe_number
= -1;
5686 tracepoint_number
= -1;
5688 if (tracepoint_list
.list
== NULL
)
5690 tracepoint_list
.listsize
= 128;
5691 tracepoint_list
.list
= xmalloc
5692 (tracepoint_list
.listsize
* sizeof (struct memrange
));
5694 if (tracepoint_list
.aexpr_list
== NULL
)
5696 tracepoint_list
.aexpr_listsize
= 128;
5697 tracepoint_list
.aexpr_list
= xmalloc
5698 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5701 if (stepping_list
.list
== NULL
)
5703 stepping_list
.listsize
= 128;
5704 stepping_list
.list
= xmalloc
5705 (stepping_list
.listsize
* sizeof (struct memrange
));
5708 if (stepping_list
.aexpr_list
== NULL
)
5710 stepping_list
.aexpr_listsize
= 128;
5711 stepping_list
.aexpr_list
= xmalloc
5712 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5715 add_info ("scope", scope_info
,
5716 _("List the variables local to a scope"));
5718 add_cmd ("tracepoints", class_trace
, NULL
,
5719 _("Tracing of program execution without stopping the program."),
5722 add_com ("tdump", class_trace
, trace_dump_command
,
5723 _("Print everything collected at the current tracepoint."));
5725 add_com ("tsave", class_trace
, trace_save_command
, _("\
5726 Save the trace data to a file.\n\
5727 Use the '-ctf' option to save the data to CTF format.\n\
5728 Use the '-r' option to direct the target to save directly to the file,\n\
5729 using its own filesystem."));
5731 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
5732 Define a trace state variable.\n\
5733 Argument is a $-prefixed name, optionally followed\n\
5734 by '=' and an expression that sets the initial value\n\
5735 at the start of tracing."));
5736 set_cmd_completer (c
, expression_completer
);
5738 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
5739 Delete one or more trace state variables.\n\
5740 Arguments are the names of the variables to delete.\n\
5741 If no arguments are supplied, delete all variables."), &deletelist
);
5742 /* FIXME add a trace variable completer. */
5744 add_info ("tvariables", tvariables_info
, _("\
5745 Status of trace state variables and their values.\n\
5748 add_info ("static-tracepoint-markers",
5749 info_static_tracepoint_markers_command
, _("\
5750 List target static tracepoints markers.\n\
5753 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
5754 Select a trace frame;\n\
5755 No argument means forward by one frame; '-' means backward by one frame."),
5756 &tfindlist
, "tfind ", 1, &cmdlist
);
5758 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
5759 Select a trace frame whose PC is outside the given range (exclusive).\n\
5760 Usage: tfind outside addr1, addr2"),
5763 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
5764 Select a trace frame whose PC is in the given range (inclusive).\n\
5765 Usage: tfind range addr1,addr2"),
5768 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
5769 Select a trace frame by source line.\n\
5770 Argument can be a line number (with optional source file),\n\
5771 a function name, or '*' followed by an address.\n\
5772 Default argument is 'the next source line that was traced'."),
5775 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
5776 Select a trace frame by tracepoint number.\n\
5777 Default is the tracepoint for the current trace frame."),
5780 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
5781 Select a trace frame by PC.\n\
5782 Default is the current PC, or the PC of the current trace frame."),
5785 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
5786 De-select any trace frame and resume 'live' debugging."),
5789 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
5791 add_cmd ("start", class_trace
, trace_find_start_command
,
5792 _("Select the first trace frame in the trace buffer."),
5795 add_com ("tstatus", class_trace
, trace_status_command
,
5796 _("Display the status of the current trace data collection."));
5798 add_com ("tstop", class_trace
, trace_stop_command
, _("\
5799 Stop trace data collection.\n\
5800 Usage: tstop [ <notes> ... ]\n\
5801 Any arguments supplied are recorded with the trace as a stop reason and\n\
5802 reported by tstatus (if the target supports trace notes)."));
5804 add_com ("tstart", class_trace
, trace_start_command
, _("\
5805 Start trace data collection.\n\
5806 Usage: tstart [ <notes> ... ]\n\
5807 Any arguments supplied are recorded with the trace as a note and\n\
5808 reported by tstatus (if the target supports trace notes)."));
5810 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
5811 Ends a list of commands or actions.\n\
5812 Several GDB commands allow you to enter a list of commands or actions.\n\
5813 Entering \"end\" on a line by itself is the normal way to terminate\n\
5815 Note: the \"end\" command cannot be used at the gdb prompt."));
5817 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
5818 Specify single-stepping behavior at a tracepoint.\n\
5819 Argument is number of instructions to trace in single-step mode\n\
5820 following the tracepoint. This command is normally followed by\n\
5821 one or more \"collect\" commands, to specify what to collect\n\
5822 while single-stepping.\n\n\
5823 Note: this command can only be used in a tracepoint \"actions\" list."));
5825 add_com_alias ("ws", "while-stepping", class_alias
, 0);
5826 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
5828 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
5829 Specify one or more data items to be collected at a tracepoint.\n\
5830 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5831 collect all data (variables, registers) referenced by that expression.\n\
5832 Also accepts the following special arguments:\n\
5833 $regs -- all registers.\n\
5834 $args -- all function arguments.\n\
5835 $locals -- all variables local to the block/function scope.\n\
5836 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5837 Note: this command can only be used in a tracepoint \"actions\" list."));
5839 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
5840 Specify one or more expressions to be evaluated at a tracepoint.\n\
5841 Accepts a comma-separated list of (one or more) expressions.\n\
5842 The result of each evaluation will be discarded.\n\
5843 Note: this command can only be used in a tracepoint \"actions\" list."));
5845 add_com ("actions", class_trace
, trace_actions_command
, _("\
5846 Specify the actions to be taken at a tracepoint.\n\
5847 Tracepoint actions may include collecting of specified data,\n\
5848 single-stepping, or enabling/disabling other tracepoints,\n\
5849 depending on target's capabilities."));
5851 default_collect
= xstrdup ("");
5852 add_setshow_string_cmd ("default-collect", class_trace
,
5853 &default_collect
, _("\
5854 Set the list of expressions to collect by default"), _("\
5855 Show the list of expressions to collect by default"), NULL
,
5857 &setlist
, &showlist
);
5859 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
5860 &disconnected_tracing
, _("\
5861 Set whether tracing continues after GDB disconnects."), _("\
5862 Show whether tracing continues after GDB disconnects."), _("\
5863 Use this to continue a tracing run even if GDB disconnects\n\
5864 or detaches from the target. You can reconnect later and look at\n\
5865 trace data collected in the meantime."),
5866 set_disconnected_tracing
,
5871 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
5872 &circular_trace_buffer
, _("\
5873 Set target's use of circular trace buffer."), _("\
5874 Show target's use of circular trace buffer."), _("\
5875 Use this to make the trace buffer into a circular buffer,\n\
5876 which will discard traceframes (oldest first) instead of filling\n\
5877 up and stopping the trace run."),
5878 set_circular_trace_buffer
,
5883 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class
,
5884 &trace_buffer_size
, _("\
5885 Set requested size of trace buffer."), _("\
5886 Show requested size of trace buffer."), _("\
5887 Use this to choose a size for the trace buffer. Some targets\n\
5888 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
5889 disables any attempt to set the buffer size and lets the target choose."),
5890 set_trace_buffer_size
, NULL
,
5891 &setlist
, &showlist
);
5893 add_setshow_string_cmd ("trace-user", class_trace
,
5895 Set the user name to use for current and future trace runs"), _("\
5896 Show the user name to use for current and future trace runs"), NULL
,
5897 set_trace_user
, NULL
,
5898 &setlist
, &showlist
);
5900 add_setshow_string_cmd ("trace-notes", class_trace
,
5902 Set notes string to use for current and future trace runs"), _("\
5903 Show the notes string to use for current and future trace runs"), NULL
,
5904 set_trace_notes
, NULL
,
5905 &setlist
, &showlist
);
5907 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
5908 &trace_stop_notes
, _("\
5909 Set notes string to use for future tstop commands"), _("\
5910 Show the notes string to use for future tstop commands"), NULL
,
5911 set_trace_stop_notes
, NULL
,
5912 &setlist
, &showlist
);
5916 add_target_with_completer (&tfile_ops
, filename_completer
);