1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
25 #include "expression.h"
30 #include "gdb_string.h"
32 #include "breakpoint.h"
33 #include "tracepoint.h"
36 #include "completer.h"
38 #include "dictionary.h"
40 #include "user-regs.h"
44 #include "filenames.h"
45 #include "gdbthread.h"
53 #include "exceptions.h"
54 #include "cli/cli-utils.h"
57 #include "completer.h"
58 #include "filestuff.h"
60 /* readline include files */
61 #include "readline/readline.h"
62 #include "readline/history.h"
64 /* readline defines this. */
75 /* Maximum length of an agent aexpression.
76 This accounts for the fact that packets are limited to 400 bytes
77 (which includes everything -- including the checksum), and assumes
78 the worst case of maximum length for each of the pieces of a
81 NOTE: expressions get mem2hex'ed otherwise this would be twice as
82 large. (400 - 31)/2 == 184 */
83 #define MAX_AGENT_EXPR_LEN 184
85 /* A hook used to notify the UI of tracepoint operations. */
87 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
88 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
90 extern void (*deprecated_readline_begin_hook
) (char *, ...);
91 extern char *(*deprecated_readline_hook
) (char *);
92 extern void (*deprecated_readline_end_hook
) (void);
97 This module defines the following debugger commands:
98 trace : set a tracepoint on a function, line, or address.
99 info trace : list all debugger-defined tracepoints.
100 delete trace : delete one or more tracepoints.
101 enable trace : enable one or more tracepoints.
102 disable trace : disable one or more tracepoints.
103 actions : specify actions to be taken at a tracepoint.
104 passcount : specify a pass count for a tracepoint.
105 tstart : start a trace experiment.
106 tstop : stop a trace experiment.
107 tstatus : query the status of a trace experiment.
108 tfind : find a trace frame in the trace buffer.
109 tdump : print everything collected at the current tracepoint.
110 save-tracepoints : write tracepoint setup into a file.
112 This module defines the following user-visible debugger variables:
113 $trace_frame : sequence number of trace frame currently being debugged.
114 $trace_line : source line of trace frame currently being debugged.
115 $trace_file : source file of trace frame currently being debugged.
116 $tracepoint : tracepoint number of trace frame currently being debugged.
120 /* ======= Important global variables: ======= */
122 /* The list of all trace state variables. We don't retain pointers to
123 any of these for any reason - API is by name or number only - so it
124 works to have a vector of objects. */
126 typedef struct trace_state_variable tsv_s
;
129 static VEC(tsv_s
) *tvariables
;
131 /* The next integer to assign to a variable. */
133 static int next_tsv_number
= 1;
135 /* Number of last traceframe collected. */
136 static int traceframe_number
;
138 /* Tracepoint for last traceframe collected. */
139 static int tracepoint_number
;
141 /* Symbol for function for last traceframe collected. */
142 static struct symbol
*traceframe_fun
;
144 /* Symtab and line for last traceframe collected. */
145 static struct symtab_and_line traceframe_sal
;
147 /* The traceframe info of the current traceframe. NULL if we haven't
148 yet attempted to fetch it, or if the target does not support
149 fetching this object, or if we're not inspecting a traceframe
151 static struct traceframe_info
*traceframe_info
;
153 /* Tracing command lists. */
154 static struct cmd_list_element
*tfindlist
;
156 /* List of expressions to collect by default at each tracepoint hit. */
157 char *default_collect
= "";
159 static int disconnected_tracing
;
161 /* This variable controls whether we ask the target for a linear or
162 circular trace buffer. */
164 static int circular_trace_buffer
;
166 /* This variable is the requested trace buffer size, or -1 to indicate
167 that we don't care and leave it up to the target to set a size. */
169 static int trace_buffer_size
= -1;
171 /* Textual notes applying to the current and/or future trace runs. */
173 char *trace_user
= NULL
;
175 /* Textual notes applying to the current and/or future trace runs. */
177 char *trace_notes
= NULL
;
179 /* Textual notes applying to the stopping of a trace. */
181 char *trace_stop_notes
= NULL
;
183 /* ======= Important command functions: ======= */
184 static void trace_actions_command (char *, int);
185 static void trace_start_command (char *, int);
186 static void trace_stop_command (char *, int);
187 static void trace_status_command (char *, int);
188 static void trace_find_command (char *, int);
189 static void trace_find_pc_command (char *, int);
190 static void trace_find_tracepoint_command (char *, int);
191 static void trace_find_line_command (char *, int);
192 static void trace_find_range_command (char *, int);
193 static void trace_find_outside_command (char *, int);
194 static void trace_dump_command (char *, int);
196 /* support routines */
198 struct collection_list
;
199 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
200 static char *mem2hex (gdb_byte
*, char *, int);
201 static void add_register (struct collection_list
*collection
,
204 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
205 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
207 static struct command_line
*
208 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
);
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
)
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 bp_location
*tloc
,
1371 LONGEST frame_offset
,
1372 struct collection_list
*collect
,
1373 struct collection_list
*stepping_list
)
1375 const char *action_exp
;
1376 struct expression
*exp
= NULL
;
1378 struct value
*tempval
;
1379 struct cmd_list_element
*cmd
;
1380 struct agent_expr
*aexpr
;
1382 for (; action
; action
= action
->next
)
1384 QUIT
; /* Allow user to bail out with ^C. */
1385 action_exp
= action
->line
;
1386 action_exp
= skip_spaces_const (action_exp
);
1388 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1390 error (_("Bad action list item: %s"), action_exp
);
1392 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1394 int trace_string
= 0;
1396 if (*action_exp
== '/')
1397 action_exp
= decode_agent_options (action_exp
, &trace_string
);
1400 { /* Repeat over a comma-separated list. */
1401 QUIT
; /* Allow user to bail out with ^C. */
1402 action_exp
= skip_spaces_const (action_exp
);
1404 if (0 == strncasecmp ("$reg", action_exp
, 4))
1406 for (i
= 0; i
< gdbarch_num_regs (tloc
->gdbarch
); i
++)
1407 add_register (collect
, i
);
1408 action_exp
= strchr (action_exp
, ','); /* more? */
1410 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1412 add_local_symbols (collect
,
1419 action_exp
= strchr (action_exp
, ','); /* more? */
1421 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1423 add_local_symbols (collect
,
1430 action_exp
= strchr (action_exp
, ','); /* more? */
1432 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1434 struct cleanup
*old_chain1
= NULL
;
1436 aexpr
= gen_trace_for_return_address (tloc
->address
,
1440 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1443 report_agent_reqs_errors (aexpr
);
1445 discard_cleanups (old_chain1
);
1446 add_aexpr (collect
, aexpr
);
1448 /* take care of the registers */
1449 if (aexpr
->reg_mask_len
> 0)
1453 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1455 QUIT
; /* allow user to bail out with ^C */
1456 if (aexpr
->reg_mask
[ndx1
] != 0)
1458 /* assume chars have 8 bits */
1459 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1460 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1461 /* it's used -- record it */
1462 add_register (collect
,
1468 action_exp
= strchr (action_exp
, ','); /* more? */
1470 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1472 add_static_trace_data (collect
);
1473 action_exp
= strchr (action_exp
, ','); /* more? */
1478 struct cleanup
*old_chain
= NULL
;
1479 struct cleanup
*old_chain1
= NULL
;
1481 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1482 block_for_pc (tloc
->address
), 1);
1483 old_chain
= make_cleanup (free_current_contents
, &exp
);
1485 switch (exp
->elts
[0].opcode
)
1489 const char *name
= &exp
->elts
[2].string
;
1491 i
= user_reg_map_name_to_regnum (tloc
->gdbarch
,
1492 name
, strlen (name
));
1494 internal_error (__FILE__
, __LINE__
,
1495 _("Register $%s not available"),
1498 printf_filtered ("OP_REGISTER: ");
1499 add_register (collect
, i
);
1504 /* Safe because we know it's a simple expression. */
1505 tempval
= evaluate_expression (exp
);
1506 addr
= value_address (tempval
);
1507 /* Initialize the TYPE_LENGTH if it is a typedef. */
1508 check_typedef (exp
->elts
[1].type
);
1509 add_memrange (collect
, memrange_absolute
, addr
,
1510 TYPE_LENGTH (exp
->elts
[1].type
));
1514 collect_symbol (collect
,
1515 exp
->elts
[2].symbol
,
1523 default: /* Full-fledged expression. */
1524 aexpr
= gen_trace_for_expr (tloc
->address
, exp
,
1527 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1531 report_agent_reqs_errors (aexpr
);
1533 discard_cleanups (old_chain1
);
1534 add_aexpr (collect
, aexpr
);
1536 /* Take care of the registers. */
1537 if (aexpr
->reg_mask_len
> 0)
1542 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1544 QUIT
; /* Allow user to bail out with ^C. */
1545 if (aexpr
->reg_mask
[ndx1
] != 0)
1547 /* Assume chars have 8 bits. */
1548 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1549 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1550 /* It's used -- record it. */
1551 add_register (collect
,
1558 do_cleanups (old_chain
);
1561 while (action_exp
&& *action_exp
++ == ',');
1563 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1566 { /* Repeat over a comma-separated list. */
1567 QUIT
; /* Allow user to bail out with ^C. */
1568 action_exp
= skip_spaces_const (action_exp
);
1571 struct cleanup
*old_chain
= NULL
;
1572 struct cleanup
*old_chain1
= NULL
;
1574 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1575 block_for_pc (tloc
->address
), 1);
1576 old_chain
= make_cleanup (free_current_contents
, &exp
);
1578 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1579 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1582 report_agent_reqs_errors (aexpr
);
1584 discard_cleanups (old_chain1
);
1585 /* Even though we're not officially collecting, add
1586 to the collect list anyway. */
1587 add_aexpr (collect
, aexpr
);
1589 do_cleanups (old_chain
);
1592 while (action_exp
&& *action_exp
++ == ',');
1594 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1596 /* We check against nested while-stepping when setting
1597 breakpoint action, so no way to run into nested
1599 gdb_assert (stepping_list
);
1601 encode_actions_1 (action
->body_list
[0], tloc
, frame_reg
,
1602 frame_offset
, stepping_list
, NULL
);
1605 error (_("Invalid tracepoint command '%s'"), action
->line
);
1609 /* Render all actions into gdb protocol. */
1612 encode_actions (struct bp_location
*tloc
, char ***tdp_actions
,
1613 char ***stepping_actions
)
1615 char *default_collect_line
= NULL
;
1616 struct command_line
*actions
;
1617 struct command_line
*default_collect_action
= NULL
;
1619 LONGEST frame_offset
;
1620 struct cleanup
*back_to
;
1622 back_to
= make_cleanup (null_cleanup
, NULL
);
1624 clear_collection_list (&tracepoint_list
);
1625 clear_collection_list (&stepping_list
);
1627 *tdp_actions
= NULL
;
1628 *stepping_actions
= NULL
;
1630 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1631 tloc
->address
, &frame_reg
, &frame_offset
);
1633 actions
= all_tracepoint_actions_and_cleanup (tloc
->owner
);
1635 encode_actions_1 (actions
, tloc
, frame_reg
, frame_offset
,
1636 &tracepoint_list
, &stepping_list
);
1638 memrange_sortmerge (&tracepoint_list
);
1639 memrange_sortmerge (&stepping_list
);
1641 *tdp_actions
= stringify_collection_list (&tracepoint_list
);
1642 *stepping_actions
= stringify_collection_list (&stepping_list
);
1644 do_cleanups (back_to
);
1648 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1650 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1652 collect
->aexpr_list
=
1653 xrealloc (collect
->aexpr_list
,
1654 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1655 collect
->aexpr_listsize
*= 2;
1657 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1658 collect
->next_aexpr_elt
++;
1662 process_tracepoint_on_disconnect (void)
1664 VEC(breakpoint_p
) *tp_vec
= NULL
;
1666 struct breakpoint
*b
;
1667 int has_pending_p
= 0;
1669 /* Check whether we still have pending tracepoint. If we have, warn the
1670 user that pending tracepoint will no longer work. */
1671 tp_vec
= all_tracepoints ();
1672 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1681 struct bp_location
*loc1
;
1683 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1685 if (loc1
->shlib_disabled
)
1696 VEC_free (breakpoint_p
, tp_vec
);
1699 warning (_("Pending tracepoints will not be resolved while"
1700 " GDB is disconnected\n"));
1705 start_tracing (char *notes
)
1707 VEC(breakpoint_p
) *tp_vec
= NULL
;
1709 struct breakpoint
*b
;
1710 struct trace_state_variable
*tsv
;
1711 int any_enabled
= 0, num_to_download
= 0;
1714 tp_vec
= all_tracepoints ();
1716 /* No point in tracing without any tracepoints... */
1717 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1719 VEC_free (breakpoint_p
, tp_vec
);
1720 error (_("No tracepoints defined, not starting trace"));
1723 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1725 struct tracepoint
*t
= (struct tracepoint
*) b
;
1726 struct bp_location
*loc
;
1728 if (b
->enable_state
== bp_enabled
)
1731 if ((b
->type
== bp_fast_tracepoint
1732 ? may_insert_fast_tracepoints
1733 : may_insert_tracepoints
))
1736 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1737 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1742 if (target_supports_enable_disable_tracepoint ())
1743 warning (_("No tracepoints enabled"));
1746 /* No point in tracing with only disabled tracepoints that
1747 cannot be re-enabled. */
1748 VEC_free (breakpoint_p
, tp_vec
);
1749 error (_("No tracepoints enabled, not starting trace"));
1753 if (num_to_download
<= 0)
1755 VEC_free (breakpoint_p
, tp_vec
);
1756 error (_("No tracepoints that may be downloaded, not starting trace"));
1759 target_trace_init ();
1761 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1763 struct tracepoint
*t
= (struct tracepoint
*) b
;
1764 struct bp_location
*loc
;
1765 int bp_location_downloaded
= 0;
1767 /* Clear `inserted' flag. */
1768 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1771 if ((b
->type
== bp_fast_tracepoint
1772 ? !may_insert_fast_tracepoints
1773 : !may_insert_tracepoints
))
1776 t
->number_on_target
= 0;
1778 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1780 /* Since tracepoint locations are never duplicated, `inserted'
1781 flag should be zero. */
1782 gdb_assert (!loc
->inserted
);
1784 target_download_tracepoint (loc
);
1787 bp_location_downloaded
= 1;
1790 t
->number_on_target
= b
->number
;
1792 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1793 if (loc
->probe
!= NULL
)
1794 loc
->probe
->pops
->set_semaphore (loc
->probe
, loc
->gdbarch
);
1796 if (bp_location_downloaded
)
1797 observer_notify_breakpoint_modified (b
);
1799 VEC_free (breakpoint_p
, tp_vec
);
1801 /* Send down all the trace state variables too. */
1802 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1804 target_download_trace_state_variable (tsv
);
1807 /* Tell target to treat text-like sections as transparent. */
1808 target_trace_set_readonly_regions ();
1809 /* Set some mode flags. */
1810 target_set_disconnected_tracing (disconnected_tracing
);
1811 target_set_circular_trace_buffer (circular_trace_buffer
);
1812 target_set_trace_buffer_size (trace_buffer_size
);
1815 notes
= trace_notes
;
1816 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1818 if (!ret
&& (trace_user
|| notes
))
1819 warning (_("Target does not support trace user/notes, info ignored"));
1821 /* Now insert traps and begin collecting data. */
1822 target_trace_start ();
1824 /* Reset our local state. */
1825 set_traceframe_num (-1);
1826 set_tracepoint_num (-1);
1827 set_traceframe_context (NULL
);
1828 current_trace_status()->running
= 1;
1829 clear_traceframe_info ();
1832 /* The tstart command requests the target to start a new trace run.
1833 The command passes any arguments it has to the target verbatim, as
1834 an optional "trace note". This is useful as for instance a warning
1835 to other users if the trace runs disconnected, and you don't want
1836 anybody else messing with the target. */
1839 trace_start_command (char *args
, int from_tty
)
1841 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1843 if (current_trace_status ()->running
)
1846 && !query (_("A trace is running already. Start a new run? ")))
1847 error (_("New trace run not started."));
1850 start_tracing (args
);
1853 /* The tstop command stops the tracing run. The command passes any
1854 supplied arguments to the target verbatim as a "stop note"; if the
1855 target supports trace notes, then it will be reported back as part
1856 of the trace run's status. */
1859 trace_stop_command (char *args
, int from_tty
)
1861 if (!current_trace_status ()->running
)
1862 error (_("Trace is not running."));
1864 stop_tracing (args
);
1868 stop_tracing (char *note
)
1871 VEC(breakpoint_p
) *tp_vec
= NULL
;
1873 struct breakpoint
*t
;
1875 target_trace_stop ();
1877 tp_vec
= all_tracepoints ();
1878 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1880 struct bp_location
*loc
;
1882 if ((t
->type
== bp_fast_tracepoint
1883 ? !may_insert_fast_tracepoints
1884 : !may_insert_tracepoints
))
1887 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1889 /* GDB can be totally absent in some disconnected trace scenarios,
1890 but we don't really care if this semaphore goes out of sync.
1891 That's why we are decrementing it here, but not taking care
1893 if (loc
->probe
!= NULL
)
1894 loc
->probe
->pops
->clear_semaphore (loc
->probe
, loc
->gdbarch
);
1898 VEC_free (breakpoint_p
, tp_vec
);
1901 note
= trace_stop_notes
;
1902 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1905 warning (_("Target does not support trace notes, note ignored"));
1907 /* Should change in response to reply? */
1908 current_trace_status ()->running
= 0;
1911 /* tstatus command */
1913 trace_status_command (char *args
, int from_tty
)
1915 struct trace_status
*ts
= current_trace_status ();
1917 VEC(breakpoint_p
) *tp_vec
= NULL
;
1918 struct breakpoint
*t
;
1920 status
= target_get_trace_status (ts
);
1924 if (ts
->filename
!= NULL
)
1925 printf_filtered (_("Using a trace file.\n"));
1928 printf_filtered (_("Trace can not be run on this target.\n"));
1933 if (!ts
->running_known
)
1935 printf_filtered (_("Run/stop status is unknown.\n"));
1937 else if (ts
->running
)
1939 printf_filtered (_("Trace is running on the target.\n"));
1943 switch (ts
->stop_reason
)
1945 case trace_never_run
:
1946 printf_filtered (_("No trace has been run on the target.\n"));
1950 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1953 printf_filtered (_("Trace stopped by a tstop command.\n"));
1955 case trace_buffer_full
:
1956 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1958 case trace_disconnected
:
1959 printf_filtered (_("Trace stopped because of disconnection.\n"));
1961 case tracepoint_passcount
:
1962 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1963 ts
->stopping_tracepoint
);
1965 case tracepoint_error
:
1966 if (ts
->stopping_tracepoint
)
1967 printf_filtered (_("Trace stopped by an "
1968 "error (%s, tracepoint %d).\n"),
1969 ts
->stop_desc
, ts
->stopping_tracepoint
);
1971 printf_filtered (_("Trace stopped by an error (%s).\n"),
1974 case trace_stop_reason_unknown
:
1975 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1978 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1984 if (ts
->traceframes_created
>= 0
1985 && ts
->traceframe_count
!= ts
->traceframes_created
)
1987 printf_filtered (_("Buffer contains %d trace "
1988 "frames (of %d created total).\n"),
1989 ts
->traceframe_count
, ts
->traceframes_created
);
1991 else if (ts
->traceframe_count
>= 0)
1993 printf_filtered (_("Collected %d trace frames.\n"),
1994 ts
->traceframe_count
);
1997 if (ts
->buffer_free
>= 0)
1999 if (ts
->buffer_size
>= 0)
2001 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2002 ts
->buffer_free
, ts
->buffer_size
);
2003 if (ts
->buffer_size
> 0)
2004 printf_filtered (_(" (%d%% full)"),
2005 ((int) ((((long long) (ts
->buffer_size
2006 - ts
->buffer_free
)) * 100)
2007 / ts
->buffer_size
)));
2008 printf_filtered (_(".\n"));
2011 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2015 if (ts
->disconnected_tracing
)
2016 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2018 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2020 if (ts
->circular_buffer
)
2021 printf_filtered (_("Trace buffer is circular.\n"));
2023 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
2024 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
2026 if (ts
->notes
&& strlen (ts
->notes
) > 0)
2027 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
2029 /* Now report on what we're doing with tfind. */
2030 if (traceframe_number
>= 0)
2031 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2032 traceframe_number
, tracepoint_number
);
2034 printf_filtered (_("Not looking at any trace frame.\n"));
2036 /* Report start/stop times if supplied. */
2041 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
2043 /* Reporting a run time is more readable than two long numbers. */
2044 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2045 (long int) ts
->start_time
/ 1000000,
2046 (long int) ts
->start_time
% 1000000,
2047 (long int) run_time
/ 1000000,
2048 (long int) run_time
% 1000000);
2051 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2052 (long int) ts
->start_time
/ 1000000,
2053 (long int) ts
->start_time
% 1000000);
2055 else if (ts
->stop_time
)
2056 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2057 (long int) ts
->stop_time
/ 1000000,
2058 (long int) ts
->stop_time
% 1000000);
2060 /* Now report any per-tracepoint status available. */
2061 tp_vec
= all_tracepoints ();
2063 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2064 target_get_tracepoint_status (t
, NULL
);
2066 VEC_free (breakpoint_p
, tp_vec
);
2069 /* Report the trace status to uiout, in a way suitable for MI, and not
2070 suitable for CLI. If ON_STOP is true, suppress a few fields that
2071 are not meaningful in the -trace-stop response.
2073 The implementation is essentially parallel to trace_status_command, but
2074 merging them will result in unreadable code. */
2076 trace_status_mi (int on_stop
)
2078 struct ui_out
*uiout
= current_uiout
;
2079 struct trace_status
*ts
= current_trace_status ();
2082 status
= target_get_trace_status (ts
);
2084 if (status
== -1 && ts
->filename
== NULL
)
2086 ui_out_field_string (uiout
, "supported", "0");
2090 if (ts
->filename
!= NULL
)
2091 ui_out_field_string (uiout
, "supported", "file");
2093 ui_out_field_string (uiout
, "supported", "1");
2095 if (ts
->filename
!= NULL
)
2096 ui_out_field_string (uiout
, "trace-file", ts
->filename
);
2098 gdb_assert (ts
->running_known
);
2102 ui_out_field_string (uiout
, "running", "1");
2104 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2105 Given that the frontend gets the status either on -trace-stop, or from
2106 -trace-status after re-connection, it does not seem like this
2107 information is necessary for anything. It is not necessary for either
2108 figuring the vital state of the target nor for navigation of trace
2109 frames. If the frontend wants to show the current state is some
2110 configure dialog, it can request the value when such dialog is
2111 invoked by the user. */
2115 char *stop_reason
= NULL
;
2116 int stopping_tracepoint
= -1;
2119 ui_out_field_string (uiout
, "running", "0");
2121 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2123 switch (ts
->stop_reason
)
2126 stop_reason
= "request";
2128 case trace_buffer_full
:
2129 stop_reason
= "overflow";
2131 case trace_disconnected
:
2132 stop_reason
= "disconnection";
2134 case tracepoint_passcount
:
2135 stop_reason
= "passcount";
2136 stopping_tracepoint
= ts
->stopping_tracepoint
;
2138 case tracepoint_error
:
2139 stop_reason
= "error";
2140 stopping_tracepoint
= ts
->stopping_tracepoint
;
2146 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2147 if (stopping_tracepoint
!= -1)
2148 ui_out_field_int (uiout
, "stopping-tracepoint",
2149 stopping_tracepoint
);
2150 if (ts
->stop_reason
== tracepoint_error
)
2151 ui_out_field_string (uiout
, "error-description",
2157 if (ts
->traceframe_count
!= -1)
2158 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2159 if (ts
->traceframes_created
!= -1)
2160 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2161 if (ts
->buffer_size
!= -1)
2162 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2163 if (ts
->buffer_free
!= -1)
2164 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2166 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2167 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2169 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2170 ui_out_field_string (uiout
, "notes", ts
->notes
);
2175 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2176 (long int) ts
->start_time
/ 1000000,
2177 (long int) ts
->start_time
% 1000000);
2178 ui_out_field_string (uiout
, "start-time", buf
);
2179 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2180 (long int) ts
->stop_time
/ 1000000,
2181 (long int) ts
->stop_time
% 1000000);
2182 ui_out_field_string (uiout
, "stop-time", buf
);
2186 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2187 user if she really wants to detach. */
2190 query_if_trace_running (int from_tty
)
2195 /* It can happen that the target that was tracing went away on its
2196 own, and we didn't notice. Get a status update, and if the
2197 current target doesn't even do tracing, then assume it's not
2199 if (target_get_trace_status (current_trace_status ()) < 0)
2200 current_trace_status ()->running
= 0;
2202 /* If running interactively, give the user the option to cancel and
2203 then decide what to do differently with the run. Scripts are
2204 just going to disconnect and let the target deal with it,
2205 according to how it's been instructed previously via
2206 disconnected-tracing. */
2207 if (current_trace_status ()->running
)
2209 process_tracepoint_on_disconnect ();
2211 if (current_trace_status ()->disconnected_tracing
)
2213 if (!query (_("Trace is running and will "
2214 "continue after detach; detach anyway? ")))
2215 error (_("Not confirmed."));
2219 if (!query (_("Trace is running but will "
2220 "stop on detach; detach anyway? ")))
2221 error (_("Not confirmed."));
2226 /* This function handles the details of what to do about an ongoing
2227 tracing run if the user has asked to detach or otherwise disconnect
2231 disconnect_tracing (void)
2233 /* Also we want to be out of tfind mode, otherwise things can get
2234 confusing upon reconnection. Just use these calls instead of
2235 full tfind_1 behavior because we're in the middle of detaching,
2236 and there's no point to updating current stack frame etc. */
2237 set_current_traceframe (-1);
2238 set_tracepoint_num (-1);
2239 set_traceframe_context (NULL
);
2242 /* Worker function for the various flavors of the tfind command. */
2244 tfind_1 (enum trace_find_type type
, int num
,
2245 CORE_ADDR addr1
, CORE_ADDR addr2
,
2248 int target_frameno
= -1, target_tracept
= -1;
2249 struct frame_id old_frame_id
= null_frame_id
;
2250 struct tracepoint
*tp
;
2251 struct ui_out
*uiout
= current_uiout
;
2253 /* Only try to get the current stack frame if we have a chance of
2254 succeeding. In particular, if we're trying to get a first trace
2255 frame while all threads are running, it's not going to succeed,
2256 so leave it with a default value and let the frame comparison
2257 below (correctly) decide to print out the source location of the
2259 if (!(type
== tfind_number
&& num
== -1)
2260 && (has_stack_frames () || traceframe_number
>= 0))
2261 old_frame_id
= get_frame_id (get_current_frame ());
2263 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2266 if (type
== tfind_number
2268 && target_frameno
== -1)
2270 /* We told the target to get out of tfind mode, and it did. */
2272 else if (target_frameno
== -1)
2274 /* A request for a non-existent trace frame has failed.
2275 Our response will be different, depending on FROM_TTY:
2277 If FROM_TTY is true, meaning that this command was
2278 typed interactively by the user, then give an error
2279 and DO NOT change the state of traceframe_number etc.
2281 However if FROM_TTY is false, meaning that we're either
2282 in a script, a loop, or a user-defined command, then
2283 DON'T give an error, but DO change the state of
2284 traceframe_number etc. to invalid.
2286 The rationalle is that if you typed the command, you
2287 might just have committed a typo or something, and you'd
2288 like to NOT lose your current debugging state. However
2289 if you're in a user-defined command or especially in a
2290 loop, then you need a way to detect that the command
2291 failed WITHOUT aborting. This allows you to write
2292 scripts that search thru the trace buffer until the end,
2293 and then continue on to do something else. */
2296 error (_("Target failed to find requested trace frame."));
2300 printf_filtered ("End of trace buffer.\n");
2301 #if 0 /* dubious now? */
2302 /* The following will not recurse, since it's
2304 trace_find_command ("-1", from_tty
);
2309 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2311 reinit_frame_cache ();
2312 target_dcache_invalidate ();
2314 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2316 if (target_frameno
!= get_traceframe_number ())
2317 observer_notify_traceframe_changed (target_frameno
, tracepoint_number
);
2319 set_current_traceframe (target_frameno
);
2321 if (target_frameno
== -1)
2322 set_traceframe_context (NULL
);
2324 set_traceframe_context (get_current_frame ());
2326 if (traceframe_number
>= 0)
2328 /* Use different branches for MI and CLI to make CLI messages
2330 if (ui_out_is_mi_like_p (uiout
))
2332 ui_out_field_string (uiout
, "found", "1");
2333 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2334 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2338 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2339 traceframe_number
, tracepoint_number
);
2344 if (ui_out_is_mi_like_p (uiout
))
2345 ui_out_field_string (uiout
, "found", "0");
2346 else if (type
== tfind_number
&& num
== -1)
2347 printf_unfiltered (_("No longer looking at any trace frame\n"));
2348 else /* This case may never occur, check. */
2349 printf_unfiltered (_("No trace frame found\n"));
2352 /* If we're in nonstop mode and getting out of looking at trace
2353 frames, there won't be any current frame to go back to and
2356 && (has_stack_frames () || traceframe_number
>= 0))
2358 enum print_what print_what
;
2360 /* NOTE: in imitation of the step command, try to determine
2361 whether we have made a transition from one function to
2362 another. If so, we'll print the "stack frame" (ie. the new
2363 function and it's arguments) -- otherwise we'll just show the
2366 if (frame_id_eq (old_frame_id
,
2367 get_frame_id (get_current_frame ())))
2368 print_what
= SRC_LINE
;
2370 print_what
= SRC_AND_LOC
;
2372 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2377 /* trace_find_command takes a trace frame number n,
2378 sends "QTFrame:<n>" to the target,
2379 and accepts a reply that may contain several optional pieces
2380 of information: a frame number, a tracepoint number, and an
2381 indication of whether this is a trap frame or a stepping frame.
2383 The minimal response is just "OK" (which indicates that the
2384 target does not give us a frame number or a tracepoint number).
2385 Instead of that, the target may send us a string containing
2387 F<hexnum> (gives the selected frame number)
2388 T<hexnum> (gives the selected tracepoint number)
2393 trace_find_command (char *args
, int from_tty
)
2394 { /* This should only be called with a numeric argument. */
2397 if (current_trace_status ()->running
2398 && current_trace_status ()->filename
== NULL
)
2399 error (_("May not look at trace frames while trace is running."));
2401 if (args
== 0 || *args
== 0)
2402 { /* TFIND with no args means find NEXT trace frame. */
2403 if (traceframe_number
== -1)
2404 frameno
= 0; /* "next" is first one. */
2406 frameno
= traceframe_number
+ 1;
2408 else if (0 == strcmp (args
, "-"))
2410 if (traceframe_number
== -1)
2411 error (_("not debugging trace buffer"));
2412 else if (from_tty
&& traceframe_number
== 0)
2413 error (_("already at start of trace buffer"));
2415 frameno
= traceframe_number
- 1;
2417 /* A hack to work around eval's need for fp to have been collected. */
2418 else if (0 == strcmp (args
, "-1"))
2421 frameno
= parse_and_eval_long (args
);
2424 error (_("invalid input (%d is less than zero)"), frameno
);
2426 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2431 trace_find_end_command (char *args
, int from_tty
)
2433 trace_find_command ("-1", from_tty
);
2438 trace_find_start_command (char *args
, int from_tty
)
2440 trace_find_command ("0", from_tty
);
2443 /* tfind pc command */
2445 trace_find_pc_command (char *args
, int from_tty
)
2449 if (current_trace_status ()->running
2450 && current_trace_status ()->filename
== NULL
)
2451 error (_("May not look at trace frames while trace is running."));
2453 if (args
== 0 || *args
== 0)
2454 pc
= regcache_read_pc (get_current_regcache ());
2456 pc
= parse_and_eval_address (args
);
2458 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2461 /* tfind tracepoint command */
2463 trace_find_tracepoint_command (char *args
, int from_tty
)
2466 struct tracepoint
*tp
;
2468 if (current_trace_status ()->running
2469 && current_trace_status ()->filename
== NULL
)
2470 error (_("May not look at trace frames while trace is running."));
2472 if (args
== 0 || *args
== 0)
2474 if (tracepoint_number
== -1)
2475 error (_("No current tracepoint -- please supply an argument."));
2477 tdp
= tracepoint_number
; /* Default is current TDP. */
2480 tdp
= parse_and_eval_long (args
);
2482 /* If we have the tracepoint on hand, use the number that the
2483 target knows about (which may be different if we disconnected
2484 and reconnected). */
2485 tp
= get_tracepoint (tdp
);
2487 tdp
= tp
->number_on_target
;
2489 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2492 /* TFIND LINE command:
2494 This command will take a sourceline for argument, just like BREAK
2495 or TRACE (ie. anything that "decode_line_1" can handle).
2497 With no argument, this command will find the next trace frame
2498 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2501 trace_find_line_command (char *args
, int from_tty
)
2503 static CORE_ADDR start_pc
, end_pc
;
2504 struct symtabs_and_lines sals
;
2505 struct symtab_and_line sal
;
2506 struct cleanup
*old_chain
;
2508 if (current_trace_status ()->running
2509 && current_trace_status ()->filename
== NULL
)
2510 error (_("May not look at trace frames while trace is running."));
2512 if (args
== 0 || *args
== 0)
2514 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2516 sals
.sals
= (struct symtab_and_line
*)
2517 xmalloc (sizeof (struct symtab_and_line
));
2522 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2526 old_chain
= make_cleanup (xfree
, sals
.sals
);
2527 if (sal
.symtab
== 0)
2528 error (_("No line number information available."));
2530 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2532 if (start_pc
== end_pc
)
2534 printf_filtered ("Line %d of \"%s\"",
2536 symtab_to_filename_for_display (sal
.symtab
));
2538 printf_filtered (" is at address ");
2539 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2541 printf_filtered (" but contains no code.\n");
2542 sal
= find_pc_line (start_pc
, 0);
2544 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2545 && start_pc
!= end_pc
)
2546 printf_filtered ("Attempting to find line %d instead.\n",
2549 error (_("Cannot find a good line."));
2553 /* Is there any case in which we get here, and have an address
2554 which the user would want to see? If we have debugging
2555 symbols and no line numbers? */
2556 error (_("Line number %d is out of range for \"%s\"."),
2557 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2559 /* Find within range of stated line. */
2561 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2563 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2564 do_cleanups (old_chain
);
2567 /* tfind range command */
2569 trace_find_range_command (char *args
, int from_tty
)
2571 static CORE_ADDR start
, stop
;
2574 if (current_trace_status ()->running
2575 && current_trace_status ()->filename
== NULL
)
2576 error (_("May not look at trace frames while trace is running."));
2578 if (args
== 0 || *args
== 0)
2579 { /* XXX FIXME: what should default behavior be? */
2580 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2584 if (0 != (tmp
= strchr (args
, ',')))
2586 *tmp
++ = '\0'; /* Terminate start address. */
2587 tmp
= skip_spaces (tmp
);
2588 start
= parse_and_eval_address (args
);
2589 stop
= parse_and_eval_address (tmp
);
2592 { /* No explicit end address? */
2593 start
= parse_and_eval_address (args
);
2594 stop
= start
+ 1; /* ??? */
2597 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2600 /* tfind outside command */
2602 trace_find_outside_command (char *args
, int from_tty
)
2604 CORE_ADDR start
, stop
;
2607 if (current_trace_status ()->running
2608 && current_trace_status ()->filename
== NULL
)
2609 error (_("May not look at trace frames while trace is running."));
2611 if (args
== 0 || *args
== 0)
2612 { /* XXX FIXME: what should default behavior be? */
2613 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2617 if (0 != (tmp
= strchr (args
, ',')))
2619 *tmp
++ = '\0'; /* Terminate start address. */
2620 tmp
= skip_spaces (tmp
);
2621 start
= parse_and_eval_address (args
);
2622 stop
= parse_and_eval_address (tmp
);
2625 { /* No explicit end address? */
2626 start
= parse_and_eval_address (args
);
2627 stop
= start
+ 1; /* ??? */
2630 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2633 /* info scope command: list the locals for a scope. */
2635 scope_info (char *args
, int from_tty
)
2637 struct symtabs_and_lines sals
;
2639 struct minimal_symbol
*msym
;
2640 struct block
*block
;
2641 const char *symname
;
2642 char *save_args
= args
;
2643 struct block_iterator iter
;
2645 struct gdbarch
*gdbarch
;
2648 if (args
== 0 || *args
== 0)
2649 error (_("requires an argument (function, "
2650 "line or *addr) to define a scope"));
2652 sals
= decode_line_1 (&args
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2653 if (sals
.nelts
== 0)
2654 return; /* Presumably decode_line_1 has already warned. */
2656 /* Resolve line numbers to PC. */
2657 resolve_sal_pc (&sals
.sals
[0]);
2658 block
= block_for_pc (sals
.sals
[0].pc
);
2662 QUIT
; /* Allow user to bail out with ^C. */
2663 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2665 QUIT
; /* Allow user to bail out with ^C. */
2667 printf_filtered ("Scope for %s:\n", save_args
);
2670 symname
= SYMBOL_PRINT_NAME (sym
);
2671 if (symname
== NULL
|| *symname
== '\0')
2672 continue; /* Probably botched, certainly useless. */
2674 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2676 printf_filtered ("Symbol %s is ", symname
);
2678 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
2679 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2680 BLOCK_START (block
),
2684 switch (SYMBOL_CLASS (sym
))
2687 case LOC_UNDEF
: /* Messed up symbol? */
2688 printf_filtered ("a bogus symbol, class %d.\n",
2689 SYMBOL_CLASS (sym
));
2690 count
--; /* Don't count this one. */
2693 printf_filtered ("a constant with value %s (%s)",
2694 plongest (SYMBOL_VALUE (sym
)),
2695 hex_string (SYMBOL_VALUE (sym
)));
2697 case LOC_CONST_BYTES
:
2698 printf_filtered ("constant bytes: ");
2699 if (SYMBOL_TYPE (sym
))
2700 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2701 fprintf_filtered (gdb_stdout
, " %02x",
2702 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2705 printf_filtered ("in static storage at address ");
2706 printf_filtered ("%s", paddress (gdbarch
,
2707 SYMBOL_VALUE_ADDRESS (sym
)));
2710 /* GDBARCH is the architecture associated with the objfile
2711 the symbol is defined in; the target architecture may be
2712 different, and may provide additional registers. However,
2713 we do not know the target architecture at this point.
2714 We assume the objfile architecture will contain all the
2715 standard registers that occur in debug info in that
2717 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2720 if (SYMBOL_IS_ARGUMENT (sym
))
2721 printf_filtered ("an argument in register $%s",
2722 gdbarch_register_name (gdbarch
, regno
));
2724 printf_filtered ("a local variable in register $%s",
2725 gdbarch_register_name (gdbarch
, regno
));
2728 printf_filtered ("an argument at stack/frame offset %s",
2729 plongest (SYMBOL_VALUE (sym
)));
2732 printf_filtered ("a local variable at frame offset %s",
2733 plongest (SYMBOL_VALUE (sym
)));
2736 printf_filtered ("a reference argument at offset %s",
2737 plongest (SYMBOL_VALUE (sym
)));
2739 case LOC_REGPARM_ADDR
:
2740 /* Note comment at LOC_REGISTER. */
2741 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2743 printf_filtered ("the address of an argument, in register $%s",
2744 gdbarch_register_name (gdbarch
, regno
));
2747 printf_filtered ("a typedef.\n");
2750 printf_filtered ("a label at address ");
2751 printf_filtered ("%s", paddress (gdbarch
,
2752 SYMBOL_VALUE_ADDRESS (sym
)));
2755 printf_filtered ("a function at address ");
2756 printf_filtered ("%s",
2757 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2759 case LOC_UNRESOLVED
:
2760 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2763 printf_filtered ("Unresolved Static");
2766 printf_filtered ("static storage at address ");
2767 printf_filtered ("%s",
2769 SYMBOL_VALUE_ADDRESS (msym
)));
2772 case LOC_OPTIMIZED_OUT
:
2773 printf_filtered ("optimized out.\n");
2776 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2779 if (SYMBOL_TYPE (sym
))
2780 printf_filtered (", length %d.\n",
2781 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2783 if (BLOCK_FUNCTION (block
))
2786 block
= BLOCK_SUPERBLOCK (block
);
2789 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2793 /* Helper for trace_dump_command. Dump the action list starting at
2794 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2795 actions of the body of a while-stepping action. STEPPING_FRAME is
2796 set if the current traceframe was determined to be a while-stepping
2800 trace_dump_actions (struct command_line
*action
,
2801 int stepping_actions
, int stepping_frame
,
2804 const char *action_exp
, *next_comma
;
2806 for (; action
!= NULL
; action
= action
->next
)
2808 struct cmd_list_element
*cmd
;
2810 QUIT
; /* Allow user to bail out with ^C. */
2811 action_exp
= action
->line
;
2812 action_exp
= skip_spaces_const (action_exp
);
2814 /* The collection actions to be done while stepping are
2815 bracketed by the commands "while-stepping" and "end". */
2817 if (*action_exp
== '#') /* comment line */
2820 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2822 error (_("Bad action list item: %s"), action_exp
);
2824 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2828 for (i
= 0; i
< action
->body_count
; ++i
)
2829 trace_dump_actions (action
->body_list
[i
],
2830 1, stepping_frame
, from_tty
);
2832 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2834 /* Display the collected data.
2835 For the trap frame, display only what was collected at
2836 the trap. Likewise for stepping frames, display only
2837 what was collected while stepping. This means that the
2838 two boolean variables, STEPPING_FRAME and
2839 STEPPING_ACTIONS should be equal. */
2840 if (stepping_frame
== stepping_actions
)
2843 struct cleanup
*old_chain
2844 = make_cleanup (free_current_contents
, &cmd
);
2845 int trace_string
= 0;
2847 if (*action_exp
== '/')
2848 action_exp
= decode_agent_options (action_exp
, &trace_string
);
2851 { /* Repeat over a comma-separated list. */
2852 QUIT
; /* Allow user to bail out with ^C. */
2853 if (*action_exp
== ',')
2855 action_exp
= skip_spaces_const (action_exp
);
2857 next_comma
= strchr (action_exp
, ',');
2859 if (0 == strncasecmp (action_exp
, "$reg", 4))
2860 registers_info (NULL
, from_tty
);
2861 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2863 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2864 locals_info (NULL
, from_tty
);
2865 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2866 args_info (NULL
, from_tty
);
2869 if (next_comma
!= NULL
)
2871 size_t len
= next_comma
- action_exp
;
2873 cmd
= xrealloc (cmd
, len
+ 1);
2874 memcpy (cmd
, action_exp
, len
);
2879 size_t len
= strlen (action_exp
);
2881 cmd
= xrealloc (cmd
, len
+ 1);
2882 memcpy (cmd
, action_exp
, len
+ 1);
2885 printf_filtered ("%s = ", cmd
);
2886 output_command_const (cmd
, from_tty
);
2887 printf_filtered ("\n");
2889 action_exp
= next_comma
;
2891 while (action_exp
&& *action_exp
== ',');
2893 do_cleanups (old_chain
);
2899 /* Return all the actions, including default collect, of a tracepoint
2900 T. It constructs cleanups into the chain, and leaves the caller to
2901 handle them (call do_cleanups). */
2903 static struct command_line
*
2904 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
)
2906 struct command_line
*actions
;
2908 actions
= breakpoint_commands (t
);
2910 /* If there are default expressions to collect, make up a collect
2911 action and prepend to the action list to encode. Note that since
2912 validation is per-tracepoint (local var "xyz" might be valid for
2913 one tracepoint and not another, etc), we make up the action on
2914 the fly, and don't cache it. */
2915 if (*default_collect
)
2917 struct command_line
*default_collect_action
;
2918 char *default_collect_line
;
2920 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2921 make_cleanup (xfree
, default_collect_line
);
2923 validate_actionline (default_collect_line
, t
);
2924 default_collect_action
= xmalloc (sizeof (struct command_line
));
2925 make_cleanup (xfree
, default_collect_action
);
2926 default_collect_action
->next
= actions
;
2927 default_collect_action
->line
= default_collect_line
;
2928 actions
= default_collect_action
;
2934 /* The tdump command. */
2937 trace_dump_command (char *args
, int from_tty
)
2939 struct regcache
*regcache
;
2940 struct tracepoint
*t
;
2941 int stepping_frame
= 0;
2942 struct bp_location
*loc
;
2943 char *default_collect_line
= NULL
;
2944 struct command_line
*actions
, *default_collect_action
= NULL
;
2945 struct cleanup
*old_chain
;
2947 if (tracepoint_number
== -1)
2949 warning (_("No current trace frame."));
2953 old_chain
= make_cleanup (null_cleanup
, NULL
);
2954 t
= get_tracepoint (tracepoint_number
);
2957 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2960 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2961 tracepoint_number
, traceframe_number
);
2963 /* The current frame is a trap frame if the frame PC is equal
2964 to the tracepoint PC. If not, then the current frame was
2965 collected during single-stepping. */
2967 regcache
= get_current_regcache ();
2969 /* If the traceframe's address matches any of the tracepoint's
2970 locations, assume it is a direct hit rather than a while-stepping
2971 frame. (FIXME this is not reliable, should record each frame's
2974 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
2975 if (loc
->address
== regcache_read_pc (regcache
))
2978 actions
= all_tracepoint_actions_and_cleanup (&t
->base
);
2980 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2982 do_cleanups (old_chain
);
2985 /* Encode a piece of a tracepoint's source-level definition in a form
2986 that is suitable for both protocol and saving in files. */
2987 /* This version does not do multiple encodes for long strings; it should
2988 return an offset to the next piece to encode. FIXME */
2991 encode_source_string (int tpnum
, ULONGEST addr
,
2992 char *srctype
, char *src
, char *buf
, int buf_size
)
2994 if (80 + strlen (srctype
) > buf_size
)
2995 error (_("Buffer too small for source encoding"));
2996 sprintf (buf
, "%x:%s:%s:%x:%x:",
2997 tpnum
, phex_nz (addr
, sizeof (addr
)),
2998 srctype
, 0, (int) strlen (src
));
2999 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
3000 error (_("Source string too long for buffer"));
3001 bin2hex ((gdb_byte
*) src
, buf
+ strlen (buf
), 0);
3005 /* Free trace file writer. */
3008 trace_file_writer_xfree (void *arg
)
3010 struct trace_file_writer
*writer
= arg
;
3012 writer
->ops
->dtor (writer
);
3016 /* TFILE trace writer. */
3018 struct tfile_trace_file_writer
3020 struct trace_file_writer base
;
3022 /* File pointer to tfile trace file. */
3024 /* Path name of the tfile trace file. */
3028 /* This is the implementation of trace_file_write_ops method
3029 target_save. We just call the generic target
3030 target_save_trace_data to do target-side saving. */
3033 tfile_target_save (struct trace_file_writer
*self
,
3034 const char *filename
)
3036 int err
= target_save_trace_data (filename
);
3041 /* This is the implementation of trace_file_write_ops method
3045 tfile_dtor (struct trace_file_writer
*self
)
3047 struct tfile_trace_file_writer
*writer
3048 = (struct tfile_trace_file_writer
*) self
;
3050 xfree (writer
->pathname
);
3052 if (writer
->fp
!= NULL
)
3053 fclose (writer
->fp
);
3056 /* This is the implementation of trace_file_write_ops method
3057 start. It creates the trace file FILENAME and registers some
3061 tfile_start (struct trace_file_writer
*self
, const char *filename
)
3063 struct tfile_trace_file_writer
*writer
3064 = (struct tfile_trace_file_writer
*) self
;
3066 writer
->pathname
= tilde_expand (filename
);
3067 writer
->fp
= gdb_fopen_cloexec (writer
->pathname
, "wb");
3068 if (writer
->fp
== NULL
)
3069 error (_("Unable to open file '%s' for saving trace data (%s)"),
3070 filename
, safe_strerror (errno
));
3073 /* This is the implementation of trace_file_write_ops method
3074 write_header. Write the TFILE header. */
3077 tfile_write_header (struct trace_file_writer
*self
)
3079 struct tfile_trace_file_writer
*writer
3080 = (struct tfile_trace_file_writer
*) self
;
3083 /* Write a file header, with a high-bit-set char to indicate a
3084 binary file, plus a hint as what this file is, and a version
3085 number in case of future needs. */
3086 written
= fwrite ("\x7fTRACE0\n", 8, 1, writer
->fp
);
3088 perror_with_name (writer
->pathname
);
3091 /* This is the implementation of trace_file_write_ops method
3092 write_regblock_type. Write the size of register block. */
3095 tfile_write_regblock_type (struct trace_file_writer
*self
, int size
)
3097 struct tfile_trace_file_writer
*writer
3098 = (struct tfile_trace_file_writer
*) self
;
3100 fprintf (writer
->fp
, "R %x\n", size
);
3103 /* This is the implementation of trace_file_write_ops method
3107 tfile_write_status (struct trace_file_writer
*self
,
3108 struct trace_status
*ts
)
3110 struct tfile_trace_file_writer
*writer
3111 = (struct tfile_trace_file_writer
*) self
;
3113 fprintf (writer
->fp
, "status %c;%s",
3114 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
3115 if (ts
->stop_reason
== tracepoint_error
3116 || ts
->stop_reason
== tstop_command
)
3118 char *buf
= (char *) alloca (strlen (ts
->stop_desc
) * 2 + 1);
3120 bin2hex ((gdb_byte
*) ts
->stop_desc
, buf
, 0);
3121 fprintf (writer
->fp
, ":%s", buf
);
3123 fprintf (writer
->fp
, ":%x", ts
->stopping_tracepoint
);
3124 if (ts
->traceframe_count
>= 0)
3125 fprintf (writer
->fp
, ";tframes:%x", ts
->traceframe_count
);
3126 if (ts
->traceframes_created
>= 0)
3127 fprintf (writer
->fp
, ";tcreated:%x", ts
->traceframes_created
);
3128 if (ts
->buffer_free
>= 0)
3129 fprintf (writer
->fp
, ";tfree:%x", ts
->buffer_free
);
3130 if (ts
->buffer_size
>= 0)
3131 fprintf (writer
->fp
, ";tsize:%x", ts
->buffer_size
);
3132 if (ts
->disconnected_tracing
)
3133 fprintf (writer
->fp
, ";disconn:%x", ts
->disconnected_tracing
);
3134 if (ts
->circular_buffer
)
3135 fprintf (writer
->fp
, ";circular:%x", ts
->circular_buffer
);
3136 if (ts
->notes
!= NULL
)
3138 char *buf
= (char *) alloca (strlen (ts
->notes
) * 2 + 1);
3140 bin2hex ((gdb_byte
*) ts
->notes
, buf
, 0);
3141 fprintf (writer
->fp
, ";notes:%s", buf
);
3143 if (ts
->user_name
!= NULL
)
3145 char *buf
= (char *) alloca (strlen (ts
->user_name
) * 2 + 1);
3147 bin2hex ((gdb_byte
*) ts
->user_name
, buf
, 0);
3148 fprintf (writer
->fp
, ";username:%s", buf
);
3150 fprintf (writer
->fp
, "\n");
3153 /* This is the implementation of trace_file_write_ops method
3154 write_uploaded_tsv. */
3157 tfile_write_uploaded_tsv (struct trace_file_writer
*self
,
3158 struct uploaded_tsv
*utsv
)
3161 struct tfile_trace_file_writer
*writer
3162 = (struct tfile_trace_file_writer
*) self
;
3166 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
3167 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
3170 fprintf (writer
->fp
, "tsv %x:%s:%x:%s\n",
3171 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
3172 utsv
->builtin
, buf
);
3178 #define MAX_TRACE_UPLOAD 2000
3180 /* This is the implementation of trace_file_write_ops method
3181 write_uploaded_tp. */
3184 tfile_write_uploaded_tp (struct trace_file_writer
*self
,
3185 struct uploaded_tp
*utp
)
3187 struct tfile_trace_file_writer
*writer
3188 = (struct tfile_trace_file_writer
*) self
;
3191 char buf
[MAX_TRACE_UPLOAD
];
3193 fprintf (writer
->fp
, "tp T%x:%s:%c:%x:%x",
3194 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3195 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
3196 if (utp
->type
== bp_fast_tracepoint
)
3197 fprintf (writer
->fp
, ":F%x", utp
->orig_size
);
3199 fprintf (writer
->fp
,
3200 ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
3202 fprintf (writer
->fp
, "\n");
3203 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
3204 fprintf (writer
->fp
, "tp A%x:%s:%s\n",
3205 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3206 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
3207 fprintf (writer
->fp
, "tp S%x:%s:%s\n",
3208 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3211 encode_source_string (utp
->number
, utp
->addr
,
3212 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
3213 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3215 if (utp
->cond_string
)
3217 encode_source_string (utp
->number
, utp
->addr
,
3218 "cond", utp
->cond_string
,
3219 buf
, MAX_TRACE_UPLOAD
);
3220 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3222 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
3224 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
3225 buf
, MAX_TRACE_UPLOAD
);
3226 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3228 fprintf (writer
->fp
, "tp V%x:%s:%x:%s\n",
3229 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3231 phex_nz (utp
->traceframe_usage
,
3232 sizeof (utp
->traceframe_usage
)));
3235 /* This is the implementation of trace_file_write_ops method
3236 write_definition_end. */
3239 tfile_write_definition_end (struct trace_file_writer
*self
)
3241 struct tfile_trace_file_writer
*writer
3242 = (struct tfile_trace_file_writer
*) self
;
3244 fprintf (writer
->fp
, "\n");
3247 /* This is the implementation of trace_file_write_ops method
3251 tfile_write_raw_data (struct trace_file_writer
*self
, gdb_byte
*buf
,
3254 struct tfile_trace_file_writer
*writer
3255 = (struct tfile_trace_file_writer
*) self
;
3257 if (fwrite (buf
, len
, 1, writer
->fp
) < 1)
3258 perror_with_name (writer
->pathname
);
3261 /* This is the implementation of trace_file_write_ops method
3265 tfile_end (struct trace_file_writer
*self
)
3267 struct tfile_trace_file_writer
*writer
3268 = (struct tfile_trace_file_writer
*) self
;
3269 uint32_t gotten
= 0;
3271 /* Mark the end of trace data. */
3272 if (fwrite (&gotten
, 4, 1, writer
->fp
) < 1)
3273 perror_with_name (writer
->pathname
);
3276 /* Operations to write trace buffers into TFILE format. */
3278 static const struct trace_file_write_ops tfile_write_ops
=
3284 tfile_write_regblock_type
,
3286 tfile_write_uploaded_tsv
,
3287 tfile_write_uploaded_tp
,
3288 tfile_write_definition_end
,
3289 tfile_write_raw_data
,
3294 /* Helper macros. */
3296 #define TRACE_WRITE_R_BLOCK(writer, buf, size) \
3297 writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
3298 #define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
3299 writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
3301 #define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
3302 writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
3304 #define TRACE_WRITE_V_BLOCK(writer, num, val) \
3305 writer->ops->frame_ops->write_v_block ((writer), (num), (val))
3307 /* Save tracepoint data to file named FILENAME through WRITER. WRITER
3308 determines the trace file format. If TARGET_DOES_SAVE is non-zero,
3309 the save is performed on the target, otherwise GDB obtains all trace
3310 data and saves it locally. */
3313 trace_save (const char *filename
, struct trace_file_writer
*writer
,
3314 int target_does_save
)
3316 struct trace_status
*ts
= current_trace_status ();
3318 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
3319 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
3321 ULONGEST offset
= 0;
3322 gdb_byte buf
[MAX_TRACE_UPLOAD
];
3323 #define MAX_TRACE_UPLOAD 2000
3325 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
3327 /* If the target is to save the data to a file on its own, then just
3328 send the command and be done with it. */
3329 if (target_does_save
)
3331 if (!writer
->ops
->target_save (writer
, filename
))
3332 error (_("Target failed to save trace data to '%s'."),
3337 /* Get the trace status first before opening the file, so if the
3338 target is losing, we can get out without touching files. */
3339 status
= target_get_trace_status (ts
);
3341 writer
->ops
->start (writer
, filename
);
3343 writer
->ops
->write_header (writer
);
3345 /* Write descriptive info. */
3347 /* Write out the size of a register block. */
3348 writer
->ops
->write_regblock_type (writer
, trace_regblock_size
);
3350 /* Write out status of the tracing run (aka "tstatus" info). */
3351 writer
->ops
->write_status (writer
, ts
);
3353 /* Note that we want to upload tracepoints and save those, rather
3354 than simply writing out the local ones, because the user may have
3355 changed tracepoints in GDB in preparation for a future tracing
3356 run, or maybe just mass-deleted all types of breakpoints as part
3357 of cleaning up. So as not to contaminate the session, leave the
3358 data in its uploaded form, don't make into real tracepoints. */
3360 /* Get trace state variables first, they may be checked when parsing
3361 uploaded commands. */
3363 target_upload_trace_state_variables (&uploaded_tsvs
);
3365 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3366 writer
->ops
->write_uploaded_tsv (writer
, utsv
);
3368 free_uploaded_tsvs (&uploaded_tsvs
);
3370 target_upload_tracepoints (&uploaded_tps
);
3372 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3373 target_get_tracepoint_status (NULL
, utp
);
3375 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3376 writer
->ops
->write_uploaded_tp (writer
, utp
);
3378 free_uploaded_tps (&uploaded_tps
);
3380 /* Mark the end of the definition section. */
3381 writer
->ops
->write_definition_end (writer
);
3383 /* Get and write the trace data proper. */
3388 /* The writer supports writing the contents of trace buffer
3389 directly to trace file. Don't parse the contents of trace
3391 if (writer
->ops
->write_trace_buffer
!= NULL
)
3393 /* We ask for big blocks, in the hopes of efficiency, but
3394 will take less if the target has packet size limitations
3396 gotten
= target_get_raw_trace_data (buf
, offset
,
3399 error (_("Failure to get requested trace buffer data"));
3400 /* No more data is forthcoming, we're done. */
3404 writer
->ops
->write_trace_buffer (writer
, buf
, gotten
);
3412 /* Parse the trace buffers according to how data are stored
3413 in trace buffer in GDBserver. */
3415 gotten
= target_get_raw_trace_data (buf
, offset
, 6);
3420 /* Read the first six bytes in, which is the tracepoint
3421 number and trace frame size. */
3423 extract_unsigned_integer (&buf
[0], 2, byte_order
);
3425 tf_size
= (uint32_t)
3426 extract_unsigned_integer (&buf
[2], 4, byte_order
);
3428 writer
->ops
->frame_ops
->start (writer
, tp_num
);
3437 for (block
= 0; block
< tf_size
; )
3439 gdb_byte block_type
;
3441 /* We'll fetch one block each time, in order to
3442 handle the extremely large 'M' block. We first
3443 fetch one byte to get the type of the block. */
3444 gotten
= target_get_raw_trace_data (buf
, offset
, 1);
3446 error (_("Failure to get requested trace buffer data"));
3452 block_type
= buf
[0];
3457 = target_get_raw_trace_data (buf
, offset
,
3458 trace_regblock_size
);
3459 if (gotten
< trace_regblock_size
)
3460 error (_("Failure to get requested trace"
3463 TRACE_WRITE_R_BLOCK (writer
, buf
,
3464 trace_regblock_size
);
3468 unsigned short mlen
;
3473 t
= target_get_raw_trace_data (buf
,offset
, 10);
3475 error (_("Failure to get requested trace"
3483 extract_unsigned_integer (buf
, 8,
3485 mlen
= (unsigned short)
3486 extract_unsigned_integer (&buf
[8], 2,
3489 TRACE_WRITE_M_BLOCK_HEADER (writer
, addr
,
3492 /* The memory contents in 'M' block may be
3493 very large. Fetch the data from the target
3494 and write them into file one by one. */
3495 for (j
= 0; j
< mlen
; )
3497 unsigned int read_length
;
3499 if (mlen
- j
> MAX_TRACE_UPLOAD
)
3500 read_length
= MAX_TRACE_UPLOAD
;
3502 read_length
= mlen
- j
;
3504 t
= target_get_raw_trace_data (buf
,
3507 if (t
< read_length
)
3508 error (_("Failure to get requested"
3509 " trace buffer data"));
3511 TRACE_WRITE_M_BLOCK_MEMORY (writer
, buf
,
3515 gotten
+= read_length
;
3526 = target_get_raw_trace_data (buf
, offset
,
3529 error (_("Failure to get requested"
3530 " trace buffer data"));
3532 vnum
= (int) extract_signed_integer (buf
,
3536 = extract_signed_integer (&buf
[4], 8,
3539 TRACE_WRITE_V_BLOCK (writer
, vnum
, val
);
3543 error (_("Unknown block type '%c' (0x%x) in"
3545 block_type
, block_type
);
3555 writer
->ops
->frame_ops
->end (writer
);
3559 writer
->ops
->end (writer
);
3562 /* Return a trace writer for TFILE format. */
3564 static struct trace_file_writer
*
3565 tfile_trace_file_writer_new (void)
3567 struct tfile_trace_file_writer
*writer
3568 = xmalloc (sizeof (struct tfile_trace_file_writer
));
3570 writer
->base
.ops
= &tfile_write_ops
;
3572 writer
->pathname
= NULL
;
3574 return (struct trace_file_writer
*) writer
;
3578 trace_save_command (char *args
, int from_tty
)
3580 int target_does_save
= 0;
3582 char *filename
= NULL
;
3583 struct cleanup
*back_to
;
3584 int generate_ctf
= 0;
3585 struct trace_file_writer
*writer
= NULL
;
3588 error_no_arg (_("file in which to save trace data"));
3590 argv
= gdb_buildargv (args
);
3591 back_to
= make_cleanup_freeargv (argv
);
3593 for (; *argv
; ++argv
)
3595 if (strcmp (*argv
, "-r") == 0)
3596 target_does_save
= 1;
3597 if (strcmp (*argv
, "-ctf") == 0)
3599 else if (**argv
== '-')
3600 error (_("unknown option `%s'"), *argv
);
3606 error_no_arg (_("file in which to save trace data"));
3609 writer
= ctf_trace_file_writer_new ();
3611 writer
= tfile_trace_file_writer_new ();
3613 make_cleanup (trace_file_writer_xfree
, writer
);
3615 trace_save (filename
, writer
, target_does_save
);
3618 printf_filtered (_("Trace data saved to %s '%s'.\n"),
3619 generate_ctf
? "directory" : "file", filename
);
3621 do_cleanups (back_to
);
3624 /* Save the trace data to file FILENAME of tfile format. */
3627 trace_save_tfile (const char *filename
, int target_does_save
)
3629 struct trace_file_writer
*writer
;
3630 struct cleanup
*back_to
;
3632 writer
= tfile_trace_file_writer_new ();
3633 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
3634 trace_save (filename
, writer
, target_does_save
);
3635 do_cleanups (back_to
);
3638 /* Save the trace data to dir DIRNAME of ctf format. */
3641 trace_save_ctf (const char *dirname
, int target_does_save
)
3643 struct trace_file_writer
*writer
;
3644 struct cleanup
*back_to
;
3646 writer
= ctf_trace_file_writer_new ();
3647 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
3649 trace_save (dirname
, writer
, target_does_save
);
3650 do_cleanups (back_to
);
3653 /* Tell the target what to do with an ongoing tracing run if GDB
3654 disconnects for some reason. */
3657 set_disconnected_tracing (char *args
, int from_tty
,
3658 struct cmd_list_element
*c
)
3660 target_set_disconnected_tracing (disconnected_tracing
);
3664 set_circular_trace_buffer (char *args
, int from_tty
,
3665 struct cmd_list_element
*c
)
3667 target_set_circular_trace_buffer (circular_trace_buffer
);
3671 set_trace_buffer_size (char *args
, int from_tty
,
3672 struct cmd_list_element
*c
)
3674 target_set_trace_buffer_size (trace_buffer_size
);
3678 set_trace_user (char *args
, int from_tty
,
3679 struct cmd_list_element
*c
)
3683 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3686 warning (_("Target does not support trace notes, user ignored"));
3690 set_trace_notes (char *args
, int from_tty
,
3691 struct cmd_list_element
*c
)
3695 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3698 warning (_("Target does not support trace notes, note ignored"));
3702 set_trace_stop_notes (char *args
, int from_tty
,
3703 struct cmd_list_element
*c
)
3707 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3710 warning (_("Target does not support trace notes, stop note ignored"));
3713 /* Convert the memory pointed to by mem into hex, placing result in buf.
3714 * Return a pointer to the last char put in buf (null)
3715 * "stolen" from sparc-stub.c
3718 static const char hexchars
[] = "0123456789abcdef";
3721 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3729 *buf
++ = hexchars
[ch
>> 4];
3730 *buf
++ = hexchars
[ch
& 0xf];
3739 get_traceframe_number (void)
3741 return traceframe_number
;
3745 get_tracepoint_number (void)
3747 return tracepoint_number
;
3750 /* Make the traceframe NUM be the current trace frame. Does nothing
3751 if NUM is already current. */
3754 set_current_traceframe (int num
)
3758 if (traceframe_number
== num
)
3760 /* Nothing to do. */
3764 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3767 warning (_("could not change traceframe"));
3769 set_traceframe_num (newnum
);
3771 /* Changing the traceframe changes our view of registers and of the
3773 registers_changed ();
3775 clear_traceframe_info ();
3778 /* Make the traceframe NUM be the current trace frame, and do nothing
3782 set_traceframe_number (int num
)
3784 traceframe_number
= num
;
3787 /* A cleanup used when switching away and back from tfind mode. */
3789 struct current_traceframe_cleanup
3791 /* The traceframe we were inspecting. */
3792 int traceframe_number
;
3796 do_restore_current_traceframe_cleanup (void *arg
)
3798 struct current_traceframe_cleanup
*old
= arg
;
3800 set_current_traceframe (old
->traceframe_number
);
3804 restore_current_traceframe_cleanup_dtor (void *arg
)
3806 struct current_traceframe_cleanup
*old
= arg
;
3812 make_cleanup_restore_current_traceframe (void)
3814 struct current_traceframe_cleanup
*old
;
3816 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3817 old
->traceframe_number
= traceframe_number
;
3819 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3820 restore_current_traceframe_cleanup_dtor
);
3824 make_cleanup_restore_traceframe_number (void)
3826 return make_cleanup_restore_integer (&traceframe_number
);
3829 /* Given a number and address, return an uploaded tracepoint with that
3830 number, creating if necessary. */
3832 struct uploaded_tp
*
3833 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3835 struct uploaded_tp
*utp
;
3837 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3838 if (utp
->number
== num
&& utp
->addr
== addr
)
3840 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3841 memset (utp
, 0, sizeof (struct uploaded_tp
));
3844 utp
->actions
= NULL
;
3845 utp
->step_actions
= NULL
;
3846 utp
->cmd_strings
= NULL
;
3853 free_uploaded_tps (struct uploaded_tp
**utpp
)
3855 struct uploaded_tp
*next_one
;
3859 next_one
= (*utpp
)->next
;
3865 /* Given a number and address, return an uploaded tracepoint with that
3866 number, creating if necessary. */
3868 struct uploaded_tsv
*
3869 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3871 struct uploaded_tsv
*utsv
;
3873 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3874 if (utsv
->number
== num
)
3876 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3877 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3879 utsv
->next
= *utsvp
;
3885 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3887 struct uploaded_tsv
*next_one
;
3891 next_one
= (*utsvp
)->next
;
3897 /* FIXME this function is heuristic and will miss the cases where the
3898 conditional is semantically identical but differs in whitespace,
3899 such as "x == 0" vs "x==0". */
3902 cond_string_is_same (char *str1
, char *str2
)
3904 if (str1
== NULL
|| str2
== NULL
)
3905 return (str1
== str2
);
3907 return (strcmp (str1
, str2
) == 0);
3910 /* Look for an existing tracepoint that seems similar enough to the
3911 uploaded one. Enablement isn't compared, because the user can
3912 toggle that freely, and may have done so in anticipation of the
3913 next trace run. Return the location of matched tracepoint. */
3915 static struct bp_location
*
3916 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3918 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3920 struct breakpoint
*b
;
3921 struct bp_location
*loc
;
3923 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3925 struct tracepoint
*t
= (struct tracepoint
*) b
;
3927 if (b
->type
== utp
->type
3928 && t
->step_count
== utp
->step
3929 && t
->pass_count
== utp
->pass
3930 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3931 /* FIXME also test actions. */
3934 /* Scan the locations for an address match. */
3935 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3937 if (loc
->address
== utp
->addr
)
3945 /* Given a list of tracepoints uploaded from a target, attempt to
3946 match them up with existing tracepoints, and create new ones if not
3950 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3952 struct uploaded_tp
*utp
;
3953 /* A set of tracepoints which are modified. */
3954 VEC(breakpoint_p
) *modified_tp
= NULL
;
3956 struct breakpoint
*b
;
3958 /* Look for GDB tracepoints that match up with our uploaded versions. */
3959 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3961 struct bp_location
*loc
;
3962 struct tracepoint
*t
;
3964 loc
= find_matching_tracepoint_location (utp
);
3969 /* Mark this location as already inserted. */
3971 t
= (struct tracepoint
*) loc
->owner
;
3972 printf_filtered (_("Assuming tracepoint %d is same "
3973 "as target's tracepoint %d at %s.\n"),
3974 loc
->owner
->number
, utp
->number
,
3975 paddress (loc
->gdbarch
, utp
->addr
));
3977 /* The tracepoint LOC->owner was modified (the location LOC
3978 was marked as inserted in the target). Save it in
3979 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3980 observers will be notified later once for each tracepoint
3981 saved in MODIFIED_TP. */
3983 VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
);
3985 if (b
== loc
->owner
)
3991 VEC_safe_push (breakpoint_p
, modified_tp
, loc
->owner
);
3995 t
= create_tracepoint_from_upload (utp
);
3997 printf_filtered (_("Created tracepoint %d for "
3998 "target's tracepoint %d at %s.\n"),
3999 t
->base
.number
, utp
->number
,
4000 paddress (get_current_arch (), utp
->addr
));
4002 printf_filtered (_("Failed to create tracepoint for target's "
4003 "tracepoint %d at %s, skipping it.\n"),
4005 paddress (get_current_arch (), utp
->addr
));
4007 /* Whether found or created, record the number used by the
4008 target, to help with mapping target tracepoints back to their
4009 counterparts here. */
4011 t
->number_on_target
= utp
->number
;
4014 /* Notify 'breakpoint-modified' observer that at least one of B's
4015 locations was changed. */
4016 for (ix
= 0; VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
); ix
++)
4017 observer_notify_breakpoint_modified (b
);
4019 VEC_free (breakpoint_p
, modified_tp
);
4020 free_uploaded_tps (uploaded_tps
);
4023 /* Trace state variables don't have much to identify them beyond their
4024 name, so just use that to detect matches. */
4026 static struct trace_state_variable
*
4027 find_matching_tsv (struct uploaded_tsv
*utsv
)
4032 return find_trace_state_variable (utsv
->name
);
4035 static struct trace_state_variable
*
4036 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
4038 const char *namebase
;
4041 struct trace_state_variable
*tsv
;
4042 struct cleanup
*old_chain
;
4046 namebase
= utsv
->name
;
4047 buf
= xstrprintf ("%s", namebase
);
4052 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
4055 /* Fish for a name that is not in use. */
4056 /* (should check against all internal vars?) */
4057 while (find_trace_state_variable (buf
))
4060 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
4063 old_chain
= make_cleanup (xfree
, buf
);
4065 /* We have an available name, create the variable. */
4066 tsv
= create_trace_state_variable (buf
);
4067 tsv
->initial_value
= utsv
->initial_value
;
4068 tsv
->builtin
= utsv
->builtin
;
4070 observer_notify_tsv_created (tsv
);
4072 do_cleanups (old_chain
);
4077 /* Given a list of uploaded trace state variables, try to match them
4078 up with existing variables, or create additional ones. */
4081 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
4084 struct uploaded_tsv
*utsv
;
4085 struct trace_state_variable
*tsv
;
4088 /* Most likely some numbers will have to be reassigned as part of
4089 the merge, so clear them all in anticipation. */
4090 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4093 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
4095 tsv
= find_matching_tsv (utsv
);
4099 printf_filtered (_("Assuming trace state variable $%s "
4100 "is same as target's variable %d.\n"),
4101 tsv
->name
, utsv
->number
);
4105 tsv
= create_tsv_from_upload (utsv
);
4107 printf_filtered (_("Created trace state variable "
4108 "$%s for target's variable %d.\n"),
4109 tsv
->name
, utsv
->number
);
4111 /* Give precedence to numberings that come from the target. */
4113 tsv
->number
= utsv
->number
;
4116 /* Renumber everything that didn't get a target-assigned number. */
4118 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4119 if (tsv
->number
> highest
)
4120 highest
= tsv
->number
;
4123 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4124 if (tsv
->number
== 0)
4125 tsv
->number
= highest
++;
4127 free_uploaded_tsvs (uploaded_tsvs
);
4130 /* target tfile command */
4132 static struct target_ops tfile_ops
;
4134 /* Fill in tfile_ops with its defined operations and properties. */
4136 #define TRACE_HEADER_SIZE 8
4138 static char *trace_filename
;
4139 static int trace_fd
= -1;
4140 static off_t trace_frames_offset
;
4141 static off_t cur_offset
;
4142 static int cur_data_size
;
4143 int trace_regblock_size
;
4145 static void tfile_interp_line (char *line
,
4146 struct uploaded_tp
**utpp
,
4147 struct uploaded_tsv
**utsvp
);
4149 /* Read SIZE bytes into READBUF from the trace frame, starting at
4150 TRACE_FD's current position. Note that this call `read'
4151 underneath, hence it advances the file's seek position. Throws an
4152 error if the `read' syscall fails, or less than SIZE bytes are
4156 tfile_read (gdb_byte
*readbuf
, int size
)
4160 gotten
= read (trace_fd
, readbuf
, size
);
4162 perror_with_name (trace_filename
);
4163 else if (gotten
< size
)
4164 error (_("Premature end of file while reading trace file"));
4168 tfile_open (char *filename
, int from_tty
)
4170 volatile struct gdb_exception ex
;
4172 struct cleanup
*old_chain
;
4175 char header
[TRACE_HEADER_SIZE
];
4176 char linebuf
[1000]; /* Should be max remote packet size or so. */
4179 struct trace_status
*ts
;
4180 struct uploaded_tp
*uploaded_tps
= NULL
;
4181 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4183 target_preopen (from_tty
);
4185 error (_("No trace file specified."));
4187 filename
= tilde_expand (filename
);
4188 if (!IS_ABSOLUTE_PATH(filename
))
4190 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
4195 old_chain
= make_cleanup (xfree
, filename
);
4197 flags
= O_BINARY
| O_LARGEFILE
;
4199 scratch_chan
= gdb_open_cloexec (filename
, flags
, 0);
4200 if (scratch_chan
< 0)
4201 perror_with_name (filename
);
4203 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
4205 discard_cleanups (old_chain
); /* Don't free filename any more. */
4206 unpush_target (&tfile_ops
);
4208 trace_filename
= xstrdup (filename
);
4209 trace_fd
= scratch_chan
;
4212 /* Read the file header and test for validity. */
4213 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
4215 bytes
+= TRACE_HEADER_SIZE
;
4216 if (!(header
[0] == 0x7f
4217 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
4218 error (_("File is not a valid trace file."));
4220 push_target (&tfile_ops
);
4222 trace_regblock_size
= 0;
4223 ts
= current_trace_status ();
4224 /* We know we're working with a file. Record its name. */
4225 ts
->filename
= trace_filename
;
4226 /* Set defaults in case there is no status line. */
4227 ts
->running_known
= 0;
4228 ts
->stop_reason
= trace_stop_reason_unknown
;
4229 ts
->traceframe_count
= -1;
4230 ts
->buffer_free
= 0;
4231 ts
->disconnected_tracing
= 0;
4232 ts
->circular_buffer
= 0;
4234 TRY_CATCH (ex
, RETURN_MASK_ALL
)
4236 /* Read through a section of newline-terminated lines that
4237 define things like tracepoints. */
4241 tfile_read (&byte
, 1);
4246 /* Empty line marks end of the definition section. */
4251 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
4254 linebuf
[i
++] = byte
;
4256 error (_("Excessively long lines in trace file"));
4259 /* Record the starting offset of the binary trace data. */
4260 trace_frames_offset
= bytes
;
4262 /* If we don't have a blocksize, we can't interpret the
4264 if (trace_regblock_size
== 0)
4265 error (_("No register block size recorded in trace file"));
4269 /* Pop the partially set up target. */
4271 throw_exception (ex
);
4274 if (ts
->traceframe_count
<= 0)
4275 warning (_("No traceframes present in this file."));
4277 /* Add the file's tracepoints and variables into the current mix. */
4279 /* Get trace state variables first, they may be checked when parsing
4280 uploaded commands. */
4281 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4283 merge_uploaded_tracepoints (&uploaded_tps
);
4286 /* Interpret the given line from the definitions part of the trace
4290 tfile_interp_line (char *line
, struct uploaded_tp
**utpp
,
4291 struct uploaded_tsv
**utsvp
)
4295 if (strncmp (p
, "R ", strlen ("R ")) == 0)
4298 trace_regblock_size
= strtol (p
, &p
, 16);
4300 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
4302 p
+= strlen ("status ");
4303 parse_trace_status (p
, current_trace_status ());
4305 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
4307 p
+= strlen ("tp ");
4308 parse_tracepoint_definition (p
, utpp
);
4310 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
4312 p
+= strlen ("tsv ");
4313 parse_tsv_definition (p
, utsvp
);
4316 warning (_("Ignoring trace file definition \"%s\""), line
);
4319 /* Parse the part of trace status syntax that is shared between
4320 the remote protocol and the trace file reader. */
4323 parse_trace_status (char *line
, struct trace_status
*ts
)
4325 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
4329 ts
->running_known
= 1;
4330 ts
->running
= (*p
++ == '1');
4331 ts
->stop_reason
= trace_stop_reason_unknown
;
4332 xfree (ts
->stop_desc
);
4333 ts
->stop_desc
= NULL
;
4334 ts
->traceframe_count
= -1;
4335 ts
->traceframes_created
= -1;
4336 ts
->buffer_free
= -1;
4337 ts
->buffer_size
= -1;
4338 ts
->disconnected_tracing
= 0;
4339 ts
->circular_buffer
= 0;
4340 xfree (ts
->user_name
);
4341 ts
->user_name
= NULL
;
4344 ts
->start_time
= ts
->stop_time
= 0;
4348 p1
= strchr (p
, ':');
4350 error (_("Malformed trace status, at %s\n\
4351 Status line: '%s'\n"), p
, line
);
4352 p3
= strchr (p
, ';');
4354 p3
= p
+ strlen (p
);
4355 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
4357 p
= unpack_varlen_hex (++p1
, &val
);
4358 ts
->stop_reason
= trace_buffer_full
;
4360 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
4362 p
= unpack_varlen_hex (++p1
, &val
);
4363 ts
->stop_reason
= trace_never_run
;
4365 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
4368 p
= unpack_varlen_hex (++p1
, &val
);
4369 ts
->stop_reason
= tracepoint_passcount
;
4370 ts
->stopping_tracepoint
= val
;
4372 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
4374 p2
= strchr (++p1
, ':');
4382 ts
->stop_desc
= xmalloc (strlen (line
));
4383 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
4384 ts
->stop_desc
[end
] = '\0';
4387 ts
->stop_desc
= xstrdup ("");
4389 p
= unpack_varlen_hex (++p2
, &val
);
4390 ts
->stop_reason
= tstop_command
;
4392 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
4394 p
= unpack_varlen_hex (++p1
, &val
);
4395 ts
->stop_reason
= trace_disconnected
;
4397 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
4399 p2
= strchr (++p1
, ':');
4402 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
4403 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
4404 ts
->stop_desc
[end
] = '\0';
4407 ts
->stop_desc
= xstrdup ("");
4409 p
= unpack_varlen_hex (++p2
, &val
);
4410 ts
->stopping_tracepoint
= val
;
4411 ts
->stop_reason
= tracepoint_error
;
4413 else if (strncmp (p
, "tframes", p1
- p
) == 0)
4415 p
= unpack_varlen_hex (++p1
, &val
);
4416 ts
->traceframe_count
= val
;
4418 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
4420 p
= unpack_varlen_hex (++p1
, &val
);
4421 ts
->traceframes_created
= val
;
4423 else if (strncmp (p
, "tfree", p1
- p
) == 0)
4425 p
= unpack_varlen_hex (++p1
, &val
);
4426 ts
->buffer_free
= val
;
4428 else if (strncmp (p
, "tsize", p1
- p
) == 0)
4430 p
= unpack_varlen_hex (++p1
, &val
);
4431 ts
->buffer_size
= val
;
4433 else if (strncmp (p
, "disconn", p1
- p
) == 0)
4435 p
= unpack_varlen_hex (++p1
, &val
);
4436 ts
->disconnected_tracing
= val
;
4438 else if (strncmp (p
, "circular", p1
- p
) == 0)
4440 p
= unpack_varlen_hex (++p1
, &val
);
4441 ts
->circular_buffer
= val
;
4443 else if (strncmp (p
, "starttime", p1
- p
) == 0)
4445 p
= unpack_varlen_hex (++p1
, &val
);
4446 ts
->start_time
= val
;
4448 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
4450 p
= unpack_varlen_hex (++p1
, &val
);
4451 ts
->stop_time
= val
;
4453 else if (strncmp (p
, "username", p1
- p
) == 0)
4456 ts
->user_name
= xmalloc (strlen (p
) / 2);
4457 end
= hex2bin (p1
, (gdb_byte
*) ts
->user_name
, (p3
- p1
) / 2);
4458 ts
->user_name
[end
] = '\0';
4461 else if (strncmp (p
, "notes", p1
- p
) == 0)
4464 ts
->notes
= xmalloc (strlen (p
) / 2);
4465 end
= hex2bin (p1
, (gdb_byte
*) ts
->notes
, (p3
- p1
) / 2);
4466 ts
->notes
[end
] = '\0';
4471 /* Silently skip unknown optional info. */
4472 p_temp
= strchr (p1
+ 1, ';');
4476 /* Must be at the end. */
4483 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
4484 struct uploaded_tp
*utp
)
4487 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
4489 p
= unpack_varlen_hex (p
, &uval
);
4491 tp
->base
.hit_count
+= uval
;
4493 utp
->hit_count
+= uval
;
4494 p
= unpack_varlen_hex (p
+ 1, &uval
);
4496 tp
->traceframe_usage
+= uval
;
4498 utp
->traceframe_usage
+= uval
;
4499 /* Ignore any extra, allowing for future extensions. */
4502 /* Given a line of text defining a part of a tracepoint, parse it into
4503 an "uploaded tracepoint". */
4506 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
4510 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
4513 char *cond
, *srctype
, *buf
;
4514 struct uploaded_tp
*utp
= NULL
;
4517 /* Both tracepoint and action definitions start with the same number
4518 and address sequence. */
4520 p
= unpack_varlen_hex (p
, &num
);
4521 p
++; /* skip a colon */
4522 p
= unpack_varlen_hex (p
, &addr
);
4523 p
++; /* skip a colon */
4526 enabled
= (*p
++ == 'E');
4527 p
++; /* skip a colon */
4528 p
= unpack_varlen_hex (p
, &step
);
4529 p
++; /* skip a colon */
4530 p
= unpack_varlen_hex (p
, &pass
);
4531 type
= bp_tracepoint
;
4533 /* Thumb through optional fields. */
4536 p
++; /* skip a colon */
4539 type
= bp_fast_tracepoint
;
4541 p
= unpack_varlen_hex (p
, &orig_size
);
4545 type
= bp_static_tracepoint
;
4551 p
= unpack_varlen_hex (p
, &xlen
);
4552 p
++; /* skip a comma */
4553 cond
= (char *) xmalloc (2 * xlen
+ 1);
4554 strncpy (cond
, p
, 2 * xlen
);
4555 cond
[2 * xlen
] = '\0';
4559 warning (_("Unrecognized char '%c' in tracepoint "
4560 "definition, skipping rest"), *p
);
4562 utp
= get_uploaded_tp (num
, addr
, utpp
);
4564 utp
->enabled
= enabled
;
4569 else if (piece
== 'A')
4571 utp
= get_uploaded_tp (num
, addr
, utpp
);
4572 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
4574 else if (piece
== 'S')
4576 utp
= get_uploaded_tp (num
, addr
, utpp
);
4577 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
4579 else if (piece
== 'Z')
4581 /* Parse a chunk of source form definition. */
4582 utp
= get_uploaded_tp (num
, addr
, utpp
);
4584 p
= strchr (p
, ':');
4585 p
++; /* skip a colon */
4586 p
= unpack_varlen_hex (p
, &start
);
4587 p
++; /* skip a colon */
4588 p
= unpack_varlen_hex (p
, &xlen
);
4589 p
++; /* skip a colon */
4591 buf
= alloca (strlen (line
));
4593 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4596 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
4597 utp
->at_string
= xstrdup (buf
);
4598 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
4599 utp
->cond_string
= xstrdup (buf
);
4600 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
4601 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
4603 else if (piece
== 'V')
4605 utp
= get_uploaded_tp (num
, addr
, utpp
);
4607 parse_tracepoint_status (p
, NULL
, utp
);
4611 /* Don't error out, the target might be sending us optional
4612 info that we don't care about. */
4613 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
4617 /* Convert a textual description of a trace state variable into an
4621 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
4624 ULONGEST num
, initval
, builtin
;
4626 struct uploaded_tsv
*utsv
= NULL
;
4628 buf
= alloca (strlen (line
));
4631 p
= unpack_varlen_hex (p
, &num
);
4632 p
++; /* skip a colon */
4633 p
= unpack_varlen_hex (p
, &initval
);
4634 p
++; /* skip a colon */
4635 p
= unpack_varlen_hex (p
, &builtin
);
4636 p
++; /* skip a colon */
4637 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4640 utsv
= get_uploaded_tsv (num
, utsvp
);
4641 utsv
->initial_value
= initval
;
4642 utsv
->builtin
= builtin
;
4643 utsv
->name
= xstrdup (buf
);
4646 /* Close the trace file and generally clean up. */
4658 xfree (trace_filename
);
4659 trace_filename
= NULL
;
4663 tfile_files_info (struct target_ops
*t
)
4665 printf_filtered ("\t`%s'\n", trace_filename
);
4668 /* The trace status for a file is that tracing can never be run. */
4671 tfile_get_trace_status (struct trace_status
*ts
)
4673 /* Other bits of trace status were collected as part of opening the
4674 trace files, so nothing to do here. */
4680 tfile_get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
4682 /* Other bits of trace status were collected as part of opening the
4683 trace files, so nothing to do here. */
4686 /* Given the position of a traceframe in the file, figure out what
4687 address the frame was collected at. This would normally be the
4688 value of a collected PC register, but if not available, we
4692 tfile_get_traceframe_address (off_t tframe_offset
)
4696 struct tracepoint
*tp
;
4697 off_t saved_offset
= cur_offset
;
4699 /* FIXME dig pc out of collected registers. */
4701 /* Fall back to using tracepoint address. */
4702 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
4703 tfile_read ((gdb_byte
*) &tpnum
, 2);
4704 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4706 (target_gdbarch ()));
4708 tp
= get_tracepoint_by_number_on_target (tpnum
);
4709 /* FIXME this is a poor heuristic if multiple locations. */
4710 if (tp
&& tp
->base
.loc
)
4711 addr
= tp
->base
.loc
->address
;
4713 /* Restore our seek position. */
4714 cur_offset
= saved_offset
;
4715 lseek (trace_fd
, cur_offset
, SEEK_SET
);
4719 /* Given a type of search and some parameters, scan the collection of
4720 traceframes in the file looking for a match. When found, return
4721 both the traceframe and tracepoint number, otherwise -1 for
4725 tfile_trace_find (enum trace_find_type type
, int num
,
4726 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
)
4729 int tfnum
= 0, found
= 0;
4730 unsigned int data_size
;
4731 struct tracepoint
*tp
;
4732 off_t offset
, tframe_offset
;
4742 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
4743 offset
= trace_frames_offset
;
4746 tframe_offset
= offset
;
4747 tfile_read ((gdb_byte
*) &tpnum
, 2);
4748 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4750 (target_gdbarch ()));
4754 tfile_read ((gdb_byte
*) &data_size
, 4);
4755 data_size
= (unsigned int) extract_unsigned_integer
4756 ((gdb_byte
*) &data_size
, 4,
4757 gdbarch_byte_order (target_gdbarch ()));
4760 if (type
== tfind_number
)
4762 /* Looking for a specific trace frame. */
4768 /* Start from the _next_ trace frame. */
4769 if (tfnum
> traceframe_number
)
4774 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4775 if (tfaddr
== addr1
)
4779 tp
= get_tracepoint (num
);
4780 if (tp
&& tpnum
== tp
->number_on_target
)
4784 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4785 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
4789 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4790 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
4794 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
4803 cur_offset
= offset
;
4804 cur_data_size
= data_size
;
4808 /* Skip past the traceframe's data. */
4809 lseek (trace_fd
, data_size
, SEEK_CUR
);
4810 offset
+= data_size
;
4811 /* Update our own count of traceframes. */
4814 /* Did not find what we were looking for. */
4820 /* Prototype of the callback passed to tframe_walk_blocks. */
4821 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
4823 /* Callback for traceframe_walk_blocks, used to find a given block
4824 type in a traceframe. */
4827 match_blocktype (char blocktype
, void *data
)
4829 char *wantedp
= data
;
4831 if (*wantedp
== blocktype
)
4837 /* Walk over all traceframe block starting at POS offset from
4838 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4839 unmodified. If CALLBACK returns true, this returns the position in
4840 the traceframe where the block is found, relative to the start of
4841 the traceframe (cur_offset). Returns -1 if no callback call
4842 returned true, indicating that all blocks have been walked. */
4845 traceframe_walk_blocks (walk_blocks_callback_func callback
,
4846 int pos
, void *data
)
4848 /* Iterate through a traceframe's blocks, looking for a block of the
4851 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
4852 while (pos
< cur_data_size
)
4854 unsigned short mlen
;
4857 tfile_read ((gdb_byte
*) &block_type
, 1);
4861 if ((*callback
) (block_type
, data
))
4867 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4868 pos
+= trace_regblock_size
;
4871 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4872 tfile_read ((gdb_byte
*) &mlen
, 2);
4873 mlen
= (unsigned short)
4874 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4876 (target_gdbarch ()));
4877 lseek (trace_fd
, mlen
, SEEK_CUR
);
4878 pos
+= (8 + 2 + mlen
);
4881 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
4885 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4886 block_type
, block_type
);
4894 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4895 position offset of a block of type TYPE_WANTED in the current trace
4896 frame, starting at POS. Returns -1 if no such block was found. */
4899 traceframe_find_block_type (char type_wanted
, int pos
)
4901 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
4904 /* Look for a block of saved registers in the traceframe, and get the
4905 requested register from it. */
4908 tfile_fetch_registers (struct target_ops
*ops
,
4909 struct regcache
*regcache
, int regno
)
4911 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4912 int offset
, regn
, regsize
, pc_regno
;
4915 /* An uninitialized reg size says we're not going to be
4916 successful at getting register blocks. */
4917 if (!trace_regblock_size
)
4920 regs
= alloca (trace_regblock_size
);
4922 if (traceframe_find_block_type ('R', 0) >= 0)
4924 tfile_read (regs
, trace_regblock_size
);
4926 /* Assume the block is laid out in GDB register number order,
4927 each register with the size that it has in GDB. */
4929 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4931 regsize
= register_size (gdbarch
, regn
);
4932 /* Make sure we stay within block bounds. */
4933 if (offset
+ regsize
>= trace_regblock_size
)
4935 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
4939 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
4942 else if (regno
== -1)
4944 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
4952 /* We get here if no register data has been found. Mark registers
4954 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4955 regcache_raw_supply (regcache
, regn
, NULL
);
4957 /* We can often usefully guess that the PC is going to be the same
4958 as the address of the tracepoint. */
4959 pc_regno
= gdbarch_pc_regnum (gdbarch
);
4960 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
4962 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
4964 if (tp
&& tp
->base
.loc
)
4966 /* But don't try to guess if tracepoint is multi-location... */
4967 if (tp
->base
.loc
->next
)
4969 warning (_("Tracepoint %d has multiple "
4970 "locations, cannot infer $pc"),
4974 /* ... or does while-stepping. */
4975 if (tp
->step_count
> 0)
4977 warning (_("Tracepoint %d does while-stepping, "
4978 "cannot infer $pc"),
4983 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
4984 gdbarch_byte_order (gdbarch
),
4985 tp
->base
.loc
->address
);
4986 regcache_raw_supply (regcache
, pc_regno
, regs
);
4992 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4993 const char *annex
, gdb_byte
*readbuf
,
4994 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
4996 /* We're only doing regular memory for now. */
4997 if (object
!= TARGET_OBJECT_MEMORY
)
5000 if (readbuf
== NULL
)
5001 error (_("tfile_xfer_partial: trace file is read-only"));
5003 if (traceframe_number
!= -1)
5007 /* Iterate through the traceframe's blocks, looking for
5009 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
5011 ULONGEST maddr
, amt
;
5012 unsigned short mlen
;
5013 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
5015 tfile_read ((gdb_byte
*) &maddr
, 8);
5016 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
5018 tfile_read ((gdb_byte
*) &mlen
, 2);
5019 mlen
= (unsigned short)
5020 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
5022 /* If the block includes the first part of the desired
5023 range, return as much it has; GDB will re-request the
5024 remainder, which might be in a different block of this
5026 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
5028 amt
= (maddr
+ mlen
) - offset
;
5032 if (maddr
!= offset
)
5033 lseek (trace_fd
, offset
- maddr
, SEEK_CUR
);
5034 tfile_read (readbuf
, amt
);
5038 /* Skip over this block. */
5039 pos
+= (8 + 2 + mlen
);
5043 /* It's unduly pedantic to refuse to look at the executable for
5044 read-only pieces; so do the equivalent of readonly regions aka
5046 /* FIXME account for relocation at some point. */
5053 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5055 if ((s
->flags
& SEC_LOAD
) == 0
5056 || (s
->flags
& SEC_READONLY
) == 0)
5060 size
= bfd_get_section_size (s
);
5061 if (vma
<= offset
&& offset
< (vma
+ size
))
5065 amt
= (vma
+ size
) - offset
;
5069 amt
= bfd_get_section_contents (exec_bfd
, s
,
5070 readbuf
, offset
- vma
, amt
);
5076 /* Indicate failure to find the requested memory block. */
5080 /* Iterate through the blocks of a trace frame, looking for a 'V'
5081 block with a matching tsv number. */
5084 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
5089 /* Iterate over blocks in current frame and find the last 'V'
5090 block in which tsv number is TSVNUM. In one trace frame, there
5091 may be multiple 'V' blocks created for a given trace variable,
5092 and the last matched 'V' block contains the updated value. */
5094 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
5098 tfile_read ((gdb_byte
*) &vnum
, 4);
5099 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
5101 (target_gdbarch ()));
5104 tfile_read ((gdb_byte
*) val
, 8);
5105 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
5107 (target_gdbarch ()));
5117 tfile_has_all_memory (struct target_ops
*ops
)
5123 tfile_has_memory (struct target_ops
*ops
)
5129 tfile_has_stack (struct target_ops
*ops
)
5131 return traceframe_number
!= -1;
5135 tfile_has_registers (struct target_ops
*ops
)
5137 return traceframe_number
!= -1;
5140 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
5141 object for the tfile target's current traceframe. */
5144 build_traceframe_info (char blocktype
, void *data
)
5146 struct traceframe_info
*info
= data
;
5152 struct mem_range
*r
;
5154 unsigned short mlen
;
5156 tfile_read ((gdb_byte
*) &maddr
, 8);
5157 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
5159 (target_gdbarch ()));
5160 tfile_read ((gdb_byte
*) &mlen
, 2);
5161 mlen
= (unsigned short)
5162 extract_unsigned_integer ((gdb_byte
*) &mlen
,
5163 2, gdbarch_byte_order
5164 (target_gdbarch ()));
5166 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5179 warning (_("Unhandled trace block type (%d) '%c ' "
5180 "while building trace frame info."),
5181 blocktype
, blocktype
);
5188 static struct traceframe_info
*
5189 tfile_traceframe_info (void)
5191 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
5193 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
5198 init_tfile_ops (void)
5200 tfile_ops
.to_shortname
= "tfile";
5201 tfile_ops
.to_longname
= "Local trace dump file";
5203 = "Use a trace file as a target. Specify the filename of the trace file.";
5204 tfile_ops
.to_open
= tfile_open
;
5205 tfile_ops
.to_close
= tfile_close
;
5206 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
5207 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
5208 tfile_ops
.to_files_info
= tfile_files_info
;
5209 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
5210 tfile_ops
.to_get_tracepoint_status
= tfile_get_tracepoint_status
;
5211 tfile_ops
.to_trace_find
= tfile_trace_find
;
5212 tfile_ops
.to_get_trace_state_variable_value
5213 = tfile_get_trace_state_variable_value
;
5214 tfile_ops
.to_stratum
= process_stratum
;
5215 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
5216 tfile_ops
.to_has_memory
= tfile_has_memory
;
5217 tfile_ops
.to_has_stack
= tfile_has_stack
;
5218 tfile_ops
.to_has_registers
= tfile_has_registers
;
5219 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
5220 tfile_ops
.to_magic
= OPS_MAGIC
;
5224 free_current_marker (void *arg
)
5226 struct static_tracepoint_marker
**marker_p
= arg
;
5228 if (*marker_p
!= NULL
)
5230 release_static_tracepoint_marker (*marker_p
);
5237 /* Given a line of text defining a static tracepoint marker, parse it
5238 into a "static tracepoint marker" object. Throws an error is
5239 parsing fails. If PP is non-null, it points to one past the end of
5240 the parsed marker definition. */
5243 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
5244 struct static_tracepoint_marker
*marker
)
5251 p
= unpack_varlen_hex (p
, &addr
);
5252 p
++; /* skip a colon */
5254 marker
->gdbarch
= target_gdbarch ();
5255 marker
->address
= (CORE_ADDR
) addr
;
5257 endp
= strchr (p
, ':');
5259 error (_("bad marker definition: %s"), line
);
5261 marker
->str_id
= xmalloc (endp
- p
+ 1);
5262 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
5263 marker
->str_id
[end
] = '\0';
5266 p
++; /* skip a colon */
5268 marker
->extra
= xmalloc (strlen (p
) + 1);
5269 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
5270 marker
->extra
[end
] = '\0';
5276 /* Release a static tracepoint marker's contents. Note that the
5277 object itself isn't released here. There objects are usually on
5281 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
5283 xfree (marker
->str_id
);
5284 marker
->str_id
= NULL
;
5287 /* Print MARKER to gdb_stdout. */
5290 print_one_static_tracepoint_marker (int count
,
5291 struct static_tracepoint_marker
*marker
)
5293 struct command_line
*l
;
5296 char wrap_indent
[80];
5297 char extra_field_indent
[80];
5298 struct ui_out
*uiout
= current_uiout
;
5299 struct cleanup
*bkpt_chain
;
5300 VEC(breakpoint_p
) *tracepoints
;
5302 struct symtab_and_line sal
;
5306 sal
.pc
= marker
->address
;
5308 tracepoints
= static_tracepoints_here (marker
->address
);
5310 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
5312 /* A counter field to help readability. This is not a stable
5314 ui_out_field_int (uiout
, "count", count
);
5316 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
5318 ui_out_field_fmt (uiout
, "enabled", "%c",
5319 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
5320 ui_out_spaces (uiout
, 2);
5322 strcpy (wrap_indent
, " ");
5324 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
5325 strcat (wrap_indent
, " ");
5327 strcat (wrap_indent
, " ");
5329 strcpy (extra_field_indent
, " ");
5331 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
5333 sal
= find_pc_line (marker
->address
, 0);
5334 sym
= find_pc_sect_function (marker
->address
, NULL
);
5337 ui_out_text (uiout
, "in ");
5338 ui_out_field_string (uiout
, "func",
5339 SYMBOL_PRINT_NAME (sym
));
5340 ui_out_wrap_hint (uiout
, wrap_indent
);
5341 ui_out_text (uiout
, " at ");
5344 ui_out_field_skip (uiout
, "func");
5346 if (sal
.symtab
!= NULL
)
5348 ui_out_field_string (uiout
, "file",
5349 symtab_to_filename_for_display (sal
.symtab
));
5350 ui_out_text (uiout
, ":");
5352 if (ui_out_is_mi_like_p (uiout
))
5354 const char *fullname
= symtab_to_fullname (sal
.symtab
);
5356 ui_out_field_string (uiout
, "fullname", fullname
);
5359 ui_out_field_skip (uiout
, "fullname");
5361 ui_out_field_int (uiout
, "line", sal
.line
);
5365 ui_out_field_skip (uiout
, "fullname");
5366 ui_out_field_skip (uiout
, "line");
5369 ui_out_text (uiout
, "\n");
5370 ui_out_text (uiout
, extra_field_indent
);
5371 ui_out_text (uiout
, _("Data: \""));
5372 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
5373 ui_out_text (uiout
, "\"\n");
5375 if (!VEC_empty (breakpoint_p
, tracepoints
))
5377 struct cleanup
*cleanup_chain
;
5379 struct breakpoint
*b
;
5381 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
5384 ui_out_text (uiout
, extra_field_indent
);
5385 ui_out_text (uiout
, _("Probed by static tracepoints: "));
5386 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
5389 ui_out_text (uiout
, ", ");
5390 ui_out_text (uiout
, "#");
5391 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
5394 do_cleanups (cleanup_chain
);
5396 if (ui_out_is_mi_like_p (uiout
))
5397 ui_out_field_int (uiout
, "number-of-tracepoints",
5398 VEC_length(breakpoint_p
, tracepoints
));
5400 ui_out_text (uiout
, "\n");
5402 VEC_free (breakpoint_p
, tracepoints
);
5404 do_cleanups (bkpt_chain
);
5408 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
5410 VEC(static_tracepoint_marker_p
) *markers
;
5411 struct cleanup
*old_chain
;
5412 struct static_tracepoint_marker
*marker
;
5413 struct ui_out
*uiout
= current_uiout
;
5416 /* We don't have to check target_can_use_agent and agent's capability on
5417 static tracepoint here, in order to be compatible with older GDBserver.
5418 We don't check USE_AGENT is true or not, because static tracepoints
5419 don't work without in-process agent, so we don't bother users to type
5420 `set agent on' when to use static tracepoint. */
5423 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
5424 "StaticTracepointMarkersTable");
5426 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
5428 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
5430 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
5431 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
5432 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
5434 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
5435 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
5437 ui_out_table_body (uiout
);
5439 markers
= target_static_tracepoint_markers_by_strid (NULL
);
5440 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
5443 VEC_iterate (static_tracepoint_marker_p
,
5444 markers
, i
, marker
);
5447 print_one_static_tracepoint_marker (i
+ 1, marker
);
5448 release_static_tracepoint_marker (marker
);
5451 do_cleanups (old_chain
);
5454 /* The $_sdata convenience variable is a bit special. We don't know
5455 for sure type of the value until we actually have a chance to fetch
5456 the data --- the size of the object depends on what has been
5457 collected. We solve this by making $_sdata be an internalvar that
5458 creates a new value on access. */
5460 /* Return a new value with the correct type for the sdata object of
5461 the current trace frame. Return a void value if there's no object
5464 static struct value
*
5465 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
5471 /* We need to read the whole object before we know its size. */
5472 size
= target_read_alloc (¤t_target
,
5473 TARGET_OBJECT_STATIC_TRACE_DATA
,
5480 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
5482 v
= allocate_value (type
);
5483 memcpy (value_contents_raw (v
), buf
, size
);
5488 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
5491 #if !defined(HAVE_LIBEXPAT)
5493 struct traceframe_info
*
5494 parse_traceframe_info (const char *tframe_info
)
5496 static int have_warned
;
5501 warning (_("Can not parse XML trace frame info; XML support "
5502 "was disabled at compile time"));
5508 #else /* HAVE_LIBEXPAT */
5510 #include "xml-support.h"
5512 /* Handle the start of a <memory> element. */
5515 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
5516 const struct gdb_xml_element
*element
,
5517 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
5519 struct traceframe_info
*info
= user_data
;
5520 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5521 ULONGEST
*start_p
, *length_p
;
5523 start_p
= xml_find_attribute (attributes
, "start")->value
;
5524 length_p
= xml_find_attribute (attributes
, "length")->value
;
5526 r
->start
= *start_p
;
5527 r
->length
= *length_p
;
5530 /* Discard the constructed trace frame info (if an error occurs). */
5533 free_result (void *p
)
5535 struct traceframe_info
*result
= p
;
5537 free_traceframe_info (result
);
5540 /* The allowed elements and attributes for an XML memory map. */
5542 static const struct gdb_xml_attribute memory_attributes
[] = {
5543 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5544 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5545 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5548 static const struct gdb_xml_element traceframe_info_children
[] = {
5549 { "memory", memory_attributes
, NULL
,
5550 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5551 traceframe_info_start_memory
, NULL
},
5552 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5555 static const struct gdb_xml_element traceframe_info_elements
[] = {
5556 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
5558 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5561 /* Parse a traceframe-info XML document. */
5563 struct traceframe_info
*
5564 parse_traceframe_info (const char *tframe_info
)
5566 struct traceframe_info
*result
;
5567 struct cleanup
*back_to
;
5569 result
= XCNEW (struct traceframe_info
);
5570 back_to
= make_cleanup (free_result
, result
);
5572 if (gdb_xml_parse_quick (_("trace frame info"),
5573 "traceframe-info.dtd", traceframe_info_elements
,
5574 tframe_info
, result
) == 0)
5576 /* Parsed successfully, keep the result. */
5577 discard_cleanups (back_to
);
5582 do_cleanups (back_to
);
5586 #endif /* HAVE_LIBEXPAT */
5588 /* Returns the traceframe_info object for the current traceframe.
5589 This is where we avoid re-fetching the object from the target if we
5590 already have it cached. */
5592 static struct traceframe_info
*
5593 get_traceframe_info (void)
5595 if (traceframe_info
== NULL
)
5596 traceframe_info
= target_traceframe_info ();
5598 return traceframe_info
;
5601 /* If the target supports the query, return in RESULT the set of
5602 collected memory in the current traceframe, found within the LEN
5603 bytes range starting at MEMADDR. Returns true if the target
5604 supports the query, otherwise returns false, and RESULT is left
5608 traceframe_available_memory (VEC(mem_range_s
) **result
,
5609 CORE_ADDR memaddr
, ULONGEST len
)
5611 struct traceframe_info
*info
= get_traceframe_info ();
5615 struct mem_range
*r
;
5620 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
5621 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
5623 ULONGEST lo1
, hi1
, lo2
, hi2
;
5624 struct mem_range
*nr
;
5627 hi1
= memaddr
+ len
;
5630 hi2
= r
->start
+ r
->length
;
5632 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
5634 nr
->start
= max (lo1
, lo2
);
5635 nr
->length
= min (hi1
, hi2
) - nr
->start
;
5638 normalize_mem_ranges (*result
);
5645 /* Implementation of `sdata' variable. */
5647 static const struct internalvar_funcs sdata_funcs
=
5654 /* module initialization */
5656 _initialize_tracepoint (void)
5658 struct cmd_list_element
*c
;
5660 /* Explicitly create without lookup, since that tries to create a
5661 value with a void typed value, and when we get here, gdbarch
5662 isn't initialized yet. At this point, we're quite sure there
5663 isn't another convenience variable of the same name. */
5664 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
5666 traceframe_number
= -1;
5667 tracepoint_number
= -1;
5669 if (tracepoint_list
.list
== NULL
)
5671 tracepoint_list
.listsize
= 128;
5672 tracepoint_list
.list
= xmalloc
5673 (tracepoint_list
.listsize
* sizeof (struct memrange
));
5675 if (tracepoint_list
.aexpr_list
== NULL
)
5677 tracepoint_list
.aexpr_listsize
= 128;
5678 tracepoint_list
.aexpr_list
= xmalloc
5679 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5682 if (stepping_list
.list
== NULL
)
5684 stepping_list
.listsize
= 128;
5685 stepping_list
.list
= xmalloc
5686 (stepping_list
.listsize
* sizeof (struct memrange
));
5689 if (stepping_list
.aexpr_list
== NULL
)
5691 stepping_list
.aexpr_listsize
= 128;
5692 stepping_list
.aexpr_list
= xmalloc
5693 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5696 add_info ("scope", scope_info
,
5697 _("List the variables local to a scope"));
5699 add_cmd ("tracepoints", class_trace
, NULL
,
5700 _("Tracing of program execution without stopping the program."),
5703 add_com ("tdump", class_trace
, trace_dump_command
,
5704 _("Print everything collected at the current tracepoint."));
5706 add_com ("tsave", class_trace
, trace_save_command
, _("\
5707 Save the trace data to a file.\n\
5708 Use the '-ctf' option to save the data to CTF format.\n\
5709 Use the '-r' option to direct the target to save directly to the file,\n\
5710 using its own filesystem."));
5712 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
5713 Define a trace state variable.\n\
5714 Argument is a $-prefixed name, optionally followed\n\
5715 by '=' and an expression that sets the initial value\n\
5716 at the start of tracing."));
5717 set_cmd_completer (c
, expression_completer
);
5719 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
5720 Delete one or more trace state variables.\n\
5721 Arguments are the names of the variables to delete.\n\
5722 If no arguments are supplied, delete all variables."), &deletelist
);
5723 /* FIXME add a trace variable completer. */
5725 add_info ("tvariables", tvariables_info
, _("\
5726 Status of trace state variables and their values.\n\
5729 add_info ("static-tracepoint-markers",
5730 info_static_tracepoint_markers_command
, _("\
5731 List target static tracepoints markers.\n\
5734 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
5735 Select a trace frame;\n\
5736 No argument means forward by one frame; '-' means backward by one frame."),
5737 &tfindlist
, "tfind ", 1, &cmdlist
);
5739 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
5740 Select a trace frame whose PC is outside the given range (exclusive).\n\
5741 Usage: tfind outside addr1, addr2"),
5744 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
5745 Select a trace frame whose PC is in the given range (inclusive).\n\
5746 Usage: tfind range addr1,addr2"),
5749 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
5750 Select a trace frame by source line.\n\
5751 Argument can be a line number (with optional source file),\n\
5752 a function name, or '*' followed by an address.\n\
5753 Default argument is 'the next source line that was traced'."),
5756 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
5757 Select a trace frame by tracepoint number.\n\
5758 Default is the tracepoint for the current trace frame."),
5761 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
5762 Select a trace frame by PC.\n\
5763 Default is the current PC, or the PC of the current trace frame."),
5766 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
5767 De-select any trace frame and resume 'live' debugging."),
5770 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
5772 add_cmd ("start", class_trace
, trace_find_start_command
,
5773 _("Select the first trace frame in the trace buffer."),
5776 add_com ("tstatus", class_trace
, trace_status_command
,
5777 _("Display the status of the current trace data collection."));
5779 add_com ("tstop", class_trace
, trace_stop_command
, _("\
5780 Stop trace data collection.\n\
5781 Usage: tstop [ <notes> ... ]\n\
5782 Any arguments supplied are recorded with the trace as a stop reason and\n\
5783 reported by tstatus (if the target supports trace notes)."));
5785 add_com ("tstart", class_trace
, trace_start_command
, _("\
5786 Start trace data collection.\n\
5787 Usage: tstart [ <notes> ... ]\n\
5788 Any arguments supplied are recorded with the trace as a note and\n\
5789 reported by tstatus (if the target supports trace notes)."));
5791 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
5792 Ends a list of commands or actions.\n\
5793 Several GDB commands allow you to enter a list of commands or actions.\n\
5794 Entering \"end\" on a line by itself is the normal way to terminate\n\
5796 Note: the \"end\" command cannot be used at the gdb prompt."));
5798 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
5799 Specify single-stepping behavior at a tracepoint.\n\
5800 Argument is number of instructions to trace in single-step mode\n\
5801 following the tracepoint. This command is normally followed by\n\
5802 one or more \"collect\" commands, to specify what to collect\n\
5803 while single-stepping.\n\n\
5804 Note: this command can only be used in a tracepoint \"actions\" list."));
5806 add_com_alias ("ws", "while-stepping", class_alias
, 0);
5807 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
5809 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
5810 Specify one or more data items to be collected at a tracepoint.\n\
5811 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5812 collect all data (variables, registers) referenced by that expression.\n\
5813 Also accepts the following special arguments:\n\
5814 $regs -- all registers.\n\
5815 $args -- all function arguments.\n\
5816 $locals -- all variables local to the block/function scope.\n\
5817 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5818 Note: this command can only be used in a tracepoint \"actions\" list."));
5820 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
5821 Specify one or more expressions to be evaluated at a tracepoint.\n\
5822 Accepts a comma-separated list of (one or more) expressions.\n\
5823 The result of each evaluation will be discarded.\n\
5824 Note: this command can only be used in a tracepoint \"actions\" list."));
5826 add_com ("actions", class_trace
, trace_actions_command
, _("\
5827 Specify the actions to be taken at a tracepoint.\n\
5828 Tracepoint actions may include collecting of specified data,\n\
5829 single-stepping, or enabling/disabling other tracepoints,\n\
5830 depending on target's capabilities."));
5832 default_collect
= xstrdup ("");
5833 add_setshow_string_cmd ("default-collect", class_trace
,
5834 &default_collect
, _("\
5835 Set the list of expressions to collect by default"), _("\
5836 Show the list of expressions to collect by default"), NULL
,
5838 &setlist
, &showlist
);
5840 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
5841 &disconnected_tracing
, _("\
5842 Set whether tracing continues after GDB disconnects."), _("\
5843 Show whether tracing continues after GDB disconnects."), _("\
5844 Use this to continue a tracing run even if GDB disconnects\n\
5845 or detaches from the target. You can reconnect later and look at\n\
5846 trace data collected in the meantime."),
5847 set_disconnected_tracing
,
5852 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
5853 &circular_trace_buffer
, _("\
5854 Set target's use of circular trace buffer."), _("\
5855 Show target's use of circular trace buffer."), _("\
5856 Use this to make the trace buffer into a circular buffer,\n\
5857 which will discard traceframes (oldest first) instead of filling\n\
5858 up and stopping the trace run."),
5859 set_circular_trace_buffer
,
5864 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class
,
5865 &trace_buffer_size
, _("\
5866 Set requested size of trace buffer."), _("\
5867 Show requested size of trace buffer."), _("\
5868 Use this to choose a size for the trace buffer. Some targets\n\
5869 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
5870 disables any attempt to set the buffer size and lets the target choose."),
5871 set_trace_buffer_size
, NULL
,
5872 &setlist
, &showlist
);
5874 add_setshow_string_cmd ("trace-user", class_trace
,
5876 Set the user name to use for current and future trace runs"), _("\
5877 Show the user name to use for current and future trace runs"), NULL
,
5878 set_trace_user
, NULL
,
5879 &setlist
, &showlist
);
5881 add_setshow_string_cmd ("trace-notes", class_trace
,
5883 Set notes string to use for current and future trace runs"), _("\
5884 Show the notes string to use for current and future trace runs"), NULL
,
5885 set_trace_notes
, NULL
,
5886 &setlist
, &showlist
);
5888 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
5889 &trace_stop_notes
, _("\
5890 Set notes string to use for future tstop commands"), _("\
5891 Show the notes string to use for future tstop commands"), NULL
,
5892 set_trace_stop_notes
, NULL
,
5893 &setlist
, &showlist
);
5897 add_target_with_completer (&tfile_ops
, filename_completer
);