1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
25 #include "expression.h"
30 #include "gdb_string.h"
32 #include "breakpoint.h"
33 #include "tracepoint.h"
36 #include "completer.h"
38 #include "dictionary.h"
40 #include "user-regs.h"
44 #include "filenames.h"
45 #include "gdbthread.h"
53 #include "exceptions.h"
54 #include "cli/cli-utils.h"
57 #include "completer.h"
58 #include "filestuff.h"
60 /* readline include files */
61 #include "readline/readline.h"
62 #include "readline/history.h"
64 /* readline defines this. */
75 /* Maximum length of an agent aexpression.
76 This accounts for the fact that packets are limited to 400 bytes
77 (which includes everything -- including the checksum), and assumes
78 the worst case of maximum length for each of the pieces of a
81 NOTE: expressions get mem2hex'ed otherwise this would be twice as
82 large. (400 - 31)/2 == 184 */
83 #define MAX_AGENT_EXPR_LEN 184
87 /* A hook used to notify the UI of tracepoint operations. */
89 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
90 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
92 extern void (*deprecated_readline_begin_hook
) (char *, ...);
93 extern char *(*deprecated_readline_hook
) (char *);
94 extern void (*deprecated_readline_end_hook
) (void);
99 This module defines the following debugger commands:
100 trace : set a tracepoint on a function, line, or address.
101 info trace : list all debugger-defined tracepoints.
102 delete trace : delete one or more tracepoints.
103 enable trace : enable one or more tracepoints.
104 disable trace : disable one or more tracepoints.
105 actions : specify actions to be taken at a tracepoint.
106 passcount : specify a pass count for a tracepoint.
107 tstart : start a trace experiment.
108 tstop : stop a trace experiment.
109 tstatus : query the status of a trace experiment.
110 tfind : find a trace frame in the trace buffer.
111 tdump : print everything collected at the current tracepoint.
112 save-tracepoints : write tracepoint setup into a file.
114 This module defines the following user-visible debugger variables:
115 $trace_frame : sequence number of trace frame currently being debugged.
116 $trace_line : source line of trace frame currently being debugged.
117 $trace_file : source file of trace frame currently being debugged.
118 $tracepoint : tracepoint number of trace frame currently being debugged.
122 /* ======= Important global variables: ======= */
124 /* The list of all trace state variables. We don't retain pointers to
125 any of these for any reason - API is by name or number only - so it
126 works to have a vector of objects. */
128 typedef struct trace_state_variable tsv_s
;
131 static VEC(tsv_s
) *tvariables
;
133 /* The next integer to assign to a variable. */
135 static int next_tsv_number
= 1;
137 /* Number of last traceframe collected. */
138 static int traceframe_number
;
140 /* Tracepoint for last traceframe collected. */
141 static int tracepoint_number
;
143 /* Symbol for function for last traceframe collected. */
144 static struct symbol
*traceframe_fun
;
146 /* Symtab and line for last traceframe collected. */
147 static struct symtab_and_line traceframe_sal
;
149 /* The traceframe info of the current traceframe. NULL if we haven't
150 yet attempted to fetch it, or if the target does not support
151 fetching this object, or if we're not inspecting a traceframe
153 static struct traceframe_info
*traceframe_info
;
155 /* Tracing command lists. */
156 static struct cmd_list_element
*tfindlist
;
158 /* List of expressions to collect by default at each tracepoint hit. */
159 char *default_collect
= "";
161 static int disconnected_tracing
;
163 /* This variable controls whether we ask the target for a linear or
164 circular trace buffer. */
166 static int circular_trace_buffer
;
168 /* This variable is the requested trace buffer size, or -1 to indicate
169 that we don't care and leave it up to the target to set a size. */
171 static int trace_buffer_size
= -1;
173 /* Textual notes applying to the current and/or future trace runs. */
175 char *trace_user
= NULL
;
177 /* Textual notes applying to the current and/or future trace runs. */
179 char *trace_notes
= NULL
;
181 /* Textual notes applying to the stopping of a trace. */
183 char *trace_stop_notes
= NULL
;
185 /* ======= Important command functions: ======= */
186 static void trace_actions_command (char *, int);
187 static void trace_start_command (char *, int);
188 static void trace_stop_command (char *, int);
189 static void trace_status_command (char *, int);
190 static void trace_find_command (char *, int);
191 static void trace_find_pc_command (char *, int);
192 static void trace_find_tracepoint_command (char *, int);
193 static void trace_find_line_command (char *, int);
194 static void trace_find_range_command (char *, int);
195 static void trace_find_outside_command (char *, int);
196 static void trace_dump_command (char *, int);
198 /* support routines */
200 struct collection_list
;
201 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
202 static char *mem2hex (gdb_byte
*, char *, int);
203 static void add_register (struct collection_list
*collection
,
206 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
207 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
210 extern void _initialize_tracepoint (void);
212 static struct trace_status trace_status
;
214 char *stop_reason_names
[] = {
224 struct trace_status
*
225 current_trace_status (void)
227 return &trace_status
;
233 free_traceframe_info (struct traceframe_info
*info
)
237 VEC_free (mem_range_s
, info
->memory
);
243 /* Free and clear the traceframe info cache of the current
247 clear_traceframe_info (void)
249 free_traceframe_info (traceframe_info
);
250 traceframe_info
= NULL
;
253 /* Set traceframe number to NUM. */
255 set_traceframe_num (int num
)
257 traceframe_number
= num
;
258 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
261 /* Set tracepoint number to NUM. */
263 set_tracepoint_num (int num
)
265 tracepoint_number
= num
;
266 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
269 /* Set externally visible debug variables for querying/printing
270 the traceframe context (line, function, file). */
273 set_traceframe_context (struct frame_info
*trace_frame
)
277 /* Save as globals for internal use. */
278 if (trace_frame
!= NULL
279 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
281 traceframe_sal
= find_pc_line (trace_pc
, 0);
282 traceframe_fun
= find_pc_function (trace_pc
);
284 /* Save linenumber as "$trace_line", a debugger variable visible to
286 set_internalvar_integer (lookup_internalvar ("trace_line"),
287 traceframe_sal
.line
);
291 init_sal (&traceframe_sal
);
292 traceframe_fun
= NULL
;
293 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
296 /* Save func name as "$trace_func", a debugger variable visible to
298 if (traceframe_fun
== NULL
299 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
300 clear_internalvar (lookup_internalvar ("trace_func"));
302 set_internalvar_string (lookup_internalvar ("trace_func"),
303 SYMBOL_LINKAGE_NAME (traceframe_fun
));
305 /* Save file name as "$trace_file", a debugger variable visible to
307 if (traceframe_sal
.symtab
== NULL
)
308 clear_internalvar (lookup_internalvar ("trace_file"));
310 set_internalvar_string (lookup_internalvar ("trace_file"),
311 symtab_to_filename_for_display (traceframe_sal
.symtab
));
314 /* Create a new trace state variable with the given name. */
316 struct trace_state_variable
*
317 create_trace_state_variable (const char *name
)
319 struct trace_state_variable tsv
;
321 memset (&tsv
, 0, sizeof (tsv
));
322 tsv
.name
= xstrdup (name
);
323 tsv
.number
= next_tsv_number
++;
324 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
327 /* Look for a trace state variable of the given name. */
329 struct trace_state_variable
*
330 find_trace_state_variable (const char *name
)
332 struct trace_state_variable
*tsv
;
335 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
336 if (strcmp (name
, tsv
->name
) == 0)
343 delete_trace_state_variable (const char *name
)
345 struct trace_state_variable
*tsv
;
348 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
349 if (strcmp (name
, tsv
->name
) == 0)
351 observer_notify_tsv_deleted (tsv
);
353 xfree ((void *)tsv
->name
);
354 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
359 warning (_("No trace variable named \"$%s\", not deleting"), name
);
362 /* Throws an error if NAME is not valid syntax for a trace state
366 validate_trace_state_variable_name (const char *name
)
371 error (_("Must supply a non-empty variable name"));
373 /* All digits in the name is reserved for value history
375 for (p
= name
; isdigit (*p
); p
++)
378 error (_("$%s is not a valid trace state variable name"), name
);
380 for (p
= name
; isalnum (*p
) || *p
== '_'; p
++)
383 error (_("$%s is not a valid trace state variable name"), name
);
386 /* The 'tvariable' command collects a name and optional expression to
387 evaluate into an initial value. */
390 trace_variable_command (char *args
, int from_tty
)
392 struct cleanup
*old_chain
;
394 struct trace_state_variable
*tsv
;
398 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
400 /* Only allow two syntaxes; "$name" and "$name=value". */
401 p
= skip_spaces (args
);
404 error (_("Name of trace variable should start with '$'"));
407 while (isalnum (*p
) || *p
== '_')
409 name
= savestring (name
, p
- name
);
410 old_chain
= make_cleanup (xfree
, name
);
413 if (*p
!= '=' && *p
!= '\0')
414 error (_("Syntax must be $NAME [ = EXPR ]"));
416 validate_trace_state_variable_name (name
);
419 initval
= value_as_long (parse_and_eval (++p
));
421 /* If the variable already exists, just change its initial value. */
422 tsv
= find_trace_state_variable (name
);
425 if (tsv
->initial_value
!= initval
)
427 tsv
->initial_value
= initval
;
428 observer_notify_tsv_modified (tsv
);
430 printf_filtered (_("Trace state variable $%s "
431 "now has initial value %s.\n"),
432 tsv
->name
, plongest (tsv
->initial_value
));
433 do_cleanups (old_chain
);
437 /* Create a new variable. */
438 tsv
= create_trace_state_variable (name
);
439 tsv
->initial_value
= initval
;
441 observer_notify_tsv_created (tsv
);
443 printf_filtered (_("Trace state variable $%s "
444 "created, with initial value %s.\n"),
445 tsv
->name
, plongest (tsv
->initial_value
));
447 do_cleanups (old_chain
);
451 delete_trace_variable_command (char *args
, int from_tty
)
455 struct cleanup
*back_to
;
459 if (query (_("Delete all trace state variables? ")))
460 VEC_free (tsv_s
, tvariables
);
462 observer_notify_tsv_deleted (NULL
);
466 argv
= gdb_buildargv (args
);
467 back_to
= make_cleanup_freeargv (argv
);
469 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
471 if (*argv
[ix
] == '$')
472 delete_trace_state_variable (argv
[ix
] + 1);
474 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
477 do_cleanups (back_to
);
483 tvariables_info_1 (void)
485 struct trace_state_variable
*tsv
;
488 struct cleanup
*back_to
;
489 struct ui_out
*uiout
= current_uiout
;
491 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
493 printf_filtered (_("No trace state variables.\n"));
497 /* Try to acquire values from the target. */
498 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
499 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
502 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
503 count
, "trace-variables");
504 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
505 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
506 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
508 ui_out_table_body (uiout
);
510 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
512 struct cleanup
*back_to2
;
516 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
518 name
= concat ("$", tsv
->name
, (char *) NULL
);
519 make_cleanup (xfree
, name
);
520 ui_out_field_string (uiout
, "name", name
);
521 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
523 if (tsv
->value_known
)
524 c
= plongest (tsv
->value
);
525 else if (ui_out_is_mi_like_p (uiout
))
526 /* For MI, we prefer not to use magic string constants, but rather
527 omit the field completely. The difference between unknown and
528 undefined does not seem important enough to represent. */
530 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
531 /* The value is/was defined, but we don't have it. */
534 /* It is not meaningful to ask about the value. */
537 ui_out_field_string (uiout
, "current", c
);
538 ui_out_text (uiout
, "\n");
540 do_cleanups (back_to2
);
543 do_cleanups (back_to
);
546 /* List all the trace state variables. */
549 tvariables_info (char *args
, int from_tty
)
551 tvariables_info_1 ();
554 /* Stash definitions of tsvs into the given file. */
557 save_trace_state_variables (struct ui_file
*fp
)
559 struct trace_state_variable
*tsv
;
562 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
564 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
565 if (tsv
->initial_value
)
566 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
567 fprintf_unfiltered (fp
, "\n");
571 /* ACTIONS functions: */
573 /* The three functions:
574 collect_pseudocommand,
575 while_stepping_pseudocommand, and
576 end_actions_pseudocommand
577 are placeholders for "commands" that are actually ONLY to be used
578 within a tracepoint action list. If the actual function is ever called,
579 it means that somebody issued the "command" at the top level,
580 which is always an error. */
583 end_actions_pseudocommand (char *args
, int from_tty
)
585 error (_("This command cannot be used at the top level."));
589 while_stepping_pseudocommand (char *args
, int from_tty
)
591 error (_("This command can only be used in a tracepoint actions list."));
595 collect_pseudocommand (char *args
, int from_tty
)
597 error (_("This command can only be used in a tracepoint actions list."));
601 teval_pseudocommand (char *args
, int from_tty
)
603 error (_("This command can only be used in a tracepoint actions list."));
606 /* Parse any collection options, such as /s for strings. */
609 decode_agent_options (const char *exp
, int *trace_string
)
611 struct value_print_options opts
;
618 /* Call this to borrow the print elements default for collection
620 get_user_print_options (&opts
);
625 if (target_supports_string_tracing ())
627 /* Allow an optional decimal number giving an explicit maximum
628 string length, defaulting it to the "print elements" value;
629 so "collect/s80 mystr" gets at most 80 bytes of string. */
630 *trace_string
= opts
.print_max
;
632 if (*exp
>= '0' && *exp
<= '9')
633 *trace_string
= atoi (exp
);
634 while (*exp
>= '0' && *exp
<= '9')
638 error (_("Target does not support \"/s\" option for string tracing."));
641 error (_("Undefined collection format \"%c\"."), *exp
);
643 exp
= skip_spaces_const (exp
);
648 /* Enter a list of actions for a tracepoint. */
650 trace_actions_command (char *args
, int from_tty
)
652 struct tracepoint
*t
;
653 struct command_line
*l
;
655 t
= get_tracepoint_by_number (&args
, NULL
, 1);
659 xstrprintf ("Enter actions for tracepoint %d, one per line.",
661 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
663 l
= read_command_lines (tmpbuf
, from_tty
, 1,
664 check_tracepoint_command
, t
);
665 do_cleanups (cleanups
);
666 breakpoint_set_commands (&t
->base
, l
);
668 /* else just return */
671 /* Report the results of checking the agent expression, as errors or
675 report_agent_reqs_errors (struct agent_expr
*aexpr
)
677 /* All of the "flaws" are serious bytecode generation issues that
678 should never occur. */
679 if (aexpr
->flaw
!= agent_flaw_none
)
680 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
682 /* If analysis shows a stack underflow, GDB must have done something
683 badly wrong in its bytecode generation. */
684 if (aexpr
->min_height
< 0)
685 internal_error (__FILE__
, __LINE__
,
686 _("expression has min height < 0"));
688 /* Issue this error if the stack is predicted to get too deep. The
689 limit is rather arbitrary; a better scheme might be for the
690 target to report how much stack it will have available. The
691 depth roughly corresponds to parenthesization, so a limit of 20
692 amounts to 20 levels of expression nesting, which is actually
693 a pretty big hairy expression. */
694 if (aexpr
->max_height
> 20)
695 error (_("Expression is too complicated."));
698 /* worker function */
700 validate_actionline (const char *line
, struct breakpoint
*b
)
702 struct cmd_list_element
*c
;
703 struct expression
*exp
= NULL
;
704 struct cleanup
*old_chain
= NULL
;
707 struct bp_location
*loc
;
708 struct agent_expr
*aexpr
;
709 struct tracepoint
*t
= (struct tracepoint
*) b
;
711 /* If EOF is typed, *line is NULL. */
715 p
= skip_spaces_const (line
);
717 /* Symbol lookup etc. */
718 if (*p
== '\0') /* empty line: just prompt for another line. */
721 if (*p
== '#') /* comment line */
724 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
726 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
728 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
730 int trace_string
= 0;
733 p
= decode_agent_options (p
, &trace_string
);
736 { /* Repeat over a comma-separated list. */
737 QUIT
; /* Allow user to bail out with ^C. */
738 p
= skip_spaces_const (p
);
740 if (*p
== '$') /* Look for special pseudo-symbols. */
742 if (0 == strncasecmp ("reg", p
+ 1, 3)
743 || 0 == strncasecmp ("arg", p
+ 1, 3)
744 || 0 == strncasecmp ("loc", p
+ 1, 3)
745 || 0 == strncasecmp ("_ret", p
+ 1, 4)
746 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
751 /* else fall thru, treat p as an expression and parse it! */
754 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
757 exp
= parse_exp_1 (&p
, loc
->address
,
758 block_for_pc (loc
->address
), 1);
759 old_chain
= make_cleanup (free_current_contents
, &exp
);
761 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
763 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
765 error (_("constant `%s' (value %s) "
766 "will not be collected."),
767 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
768 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
770 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
771 == LOC_OPTIMIZED_OUT
)
773 error (_("`%s' is optimized away "
774 "and cannot be collected."),
775 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
779 /* We have something to collect, make sure that the expr to
780 bytecode translator can handle it and that it's not too
782 aexpr
= gen_trace_for_expr (loc
->address
, exp
, trace_string
);
783 make_cleanup_free_agent_expr (aexpr
);
785 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
786 error (_("Expression is too complicated."));
790 report_agent_reqs_errors (aexpr
);
792 do_cleanups (old_chain
);
795 while (p
&& *p
++ == ',');
798 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
801 { /* Repeat over a comma-separated list. */
802 QUIT
; /* Allow user to bail out with ^C. */
803 p
= skip_spaces_const (p
);
806 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
810 /* Only expressions are allowed for this action. */
811 exp
= parse_exp_1 (&p
, loc
->address
,
812 block_for_pc (loc
->address
), 1);
813 old_chain
= make_cleanup (free_current_contents
, &exp
);
815 /* We have something to evaluate, make sure that the expr to
816 bytecode translator can handle it and that it's not too
818 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
819 make_cleanup_free_agent_expr (aexpr
);
821 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
822 error (_("Expression is too complicated."));
825 report_agent_reqs_errors (aexpr
);
827 do_cleanups (old_chain
);
830 while (p
&& *p
++ == ',');
833 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
837 p
= skip_spaces_const (p
);
838 t
->step_count
= strtol (p
, &endp
, 0);
839 if (endp
== p
|| t
->step_count
== 0)
840 error (_("while-stepping step count `%s' is malformed."), line
);
844 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
848 error (_("`%s' is not a supported tracepoint action."), line
);
852 memrange_absolute
= -1
857 int type
; /* memrange_absolute for absolute memory range,
858 else basereg number. */
859 bfd_signed_vma start
;
863 struct collection_list
865 unsigned char regs_mask
[32]; /* room for up to 256 regs */
868 struct memrange
*list
;
869 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
871 struct agent_expr
**aexpr_list
;
873 /* True is the user requested a collection of "$_sdata", "static
877 tracepoint_list
, stepping_list
;
879 /* MEMRANGE functions: */
881 static int memrange_cmp (const void *, const void *);
883 /* Compare memranges for qsort. */
885 memrange_cmp (const void *va
, const void *vb
)
887 const struct memrange
*a
= va
, *b
= vb
;
889 if (a
->type
< b
->type
)
891 if (a
->type
> b
->type
)
893 if (a
->type
== memrange_absolute
)
895 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
897 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
902 if (a
->start
< b
->start
)
904 if (a
->start
> b
->start
)
910 /* Sort the memrange list using qsort, and merge adjacent memranges. */
912 memrange_sortmerge (struct collection_list
*memranges
)
916 qsort (memranges
->list
, memranges
->next_memrange
,
917 sizeof (struct memrange
), memrange_cmp
);
918 if (memranges
->next_memrange
> 0)
920 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
922 /* If memrange b overlaps or is adjacent to memrange a,
924 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
925 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
927 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
928 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
929 continue; /* next b, same a */
933 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
934 sizeof (struct memrange
));
936 memranges
->next_memrange
= a
+ 1;
940 /* Add a register to a collection list. */
942 add_register (struct collection_list
*collection
, unsigned int regno
)
945 printf_filtered ("collect register %d\n", regno
);
946 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
947 error (_("Internal: register number %d too large for tracepoint"),
949 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
952 /* Add a memrange to a collection list. */
954 add_memrange (struct collection_list
*memranges
,
955 int type
, bfd_signed_vma base
,
960 printf_filtered ("(%d,", type
);
962 printf_filtered (",%ld)\n", len
);
965 /* type: memrange_absolute == memory, other n == basereg */
966 memranges
->list
[memranges
->next_memrange
].type
= type
;
967 /* base: addr if memory, offset if reg relative. */
968 memranges
->list
[memranges
->next_memrange
].start
= base
;
969 /* len: we actually save end (base + len) for convenience */
970 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
971 memranges
->next_memrange
++;
972 if (memranges
->next_memrange
>= memranges
->listsize
)
974 memranges
->listsize
*= 2;
975 memranges
->list
= xrealloc (memranges
->list
,
976 memranges
->listsize
);
979 if (type
!= memrange_absolute
) /* Better collect the base register! */
980 add_register (memranges
, type
);
983 /* Add a symbol to a collection list. */
985 collect_symbol (struct collection_list
*collect
,
987 struct gdbarch
*gdbarch
,
988 long frame_regno
, long frame_offset
,
994 bfd_signed_vma offset
;
995 int treat_as_expr
= 0;
997 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
998 switch (SYMBOL_CLASS (sym
))
1001 printf_filtered ("%s: don't know symbol class %d\n",
1002 SYMBOL_PRINT_NAME (sym
),
1003 SYMBOL_CLASS (sym
));
1006 printf_filtered ("constant %s (value %s) will not be collected.\n",
1007 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
1010 offset
= SYMBOL_VALUE_ADDRESS (sym
);
1015 sprintf_vma (tmp
, offset
);
1016 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1017 SYMBOL_PRINT_NAME (sym
), len
,
1020 /* A struct may be a C++ class with static fields, go to general
1021 expression handling. */
1022 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
1025 add_memrange (collect
, memrange_absolute
, offset
, len
);
1028 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1030 printf_filtered ("LOC_REG[parm] %s: ",
1031 SYMBOL_PRINT_NAME (sym
));
1032 add_register (collect
, reg
);
1033 /* Check for doubles stored in two registers. */
1034 /* FIXME: how about larger types stored in 3 or more regs? */
1035 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1036 len
> register_size (gdbarch
, reg
))
1037 add_register (collect
, reg
+ 1);
1040 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1041 printf_filtered (" (will not collect %s)\n",
1042 SYMBOL_PRINT_NAME (sym
));
1046 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1049 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1050 SYMBOL_PRINT_NAME (sym
), len
);
1051 printf_vma (offset
);
1052 printf_filtered (" from frame ptr reg %d\n", reg
);
1054 add_memrange (collect
, reg
, offset
, len
);
1056 case LOC_REGPARM_ADDR
:
1057 reg
= SYMBOL_VALUE (sym
);
1061 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1062 SYMBOL_PRINT_NAME (sym
), len
);
1063 printf_vma (offset
);
1064 printf_filtered (" from reg %d\n", reg
);
1066 add_memrange (collect
, reg
, offset
, len
);
1070 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1073 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1074 SYMBOL_PRINT_NAME (sym
), len
);
1075 printf_vma (offset
);
1076 printf_filtered (" from frame ptr reg %d\n", reg
);
1078 add_memrange (collect
, reg
, offset
, len
);
1081 case LOC_UNRESOLVED
:
1085 case LOC_OPTIMIZED_OUT
:
1086 printf_filtered ("%s has been optimized out of existence.\n",
1087 SYMBOL_PRINT_NAME (sym
));
1095 /* Expressions are the most general case. */
1098 struct agent_expr
*aexpr
;
1099 struct cleanup
*old_chain1
= NULL
;
1101 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
, trace_string
);
1103 /* It can happen that the symbol is recorded as a computed
1104 location, but it's been optimized away and doesn't actually
1105 have a location expression. */
1108 printf_filtered ("%s has been optimized out of existence.\n",
1109 SYMBOL_PRINT_NAME (sym
));
1113 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1117 report_agent_reqs_errors (aexpr
);
1119 discard_cleanups (old_chain1
);
1120 add_aexpr (collect
, aexpr
);
1122 /* Take care of the registers. */
1123 if (aexpr
->reg_mask_len
> 0)
1127 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1129 QUIT
; /* Allow user to bail out with ^C. */
1130 if (aexpr
->reg_mask
[ndx1
] != 0)
1132 /* Assume chars have 8 bits. */
1133 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1134 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1135 /* It's used -- record it. */
1136 add_register (collect
, ndx1
* 8 + ndx2
);
1143 /* Data to be passed around in the calls to the locals and args
1146 struct add_local_symbols_data
1148 struct collection_list
*collect
;
1149 struct gdbarch
*gdbarch
;
1157 /* The callback for the locals and args iterators. */
1160 do_collect_symbol (const char *print_name
,
1164 struct add_local_symbols_data
*p
= cb_data
;
1166 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1167 p
->frame_offset
, p
->pc
, p
->trace_string
);
1171 /* Add all locals (or args) symbols to collection list. */
1173 add_local_symbols (struct collection_list
*collect
,
1174 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1175 long frame_regno
, long frame_offset
, int type
,
1178 struct block
*block
;
1179 struct add_local_symbols_data cb_data
;
1181 cb_data
.collect
= collect
;
1182 cb_data
.gdbarch
= gdbarch
;
1184 cb_data
.frame_regno
= frame_regno
;
1185 cb_data
.frame_offset
= frame_offset
;
1187 cb_data
.trace_string
= trace_string
;
1191 block
= block_for_pc (pc
);
1194 warning (_("Can't collect locals; "
1195 "no symbol table info available.\n"));
1199 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1200 if (cb_data
.count
== 0)
1201 warning (_("No locals found in scope."));
1205 pc
= get_pc_function_start (pc
);
1206 block
= block_for_pc (pc
);
1209 warning (_("Can't collect args; no symbol table info available."));
1213 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1214 if (cb_data
.count
== 0)
1215 warning (_("No args found in scope."));
1220 add_static_trace_data (struct collection_list
*collection
)
1223 printf_filtered ("collect static trace data\n");
1224 collection
->strace_data
= 1;
1227 /* worker function */
1229 clear_collection_list (struct collection_list
*list
)
1233 list
->next_memrange
= 0;
1234 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1236 free_agent_expr (list
->aexpr_list
[ndx
]);
1237 list
->aexpr_list
[ndx
] = NULL
;
1239 list
->next_aexpr_elt
= 0;
1240 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1241 list
->strace_data
= 0;
1244 /* Reduce a collection list to string form (for gdb protocol). */
1246 stringify_collection_list (struct collection_list
*list
, char *string
)
1248 char temp_buf
[2048];
1252 char *(*str_list
)[];
1256 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1257 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1259 if (list
->strace_data
)
1262 printf_filtered ("\nCollecting static trace data\n");
1265 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1269 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1270 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1272 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1275 printf_filtered ("\nCollecting registers (mask): 0x");
1280 QUIT
; /* Allow user to bail out with ^C. */
1282 printf_filtered ("%02X", list
->regs_mask
[i
]);
1283 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1286 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1290 printf_filtered ("\n");
1291 if (list
->next_memrange
> 0 && info_verbose
)
1292 printf_filtered ("Collecting memranges: \n");
1293 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1295 QUIT
; /* Allow user to bail out with ^C. */
1296 sprintf_vma (tmp2
, list
->list
[i
].start
);
1299 printf_filtered ("(%d, %s, %ld)\n",
1302 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1304 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1306 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1313 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1315 /* The "%X" conversion specifier expects an unsigned argument,
1316 so passing -1 (memrange_absolute) to it directly gives you
1317 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1319 if (list
->list
[i
].type
== memrange_absolute
)
1320 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1322 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1325 count
+= strlen (end
);
1326 end
= temp_buf
+ count
;
1329 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1331 QUIT
; /* Allow user to bail out with ^C. */
1332 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1334 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1339 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1340 end
+= 10; /* 'X' + 8 hex digits + ',' */
1343 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1344 end
, list
->aexpr_list
[i
]->len
);
1345 count
+= 2 * list
->aexpr_list
[i
]->len
;
1350 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1355 (*str_list
)[ndx
] = NULL
;
1368 encode_actions_1 (struct command_line
*action
,
1369 struct breakpoint
*t
,
1370 struct bp_location
*tloc
,
1372 LONGEST frame_offset
,
1373 struct collection_list
*collect
,
1374 struct collection_list
*stepping_list
)
1376 const char *action_exp
;
1377 struct expression
*exp
= NULL
;
1379 struct value
*tempval
;
1380 struct cmd_list_element
*cmd
;
1381 struct agent_expr
*aexpr
;
1383 for (; action
; action
= action
->next
)
1385 QUIT
; /* Allow user to bail out with ^C. */
1386 action_exp
= action
->line
;
1387 action_exp
= skip_spaces_const (action_exp
);
1389 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1391 error (_("Bad action list item: %s"), action_exp
);
1393 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1395 int trace_string
= 0;
1397 if (*action_exp
== '/')
1398 action_exp
= decode_agent_options (action_exp
, &trace_string
);
1401 { /* Repeat over a comma-separated list. */
1402 QUIT
; /* Allow user to bail out with ^C. */
1403 action_exp
= skip_spaces_const (action_exp
);
1405 if (0 == strncasecmp ("$reg", action_exp
, 4))
1407 for (i
= 0; i
< gdbarch_num_regs (tloc
->gdbarch
); i
++)
1408 add_register (collect
, i
);
1409 action_exp
= strchr (action_exp
, ','); /* more? */
1411 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1413 add_local_symbols (collect
,
1420 action_exp
= strchr (action_exp
, ','); /* more? */
1422 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1424 add_local_symbols (collect
,
1431 action_exp
= strchr (action_exp
, ','); /* more? */
1433 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1435 struct cleanup
*old_chain1
= NULL
;
1437 aexpr
= gen_trace_for_return_address (tloc
->address
,
1441 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1444 report_agent_reqs_errors (aexpr
);
1446 discard_cleanups (old_chain1
);
1447 add_aexpr (collect
, aexpr
);
1449 /* take care of the registers */
1450 if (aexpr
->reg_mask_len
> 0)
1454 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1456 QUIT
; /* allow user to bail out with ^C */
1457 if (aexpr
->reg_mask
[ndx1
] != 0)
1459 /* assume chars have 8 bits */
1460 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1461 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1462 /* it's used -- record it */
1463 add_register (collect
,
1469 action_exp
= strchr (action_exp
, ','); /* more? */
1471 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1473 add_static_trace_data (collect
);
1474 action_exp
= strchr (action_exp
, ','); /* more? */
1479 struct cleanup
*old_chain
= NULL
;
1480 struct cleanup
*old_chain1
= NULL
;
1482 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1483 block_for_pc (tloc
->address
), 1);
1484 old_chain
= make_cleanup (free_current_contents
, &exp
);
1486 switch (exp
->elts
[0].opcode
)
1490 const char *name
= &exp
->elts
[2].string
;
1492 i
= user_reg_map_name_to_regnum (tloc
->gdbarch
,
1493 name
, strlen (name
));
1495 internal_error (__FILE__
, __LINE__
,
1496 _("Register $%s not available"),
1499 printf_filtered ("OP_REGISTER: ");
1500 add_register (collect
, i
);
1505 /* Safe because we know it's a simple expression. */
1506 tempval
= evaluate_expression (exp
);
1507 addr
= value_address (tempval
);
1508 /* Initialize the TYPE_LENGTH if it is a typedef. */
1509 check_typedef (exp
->elts
[1].type
);
1510 add_memrange (collect
, memrange_absolute
, addr
,
1511 TYPE_LENGTH (exp
->elts
[1].type
));
1515 collect_symbol (collect
,
1516 exp
->elts
[2].symbol
,
1524 default: /* Full-fledged expression. */
1525 aexpr
= gen_trace_for_expr (tloc
->address
, exp
,
1528 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1532 report_agent_reqs_errors (aexpr
);
1534 discard_cleanups (old_chain1
);
1535 add_aexpr (collect
, aexpr
);
1537 /* Take care of the registers. */
1538 if (aexpr
->reg_mask_len
> 0)
1543 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1545 QUIT
; /* Allow user to bail out with ^C. */
1546 if (aexpr
->reg_mask
[ndx1
] != 0)
1548 /* Assume chars have 8 bits. */
1549 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1550 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1551 /* It's used -- record it. */
1552 add_register (collect
,
1559 do_cleanups (old_chain
);
1562 while (action_exp
&& *action_exp
++ == ',');
1564 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1567 { /* Repeat over a comma-separated list. */
1568 QUIT
; /* Allow user to bail out with ^C. */
1569 action_exp
= skip_spaces_const (action_exp
);
1572 struct cleanup
*old_chain
= NULL
;
1573 struct cleanup
*old_chain1
= NULL
;
1575 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1576 block_for_pc (tloc
->address
), 1);
1577 old_chain
= make_cleanup (free_current_contents
, &exp
);
1579 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1580 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1583 report_agent_reqs_errors (aexpr
);
1585 discard_cleanups (old_chain1
);
1586 /* Even though we're not officially collecting, add
1587 to the collect list anyway. */
1588 add_aexpr (collect
, aexpr
);
1590 do_cleanups (old_chain
);
1593 while (action_exp
&& *action_exp
++ == ',');
1595 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1597 /* We check against nested while-stepping when setting
1598 breakpoint action, so no way to run into nested
1600 gdb_assert (stepping_list
);
1602 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
,
1603 frame_offset
, stepping_list
, NULL
);
1606 error (_("Invalid tracepoint command '%s'"), action
->line
);
1610 /* Render all actions into gdb protocol. */
1613 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1614 char ***tdp_actions
, char ***stepping_actions
)
1616 static char tdp_buff
[2048], step_buff
[2048];
1617 char *default_collect_line
= NULL
;
1618 struct command_line
*actions
;
1619 struct command_line
*default_collect_action
= NULL
;
1621 LONGEST frame_offset
;
1622 struct cleanup
*back_to
;
1624 back_to
= make_cleanup (null_cleanup
, NULL
);
1626 clear_collection_list (&tracepoint_list
);
1627 clear_collection_list (&stepping_list
);
1629 *tdp_actions
= NULL
;
1630 *stepping_actions
= NULL
;
1632 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1633 tloc
->address
, &frame_reg
, &frame_offset
);
1635 actions
= breakpoint_commands (t
);
1637 /* If there are default expressions to collect, make up a collect
1638 action and prepend to the action list to encode. Note that since
1639 validation is per-tracepoint (local var "xyz" might be valid for
1640 one tracepoint and not another, etc), we make up the action on
1641 the fly, and don't cache it. */
1642 if (*default_collect
)
1644 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1645 make_cleanup (xfree
, default_collect_line
);
1647 validate_actionline (default_collect_line
, t
);
1649 default_collect_action
= xmalloc (sizeof (struct command_line
));
1650 make_cleanup (xfree
, default_collect_action
);
1651 default_collect_action
->next
= actions
;
1652 default_collect_action
->line
= default_collect_line
;
1653 actions
= default_collect_action
;
1655 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1656 &tracepoint_list
, &stepping_list
);
1658 memrange_sortmerge (&tracepoint_list
);
1659 memrange_sortmerge (&stepping_list
);
1661 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1663 *stepping_actions
= stringify_collection_list (&stepping_list
,
1666 do_cleanups (back_to
);
1670 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1672 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1674 collect
->aexpr_list
=
1675 xrealloc (collect
->aexpr_list
,
1676 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1677 collect
->aexpr_listsize
*= 2;
1679 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1680 collect
->next_aexpr_elt
++;
1684 process_tracepoint_on_disconnect (void)
1686 VEC(breakpoint_p
) *tp_vec
= NULL
;
1688 struct breakpoint
*b
;
1689 int has_pending_p
= 0;
1691 /* Check whether we still have pending tracepoint. If we have, warn the
1692 user that pending tracepoint will no longer work. */
1693 tp_vec
= all_tracepoints ();
1694 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1703 struct bp_location
*loc1
;
1705 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1707 if (loc1
->shlib_disabled
)
1718 VEC_free (breakpoint_p
, tp_vec
);
1721 warning (_("Pending tracepoints will not be resolved while"
1722 " GDB is disconnected\n"));
1727 start_tracing (char *notes
)
1729 VEC(breakpoint_p
) *tp_vec
= NULL
;
1731 struct breakpoint
*b
;
1732 struct trace_state_variable
*tsv
;
1733 int any_enabled
= 0, num_to_download
= 0;
1736 tp_vec
= all_tracepoints ();
1738 /* No point in tracing without any tracepoints... */
1739 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1741 VEC_free (breakpoint_p
, tp_vec
);
1742 error (_("No tracepoints defined, not starting trace"));
1745 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1747 struct tracepoint
*t
= (struct tracepoint
*) b
;
1748 struct bp_location
*loc
;
1750 if (b
->enable_state
== bp_enabled
)
1753 if ((b
->type
== bp_fast_tracepoint
1754 ? may_insert_fast_tracepoints
1755 : may_insert_tracepoints
))
1758 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1759 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1764 if (target_supports_enable_disable_tracepoint ())
1765 warning (_("No tracepoints enabled"));
1768 /* No point in tracing with only disabled tracepoints that
1769 cannot be re-enabled. */
1770 VEC_free (breakpoint_p
, tp_vec
);
1771 error (_("No tracepoints enabled, not starting trace"));
1775 if (num_to_download
<= 0)
1777 VEC_free (breakpoint_p
, tp_vec
);
1778 error (_("No tracepoints that may be downloaded, not starting trace"));
1781 target_trace_init ();
1783 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1785 struct tracepoint
*t
= (struct tracepoint
*) b
;
1786 struct bp_location
*loc
;
1787 int bp_location_downloaded
= 0;
1789 /* Clear `inserted' flag. */
1790 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1793 if ((b
->type
== bp_fast_tracepoint
1794 ? !may_insert_fast_tracepoints
1795 : !may_insert_tracepoints
))
1798 t
->number_on_target
= 0;
1800 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1802 /* Since tracepoint locations are never duplicated, `inserted'
1803 flag should be zero. */
1804 gdb_assert (!loc
->inserted
);
1806 target_download_tracepoint (loc
);
1809 bp_location_downloaded
= 1;
1812 t
->number_on_target
= b
->number
;
1814 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1815 if (loc
->probe
!= NULL
)
1816 loc
->probe
->pops
->set_semaphore (loc
->probe
, loc
->gdbarch
);
1818 if (bp_location_downloaded
)
1819 observer_notify_breakpoint_modified (b
);
1821 VEC_free (breakpoint_p
, tp_vec
);
1823 /* Send down all the trace state variables too. */
1824 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1826 target_download_trace_state_variable (tsv
);
1829 /* Tell target to treat text-like sections as transparent. */
1830 target_trace_set_readonly_regions ();
1831 /* Set some mode flags. */
1832 target_set_disconnected_tracing (disconnected_tracing
);
1833 target_set_circular_trace_buffer (circular_trace_buffer
);
1834 target_set_trace_buffer_size (trace_buffer_size
);
1837 notes
= trace_notes
;
1838 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1840 if (!ret
&& (trace_user
|| notes
))
1841 warning (_("Target does not support trace user/notes, info ignored"));
1843 /* Now insert traps and begin collecting data. */
1844 target_trace_start ();
1846 /* Reset our local state. */
1847 set_traceframe_num (-1);
1848 set_tracepoint_num (-1);
1849 set_traceframe_context (NULL
);
1850 current_trace_status()->running
= 1;
1851 clear_traceframe_info ();
1854 /* The tstart command requests the target to start a new trace run.
1855 The command passes any arguments it has to the target verbatim, as
1856 an optional "trace note". This is useful as for instance a warning
1857 to other users if the trace runs disconnected, and you don't want
1858 anybody else messing with the target. */
1861 trace_start_command (char *args
, int from_tty
)
1863 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1865 if (current_trace_status ()->running
)
1868 && !query (_("A trace is running already. Start a new run? ")))
1869 error (_("New trace run not started."));
1872 start_tracing (args
);
1875 /* The tstop command stops the tracing run. The command passes any
1876 supplied arguments to the target verbatim as a "stop note"; if the
1877 target supports trace notes, then it will be reported back as part
1878 of the trace run's status. */
1881 trace_stop_command (char *args
, int from_tty
)
1883 if (!current_trace_status ()->running
)
1884 error (_("Trace is not running."));
1886 stop_tracing (args
);
1890 stop_tracing (char *note
)
1893 VEC(breakpoint_p
) *tp_vec
= NULL
;
1895 struct breakpoint
*t
;
1897 target_trace_stop ();
1899 tp_vec
= all_tracepoints ();
1900 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1902 struct bp_location
*loc
;
1904 if ((t
->type
== bp_fast_tracepoint
1905 ? !may_insert_fast_tracepoints
1906 : !may_insert_tracepoints
))
1909 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1911 /* GDB can be totally absent in some disconnected trace scenarios,
1912 but we don't really care if this semaphore goes out of sync.
1913 That's why we are decrementing it here, but not taking care
1915 if (loc
->probe
!= NULL
)
1916 loc
->probe
->pops
->clear_semaphore (loc
->probe
, loc
->gdbarch
);
1920 VEC_free (breakpoint_p
, tp_vec
);
1923 note
= trace_stop_notes
;
1924 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1927 warning (_("Target does not support trace notes, note ignored"));
1929 /* Should change in response to reply? */
1930 current_trace_status ()->running
= 0;
1933 /* tstatus command */
1935 trace_status_command (char *args
, int from_tty
)
1937 struct trace_status
*ts
= current_trace_status ();
1939 VEC(breakpoint_p
) *tp_vec
= NULL
;
1940 struct breakpoint
*t
;
1942 status
= target_get_trace_status (ts
);
1946 if (ts
->filename
!= NULL
)
1947 printf_filtered (_("Using a trace file.\n"));
1950 printf_filtered (_("Trace can not be run on this target.\n"));
1955 if (!ts
->running_known
)
1957 printf_filtered (_("Run/stop status is unknown.\n"));
1959 else if (ts
->running
)
1961 printf_filtered (_("Trace is running on the target.\n"));
1965 switch (ts
->stop_reason
)
1967 case trace_never_run
:
1968 printf_filtered (_("No trace has been run on the target.\n"));
1972 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1975 printf_filtered (_("Trace stopped by a tstop command.\n"));
1977 case trace_buffer_full
:
1978 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1980 case trace_disconnected
:
1981 printf_filtered (_("Trace stopped because of disconnection.\n"));
1983 case tracepoint_passcount
:
1984 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1985 ts
->stopping_tracepoint
);
1987 case tracepoint_error
:
1988 if (ts
->stopping_tracepoint
)
1989 printf_filtered (_("Trace stopped by an "
1990 "error (%s, tracepoint %d).\n"),
1991 ts
->stop_desc
, ts
->stopping_tracepoint
);
1993 printf_filtered (_("Trace stopped by an error (%s).\n"),
1996 case trace_stop_reason_unknown
:
1997 printf_filtered (_("Trace stopped for an unknown reason.\n"));
2000 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
2006 if (ts
->traceframes_created
>= 0
2007 && ts
->traceframe_count
!= ts
->traceframes_created
)
2009 printf_filtered (_("Buffer contains %d trace "
2010 "frames (of %d created total).\n"),
2011 ts
->traceframe_count
, ts
->traceframes_created
);
2013 else if (ts
->traceframe_count
>= 0)
2015 printf_filtered (_("Collected %d trace frames.\n"),
2016 ts
->traceframe_count
);
2019 if (ts
->buffer_free
>= 0)
2021 if (ts
->buffer_size
>= 0)
2023 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2024 ts
->buffer_free
, ts
->buffer_size
);
2025 if (ts
->buffer_size
> 0)
2026 printf_filtered (_(" (%d%% full)"),
2027 ((int) ((((long long) (ts
->buffer_size
2028 - ts
->buffer_free
)) * 100)
2029 / ts
->buffer_size
)));
2030 printf_filtered (_(".\n"));
2033 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2037 if (ts
->disconnected_tracing
)
2038 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2040 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2042 if (ts
->circular_buffer
)
2043 printf_filtered (_("Trace buffer is circular.\n"));
2045 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
2046 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
2048 if (ts
->notes
&& strlen (ts
->notes
) > 0)
2049 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
2051 /* Now report on what we're doing with tfind. */
2052 if (traceframe_number
>= 0)
2053 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2054 traceframe_number
, tracepoint_number
);
2056 printf_filtered (_("Not looking at any trace frame.\n"));
2058 /* Report start/stop times if supplied. */
2063 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
2065 /* Reporting a run time is more readable than two long numbers. */
2066 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2067 (long int) ts
->start_time
/ 1000000,
2068 (long int) ts
->start_time
% 1000000,
2069 (long int) run_time
/ 1000000,
2070 (long int) run_time
% 1000000);
2073 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2074 (long int) ts
->start_time
/ 1000000,
2075 (long int) ts
->start_time
% 1000000);
2077 else if (ts
->stop_time
)
2078 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2079 (long int) ts
->stop_time
/ 1000000,
2080 (long int) ts
->stop_time
% 1000000);
2082 /* Now report any per-tracepoint status available. */
2083 tp_vec
= all_tracepoints ();
2085 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2086 target_get_tracepoint_status (t
, NULL
);
2088 VEC_free (breakpoint_p
, tp_vec
);
2091 /* Report the trace status to uiout, in a way suitable for MI, and not
2092 suitable for CLI. If ON_STOP is true, suppress a few fields that
2093 are not meaningful in the -trace-stop response.
2095 The implementation is essentially parallel to trace_status_command, but
2096 merging them will result in unreadable code. */
2098 trace_status_mi (int on_stop
)
2100 struct ui_out
*uiout
= current_uiout
;
2101 struct trace_status
*ts
= current_trace_status ();
2104 status
= target_get_trace_status (ts
);
2106 if (status
== -1 && ts
->filename
== NULL
)
2108 ui_out_field_string (uiout
, "supported", "0");
2112 if (ts
->filename
!= NULL
)
2113 ui_out_field_string (uiout
, "supported", "file");
2115 ui_out_field_string (uiout
, "supported", "1");
2117 if (ts
->filename
!= NULL
)
2118 ui_out_field_string (uiout
, "trace-file", ts
->filename
);
2120 gdb_assert (ts
->running_known
);
2124 ui_out_field_string (uiout
, "running", "1");
2126 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2127 Given that the frontend gets the status either on -trace-stop, or from
2128 -trace-status after re-connection, it does not seem like this
2129 information is necessary for anything. It is not necessary for either
2130 figuring the vital state of the target nor for navigation of trace
2131 frames. If the frontend wants to show the current state is some
2132 configure dialog, it can request the value when such dialog is
2133 invoked by the user. */
2137 char *stop_reason
= NULL
;
2138 int stopping_tracepoint
= -1;
2141 ui_out_field_string (uiout
, "running", "0");
2143 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2145 switch (ts
->stop_reason
)
2148 stop_reason
= "request";
2150 case trace_buffer_full
:
2151 stop_reason
= "overflow";
2153 case trace_disconnected
:
2154 stop_reason
= "disconnection";
2156 case tracepoint_passcount
:
2157 stop_reason
= "passcount";
2158 stopping_tracepoint
= ts
->stopping_tracepoint
;
2160 case tracepoint_error
:
2161 stop_reason
= "error";
2162 stopping_tracepoint
= ts
->stopping_tracepoint
;
2168 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2169 if (stopping_tracepoint
!= -1)
2170 ui_out_field_int (uiout
, "stopping-tracepoint",
2171 stopping_tracepoint
);
2172 if (ts
->stop_reason
== tracepoint_error
)
2173 ui_out_field_string (uiout
, "error-description",
2179 if (ts
->traceframe_count
!= -1)
2180 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2181 if (ts
->traceframes_created
!= -1)
2182 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2183 if (ts
->buffer_size
!= -1)
2184 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2185 if (ts
->buffer_free
!= -1)
2186 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2188 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2189 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2191 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2192 ui_out_field_string (uiout
, "notes", ts
->notes
);
2197 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2198 (long int) ts
->start_time
/ 1000000,
2199 (long int) ts
->start_time
% 1000000);
2200 ui_out_field_string (uiout
, "start-time", buf
);
2201 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2202 (long int) ts
->stop_time
/ 1000000,
2203 (long int) ts
->stop_time
% 1000000);
2204 ui_out_field_string (uiout
, "stop-time", buf
);
2208 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2209 user if she really wants to detach. */
2212 query_if_trace_running (int from_tty
)
2217 /* It can happen that the target that was tracing went away on its
2218 own, and we didn't notice. Get a status update, and if the
2219 current target doesn't even do tracing, then assume it's not
2221 if (target_get_trace_status (current_trace_status ()) < 0)
2222 current_trace_status ()->running
= 0;
2224 /* If running interactively, give the user the option to cancel and
2225 then decide what to do differently with the run. Scripts are
2226 just going to disconnect and let the target deal with it,
2227 according to how it's been instructed previously via
2228 disconnected-tracing. */
2229 if (current_trace_status ()->running
)
2231 process_tracepoint_on_disconnect ();
2233 if (current_trace_status ()->disconnected_tracing
)
2235 if (!query (_("Trace is running and will "
2236 "continue after detach; detach anyway? ")))
2237 error (_("Not confirmed."));
2241 if (!query (_("Trace is running but will "
2242 "stop on detach; detach anyway? ")))
2243 error (_("Not confirmed."));
2248 /* This function handles the details of what to do about an ongoing
2249 tracing run if the user has asked to detach or otherwise disconnect
2253 disconnect_tracing (void)
2255 /* Also we want to be out of tfind mode, otherwise things can get
2256 confusing upon reconnection. Just use these calls instead of
2257 full tfind_1 behavior because we're in the middle of detaching,
2258 and there's no point to updating current stack frame etc. */
2259 set_current_traceframe (-1);
2260 set_tracepoint_num (-1);
2261 set_traceframe_context (NULL
);
2264 /* Worker function for the various flavors of the tfind command. */
2266 tfind_1 (enum trace_find_type type
, int num
,
2267 CORE_ADDR addr1
, CORE_ADDR addr2
,
2270 int target_frameno
= -1, target_tracept
= -1;
2271 struct frame_id old_frame_id
= null_frame_id
;
2272 struct tracepoint
*tp
;
2273 struct ui_out
*uiout
= current_uiout
;
2275 /* Only try to get the current stack frame if we have a chance of
2276 succeeding. In particular, if we're trying to get a first trace
2277 frame while all threads are running, it's not going to succeed,
2278 so leave it with a default value and let the frame comparison
2279 below (correctly) decide to print out the source location of the
2281 if (!(type
== tfind_number
&& num
== -1)
2282 && (has_stack_frames () || traceframe_number
>= 0))
2283 old_frame_id
= get_frame_id (get_current_frame ());
2285 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2288 if (type
== tfind_number
2290 && target_frameno
== -1)
2292 /* We told the target to get out of tfind mode, and it did. */
2294 else if (target_frameno
== -1)
2296 /* A request for a non-existent trace frame has failed.
2297 Our response will be different, depending on FROM_TTY:
2299 If FROM_TTY is true, meaning that this command was
2300 typed interactively by the user, then give an error
2301 and DO NOT change the state of traceframe_number etc.
2303 However if FROM_TTY is false, meaning that we're either
2304 in a script, a loop, or a user-defined command, then
2305 DON'T give an error, but DO change the state of
2306 traceframe_number etc. to invalid.
2308 The rationalle is that if you typed the command, you
2309 might just have committed a typo or something, and you'd
2310 like to NOT lose your current debugging state. However
2311 if you're in a user-defined command or especially in a
2312 loop, then you need a way to detect that the command
2313 failed WITHOUT aborting. This allows you to write
2314 scripts that search thru the trace buffer until the end,
2315 and then continue on to do something else. */
2318 error (_("Target failed to find requested trace frame."));
2322 printf_filtered ("End of trace buffer.\n");
2323 #if 0 /* dubious now? */
2324 /* The following will not recurse, since it's
2326 trace_find_command ("-1", from_tty
);
2331 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2333 reinit_frame_cache ();
2334 target_dcache_invalidate ();
2336 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2338 if (target_frameno
!= get_traceframe_number ())
2339 observer_notify_traceframe_changed (target_frameno
, tracepoint_number
);
2341 set_current_traceframe (target_frameno
);
2343 if (target_frameno
== -1)
2344 set_traceframe_context (NULL
);
2346 set_traceframe_context (get_current_frame ());
2348 if (traceframe_number
>= 0)
2350 /* Use different branches for MI and CLI to make CLI messages
2352 if (ui_out_is_mi_like_p (uiout
))
2354 ui_out_field_string (uiout
, "found", "1");
2355 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2356 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2360 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2361 traceframe_number
, tracepoint_number
);
2366 if (ui_out_is_mi_like_p (uiout
))
2367 ui_out_field_string (uiout
, "found", "0");
2368 else if (type
== tfind_number
&& num
== -1)
2369 printf_unfiltered (_("No longer looking at any trace frame\n"));
2370 else /* This case may never occur, check. */
2371 printf_unfiltered (_("No trace frame found\n"));
2374 /* If we're in nonstop mode and getting out of looking at trace
2375 frames, there won't be any current frame to go back to and
2378 && (has_stack_frames () || traceframe_number
>= 0))
2380 enum print_what print_what
;
2382 /* NOTE: in imitation of the step command, try to determine
2383 whether we have made a transition from one function to
2384 another. If so, we'll print the "stack frame" (ie. the new
2385 function and it's arguments) -- otherwise we'll just show the
2388 if (frame_id_eq (old_frame_id
,
2389 get_frame_id (get_current_frame ())))
2390 print_what
= SRC_LINE
;
2392 print_what
= SRC_AND_LOC
;
2394 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2399 /* trace_find_command takes a trace frame number n,
2400 sends "QTFrame:<n>" to the target,
2401 and accepts a reply that may contain several optional pieces
2402 of information: a frame number, a tracepoint number, and an
2403 indication of whether this is a trap frame or a stepping frame.
2405 The minimal response is just "OK" (which indicates that the
2406 target does not give us a frame number or a tracepoint number).
2407 Instead of that, the target may send us a string containing
2409 F<hexnum> (gives the selected frame number)
2410 T<hexnum> (gives the selected tracepoint number)
2415 trace_find_command (char *args
, int from_tty
)
2416 { /* This should only be called with a numeric argument. */
2419 if (current_trace_status ()->running
2420 && current_trace_status ()->filename
== NULL
)
2421 error (_("May not look at trace frames while trace is running."));
2423 if (args
== 0 || *args
== 0)
2424 { /* TFIND with no args means find NEXT trace frame. */
2425 if (traceframe_number
== -1)
2426 frameno
= 0; /* "next" is first one. */
2428 frameno
= traceframe_number
+ 1;
2430 else if (0 == strcmp (args
, "-"))
2432 if (traceframe_number
== -1)
2433 error (_("not debugging trace buffer"));
2434 else if (from_tty
&& traceframe_number
== 0)
2435 error (_("already at start of trace buffer"));
2437 frameno
= traceframe_number
- 1;
2439 /* A hack to work around eval's need for fp to have been collected. */
2440 else if (0 == strcmp (args
, "-1"))
2443 frameno
= parse_and_eval_long (args
);
2446 error (_("invalid input (%d is less than zero)"), frameno
);
2448 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2453 trace_find_end_command (char *args
, int from_tty
)
2455 trace_find_command ("-1", from_tty
);
2460 trace_find_start_command (char *args
, int from_tty
)
2462 trace_find_command ("0", from_tty
);
2465 /* tfind pc command */
2467 trace_find_pc_command (char *args
, int from_tty
)
2471 if (current_trace_status ()->running
2472 && current_trace_status ()->filename
== NULL
)
2473 error (_("May not look at trace frames while trace is running."));
2475 if (args
== 0 || *args
== 0)
2476 pc
= regcache_read_pc (get_current_regcache ());
2478 pc
= parse_and_eval_address (args
);
2480 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2483 /* tfind tracepoint command */
2485 trace_find_tracepoint_command (char *args
, int from_tty
)
2488 struct tracepoint
*tp
;
2490 if (current_trace_status ()->running
2491 && current_trace_status ()->filename
== NULL
)
2492 error (_("May not look at trace frames while trace is running."));
2494 if (args
== 0 || *args
== 0)
2496 if (tracepoint_number
== -1)
2497 error (_("No current tracepoint -- please supply an argument."));
2499 tdp
= tracepoint_number
; /* Default is current TDP. */
2502 tdp
= parse_and_eval_long (args
);
2504 /* If we have the tracepoint on hand, use the number that the
2505 target knows about (which may be different if we disconnected
2506 and reconnected). */
2507 tp
= get_tracepoint (tdp
);
2509 tdp
= tp
->number_on_target
;
2511 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2514 /* TFIND LINE command:
2516 This command will take a sourceline for argument, just like BREAK
2517 or TRACE (ie. anything that "decode_line_1" can handle).
2519 With no argument, this command will find the next trace frame
2520 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2523 trace_find_line_command (char *args
, int from_tty
)
2525 static CORE_ADDR start_pc
, end_pc
;
2526 struct symtabs_and_lines sals
;
2527 struct symtab_and_line sal
;
2528 struct cleanup
*old_chain
;
2530 if (current_trace_status ()->running
2531 && current_trace_status ()->filename
== NULL
)
2532 error (_("May not look at trace frames while trace is running."));
2534 if (args
== 0 || *args
== 0)
2536 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2538 sals
.sals
= (struct symtab_and_line
*)
2539 xmalloc (sizeof (struct symtab_and_line
));
2544 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2548 old_chain
= make_cleanup (xfree
, sals
.sals
);
2549 if (sal
.symtab
== 0)
2550 error (_("No line number information available."));
2552 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2554 if (start_pc
== end_pc
)
2556 printf_filtered ("Line %d of \"%s\"",
2558 symtab_to_filename_for_display (sal
.symtab
));
2560 printf_filtered (" is at address ");
2561 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2563 printf_filtered (" but contains no code.\n");
2564 sal
= find_pc_line (start_pc
, 0);
2566 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2567 && start_pc
!= end_pc
)
2568 printf_filtered ("Attempting to find line %d instead.\n",
2571 error (_("Cannot find a good line."));
2575 /* Is there any case in which we get here, and have an address
2576 which the user would want to see? If we have debugging
2577 symbols and no line numbers? */
2578 error (_("Line number %d is out of range for \"%s\"."),
2579 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2581 /* Find within range of stated line. */
2583 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2585 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2586 do_cleanups (old_chain
);
2589 /* tfind range command */
2591 trace_find_range_command (char *args
, int from_tty
)
2593 static CORE_ADDR start
, stop
;
2596 if (current_trace_status ()->running
2597 && current_trace_status ()->filename
== NULL
)
2598 error (_("May not look at trace frames while trace is running."));
2600 if (args
== 0 || *args
== 0)
2601 { /* XXX FIXME: what should default behavior be? */
2602 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2606 if (0 != (tmp
= strchr (args
, ',')))
2608 *tmp
++ = '\0'; /* Terminate start address. */
2609 tmp
= skip_spaces (tmp
);
2610 start
= parse_and_eval_address (args
);
2611 stop
= parse_and_eval_address (tmp
);
2614 { /* No explicit end address? */
2615 start
= parse_and_eval_address (args
);
2616 stop
= start
+ 1; /* ??? */
2619 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2622 /* tfind outside command */
2624 trace_find_outside_command (char *args
, int from_tty
)
2626 CORE_ADDR start
, stop
;
2629 if (current_trace_status ()->running
2630 && current_trace_status ()->filename
== NULL
)
2631 error (_("May not look at trace frames while trace is running."));
2633 if (args
== 0 || *args
== 0)
2634 { /* XXX FIXME: what should default behavior be? */
2635 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2639 if (0 != (tmp
= strchr (args
, ',')))
2641 *tmp
++ = '\0'; /* Terminate start address. */
2642 tmp
= skip_spaces (tmp
);
2643 start
= parse_and_eval_address (args
);
2644 stop
= parse_and_eval_address (tmp
);
2647 { /* No explicit end address? */
2648 start
= parse_and_eval_address (args
);
2649 stop
= start
+ 1; /* ??? */
2652 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2655 /* info scope command: list the locals for a scope. */
2657 scope_info (char *args
, int from_tty
)
2659 struct symtabs_and_lines sals
;
2661 struct minimal_symbol
*msym
;
2662 struct block
*block
;
2663 const char *symname
;
2664 char *save_args
= args
;
2665 struct block_iterator iter
;
2667 struct gdbarch
*gdbarch
;
2670 if (args
== 0 || *args
== 0)
2671 error (_("requires an argument (function, "
2672 "line or *addr) to define a scope"));
2674 sals
= decode_line_1 (&args
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2675 if (sals
.nelts
== 0)
2676 return; /* Presumably decode_line_1 has already warned. */
2678 /* Resolve line numbers to PC. */
2679 resolve_sal_pc (&sals
.sals
[0]);
2680 block
= block_for_pc (sals
.sals
[0].pc
);
2684 QUIT
; /* Allow user to bail out with ^C. */
2685 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2687 QUIT
; /* Allow user to bail out with ^C. */
2689 printf_filtered ("Scope for %s:\n", save_args
);
2692 symname
= SYMBOL_PRINT_NAME (sym
);
2693 if (symname
== NULL
|| *symname
== '\0')
2694 continue; /* Probably botched, certainly useless. */
2696 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2698 printf_filtered ("Symbol %s is ", symname
);
2700 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
2701 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2702 BLOCK_START (block
),
2706 switch (SYMBOL_CLASS (sym
))
2709 case LOC_UNDEF
: /* Messed up symbol? */
2710 printf_filtered ("a bogus symbol, class %d.\n",
2711 SYMBOL_CLASS (sym
));
2712 count
--; /* Don't count this one. */
2715 printf_filtered ("a constant with value %s (%s)",
2716 plongest (SYMBOL_VALUE (sym
)),
2717 hex_string (SYMBOL_VALUE (sym
)));
2719 case LOC_CONST_BYTES
:
2720 printf_filtered ("constant bytes: ");
2721 if (SYMBOL_TYPE (sym
))
2722 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2723 fprintf_filtered (gdb_stdout
, " %02x",
2724 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2727 printf_filtered ("in static storage at address ");
2728 printf_filtered ("%s", paddress (gdbarch
,
2729 SYMBOL_VALUE_ADDRESS (sym
)));
2732 /* GDBARCH is the architecture associated with the objfile
2733 the symbol is defined in; the target architecture may be
2734 different, and may provide additional registers. However,
2735 we do not know the target architecture at this point.
2736 We assume the objfile architecture will contain all the
2737 standard registers that occur in debug info in that
2739 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2742 if (SYMBOL_IS_ARGUMENT (sym
))
2743 printf_filtered ("an argument in register $%s",
2744 gdbarch_register_name (gdbarch
, regno
));
2746 printf_filtered ("a local variable in register $%s",
2747 gdbarch_register_name (gdbarch
, regno
));
2750 printf_filtered ("an argument at stack/frame offset %s",
2751 plongest (SYMBOL_VALUE (sym
)));
2754 printf_filtered ("a local variable at frame offset %s",
2755 plongest (SYMBOL_VALUE (sym
)));
2758 printf_filtered ("a reference argument at offset %s",
2759 plongest (SYMBOL_VALUE (sym
)));
2761 case LOC_REGPARM_ADDR
:
2762 /* Note comment at LOC_REGISTER. */
2763 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2765 printf_filtered ("the address of an argument, in register $%s",
2766 gdbarch_register_name (gdbarch
, regno
));
2769 printf_filtered ("a typedef.\n");
2772 printf_filtered ("a label at address ");
2773 printf_filtered ("%s", paddress (gdbarch
,
2774 SYMBOL_VALUE_ADDRESS (sym
)));
2777 printf_filtered ("a function at address ");
2778 printf_filtered ("%s",
2779 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2781 case LOC_UNRESOLVED
:
2782 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2785 printf_filtered ("Unresolved Static");
2788 printf_filtered ("static storage at address ");
2789 printf_filtered ("%s",
2791 SYMBOL_VALUE_ADDRESS (msym
)));
2794 case LOC_OPTIMIZED_OUT
:
2795 printf_filtered ("optimized out.\n");
2798 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2801 if (SYMBOL_TYPE (sym
))
2802 printf_filtered (", length %d.\n",
2803 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2805 if (BLOCK_FUNCTION (block
))
2808 block
= BLOCK_SUPERBLOCK (block
);
2811 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2815 /* Helper for trace_dump_command. Dump the action list starting at
2816 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2817 actions of the body of a while-stepping action. STEPPING_FRAME is
2818 set if the current traceframe was determined to be a while-stepping
2822 trace_dump_actions (struct command_line
*action
,
2823 int stepping_actions
, int stepping_frame
,
2826 const char *action_exp
, *next_comma
;
2828 for (; action
!= NULL
; action
= action
->next
)
2830 struct cmd_list_element
*cmd
;
2832 QUIT
; /* Allow user to bail out with ^C. */
2833 action_exp
= action
->line
;
2834 action_exp
= skip_spaces_const (action_exp
);
2836 /* The collection actions to be done while stepping are
2837 bracketed by the commands "while-stepping" and "end". */
2839 if (*action_exp
== '#') /* comment line */
2842 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2844 error (_("Bad action list item: %s"), action_exp
);
2846 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2850 for (i
= 0; i
< action
->body_count
; ++i
)
2851 trace_dump_actions (action
->body_list
[i
],
2852 1, stepping_frame
, from_tty
);
2854 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2856 /* Display the collected data.
2857 For the trap frame, display only what was collected at
2858 the trap. Likewise for stepping frames, display only
2859 what was collected while stepping. This means that the
2860 two boolean variables, STEPPING_FRAME and
2861 STEPPING_ACTIONS should be equal. */
2862 if (stepping_frame
== stepping_actions
)
2865 struct cleanup
*old_chain
2866 = make_cleanup (free_current_contents
, &cmd
);
2867 int trace_string
= 0;
2869 if (*action_exp
== '/')
2870 action_exp
= decode_agent_options (action_exp
, &trace_string
);
2873 { /* Repeat over a comma-separated list. */
2874 QUIT
; /* Allow user to bail out with ^C. */
2875 if (*action_exp
== ',')
2877 action_exp
= skip_spaces_const (action_exp
);
2879 next_comma
= strchr (action_exp
, ',');
2881 if (0 == strncasecmp (action_exp
, "$reg", 4))
2882 registers_info (NULL
, from_tty
);
2883 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2885 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2886 locals_info (NULL
, from_tty
);
2887 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2888 args_info (NULL
, from_tty
);
2891 if (next_comma
!= NULL
)
2893 size_t len
= next_comma
- action_exp
;
2895 cmd
= xrealloc (cmd
, len
+ 1);
2896 memcpy (cmd
, action_exp
, len
);
2901 size_t len
= strlen (action_exp
);
2903 cmd
= xrealloc (cmd
, len
+ 1);
2904 memcpy (cmd
, action_exp
, len
+ 1);
2907 printf_filtered ("%s = ", cmd
);
2908 output_command_const (cmd
, from_tty
);
2909 printf_filtered ("\n");
2911 action_exp
= next_comma
;
2913 while (action_exp
&& *action_exp
== ',');
2915 do_cleanups (old_chain
);
2921 /* The tdump command. */
2924 trace_dump_command (char *args
, int from_tty
)
2926 struct regcache
*regcache
;
2927 struct tracepoint
*t
;
2928 int stepping_frame
= 0;
2929 struct bp_location
*loc
;
2930 char *default_collect_line
= NULL
;
2931 struct command_line
*actions
, *default_collect_action
= NULL
;
2932 struct cleanup
*old_chain
= NULL
;
2934 if (tracepoint_number
== -1)
2936 warning (_("No current trace frame."));
2940 t
= get_tracepoint (tracepoint_number
);
2943 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2946 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2947 tracepoint_number
, traceframe_number
);
2949 /* The current frame is a trap frame if the frame PC is equal
2950 to the tracepoint PC. If not, then the current frame was
2951 collected during single-stepping. */
2953 regcache
= get_current_regcache ();
2955 /* If the traceframe's address matches any of the tracepoint's
2956 locations, assume it is a direct hit rather than a while-stepping
2957 frame. (FIXME this is not reliable, should record each frame's
2960 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
2961 if (loc
->address
== regcache_read_pc (regcache
))
2964 actions
= breakpoint_commands (&t
->base
);
2966 /* If there is a default-collect list, make up a collect command,
2967 prepend to the tracepoint's commands, and pass the whole mess to
2968 the trace dump scanner. We need to validate because
2969 default-collect might have been junked since the trace run. */
2970 if (*default_collect
)
2972 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2973 old_chain
= make_cleanup (xfree
, default_collect_line
);
2974 validate_actionline (default_collect_line
, &t
->base
);
2975 default_collect_action
= xmalloc (sizeof (struct command_line
));
2976 make_cleanup (xfree
, default_collect_action
);
2977 default_collect_action
->next
= actions
;
2978 default_collect_action
->line
= default_collect_line
;
2979 actions
= default_collect_action
;
2982 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2984 if (*default_collect
)
2985 do_cleanups (old_chain
);
2988 /* Encode a piece of a tracepoint's source-level definition in a form
2989 that is suitable for both protocol and saving in files. */
2990 /* This version does not do multiple encodes for long strings; it should
2991 return an offset to the next piece to encode. FIXME */
2994 encode_source_string (int tpnum
, ULONGEST addr
,
2995 char *srctype
, char *src
, char *buf
, int buf_size
)
2997 if (80 + strlen (srctype
) > buf_size
)
2998 error (_("Buffer too small for source encoding"));
2999 sprintf (buf
, "%x:%s:%s:%x:%x:",
3000 tpnum
, phex_nz (addr
, sizeof (addr
)),
3001 srctype
, 0, (int) strlen (src
));
3002 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
3003 error (_("Source string too long for buffer"));
3004 bin2hex ((gdb_byte
*) src
, buf
+ strlen (buf
), 0);
3008 /* Free trace file writer. */
3011 trace_file_writer_xfree (void *arg
)
3013 struct trace_file_writer
*writer
= arg
;
3015 writer
->ops
->dtor (writer
);
3019 /* TFILE trace writer. */
3021 struct tfile_trace_file_writer
3023 struct trace_file_writer base
;
3025 /* File pointer to tfile trace file. */
3027 /* Path name of the tfile trace file. */
3031 /* This is the implementation of trace_file_write_ops method
3032 target_save. We just call the generic target
3033 target_save_trace_data to do target-side saving. */
3036 tfile_target_save (struct trace_file_writer
*self
,
3037 const char *filename
)
3039 int err
= target_save_trace_data (filename
);
3044 /* This is the implementation of trace_file_write_ops method
3048 tfile_dtor (struct trace_file_writer
*self
)
3050 struct tfile_trace_file_writer
*writer
3051 = (struct tfile_trace_file_writer
*) self
;
3053 xfree (writer
->pathname
);
3055 if (writer
->fp
!= NULL
)
3056 fclose (writer
->fp
);
3059 /* This is the implementation of trace_file_write_ops method
3060 start. It creates the trace file FILENAME and registers some
3064 tfile_start (struct trace_file_writer
*self
, const char *filename
)
3066 struct tfile_trace_file_writer
*writer
3067 = (struct tfile_trace_file_writer
*) self
;
3069 writer
->pathname
= tilde_expand (filename
);
3070 writer
->fp
= gdb_fopen_cloexec (writer
->pathname
, "wb");
3071 if (writer
->fp
== NULL
)
3072 error (_("Unable to open file '%s' for saving trace data (%s)"),
3073 filename
, safe_strerror (errno
));
3076 /* This is the implementation of trace_file_write_ops method
3077 write_header. Write the TFILE header. */
3080 tfile_write_header (struct trace_file_writer
*self
)
3082 struct tfile_trace_file_writer
*writer
3083 = (struct tfile_trace_file_writer
*) self
;
3086 /* Write a file header, with a high-bit-set char to indicate a
3087 binary file, plus a hint as what this file is, and a version
3088 number in case of future needs. */
3089 written
= fwrite ("\x7fTRACE0\n", 8, 1, writer
->fp
);
3091 perror_with_name (writer
->pathname
);
3094 /* This is the implementation of trace_file_write_ops method
3095 write_regblock_type. Write the size of register block. */
3098 tfile_write_regblock_type (struct trace_file_writer
*self
, int size
)
3100 struct tfile_trace_file_writer
*writer
3101 = (struct tfile_trace_file_writer
*) self
;
3103 fprintf (writer
->fp
, "R %x\n", size
);
3106 /* This is the implementation of trace_file_write_ops method
3110 tfile_write_status (struct trace_file_writer
*self
,
3111 struct trace_status
*ts
)
3113 struct tfile_trace_file_writer
*writer
3114 = (struct tfile_trace_file_writer
*) self
;
3116 fprintf (writer
->fp
, "status %c;%s",
3117 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
3118 if (ts
->stop_reason
== tracepoint_error
3119 || ts
->stop_reason
== tstop_command
)
3121 char *buf
= (char *) alloca (strlen (ts
->stop_desc
) * 2 + 1);
3123 bin2hex ((gdb_byte
*) ts
->stop_desc
, buf
, 0);
3124 fprintf (writer
->fp
, ":%s", buf
);
3126 fprintf (writer
->fp
, ":%x", ts
->stopping_tracepoint
);
3127 if (ts
->traceframe_count
>= 0)
3128 fprintf (writer
->fp
, ";tframes:%x", ts
->traceframe_count
);
3129 if (ts
->traceframes_created
>= 0)
3130 fprintf (writer
->fp
, ";tcreated:%x", ts
->traceframes_created
);
3131 if (ts
->buffer_free
>= 0)
3132 fprintf (writer
->fp
, ";tfree:%x", ts
->buffer_free
);
3133 if (ts
->buffer_size
>= 0)
3134 fprintf (writer
->fp
, ";tsize:%x", ts
->buffer_size
);
3135 if (ts
->disconnected_tracing
)
3136 fprintf (writer
->fp
, ";disconn:%x", ts
->disconnected_tracing
);
3137 if (ts
->circular_buffer
)
3138 fprintf (writer
->fp
, ";circular:%x", ts
->circular_buffer
);
3139 if (ts
->notes
!= NULL
)
3141 char *buf
= (char *) alloca (strlen (ts
->notes
) * 2 + 1);
3143 bin2hex ((gdb_byte
*) ts
->notes
, buf
, 0);
3144 fprintf (writer
->fp
, ";notes:%s", buf
);
3146 if (ts
->user_name
!= NULL
)
3148 char *buf
= (char *) alloca (strlen (ts
->user_name
) * 2 + 1);
3150 bin2hex ((gdb_byte
*) ts
->user_name
, buf
, 0);
3151 fprintf (writer
->fp
, ";username:%s", buf
);
3153 fprintf (writer
->fp
, "\n");
3156 /* This is the implementation of trace_file_write_ops method
3157 write_uploaded_tsv. */
3160 tfile_write_uploaded_tsv (struct trace_file_writer
*self
,
3161 struct uploaded_tsv
*utsv
)
3164 struct tfile_trace_file_writer
*writer
3165 = (struct tfile_trace_file_writer
*) self
;
3169 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
3170 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
3173 fprintf (writer
->fp
, "tsv %x:%s:%x:%s\n",
3174 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
3175 utsv
->builtin
, buf
);
3181 #define MAX_TRACE_UPLOAD 2000
3183 /* This is the implementation of trace_file_write_ops method
3184 write_uploaded_tp. */
3187 tfile_write_uploaded_tp (struct trace_file_writer
*self
,
3188 struct uploaded_tp
*utp
)
3190 struct tfile_trace_file_writer
*writer
3191 = (struct tfile_trace_file_writer
*) self
;
3194 char buf
[MAX_TRACE_UPLOAD
];
3196 fprintf (writer
->fp
, "tp T%x:%s:%c:%x:%x",
3197 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3198 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
3199 if (utp
->type
== bp_fast_tracepoint
)
3200 fprintf (writer
->fp
, ":F%x", utp
->orig_size
);
3202 fprintf (writer
->fp
,
3203 ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
3205 fprintf (writer
->fp
, "\n");
3206 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
3207 fprintf (writer
->fp
, "tp A%x:%s:%s\n",
3208 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3209 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
3210 fprintf (writer
->fp
, "tp S%x:%s:%s\n",
3211 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3214 encode_source_string (utp
->number
, utp
->addr
,
3215 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
3216 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3218 if (utp
->cond_string
)
3220 encode_source_string (utp
->number
, utp
->addr
,
3221 "cond", utp
->cond_string
,
3222 buf
, MAX_TRACE_UPLOAD
);
3223 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3225 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
3227 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
3228 buf
, MAX_TRACE_UPLOAD
);
3229 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3231 fprintf (writer
->fp
, "tp V%x:%s:%x:%s\n",
3232 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3234 phex_nz (utp
->traceframe_usage
,
3235 sizeof (utp
->traceframe_usage
)));
3238 /* This is the implementation of trace_file_write_ops method
3239 write_definition_end. */
3242 tfile_write_definition_end (struct trace_file_writer
*self
)
3244 struct tfile_trace_file_writer
*writer
3245 = (struct tfile_trace_file_writer
*) self
;
3247 fprintf (writer
->fp
, "\n");
3250 /* This is the implementation of trace_file_write_ops method
3254 tfile_write_raw_data (struct trace_file_writer
*self
, gdb_byte
*buf
,
3257 struct tfile_trace_file_writer
*writer
3258 = (struct tfile_trace_file_writer
*) self
;
3260 if (fwrite (buf
, len
, 1, writer
->fp
) < 1)
3261 perror_with_name (writer
->pathname
);
3264 /* This is the implementation of trace_file_write_ops method
3268 tfile_end (struct trace_file_writer
*self
)
3270 struct tfile_trace_file_writer
*writer
3271 = (struct tfile_trace_file_writer
*) self
;
3272 uint32_t gotten
= 0;
3274 /* Mark the end of trace data. */
3275 if (fwrite (&gotten
, 4, 1, writer
->fp
) < 1)
3276 perror_with_name (writer
->pathname
);
3279 /* Operations to write trace buffers into TFILE format. */
3281 static const struct trace_file_write_ops tfile_write_ops
=
3287 tfile_write_regblock_type
,
3289 tfile_write_uploaded_tsv
,
3290 tfile_write_uploaded_tp
,
3291 tfile_write_definition_end
,
3292 tfile_write_raw_data
,
3297 /* Helper macros. */
3299 #define TRACE_WRITE_R_BLOCK(writer, buf, size) \
3300 writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
3301 #define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
3302 writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
3304 #define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
3305 writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
3307 #define TRACE_WRITE_V_BLOCK(writer, num, val) \
3308 writer->ops->frame_ops->write_v_block ((writer), (num), (val))
3310 /* Save tracepoint data to file named FILENAME through WRITER. WRITER
3311 determines the trace file format. If TARGET_DOES_SAVE is non-zero,
3312 the save is performed on the target, otherwise GDB obtains all trace
3313 data and saves it locally. */
3316 trace_save (const char *filename
, struct trace_file_writer
*writer
,
3317 int target_does_save
)
3319 struct trace_status
*ts
= current_trace_status ();
3321 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
3322 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
3324 ULONGEST offset
= 0;
3325 gdb_byte buf
[MAX_TRACE_UPLOAD
];
3326 #define MAX_TRACE_UPLOAD 2000
3328 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
3330 /* If the target is to save the data to a file on its own, then just
3331 send the command and be done with it. */
3332 if (target_does_save
)
3334 if (!writer
->ops
->target_save (writer
, filename
))
3335 error (_("Target failed to save trace data to '%s'."),
3340 /* Get the trace status first before opening the file, so if the
3341 target is losing, we can get out without touching files. */
3342 status
= target_get_trace_status (ts
);
3344 writer
->ops
->start (writer
, filename
);
3346 writer
->ops
->write_header (writer
);
3348 /* Write descriptive info. */
3350 /* Write out the size of a register block. */
3351 writer
->ops
->write_regblock_type (writer
, trace_regblock_size
);
3353 /* Write out status of the tracing run (aka "tstatus" info). */
3354 writer
->ops
->write_status (writer
, ts
);
3356 /* Note that we want to upload tracepoints and save those, rather
3357 than simply writing out the local ones, because the user may have
3358 changed tracepoints in GDB in preparation for a future tracing
3359 run, or maybe just mass-deleted all types of breakpoints as part
3360 of cleaning up. So as not to contaminate the session, leave the
3361 data in its uploaded form, don't make into real tracepoints. */
3363 /* Get trace state variables first, they may be checked when parsing
3364 uploaded commands. */
3366 target_upload_trace_state_variables (&uploaded_tsvs
);
3368 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3369 writer
->ops
->write_uploaded_tsv (writer
, utsv
);
3371 free_uploaded_tsvs (&uploaded_tsvs
);
3373 target_upload_tracepoints (&uploaded_tps
);
3375 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3376 target_get_tracepoint_status (NULL
, utp
);
3378 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3379 writer
->ops
->write_uploaded_tp (writer
, utp
);
3381 free_uploaded_tps (&uploaded_tps
);
3383 /* Mark the end of the definition section. */
3384 writer
->ops
->write_definition_end (writer
);
3386 /* Get and write the trace data proper. */
3391 /* The writer supports writing the contents of trace buffer
3392 directly to trace file. Don't parse the contents of trace
3394 if (writer
->ops
->write_trace_buffer
!= NULL
)
3396 /* We ask for big blocks, in the hopes of efficiency, but
3397 will take less if the target has packet size limitations
3399 gotten
= target_get_raw_trace_data (buf
, offset
,
3402 error (_("Failure to get requested trace buffer data"));
3403 /* No more data is forthcoming, we're done. */
3407 writer
->ops
->write_trace_buffer (writer
, buf
, gotten
);
3415 /* Parse the trace buffers according to how data are stored
3416 in trace buffer in GDBserver. */
3418 gotten
= target_get_raw_trace_data (buf
, offset
, 6);
3423 /* Read the first six bytes in, which is the tracepoint
3424 number and trace frame size. */
3426 extract_unsigned_integer (&buf
[0], 2, byte_order
);
3428 tf_size
= (uint32_t)
3429 extract_unsigned_integer (&buf
[2], 4, byte_order
);
3431 writer
->ops
->frame_ops
->start (writer
, tp_num
);
3440 for (block
= 0; block
< tf_size
; )
3442 gdb_byte block_type
;
3444 /* We'll fetch one block each time, in order to
3445 handle the extremely large 'M' block. We first
3446 fetch one byte to get the type of the block. */
3447 gotten
= target_get_raw_trace_data (buf
, offset
, 1);
3449 error (_("Failure to get requested trace buffer data"));
3455 block_type
= buf
[0];
3460 = target_get_raw_trace_data (buf
, offset
,
3461 trace_regblock_size
);
3462 if (gotten
< trace_regblock_size
)
3463 error (_("Failure to get requested trace"
3466 TRACE_WRITE_R_BLOCK (writer
, buf
,
3467 trace_regblock_size
);
3471 unsigned short mlen
;
3476 t
= target_get_raw_trace_data (buf
,offset
, 10);
3478 error (_("Failure to get requested trace"
3486 extract_unsigned_integer (buf
, 8,
3488 mlen
= (unsigned short)
3489 extract_unsigned_integer (&buf
[8], 2,
3492 TRACE_WRITE_M_BLOCK_HEADER (writer
, addr
,
3495 /* The memory contents in 'M' block may be
3496 very large. Fetch the data from the target
3497 and write them into file one by one. */
3498 for (j
= 0; j
< mlen
; )
3500 unsigned int read_length
;
3502 if (mlen
- j
> MAX_TRACE_UPLOAD
)
3503 read_length
= MAX_TRACE_UPLOAD
;
3505 read_length
= mlen
- j
;
3507 t
= target_get_raw_trace_data (buf
,
3510 if (t
< read_length
)
3511 error (_("Failure to get requested"
3512 " trace buffer data"));
3514 TRACE_WRITE_M_BLOCK_MEMORY (writer
, buf
,
3518 gotten
+= read_length
;
3529 = target_get_raw_trace_data (buf
, offset
,
3532 error (_("Failure to get requested"
3533 " trace buffer data"));
3535 vnum
= (int) extract_signed_integer (buf
,
3539 = extract_signed_integer (&buf
[4], 8,
3542 TRACE_WRITE_V_BLOCK (writer
, vnum
, val
);
3546 error (_("Unknown block type '%c' (0x%x) in"
3548 block_type
, block_type
);
3558 writer
->ops
->frame_ops
->end (writer
);
3562 writer
->ops
->end (writer
);
3565 /* Return a trace writer for TFILE format. */
3567 static struct trace_file_writer
*
3568 tfile_trace_file_writer_new (void)
3570 struct tfile_trace_file_writer
*writer
3571 = xmalloc (sizeof (struct tfile_trace_file_writer
));
3573 writer
->base
.ops
= &tfile_write_ops
;
3575 writer
->pathname
= NULL
;
3577 return (struct trace_file_writer
*) writer
;
3581 trace_save_command (char *args
, int from_tty
)
3583 int target_does_save
= 0;
3585 char *filename
= NULL
;
3586 struct cleanup
*back_to
;
3587 int generate_ctf
= 0;
3588 struct trace_file_writer
*writer
= NULL
;
3591 error_no_arg (_("file in which to save trace data"));
3593 argv
= gdb_buildargv (args
);
3594 back_to
= make_cleanup_freeargv (argv
);
3596 for (; *argv
; ++argv
)
3598 if (strcmp (*argv
, "-r") == 0)
3599 target_does_save
= 1;
3600 if (strcmp (*argv
, "-ctf") == 0)
3602 else if (**argv
== '-')
3603 error (_("unknown option `%s'"), *argv
);
3609 error_no_arg (_("file in which to save trace data"));
3612 writer
= ctf_trace_file_writer_new ();
3614 writer
= tfile_trace_file_writer_new ();
3616 make_cleanup (trace_file_writer_xfree
, writer
);
3618 trace_save (filename
, writer
, target_does_save
);
3621 printf_filtered (_("Trace data saved to %s '%s'.\n"),
3622 generate_ctf
? "directory" : "file", filename
);
3624 do_cleanups (back_to
);
3627 /* Save the trace data to file FILENAME of tfile format. */
3630 trace_save_tfile (const char *filename
, int target_does_save
)
3632 struct trace_file_writer
*writer
;
3633 struct cleanup
*back_to
;
3635 writer
= tfile_trace_file_writer_new ();
3636 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
3637 trace_save (filename
, writer
, target_does_save
);
3638 do_cleanups (back_to
);
3641 /* Save the trace data to dir DIRNAME of ctf format. */
3644 trace_save_ctf (const char *dirname
, int target_does_save
)
3646 struct trace_file_writer
*writer
;
3647 struct cleanup
*back_to
;
3649 writer
= ctf_trace_file_writer_new ();
3650 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
3652 trace_save (dirname
, writer
, target_does_save
);
3653 do_cleanups (back_to
);
3656 /* Tell the target what to do with an ongoing tracing run if GDB
3657 disconnects for some reason. */
3660 set_disconnected_tracing (char *args
, int from_tty
,
3661 struct cmd_list_element
*c
)
3663 target_set_disconnected_tracing (disconnected_tracing
);
3667 set_circular_trace_buffer (char *args
, int from_tty
,
3668 struct cmd_list_element
*c
)
3670 target_set_circular_trace_buffer (circular_trace_buffer
);
3674 set_trace_buffer_size (char *args
, int from_tty
,
3675 struct cmd_list_element
*c
)
3677 target_set_trace_buffer_size (trace_buffer_size
);
3681 set_trace_user (char *args
, int from_tty
,
3682 struct cmd_list_element
*c
)
3686 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3689 warning (_("Target does not support trace notes, user ignored"));
3693 set_trace_notes (char *args
, int from_tty
,
3694 struct cmd_list_element
*c
)
3698 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3701 warning (_("Target does not support trace notes, note ignored"));
3705 set_trace_stop_notes (char *args
, int from_tty
,
3706 struct cmd_list_element
*c
)
3710 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3713 warning (_("Target does not support trace notes, stop note ignored"));
3716 /* Convert the memory pointed to by mem into hex, placing result in buf.
3717 * Return a pointer to the last char put in buf (null)
3718 * "stolen" from sparc-stub.c
3721 static const char hexchars
[] = "0123456789abcdef";
3724 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3732 *buf
++ = hexchars
[ch
>> 4];
3733 *buf
++ = hexchars
[ch
& 0xf];
3742 get_traceframe_number (void)
3744 return traceframe_number
;
3748 get_tracepoint_number (void)
3750 return tracepoint_number
;
3753 /* Make the traceframe NUM be the current trace frame. Does nothing
3754 if NUM is already current. */
3757 set_current_traceframe (int num
)
3761 if (traceframe_number
== num
)
3763 /* Nothing to do. */
3767 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3770 warning (_("could not change traceframe"));
3772 set_traceframe_num (newnum
);
3774 /* Changing the traceframe changes our view of registers and of the
3776 registers_changed ();
3778 clear_traceframe_info ();
3781 /* Make the traceframe NUM be the current trace frame, and do nothing
3785 set_traceframe_number (int num
)
3787 traceframe_number
= num
;
3790 /* A cleanup used when switching away and back from tfind mode. */
3792 struct current_traceframe_cleanup
3794 /* The traceframe we were inspecting. */
3795 int traceframe_number
;
3799 do_restore_current_traceframe_cleanup (void *arg
)
3801 struct current_traceframe_cleanup
*old
= arg
;
3803 set_current_traceframe (old
->traceframe_number
);
3807 restore_current_traceframe_cleanup_dtor (void *arg
)
3809 struct current_traceframe_cleanup
*old
= arg
;
3815 make_cleanup_restore_current_traceframe (void)
3817 struct current_traceframe_cleanup
*old
;
3819 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3820 old
->traceframe_number
= traceframe_number
;
3822 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3823 restore_current_traceframe_cleanup_dtor
);
3827 make_cleanup_restore_traceframe_number (void)
3829 return make_cleanup_restore_integer (&traceframe_number
);
3832 /* Given a number and address, return an uploaded tracepoint with that
3833 number, creating if necessary. */
3835 struct uploaded_tp
*
3836 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3838 struct uploaded_tp
*utp
;
3840 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3841 if (utp
->number
== num
&& utp
->addr
== addr
)
3843 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3844 memset (utp
, 0, sizeof (struct uploaded_tp
));
3847 utp
->actions
= NULL
;
3848 utp
->step_actions
= NULL
;
3849 utp
->cmd_strings
= NULL
;
3856 free_uploaded_tps (struct uploaded_tp
**utpp
)
3858 struct uploaded_tp
*next_one
;
3862 next_one
= (*utpp
)->next
;
3868 /* Given a number and address, return an uploaded tracepoint with that
3869 number, creating if necessary. */
3871 struct uploaded_tsv
*
3872 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3874 struct uploaded_tsv
*utsv
;
3876 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3877 if (utsv
->number
== num
)
3879 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3880 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3882 utsv
->next
= *utsvp
;
3888 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3890 struct uploaded_tsv
*next_one
;
3894 next_one
= (*utsvp
)->next
;
3900 /* FIXME this function is heuristic and will miss the cases where the
3901 conditional is semantically identical but differs in whitespace,
3902 such as "x == 0" vs "x==0". */
3905 cond_string_is_same (char *str1
, char *str2
)
3907 if (str1
== NULL
|| str2
== NULL
)
3908 return (str1
== str2
);
3910 return (strcmp (str1
, str2
) == 0);
3913 /* Look for an existing tracepoint that seems similar enough to the
3914 uploaded one. Enablement isn't compared, because the user can
3915 toggle that freely, and may have done so in anticipation of the
3916 next trace run. Return the location of matched tracepoint. */
3918 static struct bp_location
*
3919 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3921 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3923 struct breakpoint
*b
;
3924 struct bp_location
*loc
;
3926 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3928 struct tracepoint
*t
= (struct tracepoint
*) b
;
3930 if (b
->type
== utp
->type
3931 && t
->step_count
== utp
->step
3932 && t
->pass_count
== utp
->pass
3933 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3934 /* FIXME also test actions. */
3937 /* Scan the locations for an address match. */
3938 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3940 if (loc
->address
== utp
->addr
)
3948 /* Given a list of tracepoints uploaded from a target, attempt to
3949 match them up with existing tracepoints, and create new ones if not
3953 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3955 struct uploaded_tp
*utp
;
3956 /* A set of tracepoints which are modified. */
3957 VEC(breakpoint_p
) *modified_tp
= NULL
;
3959 struct breakpoint
*b
;
3961 /* Look for GDB tracepoints that match up with our uploaded versions. */
3962 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3964 struct bp_location
*loc
;
3965 struct tracepoint
*t
;
3967 loc
= find_matching_tracepoint_location (utp
);
3972 /* Mark this location as already inserted. */
3974 t
= (struct tracepoint
*) loc
->owner
;
3975 printf_filtered (_("Assuming tracepoint %d is same "
3976 "as target's tracepoint %d at %s.\n"),
3977 loc
->owner
->number
, utp
->number
,
3978 paddress (loc
->gdbarch
, utp
->addr
));
3980 /* The tracepoint LOC->owner was modified (the location LOC
3981 was marked as inserted in the target). Save it in
3982 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3983 observers will be notified later once for each tracepoint
3984 saved in MODIFIED_TP. */
3986 VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
);
3988 if (b
== loc
->owner
)
3994 VEC_safe_push (breakpoint_p
, modified_tp
, loc
->owner
);
3998 t
= create_tracepoint_from_upload (utp
);
4000 printf_filtered (_("Created tracepoint %d for "
4001 "target's tracepoint %d at %s.\n"),
4002 t
->base
.number
, utp
->number
,
4003 paddress (get_current_arch (), utp
->addr
));
4005 printf_filtered (_("Failed to create tracepoint for target's "
4006 "tracepoint %d at %s, skipping it.\n"),
4008 paddress (get_current_arch (), utp
->addr
));
4010 /* Whether found or created, record the number used by the
4011 target, to help with mapping target tracepoints back to their
4012 counterparts here. */
4014 t
->number_on_target
= utp
->number
;
4017 /* Notify 'breakpoint-modified' observer that at least one of B's
4018 locations was changed. */
4019 for (ix
= 0; VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
); ix
++)
4020 observer_notify_breakpoint_modified (b
);
4022 VEC_free (breakpoint_p
, modified_tp
);
4023 free_uploaded_tps (uploaded_tps
);
4026 /* Trace state variables don't have much to identify them beyond their
4027 name, so just use that to detect matches. */
4029 static struct trace_state_variable
*
4030 find_matching_tsv (struct uploaded_tsv
*utsv
)
4035 return find_trace_state_variable (utsv
->name
);
4038 static struct trace_state_variable
*
4039 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
4041 const char *namebase
;
4044 struct trace_state_variable
*tsv
;
4045 struct cleanup
*old_chain
;
4049 namebase
= utsv
->name
;
4050 buf
= xstrprintf ("%s", namebase
);
4055 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
4058 /* Fish for a name that is not in use. */
4059 /* (should check against all internal vars?) */
4060 while (find_trace_state_variable (buf
))
4063 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
4066 old_chain
= make_cleanup (xfree
, buf
);
4068 /* We have an available name, create the variable. */
4069 tsv
= create_trace_state_variable (buf
);
4070 tsv
->initial_value
= utsv
->initial_value
;
4071 tsv
->builtin
= utsv
->builtin
;
4073 observer_notify_tsv_created (tsv
);
4075 do_cleanups (old_chain
);
4080 /* Given a list of uploaded trace state variables, try to match them
4081 up with existing variables, or create additional ones. */
4084 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
4087 struct uploaded_tsv
*utsv
;
4088 struct trace_state_variable
*tsv
;
4091 /* Most likely some numbers will have to be reassigned as part of
4092 the merge, so clear them all in anticipation. */
4093 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4096 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
4098 tsv
= find_matching_tsv (utsv
);
4102 printf_filtered (_("Assuming trace state variable $%s "
4103 "is same as target's variable %d.\n"),
4104 tsv
->name
, utsv
->number
);
4108 tsv
= create_tsv_from_upload (utsv
);
4110 printf_filtered (_("Created trace state variable "
4111 "$%s for target's variable %d.\n"),
4112 tsv
->name
, utsv
->number
);
4114 /* Give precedence to numberings that come from the target. */
4116 tsv
->number
= utsv
->number
;
4119 /* Renumber everything that didn't get a target-assigned number. */
4121 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4122 if (tsv
->number
> highest
)
4123 highest
= tsv
->number
;
4126 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4127 if (tsv
->number
== 0)
4128 tsv
->number
= highest
++;
4130 free_uploaded_tsvs (uploaded_tsvs
);
4133 /* target tfile command */
4135 static struct target_ops tfile_ops
;
4137 /* Fill in tfile_ops with its defined operations and properties. */
4139 #define TRACE_HEADER_SIZE 8
4141 static char *trace_filename
;
4142 static int trace_fd
= -1;
4143 static off_t trace_frames_offset
;
4144 static off_t cur_offset
;
4145 static int cur_data_size
;
4146 int trace_regblock_size
;
4148 static void tfile_interp_line (char *line
,
4149 struct uploaded_tp
**utpp
,
4150 struct uploaded_tsv
**utsvp
);
4152 /* Read SIZE bytes into READBUF from the trace frame, starting at
4153 TRACE_FD's current position. Note that this call `read'
4154 underneath, hence it advances the file's seek position. Throws an
4155 error if the `read' syscall fails, or less than SIZE bytes are
4159 tfile_read (gdb_byte
*readbuf
, int size
)
4163 gotten
= read (trace_fd
, readbuf
, size
);
4165 perror_with_name (trace_filename
);
4166 else if (gotten
< size
)
4167 error (_("Premature end of file while reading trace file"));
4171 tfile_open (char *filename
, int from_tty
)
4173 volatile struct gdb_exception ex
;
4175 struct cleanup
*old_chain
;
4178 char header
[TRACE_HEADER_SIZE
];
4179 char linebuf
[1000]; /* Should be max remote packet size or so. */
4182 struct trace_status
*ts
;
4183 struct uploaded_tp
*uploaded_tps
= NULL
;
4184 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4186 target_preopen (from_tty
);
4188 error (_("No trace file specified."));
4190 filename
= tilde_expand (filename
);
4191 if (!IS_ABSOLUTE_PATH(filename
))
4193 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
4198 old_chain
= make_cleanup (xfree
, filename
);
4200 flags
= O_BINARY
| O_LARGEFILE
;
4202 scratch_chan
= gdb_open_cloexec (filename
, flags
, 0);
4203 if (scratch_chan
< 0)
4204 perror_with_name (filename
);
4206 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
4208 discard_cleanups (old_chain
); /* Don't free filename any more. */
4209 unpush_target (&tfile_ops
);
4211 trace_filename
= xstrdup (filename
);
4212 trace_fd
= scratch_chan
;
4215 /* Read the file header and test for validity. */
4216 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
4218 bytes
+= TRACE_HEADER_SIZE
;
4219 if (!(header
[0] == 0x7f
4220 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
4221 error (_("File is not a valid trace file."));
4223 push_target (&tfile_ops
);
4225 trace_regblock_size
= 0;
4226 ts
= current_trace_status ();
4227 /* We know we're working with a file. Record its name. */
4228 ts
->filename
= trace_filename
;
4229 /* Set defaults in case there is no status line. */
4230 ts
->running_known
= 0;
4231 ts
->stop_reason
= trace_stop_reason_unknown
;
4232 ts
->traceframe_count
= -1;
4233 ts
->buffer_free
= 0;
4234 ts
->disconnected_tracing
= 0;
4235 ts
->circular_buffer
= 0;
4237 TRY_CATCH (ex
, RETURN_MASK_ALL
)
4239 /* Read through a section of newline-terminated lines that
4240 define things like tracepoints. */
4244 tfile_read (&byte
, 1);
4249 /* Empty line marks end of the definition section. */
4254 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
4257 linebuf
[i
++] = byte
;
4259 error (_("Excessively long lines in trace file"));
4262 /* Record the starting offset of the binary trace data. */
4263 trace_frames_offset
= bytes
;
4265 /* If we don't have a blocksize, we can't interpret the
4267 if (trace_regblock_size
== 0)
4268 error (_("No register block size recorded in trace file"));
4272 /* Pop the partially set up target. */
4274 throw_exception (ex
);
4277 inferior_appeared (current_inferior (), TFILE_PID
);
4278 inferior_ptid
= pid_to_ptid (TFILE_PID
);
4279 add_thread_silent (inferior_ptid
);
4281 if (ts
->traceframe_count
<= 0)
4282 warning (_("No traceframes present in this file."));
4284 /* Add the file's tracepoints and variables into the current mix. */
4286 /* Get trace state variables first, they may be checked when parsing
4287 uploaded commands. */
4288 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4290 merge_uploaded_tracepoints (&uploaded_tps
);
4292 post_create_inferior (&tfile_ops
, from_tty
);
4295 /* Interpret the given line from the definitions part of the trace
4299 tfile_interp_line (char *line
, struct uploaded_tp
**utpp
,
4300 struct uploaded_tsv
**utsvp
)
4304 if (strncmp (p
, "R ", strlen ("R ")) == 0)
4307 trace_regblock_size
= strtol (p
, &p
, 16);
4309 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
4311 p
+= strlen ("status ");
4312 parse_trace_status (p
, current_trace_status ());
4314 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
4316 p
+= strlen ("tp ");
4317 parse_tracepoint_definition (p
, utpp
);
4319 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
4321 p
+= strlen ("tsv ");
4322 parse_tsv_definition (p
, utsvp
);
4325 warning (_("Ignoring trace file definition \"%s\""), line
);
4328 /* Parse the part of trace status syntax that is shared between
4329 the remote protocol and the trace file reader. */
4332 parse_trace_status (char *line
, struct trace_status
*ts
)
4334 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
4338 ts
->running_known
= 1;
4339 ts
->running
= (*p
++ == '1');
4340 ts
->stop_reason
= trace_stop_reason_unknown
;
4341 xfree (ts
->stop_desc
);
4342 ts
->stop_desc
= NULL
;
4343 ts
->traceframe_count
= -1;
4344 ts
->traceframes_created
= -1;
4345 ts
->buffer_free
= -1;
4346 ts
->buffer_size
= -1;
4347 ts
->disconnected_tracing
= 0;
4348 ts
->circular_buffer
= 0;
4349 xfree (ts
->user_name
);
4350 ts
->user_name
= NULL
;
4353 ts
->start_time
= ts
->stop_time
= 0;
4357 p1
= strchr (p
, ':');
4359 error (_("Malformed trace status, at %s\n\
4360 Status line: '%s'\n"), p
, line
);
4361 p3
= strchr (p
, ';');
4363 p3
= p
+ strlen (p
);
4364 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
4366 p
= unpack_varlen_hex (++p1
, &val
);
4367 ts
->stop_reason
= trace_buffer_full
;
4369 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
4371 p
= unpack_varlen_hex (++p1
, &val
);
4372 ts
->stop_reason
= trace_never_run
;
4374 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
4377 p
= unpack_varlen_hex (++p1
, &val
);
4378 ts
->stop_reason
= tracepoint_passcount
;
4379 ts
->stopping_tracepoint
= val
;
4381 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
4383 p2
= strchr (++p1
, ':');
4391 ts
->stop_desc
= xmalloc (strlen (line
));
4392 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
4393 ts
->stop_desc
[end
] = '\0';
4396 ts
->stop_desc
= xstrdup ("");
4398 p
= unpack_varlen_hex (++p2
, &val
);
4399 ts
->stop_reason
= tstop_command
;
4401 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
4403 p
= unpack_varlen_hex (++p1
, &val
);
4404 ts
->stop_reason
= trace_disconnected
;
4406 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
4408 p2
= strchr (++p1
, ':');
4411 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
4412 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
4413 ts
->stop_desc
[end
] = '\0';
4416 ts
->stop_desc
= xstrdup ("");
4418 p
= unpack_varlen_hex (++p2
, &val
);
4419 ts
->stopping_tracepoint
= val
;
4420 ts
->stop_reason
= tracepoint_error
;
4422 else if (strncmp (p
, "tframes", p1
- p
) == 0)
4424 p
= unpack_varlen_hex (++p1
, &val
);
4425 ts
->traceframe_count
= val
;
4427 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
4429 p
= unpack_varlen_hex (++p1
, &val
);
4430 ts
->traceframes_created
= val
;
4432 else if (strncmp (p
, "tfree", p1
- p
) == 0)
4434 p
= unpack_varlen_hex (++p1
, &val
);
4435 ts
->buffer_free
= val
;
4437 else if (strncmp (p
, "tsize", p1
- p
) == 0)
4439 p
= unpack_varlen_hex (++p1
, &val
);
4440 ts
->buffer_size
= val
;
4442 else if (strncmp (p
, "disconn", p1
- p
) == 0)
4444 p
= unpack_varlen_hex (++p1
, &val
);
4445 ts
->disconnected_tracing
= val
;
4447 else if (strncmp (p
, "circular", p1
- p
) == 0)
4449 p
= unpack_varlen_hex (++p1
, &val
);
4450 ts
->circular_buffer
= val
;
4452 else if (strncmp (p
, "starttime", p1
- p
) == 0)
4454 p
= unpack_varlen_hex (++p1
, &val
);
4455 ts
->start_time
= val
;
4457 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
4459 p
= unpack_varlen_hex (++p1
, &val
);
4460 ts
->stop_time
= val
;
4462 else if (strncmp (p
, "username", p1
- p
) == 0)
4465 ts
->user_name
= xmalloc (strlen (p
) / 2);
4466 end
= hex2bin (p1
, (gdb_byte
*) ts
->user_name
, (p3
- p1
) / 2);
4467 ts
->user_name
[end
] = '\0';
4470 else if (strncmp (p
, "notes", p1
- p
) == 0)
4473 ts
->notes
= xmalloc (strlen (p
) / 2);
4474 end
= hex2bin (p1
, (gdb_byte
*) ts
->notes
, (p3
- p1
) / 2);
4475 ts
->notes
[end
] = '\0';
4480 /* Silently skip unknown optional info. */
4481 p_temp
= strchr (p1
+ 1, ';');
4485 /* Must be at the end. */
4492 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
4493 struct uploaded_tp
*utp
)
4496 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
4498 p
= unpack_varlen_hex (p
, &uval
);
4500 tp
->base
.hit_count
+= uval
;
4502 utp
->hit_count
+= uval
;
4503 p
= unpack_varlen_hex (p
+ 1, &uval
);
4505 tp
->traceframe_usage
+= uval
;
4507 utp
->traceframe_usage
+= uval
;
4508 /* Ignore any extra, allowing for future extensions. */
4511 /* Given a line of text defining a part of a tracepoint, parse it into
4512 an "uploaded tracepoint". */
4515 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
4519 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
4522 char *cond
, *srctype
, *buf
;
4523 struct uploaded_tp
*utp
= NULL
;
4526 /* Both tracepoint and action definitions start with the same number
4527 and address sequence. */
4529 p
= unpack_varlen_hex (p
, &num
);
4530 p
++; /* skip a colon */
4531 p
= unpack_varlen_hex (p
, &addr
);
4532 p
++; /* skip a colon */
4535 enabled
= (*p
++ == 'E');
4536 p
++; /* skip a colon */
4537 p
= unpack_varlen_hex (p
, &step
);
4538 p
++; /* skip a colon */
4539 p
= unpack_varlen_hex (p
, &pass
);
4540 type
= bp_tracepoint
;
4542 /* Thumb through optional fields. */
4545 p
++; /* skip a colon */
4548 type
= bp_fast_tracepoint
;
4550 p
= unpack_varlen_hex (p
, &orig_size
);
4554 type
= bp_static_tracepoint
;
4560 p
= unpack_varlen_hex (p
, &xlen
);
4561 p
++; /* skip a comma */
4562 cond
= (char *) xmalloc (2 * xlen
+ 1);
4563 strncpy (cond
, p
, 2 * xlen
);
4564 cond
[2 * xlen
] = '\0';
4568 warning (_("Unrecognized char '%c' in tracepoint "
4569 "definition, skipping rest"), *p
);
4571 utp
= get_uploaded_tp (num
, addr
, utpp
);
4573 utp
->enabled
= enabled
;
4578 else if (piece
== 'A')
4580 utp
= get_uploaded_tp (num
, addr
, utpp
);
4581 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
4583 else if (piece
== 'S')
4585 utp
= get_uploaded_tp (num
, addr
, utpp
);
4586 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
4588 else if (piece
== 'Z')
4590 /* Parse a chunk of source form definition. */
4591 utp
= get_uploaded_tp (num
, addr
, utpp
);
4593 p
= strchr (p
, ':');
4594 p
++; /* skip a colon */
4595 p
= unpack_varlen_hex (p
, &start
);
4596 p
++; /* skip a colon */
4597 p
= unpack_varlen_hex (p
, &xlen
);
4598 p
++; /* skip a colon */
4600 buf
= alloca (strlen (line
));
4602 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4605 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
4606 utp
->at_string
= xstrdup (buf
);
4607 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
4608 utp
->cond_string
= xstrdup (buf
);
4609 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
4610 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
4612 else if (piece
== 'V')
4614 utp
= get_uploaded_tp (num
, addr
, utpp
);
4616 parse_tracepoint_status (p
, NULL
, utp
);
4620 /* Don't error out, the target might be sending us optional
4621 info that we don't care about. */
4622 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
4626 /* Convert a textual description of a trace state variable into an
4630 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
4633 ULONGEST num
, initval
, builtin
;
4635 struct uploaded_tsv
*utsv
= NULL
;
4637 buf
= alloca (strlen (line
));
4640 p
= unpack_varlen_hex (p
, &num
);
4641 p
++; /* skip a colon */
4642 p
= unpack_varlen_hex (p
, &initval
);
4643 p
++; /* skip a colon */
4644 p
= unpack_varlen_hex (p
, &builtin
);
4645 p
++; /* skip a colon */
4646 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4649 utsv
= get_uploaded_tsv (num
, utsvp
);
4650 utsv
->initial_value
= initval
;
4651 utsv
->builtin
= builtin
;
4652 utsv
->name
= xstrdup (buf
);
4655 /* Close the trace file and generally clean up. */
4665 pid
= ptid_get_pid (inferior_ptid
);
4666 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff. */
4667 exit_inferior_silent (pid
);
4671 xfree (trace_filename
);
4672 trace_filename
= NULL
;
4676 tfile_files_info (struct target_ops
*t
)
4678 printf_filtered ("\t`%s'\n", trace_filename
);
4681 /* The trace status for a file is that tracing can never be run. */
4684 tfile_get_trace_status (struct trace_status
*ts
)
4686 /* Other bits of trace status were collected as part of opening the
4687 trace files, so nothing to do here. */
4693 tfile_get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
4695 /* Other bits of trace status were collected as part of opening the
4696 trace files, so nothing to do here. */
4699 /* Given the position of a traceframe in the file, figure out what
4700 address the frame was collected at. This would normally be the
4701 value of a collected PC register, but if not available, we
4705 tfile_get_traceframe_address (off_t tframe_offset
)
4709 struct tracepoint
*tp
;
4710 off_t saved_offset
= cur_offset
;
4712 /* FIXME dig pc out of collected registers. */
4714 /* Fall back to using tracepoint address. */
4715 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
4716 tfile_read ((gdb_byte
*) &tpnum
, 2);
4717 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4719 (target_gdbarch ()));
4721 tp
= get_tracepoint_by_number_on_target (tpnum
);
4722 /* FIXME this is a poor heuristic if multiple locations. */
4723 if (tp
&& tp
->base
.loc
)
4724 addr
= tp
->base
.loc
->address
;
4726 /* Restore our seek position. */
4727 cur_offset
= saved_offset
;
4728 lseek (trace_fd
, cur_offset
, SEEK_SET
);
4732 /* Given a type of search and some parameters, scan the collection of
4733 traceframes in the file looking for a match. When found, return
4734 both the traceframe and tracepoint number, otherwise -1 for
4738 tfile_trace_find (enum trace_find_type type
, int num
,
4739 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
)
4742 int tfnum
= 0, found
= 0;
4743 unsigned int data_size
;
4744 struct tracepoint
*tp
;
4745 off_t offset
, tframe_offset
;
4755 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
4756 offset
= trace_frames_offset
;
4759 tframe_offset
= offset
;
4760 tfile_read ((gdb_byte
*) &tpnum
, 2);
4761 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4763 (target_gdbarch ()));
4767 tfile_read ((gdb_byte
*) &data_size
, 4);
4768 data_size
= (unsigned int) extract_unsigned_integer
4769 ((gdb_byte
*) &data_size
, 4,
4770 gdbarch_byte_order (target_gdbarch ()));
4773 if (type
== tfind_number
)
4775 /* Looking for a specific trace frame. */
4781 /* Start from the _next_ trace frame. */
4782 if (tfnum
> traceframe_number
)
4787 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4788 if (tfaddr
== addr1
)
4792 tp
= get_tracepoint (num
);
4793 if (tp
&& tpnum
== tp
->number_on_target
)
4797 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4798 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
4802 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4803 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
4807 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
4816 cur_offset
= offset
;
4817 cur_data_size
= data_size
;
4821 /* Skip past the traceframe's data. */
4822 lseek (trace_fd
, data_size
, SEEK_CUR
);
4823 offset
+= data_size
;
4824 /* Update our own count of traceframes. */
4827 /* Did not find what we were looking for. */
4833 /* Prototype of the callback passed to tframe_walk_blocks. */
4834 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
4836 /* Callback for traceframe_walk_blocks, used to find a given block
4837 type in a traceframe. */
4840 match_blocktype (char blocktype
, void *data
)
4842 char *wantedp
= data
;
4844 if (*wantedp
== blocktype
)
4850 /* Walk over all traceframe block starting at POS offset from
4851 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4852 unmodified. If CALLBACK returns true, this returns the position in
4853 the traceframe where the block is found, relative to the start of
4854 the traceframe (cur_offset). Returns -1 if no callback call
4855 returned true, indicating that all blocks have been walked. */
4858 traceframe_walk_blocks (walk_blocks_callback_func callback
,
4859 int pos
, void *data
)
4861 /* Iterate through a traceframe's blocks, looking for a block of the
4864 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
4865 while (pos
< cur_data_size
)
4867 unsigned short mlen
;
4870 tfile_read ((gdb_byte
*) &block_type
, 1);
4874 if ((*callback
) (block_type
, data
))
4880 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4881 pos
+= trace_regblock_size
;
4884 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4885 tfile_read ((gdb_byte
*) &mlen
, 2);
4886 mlen
= (unsigned short)
4887 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4889 (target_gdbarch ()));
4890 lseek (trace_fd
, mlen
, SEEK_CUR
);
4891 pos
+= (8 + 2 + mlen
);
4894 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
4898 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4899 block_type
, block_type
);
4907 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4908 position offset of a block of type TYPE_WANTED in the current trace
4909 frame, starting at POS. Returns -1 if no such block was found. */
4912 traceframe_find_block_type (char type_wanted
, int pos
)
4914 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
4917 /* Look for a block of saved registers in the traceframe, and get the
4918 requested register from it. */
4921 tfile_fetch_registers (struct target_ops
*ops
,
4922 struct regcache
*regcache
, int regno
)
4924 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4925 int offset
, regn
, regsize
, pc_regno
;
4928 /* An uninitialized reg size says we're not going to be
4929 successful at getting register blocks. */
4930 if (!trace_regblock_size
)
4933 regs
= alloca (trace_regblock_size
);
4935 if (traceframe_find_block_type ('R', 0) >= 0)
4937 tfile_read (regs
, trace_regblock_size
);
4939 /* Assume the block is laid out in GDB register number order,
4940 each register with the size that it has in GDB. */
4942 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4944 regsize
= register_size (gdbarch
, regn
);
4945 /* Make sure we stay within block bounds. */
4946 if (offset
+ regsize
>= trace_regblock_size
)
4948 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
4952 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
4955 else if (regno
== -1)
4957 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
4965 /* We get here if no register data has been found. Mark registers
4967 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4968 regcache_raw_supply (regcache
, regn
, NULL
);
4970 /* We can often usefully guess that the PC is going to be the same
4971 as the address of the tracepoint. */
4972 pc_regno
= gdbarch_pc_regnum (gdbarch
);
4973 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
4975 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
4977 if (tp
&& tp
->base
.loc
)
4979 /* But don't try to guess if tracepoint is multi-location... */
4980 if (tp
->base
.loc
->next
)
4982 warning (_("Tracepoint %d has multiple "
4983 "locations, cannot infer $pc"),
4987 /* ... or does while-stepping. */
4988 if (tp
->step_count
> 0)
4990 warning (_("Tracepoint %d does while-stepping, "
4991 "cannot infer $pc"),
4996 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
4997 gdbarch_byte_order (gdbarch
),
4998 tp
->base
.loc
->address
);
4999 regcache_raw_supply (regcache
, pc_regno
, regs
);
5005 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5006 const char *annex
, gdb_byte
*readbuf
,
5007 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5009 /* We're only doing regular memory for now. */
5010 if (object
!= TARGET_OBJECT_MEMORY
)
5013 if (readbuf
== NULL
)
5014 error (_("tfile_xfer_partial: trace file is read-only"));
5016 if (traceframe_number
!= -1)
5020 /* Iterate through the traceframe's blocks, looking for
5022 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
5024 ULONGEST maddr
, amt
;
5025 unsigned short mlen
;
5026 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
5028 tfile_read ((gdb_byte
*) &maddr
, 8);
5029 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
5031 tfile_read ((gdb_byte
*) &mlen
, 2);
5032 mlen
= (unsigned short)
5033 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
5035 /* If the block includes the first part of the desired
5036 range, return as much it has; GDB will re-request the
5037 remainder, which might be in a different block of this
5039 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
5041 amt
= (maddr
+ mlen
) - offset
;
5045 if (maddr
!= offset
)
5046 lseek (trace_fd
, offset
- maddr
, SEEK_CUR
);
5047 tfile_read (readbuf
, amt
);
5051 /* Skip over this block. */
5052 pos
+= (8 + 2 + mlen
);
5056 /* It's unduly pedantic to refuse to look at the executable for
5057 read-only pieces; so do the equivalent of readonly regions aka
5059 /* FIXME account for relocation at some point. */
5066 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5068 if ((s
->flags
& SEC_LOAD
) == 0
5069 || (s
->flags
& SEC_READONLY
) == 0)
5073 size
= bfd_get_section_size (s
);
5074 if (vma
<= offset
&& offset
< (vma
+ size
))
5078 amt
= (vma
+ size
) - offset
;
5082 amt
= bfd_get_section_contents (exec_bfd
, s
,
5083 readbuf
, offset
- vma
, amt
);
5089 /* Indicate failure to find the requested memory block. */
5093 /* Iterate through the blocks of a trace frame, looking for a 'V'
5094 block with a matching tsv number. */
5097 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
5102 /* Iterate over blocks in current frame and find the last 'V'
5103 block in which tsv number is TSVNUM. In one trace frame, there
5104 may be multiple 'V' blocks created for a given trace variable,
5105 and the last matched 'V' block contains the updated value. */
5107 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
5111 tfile_read ((gdb_byte
*) &vnum
, 4);
5112 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
5114 (target_gdbarch ()));
5117 tfile_read ((gdb_byte
*) val
, 8);
5118 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
5120 (target_gdbarch ()));
5130 tfile_has_all_memory (struct target_ops
*ops
)
5136 tfile_has_memory (struct target_ops
*ops
)
5142 tfile_has_stack (struct target_ops
*ops
)
5144 return traceframe_number
!= -1;
5148 tfile_has_registers (struct target_ops
*ops
)
5150 return traceframe_number
!= -1;
5154 tfile_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
5159 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
5160 object for the tfile target's current traceframe. */
5163 build_traceframe_info (char blocktype
, void *data
)
5165 struct traceframe_info
*info
= data
;
5171 struct mem_range
*r
;
5173 unsigned short mlen
;
5175 tfile_read ((gdb_byte
*) &maddr
, 8);
5176 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
5178 (target_gdbarch ()));
5179 tfile_read ((gdb_byte
*) &mlen
, 2);
5180 mlen
= (unsigned short)
5181 extract_unsigned_integer ((gdb_byte
*) &mlen
,
5182 2, gdbarch_byte_order
5183 (target_gdbarch ()));
5185 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5198 warning (_("Unhandled trace block type (%d) '%c ' "
5199 "while building trace frame info."),
5200 blocktype
, blocktype
);
5207 static struct traceframe_info
*
5208 tfile_traceframe_info (void)
5210 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
5212 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
5217 init_tfile_ops (void)
5219 tfile_ops
.to_shortname
= "tfile";
5220 tfile_ops
.to_longname
= "Local trace dump file";
5222 = "Use a trace file as a target. Specify the filename of the trace file.";
5223 tfile_ops
.to_open
= tfile_open
;
5224 tfile_ops
.to_close
= tfile_close
;
5225 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
5226 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
5227 tfile_ops
.to_files_info
= tfile_files_info
;
5228 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
5229 tfile_ops
.to_get_tracepoint_status
= tfile_get_tracepoint_status
;
5230 tfile_ops
.to_trace_find
= tfile_trace_find
;
5231 tfile_ops
.to_get_trace_state_variable_value
5232 = tfile_get_trace_state_variable_value
;
5233 tfile_ops
.to_stratum
= process_stratum
;
5234 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
5235 tfile_ops
.to_has_memory
= tfile_has_memory
;
5236 tfile_ops
.to_has_stack
= tfile_has_stack
;
5237 tfile_ops
.to_has_registers
= tfile_has_registers
;
5238 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
5239 tfile_ops
.to_thread_alive
= tfile_thread_alive
;
5240 tfile_ops
.to_magic
= OPS_MAGIC
;
5244 free_current_marker (void *arg
)
5246 struct static_tracepoint_marker
**marker_p
= arg
;
5248 if (*marker_p
!= NULL
)
5250 release_static_tracepoint_marker (*marker_p
);
5257 /* Given a line of text defining a static tracepoint marker, parse it
5258 into a "static tracepoint marker" object. Throws an error is
5259 parsing fails. If PP is non-null, it points to one past the end of
5260 the parsed marker definition. */
5263 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
5264 struct static_tracepoint_marker
*marker
)
5271 p
= unpack_varlen_hex (p
, &addr
);
5272 p
++; /* skip a colon */
5274 marker
->gdbarch
= target_gdbarch ();
5275 marker
->address
= (CORE_ADDR
) addr
;
5277 endp
= strchr (p
, ':');
5279 error (_("bad marker definition: %s"), line
);
5281 marker
->str_id
= xmalloc (endp
- p
+ 1);
5282 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
5283 marker
->str_id
[end
] = '\0';
5286 p
++; /* skip a colon */
5288 marker
->extra
= xmalloc (strlen (p
) + 1);
5289 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
5290 marker
->extra
[end
] = '\0';
5296 /* Release a static tracepoint marker's contents. Note that the
5297 object itself isn't released here. There objects are usually on
5301 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
5303 xfree (marker
->str_id
);
5304 marker
->str_id
= NULL
;
5307 /* Print MARKER to gdb_stdout. */
5310 print_one_static_tracepoint_marker (int count
,
5311 struct static_tracepoint_marker
*marker
)
5313 struct command_line
*l
;
5316 char wrap_indent
[80];
5317 char extra_field_indent
[80];
5318 struct ui_out
*uiout
= current_uiout
;
5319 struct cleanup
*bkpt_chain
;
5320 VEC(breakpoint_p
) *tracepoints
;
5322 struct symtab_and_line sal
;
5326 sal
.pc
= marker
->address
;
5328 tracepoints
= static_tracepoints_here (marker
->address
);
5330 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
5332 /* A counter field to help readability. This is not a stable
5334 ui_out_field_int (uiout
, "count", count
);
5336 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
5338 ui_out_field_fmt (uiout
, "enabled", "%c",
5339 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
5340 ui_out_spaces (uiout
, 2);
5342 strcpy (wrap_indent
, " ");
5344 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
5345 strcat (wrap_indent
, " ");
5347 strcat (wrap_indent
, " ");
5349 strcpy (extra_field_indent
, " ");
5351 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
5353 sal
= find_pc_line (marker
->address
, 0);
5354 sym
= find_pc_sect_function (marker
->address
, NULL
);
5357 ui_out_text (uiout
, "in ");
5358 ui_out_field_string (uiout
, "func",
5359 SYMBOL_PRINT_NAME (sym
));
5360 ui_out_wrap_hint (uiout
, wrap_indent
);
5361 ui_out_text (uiout
, " at ");
5364 ui_out_field_skip (uiout
, "func");
5366 if (sal
.symtab
!= NULL
)
5368 ui_out_field_string (uiout
, "file",
5369 symtab_to_filename_for_display (sal
.symtab
));
5370 ui_out_text (uiout
, ":");
5372 if (ui_out_is_mi_like_p (uiout
))
5374 const char *fullname
= symtab_to_fullname (sal
.symtab
);
5376 ui_out_field_string (uiout
, "fullname", fullname
);
5379 ui_out_field_skip (uiout
, "fullname");
5381 ui_out_field_int (uiout
, "line", sal
.line
);
5385 ui_out_field_skip (uiout
, "fullname");
5386 ui_out_field_skip (uiout
, "line");
5389 ui_out_text (uiout
, "\n");
5390 ui_out_text (uiout
, extra_field_indent
);
5391 ui_out_text (uiout
, _("Data: \""));
5392 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
5393 ui_out_text (uiout
, "\"\n");
5395 if (!VEC_empty (breakpoint_p
, tracepoints
))
5397 struct cleanup
*cleanup_chain
;
5399 struct breakpoint
*b
;
5401 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
5404 ui_out_text (uiout
, extra_field_indent
);
5405 ui_out_text (uiout
, _("Probed by static tracepoints: "));
5406 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
5409 ui_out_text (uiout
, ", ");
5410 ui_out_text (uiout
, "#");
5411 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
5414 do_cleanups (cleanup_chain
);
5416 if (ui_out_is_mi_like_p (uiout
))
5417 ui_out_field_int (uiout
, "number-of-tracepoints",
5418 VEC_length(breakpoint_p
, tracepoints
));
5420 ui_out_text (uiout
, "\n");
5422 VEC_free (breakpoint_p
, tracepoints
);
5424 do_cleanups (bkpt_chain
);
5428 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
5430 VEC(static_tracepoint_marker_p
) *markers
;
5431 struct cleanup
*old_chain
;
5432 struct static_tracepoint_marker
*marker
;
5433 struct ui_out
*uiout
= current_uiout
;
5436 /* We don't have to check target_can_use_agent and agent's capability on
5437 static tracepoint here, in order to be compatible with older GDBserver.
5438 We don't check USE_AGENT is true or not, because static tracepoints
5439 don't work without in-process agent, so we don't bother users to type
5440 `set agent on' when to use static tracepoint. */
5443 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
5444 "StaticTracepointMarkersTable");
5446 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
5448 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
5450 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
5451 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
5452 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
5454 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
5455 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
5457 ui_out_table_body (uiout
);
5459 markers
= target_static_tracepoint_markers_by_strid (NULL
);
5460 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
5463 VEC_iterate (static_tracepoint_marker_p
,
5464 markers
, i
, marker
);
5467 print_one_static_tracepoint_marker (i
+ 1, marker
);
5468 release_static_tracepoint_marker (marker
);
5471 do_cleanups (old_chain
);
5474 /* The $_sdata convenience variable is a bit special. We don't know
5475 for sure type of the value until we actually have a chance to fetch
5476 the data --- the size of the object depends on what has been
5477 collected. We solve this by making $_sdata be an internalvar that
5478 creates a new value on access. */
5480 /* Return a new value with the correct type for the sdata object of
5481 the current trace frame. Return a void value if there's no object
5484 static struct value
*
5485 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
5491 /* We need to read the whole object before we know its size. */
5492 size
= target_read_alloc (¤t_target
,
5493 TARGET_OBJECT_STATIC_TRACE_DATA
,
5500 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
5502 v
= allocate_value (type
);
5503 memcpy (value_contents_raw (v
), buf
, size
);
5508 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
5511 #if !defined(HAVE_LIBEXPAT)
5513 struct traceframe_info
*
5514 parse_traceframe_info (const char *tframe_info
)
5516 static int have_warned
;
5521 warning (_("Can not parse XML trace frame info; XML support "
5522 "was disabled at compile time"));
5528 #else /* HAVE_LIBEXPAT */
5530 #include "xml-support.h"
5532 /* Handle the start of a <memory> element. */
5535 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
5536 const struct gdb_xml_element
*element
,
5537 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
5539 struct traceframe_info
*info
= user_data
;
5540 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5541 ULONGEST
*start_p
, *length_p
;
5543 start_p
= xml_find_attribute (attributes
, "start")->value
;
5544 length_p
= xml_find_attribute (attributes
, "length")->value
;
5546 r
->start
= *start_p
;
5547 r
->length
= *length_p
;
5550 /* Discard the constructed trace frame info (if an error occurs). */
5553 free_result (void *p
)
5555 struct traceframe_info
*result
= p
;
5557 free_traceframe_info (result
);
5560 /* The allowed elements and attributes for an XML memory map. */
5562 static const struct gdb_xml_attribute memory_attributes
[] = {
5563 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5564 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5565 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5568 static const struct gdb_xml_element traceframe_info_children
[] = {
5569 { "memory", memory_attributes
, NULL
,
5570 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5571 traceframe_info_start_memory
, NULL
},
5572 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5575 static const struct gdb_xml_element traceframe_info_elements
[] = {
5576 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
5578 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5581 /* Parse a traceframe-info XML document. */
5583 struct traceframe_info
*
5584 parse_traceframe_info (const char *tframe_info
)
5586 struct traceframe_info
*result
;
5587 struct cleanup
*back_to
;
5589 result
= XCNEW (struct traceframe_info
);
5590 back_to
= make_cleanup (free_result
, result
);
5592 if (gdb_xml_parse_quick (_("trace frame info"),
5593 "traceframe-info.dtd", traceframe_info_elements
,
5594 tframe_info
, result
) == 0)
5596 /* Parsed successfully, keep the result. */
5597 discard_cleanups (back_to
);
5602 do_cleanups (back_to
);
5606 #endif /* HAVE_LIBEXPAT */
5608 /* Returns the traceframe_info object for the current traceframe.
5609 This is where we avoid re-fetching the object from the target if we
5610 already have it cached. */
5612 static struct traceframe_info
*
5613 get_traceframe_info (void)
5615 if (traceframe_info
== NULL
)
5616 traceframe_info
= target_traceframe_info ();
5618 return traceframe_info
;
5621 /* If the target supports the query, return in RESULT the set of
5622 collected memory in the current traceframe, found within the LEN
5623 bytes range starting at MEMADDR. Returns true if the target
5624 supports the query, otherwise returns false, and RESULT is left
5628 traceframe_available_memory (VEC(mem_range_s
) **result
,
5629 CORE_ADDR memaddr
, ULONGEST len
)
5631 struct traceframe_info
*info
= get_traceframe_info ();
5635 struct mem_range
*r
;
5640 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
5641 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
5643 ULONGEST lo1
, hi1
, lo2
, hi2
;
5644 struct mem_range
*nr
;
5647 hi1
= memaddr
+ len
;
5650 hi2
= r
->start
+ r
->length
;
5652 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
5654 nr
->start
= max (lo1
, lo2
);
5655 nr
->length
= min (hi1
, hi2
) - nr
->start
;
5658 normalize_mem_ranges (*result
);
5665 /* Implementation of `sdata' variable. */
5667 static const struct internalvar_funcs sdata_funcs
=
5674 /* module initialization */
5676 _initialize_tracepoint (void)
5678 struct cmd_list_element
*c
;
5680 /* Explicitly create without lookup, since that tries to create a
5681 value with a void typed value, and when we get here, gdbarch
5682 isn't initialized yet. At this point, we're quite sure there
5683 isn't another convenience variable of the same name. */
5684 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
5686 traceframe_number
= -1;
5687 tracepoint_number
= -1;
5689 if (tracepoint_list
.list
== NULL
)
5691 tracepoint_list
.listsize
= 128;
5692 tracepoint_list
.list
= xmalloc
5693 (tracepoint_list
.listsize
* sizeof (struct memrange
));
5695 if (tracepoint_list
.aexpr_list
== NULL
)
5697 tracepoint_list
.aexpr_listsize
= 128;
5698 tracepoint_list
.aexpr_list
= xmalloc
5699 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5702 if (stepping_list
.list
== NULL
)
5704 stepping_list
.listsize
= 128;
5705 stepping_list
.list
= xmalloc
5706 (stepping_list
.listsize
* sizeof (struct memrange
));
5709 if (stepping_list
.aexpr_list
== NULL
)
5711 stepping_list
.aexpr_listsize
= 128;
5712 stepping_list
.aexpr_list
= xmalloc
5713 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5716 add_info ("scope", scope_info
,
5717 _("List the variables local to a scope"));
5719 add_cmd ("tracepoints", class_trace
, NULL
,
5720 _("Tracing of program execution without stopping the program."),
5723 add_com ("tdump", class_trace
, trace_dump_command
,
5724 _("Print everything collected at the current tracepoint."));
5726 add_com ("tsave", class_trace
, trace_save_command
, _("\
5727 Save the trace data to a file.\n\
5728 Use the '-ctf' option to save the data to CTF format.\n\
5729 Use the '-r' option to direct the target to save directly to the file,\n\
5730 using its own filesystem."));
5732 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
5733 Define a trace state variable.\n\
5734 Argument is a $-prefixed name, optionally followed\n\
5735 by '=' and an expression that sets the initial value\n\
5736 at the start of tracing."));
5737 set_cmd_completer (c
, expression_completer
);
5739 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
5740 Delete one or more trace state variables.\n\
5741 Arguments are the names of the variables to delete.\n\
5742 If no arguments are supplied, delete all variables."), &deletelist
);
5743 /* FIXME add a trace variable completer. */
5745 add_info ("tvariables", tvariables_info
, _("\
5746 Status of trace state variables and their values.\n\
5749 add_info ("static-tracepoint-markers",
5750 info_static_tracepoint_markers_command
, _("\
5751 List target static tracepoints markers.\n\
5754 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
5755 Select a trace frame;\n\
5756 No argument means forward by one frame; '-' means backward by one frame."),
5757 &tfindlist
, "tfind ", 1, &cmdlist
);
5759 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
5760 Select a trace frame whose PC is outside the given range (exclusive).\n\
5761 Usage: tfind outside addr1, addr2"),
5764 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
5765 Select a trace frame whose PC is in the given range (inclusive).\n\
5766 Usage: tfind range addr1,addr2"),
5769 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
5770 Select a trace frame by source line.\n\
5771 Argument can be a line number (with optional source file),\n\
5772 a function name, or '*' followed by an address.\n\
5773 Default argument is 'the next source line that was traced'."),
5776 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
5777 Select a trace frame by tracepoint number.\n\
5778 Default is the tracepoint for the current trace frame."),
5781 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
5782 Select a trace frame by PC.\n\
5783 Default is the current PC, or the PC of the current trace frame."),
5786 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
5787 De-select any trace frame and resume 'live' debugging."),
5790 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
5792 add_cmd ("start", class_trace
, trace_find_start_command
,
5793 _("Select the first trace frame in the trace buffer."),
5796 add_com ("tstatus", class_trace
, trace_status_command
,
5797 _("Display the status of the current trace data collection."));
5799 add_com ("tstop", class_trace
, trace_stop_command
, _("\
5800 Stop trace data collection.\n\
5801 Usage: tstop [ <notes> ... ]\n\
5802 Any arguments supplied are recorded with the trace as a stop reason and\n\
5803 reported by tstatus (if the target supports trace notes)."));
5805 add_com ("tstart", class_trace
, trace_start_command
, _("\
5806 Start trace data collection.\n\
5807 Usage: tstart [ <notes> ... ]\n\
5808 Any arguments supplied are recorded with the trace as a note and\n\
5809 reported by tstatus (if the target supports trace notes)."));
5811 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
5812 Ends a list of commands or actions.\n\
5813 Several GDB commands allow you to enter a list of commands or actions.\n\
5814 Entering \"end\" on a line by itself is the normal way to terminate\n\
5816 Note: the \"end\" command cannot be used at the gdb prompt."));
5818 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
5819 Specify single-stepping behavior at a tracepoint.\n\
5820 Argument is number of instructions to trace in single-step mode\n\
5821 following the tracepoint. This command is normally followed by\n\
5822 one or more \"collect\" commands, to specify what to collect\n\
5823 while single-stepping.\n\n\
5824 Note: this command can only be used in a tracepoint \"actions\" list."));
5826 add_com_alias ("ws", "while-stepping", class_alias
, 0);
5827 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
5829 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
5830 Specify one or more data items to be collected at a tracepoint.\n\
5831 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5832 collect all data (variables, registers) referenced by that expression.\n\
5833 Also accepts the following special arguments:\n\
5834 $regs -- all registers.\n\
5835 $args -- all function arguments.\n\
5836 $locals -- all variables local to the block/function scope.\n\
5837 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5838 Note: this command can only be used in a tracepoint \"actions\" list."));
5840 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
5841 Specify one or more expressions to be evaluated at a tracepoint.\n\
5842 Accepts a comma-separated list of (one or more) expressions.\n\
5843 The result of each evaluation will be discarded.\n\
5844 Note: this command can only be used in a tracepoint \"actions\" list."));
5846 add_com ("actions", class_trace
, trace_actions_command
, _("\
5847 Specify the actions to be taken at a tracepoint.\n\
5848 Tracepoint actions may include collecting of specified data,\n\
5849 single-stepping, or enabling/disabling other tracepoints,\n\
5850 depending on target's capabilities."));
5852 default_collect
= xstrdup ("");
5853 add_setshow_string_cmd ("default-collect", class_trace
,
5854 &default_collect
, _("\
5855 Set the list of expressions to collect by default"), _("\
5856 Show the list of expressions to collect by default"), NULL
,
5858 &setlist
, &showlist
);
5860 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
5861 &disconnected_tracing
, _("\
5862 Set whether tracing continues after GDB disconnects."), _("\
5863 Show whether tracing continues after GDB disconnects."), _("\
5864 Use this to continue a tracing run even if GDB disconnects\n\
5865 or detaches from the target. You can reconnect later and look at\n\
5866 trace data collected in the meantime."),
5867 set_disconnected_tracing
,
5872 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
5873 &circular_trace_buffer
, _("\
5874 Set target's use of circular trace buffer."), _("\
5875 Show target's use of circular trace buffer."), _("\
5876 Use this to make the trace buffer into a circular buffer,\n\
5877 which will discard traceframes (oldest first) instead of filling\n\
5878 up and stopping the trace run."),
5879 set_circular_trace_buffer
,
5884 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class
,
5885 &trace_buffer_size
, _("\
5886 Set requested size of trace buffer."), _("\
5887 Show requested size of trace buffer."), _("\
5888 Use this to choose a size for the trace buffer. Some targets\n\
5889 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
5890 disables any attempt to set the buffer size and lets the target choose."),
5891 set_trace_buffer_size
, NULL
,
5892 &setlist
, &showlist
);
5894 add_setshow_string_cmd ("trace-user", class_trace
,
5896 Set the user name to use for current and future trace runs"), _("\
5897 Show the user name to use for current and future trace runs"), NULL
,
5898 set_trace_user
, NULL
,
5899 &setlist
, &showlist
);
5901 add_setshow_string_cmd ("trace-notes", class_trace
,
5903 Set notes string to use for current and future trace runs"), _("\
5904 Show the notes string to use for current and future trace runs"), NULL
,
5905 set_trace_notes
, NULL
,
5906 &setlist
, &showlist
);
5908 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
5909 &trace_stop_notes
, _("\
5910 Set notes string to use for future tstop commands"), _("\
5911 Show the notes string to use for future tstop commands"), NULL
,
5912 set_trace_stop_notes
, NULL
,
5913 &setlist
, &showlist
);
5917 add_target_with_completer (&tfile_ops
, filename_completer
);