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
);
238 VEC_free (int, info
->tvars
);
244 /* Free and clear the traceframe info cache of the current
248 clear_traceframe_info (void)
250 free_traceframe_info (traceframe_info
);
251 traceframe_info
= NULL
;
254 /* Set traceframe number to NUM. */
256 set_traceframe_num (int num
)
258 traceframe_number
= num
;
259 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
262 /* Set tracepoint number to NUM. */
264 set_tracepoint_num (int num
)
266 tracepoint_number
= num
;
267 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
270 /* Set externally visible debug variables for querying/printing
271 the traceframe context (line, function, file). */
274 set_traceframe_context (struct frame_info
*trace_frame
)
278 /* Save as globals for internal use. */
279 if (trace_frame
!= NULL
280 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
282 traceframe_sal
= find_pc_line (trace_pc
, 0);
283 traceframe_fun
= find_pc_function (trace_pc
);
285 /* Save linenumber as "$trace_line", a debugger variable visible to
287 set_internalvar_integer (lookup_internalvar ("trace_line"),
288 traceframe_sal
.line
);
292 init_sal (&traceframe_sal
);
293 traceframe_fun
= NULL
;
294 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
297 /* Save func name as "$trace_func", a debugger variable visible to
299 if (traceframe_fun
== NULL
300 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
301 clear_internalvar (lookup_internalvar ("trace_func"));
303 set_internalvar_string (lookup_internalvar ("trace_func"),
304 SYMBOL_LINKAGE_NAME (traceframe_fun
));
306 /* Save file name as "$trace_file", a debugger variable visible to
308 if (traceframe_sal
.symtab
== NULL
)
309 clear_internalvar (lookup_internalvar ("trace_file"));
311 set_internalvar_string (lookup_internalvar ("trace_file"),
312 symtab_to_filename_for_display (traceframe_sal
.symtab
));
315 /* Create a new trace state variable with the given name. */
317 struct trace_state_variable
*
318 create_trace_state_variable (const char *name
)
320 struct trace_state_variable tsv
;
322 memset (&tsv
, 0, sizeof (tsv
));
323 tsv
.name
= xstrdup (name
);
324 tsv
.number
= next_tsv_number
++;
325 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
328 /* Look for a trace state variable of the given name. */
330 struct trace_state_variable
*
331 find_trace_state_variable (const char *name
)
333 struct trace_state_variable
*tsv
;
336 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
337 if (strcmp (name
, tsv
->name
) == 0)
344 delete_trace_state_variable (const char *name
)
346 struct trace_state_variable
*tsv
;
349 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
350 if (strcmp (name
, tsv
->name
) == 0)
352 observer_notify_tsv_deleted (tsv
);
354 xfree ((void *)tsv
->name
);
355 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
360 warning (_("No trace variable named \"$%s\", not deleting"), name
);
363 /* Throws an error if NAME is not valid syntax for a trace state
367 validate_trace_state_variable_name (const char *name
)
372 error (_("Must supply a non-empty variable name"));
374 /* All digits in the name is reserved for value history
376 for (p
= name
; isdigit (*p
); p
++)
379 error (_("$%s is not a valid trace state variable name"), name
);
381 for (p
= name
; isalnum (*p
) || *p
== '_'; p
++)
384 error (_("$%s is not a valid trace state variable name"), name
);
387 /* The 'tvariable' command collects a name and optional expression to
388 evaluate into an initial value. */
391 trace_variable_command (char *args
, int from_tty
)
393 struct cleanup
*old_chain
;
395 struct trace_state_variable
*tsv
;
399 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
401 /* Only allow two syntaxes; "$name" and "$name=value". */
402 p
= skip_spaces (args
);
405 error (_("Name of trace variable should start with '$'"));
408 while (isalnum (*p
) || *p
== '_')
410 name
= savestring (name
, p
- name
);
411 old_chain
= make_cleanup (xfree
, name
);
414 if (*p
!= '=' && *p
!= '\0')
415 error (_("Syntax must be $NAME [ = EXPR ]"));
417 validate_trace_state_variable_name (name
);
420 initval
= value_as_long (parse_and_eval (++p
));
422 /* If the variable already exists, just change its initial value. */
423 tsv
= find_trace_state_variable (name
);
426 if (tsv
->initial_value
!= initval
)
428 tsv
->initial_value
= initval
;
429 observer_notify_tsv_modified (tsv
);
431 printf_filtered (_("Trace state variable $%s "
432 "now has initial value %s.\n"),
433 tsv
->name
, plongest (tsv
->initial_value
));
434 do_cleanups (old_chain
);
438 /* Create a new variable. */
439 tsv
= create_trace_state_variable (name
);
440 tsv
->initial_value
= initval
;
442 observer_notify_tsv_created (tsv
);
444 printf_filtered (_("Trace state variable $%s "
445 "created, with initial value %s.\n"),
446 tsv
->name
, plongest (tsv
->initial_value
));
448 do_cleanups (old_chain
);
452 delete_trace_variable_command (char *args
, int from_tty
)
456 struct cleanup
*back_to
;
460 if (query (_("Delete all trace state variables? ")))
461 VEC_free (tsv_s
, tvariables
);
463 observer_notify_tsv_deleted (NULL
);
467 argv
= gdb_buildargv (args
);
468 back_to
= make_cleanup_freeargv (argv
);
470 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
472 if (*argv
[ix
] == '$')
473 delete_trace_state_variable (argv
[ix
] + 1);
475 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
478 do_cleanups (back_to
);
484 tvariables_info_1 (void)
486 struct trace_state_variable
*tsv
;
489 struct cleanup
*back_to
;
490 struct ui_out
*uiout
= current_uiout
;
492 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
494 printf_filtered (_("No trace state variables.\n"));
498 /* Try to acquire values from the target. */
499 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
500 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
503 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
504 count
, "trace-variables");
505 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
506 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
507 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
509 ui_out_table_body (uiout
);
511 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
513 struct cleanup
*back_to2
;
517 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
519 name
= concat ("$", tsv
->name
, (char *) NULL
);
520 make_cleanup (xfree
, name
);
521 ui_out_field_string (uiout
, "name", name
);
522 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
524 if (tsv
->value_known
)
525 c
= plongest (tsv
->value
);
526 else if (ui_out_is_mi_like_p (uiout
))
527 /* For MI, we prefer not to use magic string constants, but rather
528 omit the field completely. The difference between unknown and
529 undefined does not seem important enough to represent. */
531 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
532 /* The value is/was defined, but we don't have it. */
535 /* It is not meaningful to ask about the value. */
538 ui_out_field_string (uiout
, "current", c
);
539 ui_out_text (uiout
, "\n");
541 do_cleanups (back_to2
);
544 do_cleanups (back_to
);
547 /* List all the trace state variables. */
550 tvariables_info (char *args
, int from_tty
)
552 tvariables_info_1 ();
555 /* Stash definitions of tsvs into the given file. */
558 save_trace_state_variables (struct ui_file
*fp
)
560 struct trace_state_variable
*tsv
;
563 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
565 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
566 if (tsv
->initial_value
)
567 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
568 fprintf_unfiltered (fp
, "\n");
572 /* ACTIONS functions: */
574 /* The three functions:
575 collect_pseudocommand,
576 while_stepping_pseudocommand, and
577 end_actions_pseudocommand
578 are placeholders for "commands" that are actually ONLY to be used
579 within a tracepoint action list. If the actual function is ever called,
580 it means that somebody issued the "command" at the top level,
581 which is always an error. */
584 end_actions_pseudocommand (char *args
, int from_tty
)
586 error (_("This command cannot be used at the top level."));
590 while_stepping_pseudocommand (char *args
, int from_tty
)
592 error (_("This command can only be used in a tracepoint actions list."));
596 collect_pseudocommand (char *args
, int from_tty
)
598 error (_("This command can only be used in a tracepoint actions list."));
602 teval_pseudocommand (char *args
, int from_tty
)
604 error (_("This command can only be used in a tracepoint actions list."));
607 /* Parse any collection options, such as /s for strings. */
610 decode_agent_options (const char *exp
, int *trace_string
)
612 struct value_print_options opts
;
619 /* Call this to borrow the print elements default for collection
621 get_user_print_options (&opts
);
626 if (target_supports_string_tracing ())
628 /* Allow an optional decimal number giving an explicit maximum
629 string length, defaulting it to the "print elements" value;
630 so "collect/s80 mystr" gets at most 80 bytes of string. */
631 *trace_string
= opts
.print_max
;
633 if (*exp
>= '0' && *exp
<= '9')
634 *trace_string
= atoi (exp
);
635 while (*exp
>= '0' && *exp
<= '9')
639 error (_("Target does not support \"/s\" option for string tracing."));
642 error (_("Undefined collection format \"%c\"."), *exp
);
644 exp
= skip_spaces_const (exp
);
649 /* Enter a list of actions for a tracepoint. */
651 trace_actions_command (char *args
, int from_tty
)
653 struct tracepoint
*t
;
654 struct command_line
*l
;
656 t
= get_tracepoint_by_number (&args
, NULL
, 1);
660 xstrprintf ("Enter actions for tracepoint %d, one per line.",
662 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
664 l
= read_command_lines (tmpbuf
, from_tty
, 1,
665 check_tracepoint_command
, t
);
666 do_cleanups (cleanups
);
667 breakpoint_set_commands (&t
->base
, l
);
669 /* else just return */
672 /* Report the results of checking the agent expression, as errors or
676 report_agent_reqs_errors (struct agent_expr
*aexpr
)
678 /* All of the "flaws" are serious bytecode generation issues that
679 should never occur. */
680 if (aexpr
->flaw
!= agent_flaw_none
)
681 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
683 /* If analysis shows a stack underflow, GDB must have done something
684 badly wrong in its bytecode generation. */
685 if (aexpr
->min_height
< 0)
686 internal_error (__FILE__
, __LINE__
,
687 _("expression has min height < 0"));
689 /* Issue this error if the stack is predicted to get too deep. The
690 limit is rather arbitrary; a better scheme might be for the
691 target to report how much stack it will have available. The
692 depth roughly corresponds to parenthesization, so a limit of 20
693 amounts to 20 levels of expression nesting, which is actually
694 a pretty big hairy expression. */
695 if (aexpr
->max_height
> 20)
696 error (_("Expression is too complicated."));
699 /* worker function */
701 validate_actionline (const char *line
, struct breakpoint
*b
)
703 struct cmd_list_element
*c
;
704 struct expression
*exp
= NULL
;
705 struct cleanup
*old_chain
= NULL
;
708 struct bp_location
*loc
;
709 struct agent_expr
*aexpr
;
710 struct tracepoint
*t
= (struct tracepoint
*) b
;
712 /* If EOF is typed, *line is NULL. */
716 p
= skip_spaces_const (line
);
718 /* Symbol lookup etc. */
719 if (*p
== '\0') /* empty line: just prompt for another line. */
722 if (*p
== '#') /* comment line */
725 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
727 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
729 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
731 int trace_string
= 0;
734 p
= decode_agent_options (p
, &trace_string
);
737 { /* Repeat over a comma-separated list. */
738 QUIT
; /* Allow user to bail out with ^C. */
739 p
= skip_spaces_const (p
);
741 if (*p
== '$') /* Look for special pseudo-symbols. */
743 if (0 == strncasecmp ("reg", p
+ 1, 3)
744 || 0 == strncasecmp ("arg", p
+ 1, 3)
745 || 0 == strncasecmp ("loc", p
+ 1, 3)
746 || 0 == strncasecmp ("_ret", p
+ 1, 4)
747 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
752 /* else fall thru, treat p as an expression and parse it! */
755 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
758 exp
= parse_exp_1 (&p
, loc
->address
,
759 block_for_pc (loc
->address
), 1);
760 old_chain
= make_cleanup (free_current_contents
, &exp
);
762 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
764 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
766 error (_("constant `%s' (value %s) "
767 "will not be collected."),
768 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
769 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
771 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
772 == LOC_OPTIMIZED_OUT
)
774 error (_("`%s' is optimized away "
775 "and cannot be collected."),
776 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
780 /* We have something to collect, make sure that the expr to
781 bytecode translator can handle it and that it's not too
783 aexpr
= gen_trace_for_expr (loc
->address
, exp
, trace_string
);
784 make_cleanup_free_agent_expr (aexpr
);
786 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
787 error (_("Expression is too complicated."));
791 report_agent_reqs_errors (aexpr
);
793 do_cleanups (old_chain
);
796 while (p
&& *p
++ == ',');
799 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
802 { /* Repeat over a comma-separated list. */
803 QUIT
; /* Allow user to bail out with ^C. */
804 p
= skip_spaces_const (p
);
807 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
811 /* Only expressions are allowed for this action. */
812 exp
= parse_exp_1 (&p
, loc
->address
,
813 block_for_pc (loc
->address
), 1);
814 old_chain
= make_cleanup (free_current_contents
, &exp
);
816 /* We have something to evaluate, make sure that the expr to
817 bytecode translator can handle it and that it's not too
819 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
820 make_cleanup_free_agent_expr (aexpr
);
822 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
823 error (_("Expression is too complicated."));
826 report_agent_reqs_errors (aexpr
);
828 do_cleanups (old_chain
);
831 while (p
&& *p
++ == ',');
834 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
838 p
= skip_spaces_const (p
);
839 t
->step_count
= strtol (p
, &endp
, 0);
840 if (endp
== p
|| t
->step_count
== 0)
841 error (_("while-stepping step count `%s' is malformed."), line
);
845 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
849 error (_("`%s' is not a supported tracepoint action."), line
);
853 memrange_absolute
= -1
858 int type
; /* memrange_absolute for absolute memory range,
859 else basereg number. */
860 bfd_signed_vma start
;
864 struct collection_list
866 unsigned char regs_mask
[32]; /* room for up to 256 regs */
869 struct memrange
*list
;
870 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
872 struct agent_expr
**aexpr_list
;
874 /* True is the user requested a collection of "$_sdata", "static
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;
1243 xfree (list
->aexpr_list
);
1247 /* A cleanup wrapper for function clear_collection_list. */
1250 do_clear_collection_list (void *list
)
1252 struct collection_list
*l
= list
;
1254 clear_collection_list (l
);
1257 /* Initialize collection_list CLIST. */
1260 init_collection_list (struct collection_list
*clist
)
1262 memset (clist
, 0, sizeof *clist
);
1264 clist
->listsize
= 128;
1265 clist
->list
= xcalloc (clist
->listsize
,
1266 sizeof (struct memrange
));
1268 clist
->aexpr_listsize
= 128;
1269 clist
->aexpr_list
= xcalloc (clist
->aexpr_listsize
,
1270 sizeof (struct agent_expr
*));
1273 /* Reduce a collection list to string form (for gdb protocol). */
1275 stringify_collection_list (struct collection_list
*list
)
1277 char temp_buf
[2048];
1281 char *(*str_list
)[];
1285 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1286 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1288 if (list
->strace_data
)
1291 printf_filtered ("\nCollecting static trace data\n");
1294 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1298 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1299 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1301 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1304 printf_filtered ("\nCollecting registers (mask): 0x");
1309 QUIT
; /* Allow user to bail out with ^C. */
1311 printf_filtered ("%02X", list
->regs_mask
[i
]);
1312 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1315 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1319 printf_filtered ("\n");
1320 if (list
->next_memrange
> 0 && info_verbose
)
1321 printf_filtered ("Collecting memranges: \n");
1322 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1324 QUIT
; /* Allow user to bail out with ^C. */
1325 sprintf_vma (tmp2
, list
->list
[i
].start
);
1328 printf_filtered ("(%d, %s, %ld)\n",
1331 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1333 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1335 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1342 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1344 /* The "%X" conversion specifier expects an unsigned argument,
1345 so passing -1 (memrange_absolute) to it directly gives you
1346 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1348 if (list
->list
[i
].type
== memrange_absolute
)
1349 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1351 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1354 count
+= strlen (end
);
1355 end
= temp_buf
+ count
;
1358 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1360 QUIT
; /* Allow user to bail out with ^C. */
1361 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1363 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1368 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1369 end
+= 10; /* 'X' + 8 hex digits + ',' */
1372 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1373 end
, list
->aexpr_list
[i
]->len
);
1374 count
+= 2 * list
->aexpr_list
[i
]->len
;
1379 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1384 (*str_list
)[ndx
] = NULL
;
1397 encode_actions_1 (struct command_line
*action
,
1398 struct bp_location
*tloc
,
1400 LONGEST frame_offset
,
1401 struct collection_list
*collect
,
1402 struct collection_list
*stepping_list
)
1404 const char *action_exp
;
1405 struct expression
*exp
= NULL
;
1407 struct value
*tempval
;
1408 struct cmd_list_element
*cmd
;
1409 struct agent_expr
*aexpr
;
1411 for (; action
; action
= action
->next
)
1413 QUIT
; /* Allow user to bail out with ^C. */
1414 action_exp
= action
->line
;
1415 action_exp
= skip_spaces_const (action_exp
);
1417 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1419 error (_("Bad action list item: %s"), action_exp
);
1421 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1423 int trace_string
= 0;
1425 if (*action_exp
== '/')
1426 action_exp
= decode_agent_options (action_exp
, &trace_string
);
1429 { /* Repeat over a comma-separated list. */
1430 QUIT
; /* Allow user to bail out with ^C. */
1431 action_exp
= skip_spaces_const (action_exp
);
1433 if (0 == strncasecmp ("$reg", action_exp
, 4))
1435 for (i
= 0; i
< gdbarch_num_regs (tloc
->gdbarch
); i
++)
1436 add_register (collect
, i
);
1437 action_exp
= strchr (action_exp
, ','); /* more? */
1439 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1441 add_local_symbols (collect
,
1448 action_exp
= strchr (action_exp
, ','); /* more? */
1450 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1452 add_local_symbols (collect
,
1459 action_exp
= strchr (action_exp
, ','); /* more? */
1461 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1463 struct cleanup
*old_chain1
= NULL
;
1465 aexpr
= gen_trace_for_return_address (tloc
->address
,
1469 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1472 report_agent_reqs_errors (aexpr
);
1474 discard_cleanups (old_chain1
);
1475 add_aexpr (collect
, aexpr
);
1477 /* take care of the registers */
1478 if (aexpr
->reg_mask_len
> 0)
1482 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1484 QUIT
; /* allow user to bail out with ^C */
1485 if (aexpr
->reg_mask
[ndx1
] != 0)
1487 /* assume chars have 8 bits */
1488 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1489 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1490 /* it's used -- record it */
1491 add_register (collect
,
1497 action_exp
= strchr (action_exp
, ','); /* more? */
1499 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1501 add_static_trace_data (collect
);
1502 action_exp
= strchr (action_exp
, ','); /* more? */
1507 struct cleanup
*old_chain
= NULL
;
1508 struct cleanup
*old_chain1
= NULL
;
1510 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1511 block_for_pc (tloc
->address
), 1);
1512 old_chain
= make_cleanup (free_current_contents
, &exp
);
1514 switch (exp
->elts
[0].opcode
)
1518 const char *name
= &exp
->elts
[2].string
;
1520 i
= user_reg_map_name_to_regnum (tloc
->gdbarch
,
1521 name
, strlen (name
));
1523 internal_error (__FILE__
, __LINE__
,
1524 _("Register $%s not available"),
1527 printf_filtered ("OP_REGISTER: ");
1528 add_register (collect
, i
);
1533 /* Safe because we know it's a simple expression. */
1534 tempval
= evaluate_expression (exp
);
1535 addr
= value_address (tempval
);
1536 /* Initialize the TYPE_LENGTH if it is a typedef. */
1537 check_typedef (exp
->elts
[1].type
);
1538 add_memrange (collect
, memrange_absolute
, addr
,
1539 TYPE_LENGTH (exp
->elts
[1].type
));
1543 collect_symbol (collect
,
1544 exp
->elts
[2].symbol
,
1552 default: /* Full-fledged expression. */
1553 aexpr
= gen_trace_for_expr (tloc
->address
, exp
,
1556 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1560 report_agent_reqs_errors (aexpr
);
1562 discard_cleanups (old_chain1
);
1563 add_aexpr (collect
, aexpr
);
1565 /* Take care of the registers. */
1566 if (aexpr
->reg_mask_len
> 0)
1571 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1573 QUIT
; /* Allow user to bail out with ^C. */
1574 if (aexpr
->reg_mask
[ndx1
] != 0)
1576 /* Assume chars have 8 bits. */
1577 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1578 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1579 /* It's used -- record it. */
1580 add_register (collect
,
1587 do_cleanups (old_chain
);
1590 while (action_exp
&& *action_exp
++ == ',');
1592 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1595 { /* Repeat over a comma-separated list. */
1596 QUIT
; /* Allow user to bail out with ^C. */
1597 action_exp
= skip_spaces_const (action_exp
);
1600 struct cleanup
*old_chain
= NULL
;
1601 struct cleanup
*old_chain1
= NULL
;
1603 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1604 block_for_pc (tloc
->address
), 1);
1605 old_chain
= make_cleanup (free_current_contents
, &exp
);
1607 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1608 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1611 report_agent_reqs_errors (aexpr
);
1613 discard_cleanups (old_chain1
);
1614 /* Even though we're not officially collecting, add
1615 to the collect list anyway. */
1616 add_aexpr (collect
, aexpr
);
1618 do_cleanups (old_chain
);
1621 while (action_exp
&& *action_exp
++ == ',');
1623 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1625 /* We check against nested while-stepping when setting
1626 breakpoint action, so no way to run into nested
1628 gdb_assert (stepping_list
);
1630 encode_actions_1 (action
->body_list
[0], tloc
, frame_reg
,
1631 frame_offset
, stepping_list
, NULL
);
1634 error (_("Invalid tracepoint command '%s'"), action
->line
);
1638 /* Render all actions into gdb protocol. */
1641 encode_actions (struct bp_location
*tloc
, char ***tdp_actions
,
1642 char ***stepping_actions
)
1644 char *default_collect_line
= NULL
;
1645 struct command_line
*actions
;
1646 struct command_line
*default_collect_action
= NULL
;
1648 LONGEST frame_offset
;
1649 struct cleanup
*back_to
;
1650 struct collection_list tracepoint_list
, stepping_list
;
1652 back_to
= make_cleanup (null_cleanup
, NULL
);
1654 init_collection_list (&tracepoint_list
);
1655 init_collection_list (&stepping_list
);
1657 make_cleanup (do_clear_collection_list
, &tracepoint_list
);
1658 make_cleanup (do_clear_collection_list
, &stepping_list
);
1660 *tdp_actions
= NULL
;
1661 *stepping_actions
= NULL
;
1663 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1664 tloc
->address
, &frame_reg
, &frame_offset
);
1666 actions
= all_tracepoint_actions_and_cleanup (tloc
->owner
);
1668 encode_actions_1 (actions
, tloc
, frame_reg
, frame_offset
,
1669 &tracepoint_list
, &stepping_list
);
1671 memrange_sortmerge (&tracepoint_list
);
1672 memrange_sortmerge (&stepping_list
);
1674 *tdp_actions
= stringify_collection_list (&tracepoint_list
);
1675 *stepping_actions
= stringify_collection_list (&stepping_list
);
1677 do_cleanups (back_to
);
1681 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1683 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1685 collect
->aexpr_list
=
1686 xrealloc (collect
->aexpr_list
,
1687 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1688 collect
->aexpr_listsize
*= 2;
1690 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1691 collect
->next_aexpr_elt
++;
1695 process_tracepoint_on_disconnect (void)
1697 VEC(breakpoint_p
) *tp_vec
= NULL
;
1699 struct breakpoint
*b
;
1700 int has_pending_p
= 0;
1702 /* Check whether we still have pending tracepoint. If we have, warn the
1703 user that pending tracepoint will no longer work. */
1704 tp_vec
= all_tracepoints ();
1705 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1714 struct bp_location
*loc1
;
1716 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1718 if (loc1
->shlib_disabled
)
1729 VEC_free (breakpoint_p
, tp_vec
);
1732 warning (_("Pending tracepoints will not be resolved while"
1733 " GDB is disconnected\n"));
1736 /* Reset local state of tracing. */
1739 trace_reset_local_state (void)
1741 set_traceframe_num (-1);
1742 set_tracepoint_num (-1);
1743 set_traceframe_context (NULL
);
1744 clear_traceframe_info ();
1748 start_tracing (char *notes
)
1750 VEC(breakpoint_p
) *tp_vec
= NULL
;
1752 struct breakpoint
*b
;
1753 struct trace_state_variable
*tsv
;
1754 int any_enabled
= 0, num_to_download
= 0;
1757 tp_vec
= all_tracepoints ();
1759 /* No point in tracing without any tracepoints... */
1760 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1762 VEC_free (breakpoint_p
, tp_vec
);
1763 error (_("No tracepoints defined, not starting trace"));
1766 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1768 struct tracepoint
*t
= (struct tracepoint
*) b
;
1769 struct bp_location
*loc
;
1771 if (b
->enable_state
== bp_enabled
)
1774 if ((b
->type
== bp_fast_tracepoint
1775 ? may_insert_fast_tracepoints
1776 : may_insert_tracepoints
))
1779 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1780 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1785 if (target_supports_enable_disable_tracepoint ())
1786 warning (_("No tracepoints enabled"));
1789 /* No point in tracing with only disabled tracepoints that
1790 cannot be re-enabled. */
1791 VEC_free (breakpoint_p
, tp_vec
);
1792 error (_("No tracepoints enabled, not starting trace"));
1796 if (num_to_download
<= 0)
1798 VEC_free (breakpoint_p
, tp_vec
);
1799 error (_("No tracepoints that may be downloaded, not starting trace"));
1802 target_trace_init ();
1804 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1806 struct tracepoint
*t
= (struct tracepoint
*) b
;
1807 struct bp_location
*loc
;
1808 int bp_location_downloaded
= 0;
1810 /* Clear `inserted' flag. */
1811 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1814 if ((b
->type
== bp_fast_tracepoint
1815 ? !may_insert_fast_tracepoints
1816 : !may_insert_tracepoints
))
1819 t
->number_on_target
= 0;
1821 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1823 /* Since tracepoint locations are never duplicated, `inserted'
1824 flag should be zero. */
1825 gdb_assert (!loc
->inserted
);
1827 target_download_tracepoint (loc
);
1830 bp_location_downloaded
= 1;
1833 t
->number_on_target
= b
->number
;
1835 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1836 if (loc
->probe
!= NULL
)
1837 loc
->probe
->pops
->set_semaphore (loc
->probe
, loc
->gdbarch
);
1839 if (bp_location_downloaded
)
1840 observer_notify_breakpoint_modified (b
);
1842 VEC_free (breakpoint_p
, tp_vec
);
1844 /* Send down all the trace state variables too. */
1845 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1847 target_download_trace_state_variable (tsv
);
1850 /* Tell target to treat text-like sections as transparent. */
1851 target_trace_set_readonly_regions ();
1852 /* Set some mode flags. */
1853 target_set_disconnected_tracing (disconnected_tracing
);
1854 target_set_circular_trace_buffer (circular_trace_buffer
);
1855 target_set_trace_buffer_size (trace_buffer_size
);
1858 notes
= trace_notes
;
1859 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1861 if (!ret
&& (trace_user
|| notes
))
1862 warning (_("Target does not support trace user/notes, info ignored"));
1864 /* Now insert traps and begin collecting data. */
1865 target_trace_start ();
1867 /* Reset our local state. */
1868 trace_reset_local_state ();
1869 current_trace_status()->running
= 1;
1872 /* The tstart command requests the target to start a new trace run.
1873 The command passes any arguments it has to the target verbatim, as
1874 an optional "trace note". This is useful as for instance a warning
1875 to other users if the trace runs disconnected, and you don't want
1876 anybody else messing with the target. */
1879 trace_start_command (char *args
, int from_tty
)
1881 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1883 if (current_trace_status ()->running
)
1886 && !query (_("A trace is running already. Start a new run? ")))
1887 error (_("New trace run not started."));
1890 start_tracing (args
);
1893 /* The tstop command stops the tracing run. The command passes any
1894 supplied arguments to the target verbatim as a "stop note"; if the
1895 target supports trace notes, then it will be reported back as part
1896 of the trace run's status. */
1899 trace_stop_command (char *args
, int from_tty
)
1901 if (!current_trace_status ()->running
)
1902 error (_("Trace is not running."));
1904 stop_tracing (args
);
1908 stop_tracing (char *note
)
1911 VEC(breakpoint_p
) *tp_vec
= NULL
;
1913 struct breakpoint
*t
;
1915 target_trace_stop ();
1917 tp_vec
= all_tracepoints ();
1918 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1920 struct bp_location
*loc
;
1922 if ((t
->type
== bp_fast_tracepoint
1923 ? !may_insert_fast_tracepoints
1924 : !may_insert_tracepoints
))
1927 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1929 /* GDB can be totally absent in some disconnected trace scenarios,
1930 but we don't really care if this semaphore goes out of sync.
1931 That's why we are decrementing it here, but not taking care
1933 if (loc
->probe
!= NULL
)
1934 loc
->probe
->pops
->clear_semaphore (loc
->probe
, loc
->gdbarch
);
1938 VEC_free (breakpoint_p
, tp_vec
);
1941 note
= trace_stop_notes
;
1942 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1945 warning (_("Target does not support trace notes, note ignored"));
1947 /* Should change in response to reply? */
1948 current_trace_status ()->running
= 0;
1951 /* tstatus command */
1953 trace_status_command (char *args
, int from_tty
)
1955 struct trace_status
*ts
= current_trace_status ();
1957 VEC(breakpoint_p
) *tp_vec
= NULL
;
1958 struct breakpoint
*t
;
1960 status
= target_get_trace_status (ts
);
1964 if (ts
->filename
!= NULL
)
1965 printf_filtered (_("Using a trace file.\n"));
1968 printf_filtered (_("Trace can not be run on this target.\n"));
1973 if (!ts
->running_known
)
1975 printf_filtered (_("Run/stop status is unknown.\n"));
1977 else if (ts
->running
)
1979 printf_filtered (_("Trace is running on the target.\n"));
1983 switch (ts
->stop_reason
)
1985 case trace_never_run
:
1986 printf_filtered (_("No trace has been run on the target.\n"));
1990 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1993 printf_filtered (_("Trace stopped by a tstop command.\n"));
1995 case trace_buffer_full
:
1996 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1998 case trace_disconnected
:
1999 printf_filtered (_("Trace stopped because of disconnection.\n"));
2001 case tracepoint_passcount
:
2002 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
2003 ts
->stopping_tracepoint
);
2005 case tracepoint_error
:
2006 if (ts
->stopping_tracepoint
)
2007 printf_filtered (_("Trace stopped by an "
2008 "error (%s, tracepoint %d).\n"),
2009 ts
->stop_desc
, ts
->stopping_tracepoint
);
2011 printf_filtered (_("Trace stopped by an error (%s).\n"),
2014 case trace_stop_reason_unknown
:
2015 printf_filtered (_("Trace stopped for an unknown reason.\n"));
2018 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
2024 if (ts
->traceframes_created
>= 0
2025 && ts
->traceframe_count
!= ts
->traceframes_created
)
2027 printf_filtered (_("Buffer contains %d trace "
2028 "frames (of %d created total).\n"),
2029 ts
->traceframe_count
, ts
->traceframes_created
);
2031 else if (ts
->traceframe_count
>= 0)
2033 printf_filtered (_("Collected %d trace frames.\n"),
2034 ts
->traceframe_count
);
2037 if (ts
->buffer_free
>= 0)
2039 if (ts
->buffer_size
>= 0)
2041 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2042 ts
->buffer_free
, ts
->buffer_size
);
2043 if (ts
->buffer_size
> 0)
2044 printf_filtered (_(" (%d%% full)"),
2045 ((int) ((((long long) (ts
->buffer_size
2046 - ts
->buffer_free
)) * 100)
2047 / ts
->buffer_size
)));
2048 printf_filtered (_(".\n"));
2051 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2055 if (ts
->disconnected_tracing
)
2056 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2058 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2060 if (ts
->circular_buffer
)
2061 printf_filtered (_("Trace buffer is circular.\n"));
2063 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
2064 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
2066 if (ts
->notes
&& strlen (ts
->notes
) > 0)
2067 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
2069 /* Now report on what we're doing with tfind. */
2070 if (traceframe_number
>= 0)
2071 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2072 traceframe_number
, tracepoint_number
);
2074 printf_filtered (_("Not looking at any trace frame.\n"));
2076 /* Report start/stop times if supplied. */
2081 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
2083 /* Reporting a run time is more readable than two long numbers. */
2084 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2085 (long int) ts
->start_time
/ 1000000,
2086 (long int) ts
->start_time
% 1000000,
2087 (long int) run_time
/ 1000000,
2088 (long int) run_time
% 1000000);
2091 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2092 (long int) ts
->start_time
/ 1000000,
2093 (long int) ts
->start_time
% 1000000);
2095 else if (ts
->stop_time
)
2096 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2097 (long int) ts
->stop_time
/ 1000000,
2098 (long int) ts
->stop_time
% 1000000);
2100 /* Now report any per-tracepoint status available. */
2101 tp_vec
= all_tracepoints ();
2103 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2104 target_get_tracepoint_status (t
, NULL
);
2106 VEC_free (breakpoint_p
, tp_vec
);
2109 /* Report the trace status to uiout, in a way suitable for MI, and not
2110 suitable for CLI. If ON_STOP is true, suppress a few fields that
2111 are not meaningful in the -trace-stop response.
2113 The implementation is essentially parallel to trace_status_command, but
2114 merging them will result in unreadable code. */
2116 trace_status_mi (int on_stop
)
2118 struct ui_out
*uiout
= current_uiout
;
2119 struct trace_status
*ts
= current_trace_status ();
2122 status
= target_get_trace_status (ts
);
2124 if (status
== -1 && ts
->filename
== NULL
)
2126 ui_out_field_string (uiout
, "supported", "0");
2130 if (ts
->filename
!= NULL
)
2131 ui_out_field_string (uiout
, "supported", "file");
2133 ui_out_field_string (uiout
, "supported", "1");
2135 if (ts
->filename
!= NULL
)
2136 ui_out_field_string (uiout
, "trace-file", ts
->filename
);
2138 gdb_assert (ts
->running_known
);
2142 ui_out_field_string (uiout
, "running", "1");
2144 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2145 Given that the frontend gets the status either on -trace-stop, or from
2146 -trace-status after re-connection, it does not seem like this
2147 information is necessary for anything. It is not necessary for either
2148 figuring the vital state of the target nor for navigation of trace
2149 frames. If the frontend wants to show the current state is some
2150 configure dialog, it can request the value when such dialog is
2151 invoked by the user. */
2155 char *stop_reason
= NULL
;
2156 int stopping_tracepoint
= -1;
2159 ui_out_field_string (uiout
, "running", "0");
2161 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2163 switch (ts
->stop_reason
)
2166 stop_reason
= "request";
2168 case trace_buffer_full
:
2169 stop_reason
= "overflow";
2171 case trace_disconnected
:
2172 stop_reason
= "disconnection";
2174 case tracepoint_passcount
:
2175 stop_reason
= "passcount";
2176 stopping_tracepoint
= ts
->stopping_tracepoint
;
2178 case tracepoint_error
:
2179 stop_reason
= "error";
2180 stopping_tracepoint
= ts
->stopping_tracepoint
;
2186 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2187 if (stopping_tracepoint
!= -1)
2188 ui_out_field_int (uiout
, "stopping-tracepoint",
2189 stopping_tracepoint
);
2190 if (ts
->stop_reason
== tracepoint_error
)
2191 ui_out_field_string (uiout
, "error-description",
2197 if (ts
->traceframe_count
!= -1)
2198 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2199 if (ts
->traceframes_created
!= -1)
2200 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2201 if (ts
->buffer_size
!= -1)
2202 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2203 if (ts
->buffer_free
!= -1)
2204 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2206 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2207 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2209 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2210 ui_out_field_string (uiout
, "notes", ts
->notes
);
2215 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2216 (long int) ts
->start_time
/ 1000000,
2217 (long int) ts
->start_time
% 1000000);
2218 ui_out_field_string (uiout
, "start-time", buf
);
2219 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2220 (long int) ts
->stop_time
/ 1000000,
2221 (long int) ts
->stop_time
% 1000000);
2222 ui_out_field_string (uiout
, "stop-time", buf
);
2226 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2227 user if she really wants to detach. */
2230 query_if_trace_running (int from_tty
)
2235 /* It can happen that the target that was tracing went away on its
2236 own, and we didn't notice. Get a status update, and if the
2237 current target doesn't even do tracing, then assume it's not
2239 if (target_get_trace_status (current_trace_status ()) < 0)
2240 current_trace_status ()->running
= 0;
2242 /* If running interactively, give the user the option to cancel and
2243 then decide what to do differently with the run. Scripts are
2244 just going to disconnect and let the target deal with it,
2245 according to how it's been instructed previously via
2246 disconnected-tracing. */
2247 if (current_trace_status ()->running
)
2249 process_tracepoint_on_disconnect ();
2251 if (current_trace_status ()->disconnected_tracing
)
2253 if (!query (_("Trace is running and will "
2254 "continue after detach; detach anyway? ")))
2255 error (_("Not confirmed."));
2259 if (!query (_("Trace is running but will "
2260 "stop on detach; detach anyway? ")))
2261 error (_("Not confirmed."));
2266 /* This function handles the details of what to do about an ongoing
2267 tracing run if the user has asked to detach or otherwise disconnect
2271 disconnect_tracing (void)
2273 /* Also we want to be out of tfind mode, otherwise things can get
2274 confusing upon reconnection. Just use these calls instead of
2275 full tfind_1 behavior because we're in the middle of detaching,
2276 and there's no point to updating current stack frame etc. */
2277 trace_reset_local_state ();
2280 /* Worker function for the various flavors of the tfind command. */
2282 tfind_1 (enum trace_find_type type
, int num
,
2283 CORE_ADDR addr1
, CORE_ADDR addr2
,
2286 int target_frameno
= -1, target_tracept
= -1;
2287 struct frame_id old_frame_id
= null_frame_id
;
2288 struct tracepoint
*tp
;
2289 struct ui_out
*uiout
= current_uiout
;
2291 /* Only try to get the current stack frame if we have a chance of
2292 succeeding. In particular, if we're trying to get a first trace
2293 frame while all threads are running, it's not going to succeed,
2294 so leave it with a default value and let the frame comparison
2295 below (correctly) decide to print out the source location of the
2297 if (!(type
== tfind_number
&& num
== -1)
2298 && (has_stack_frames () || traceframe_number
>= 0))
2299 old_frame_id
= get_frame_id (get_current_frame ());
2301 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2304 if (type
== tfind_number
2306 && target_frameno
== -1)
2308 /* We told the target to get out of tfind mode, and it did. */
2310 else if (target_frameno
== -1)
2312 /* A request for a non-existent trace frame has failed.
2313 Our response will be different, depending on FROM_TTY:
2315 If FROM_TTY is true, meaning that this command was
2316 typed interactively by the user, then give an error
2317 and DO NOT change the state of traceframe_number etc.
2319 However if FROM_TTY is false, meaning that we're either
2320 in a script, a loop, or a user-defined command, then
2321 DON'T give an error, but DO change the state of
2322 traceframe_number etc. to invalid.
2324 The rationalle is that if you typed the command, you
2325 might just have committed a typo or something, and you'd
2326 like to NOT lose your current debugging state. However
2327 if you're in a user-defined command or especially in a
2328 loop, then you need a way to detect that the command
2329 failed WITHOUT aborting. This allows you to write
2330 scripts that search thru the trace buffer until the end,
2331 and then continue on to do something else. */
2334 error (_("Target failed to find requested trace frame."));
2338 printf_filtered ("End of trace buffer.\n");
2339 #if 0 /* dubious now? */
2340 /* The following will not recurse, since it's
2342 trace_find_command ("-1", from_tty
);
2347 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2349 reinit_frame_cache ();
2350 target_dcache_invalidate ();
2352 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2354 if (target_frameno
!= get_traceframe_number ())
2355 observer_notify_traceframe_changed (target_frameno
, tracepoint_number
);
2357 set_current_traceframe (target_frameno
);
2359 if (target_frameno
== -1)
2360 set_traceframe_context (NULL
);
2362 set_traceframe_context (get_current_frame ());
2364 if (traceframe_number
>= 0)
2366 /* Use different branches for MI and CLI to make CLI messages
2368 if (ui_out_is_mi_like_p (uiout
))
2370 ui_out_field_string (uiout
, "found", "1");
2371 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2372 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2376 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2377 traceframe_number
, tracepoint_number
);
2382 if (ui_out_is_mi_like_p (uiout
))
2383 ui_out_field_string (uiout
, "found", "0");
2384 else if (type
== tfind_number
&& num
== -1)
2385 printf_unfiltered (_("No longer looking at any trace frame\n"));
2386 else /* This case may never occur, check. */
2387 printf_unfiltered (_("No trace frame found\n"));
2390 /* If we're in nonstop mode and getting out of looking at trace
2391 frames, there won't be any current frame to go back to and
2394 && (has_stack_frames () || traceframe_number
>= 0))
2396 enum print_what print_what
;
2398 /* NOTE: in imitation of the step command, try to determine
2399 whether we have made a transition from one function to
2400 another. If so, we'll print the "stack frame" (ie. the new
2401 function and it's arguments) -- otherwise we'll just show the
2404 if (frame_id_eq (old_frame_id
,
2405 get_frame_id (get_current_frame ())))
2406 print_what
= SRC_LINE
;
2408 print_what
= SRC_AND_LOC
;
2410 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2415 /* trace_find_command takes a trace frame number n,
2416 sends "QTFrame:<n>" to the target,
2417 and accepts a reply that may contain several optional pieces
2418 of information: a frame number, a tracepoint number, and an
2419 indication of whether this is a trap frame or a stepping frame.
2421 The minimal response is just "OK" (which indicates that the
2422 target does not give us a frame number or a tracepoint number).
2423 Instead of that, the target may send us a string containing
2425 F<hexnum> (gives the selected frame number)
2426 T<hexnum> (gives the selected tracepoint number)
2431 trace_find_command (char *args
, int from_tty
)
2432 { /* This should only be called with a numeric argument. */
2435 if (current_trace_status ()->running
2436 && current_trace_status ()->filename
== NULL
)
2437 error (_("May not look at trace frames while trace is running."));
2439 if (args
== 0 || *args
== 0)
2440 { /* TFIND with no args means find NEXT trace frame. */
2441 if (traceframe_number
== -1)
2442 frameno
= 0; /* "next" is first one. */
2444 frameno
= traceframe_number
+ 1;
2446 else if (0 == strcmp (args
, "-"))
2448 if (traceframe_number
== -1)
2449 error (_("not debugging trace buffer"));
2450 else if (from_tty
&& traceframe_number
== 0)
2451 error (_("already at start of trace buffer"));
2453 frameno
= traceframe_number
- 1;
2455 /* A hack to work around eval's need for fp to have been collected. */
2456 else if (0 == strcmp (args
, "-1"))
2459 frameno
= parse_and_eval_long (args
);
2462 error (_("invalid input (%d is less than zero)"), frameno
);
2464 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2469 trace_find_end_command (char *args
, int from_tty
)
2471 trace_find_command ("-1", from_tty
);
2476 trace_find_start_command (char *args
, int from_tty
)
2478 trace_find_command ("0", from_tty
);
2481 /* tfind pc command */
2483 trace_find_pc_command (char *args
, int from_tty
)
2487 if (current_trace_status ()->running
2488 && current_trace_status ()->filename
== NULL
)
2489 error (_("May not look at trace frames while trace is running."));
2491 if (args
== 0 || *args
== 0)
2492 pc
= regcache_read_pc (get_current_regcache ());
2494 pc
= parse_and_eval_address (args
);
2496 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2499 /* tfind tracepoint command */
2501 trace_find_tracepoint_command (char *args
, int from_tty
)
2504 struct tracepoint
*tp
;
2506 if (current_trace_status ()->running
2507 && current_trace_status ()->filename
== NULL
)
2508 error (_("May not look at trace frames while trace is running."));
2510 if (args
== 0 || *args
== 0)
2512 if (tracepoint_number
== -1)
2513 error (_("No current tracepoint -- please supply an argument."));
2515 tdp
= tracepoint_number
; /* Default is current TDP. */
2518 tdp
= parse_and_eval_long (args
);
2520 /* If we have the tracepoint on hand, use the number that the
2521 target knows about (which may be different if we disconnected
2522 and reconnected). */
2523 tp
= get_tracepoint (tdp
);
2525 tdp
= tp
->number_on_target
;
2527 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2530 /* TFIND LINE command:
2532 This command will take a sourceline for argument, just like BREAK
2533 or TRACE (ie. anything that "decode_line_1" can handle).
2535 With no argument, this command will find the next trace frame
2536 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2539 trace_find_line_command (char *args
, int from_tty
)
2541 static CORE_ADDR start_pc
, end_pc
;
2542 struct symtabs_and_lines sals
;
2543 struct symtab_and_line sal
;
2544 struct cleanup
*old_chain
;
2546 if (current_trace_status ()->running
2547 && current_trace_status ()->filename
== NULL
)
2548 error (_("May not look at trace frames while trace is running."));
2550 if (args
== 0 || *args
== 0)
2552 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2554 sals
.sals
= (struct symtab_and_line
*)
2555 xmalloc (sizeof (struct symtab_and_line
));
2560 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2564 old_chain
= make_cleanup (xfree
, sals
.sals
);
2565 if (sal
.symtab
== 0)
2566 error (_("No line number information available."));
2568 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2570 if (start_pc
== end_pc
)
2572 printf_filtered ("Line %d of \"%s\"",
2574 symtab_to_filename_for_display (sal
.symtab
));
2576 printf_filtered (" is at address ");
2577 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2579 printf_filtered (" but contains no code.\n");
2580 sal
= find_pc_line (start_pc
, 0);
2582 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2583 && start_pc
!= end_pc
)
2584 printf_filtered ("Attempting to find line %d instead.\n",
2587 error (_("Cannot find a good line."));
2591 /* Is there any case in which we get here, and have an address
2592 which the user would want to see? If we have debugging
2593 symbols and no line numbers? */
2594 error (_("Line number %d is out of range for \"%s\"."),
2595 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2597 /* Find within range of stated line. */
2599 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2601 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2602 do_cleanups (old_chain
);
2605 /* tfind range command */
2607 trace_find_range_command (char *args
, int from_tty
)
2609 static CORE_ADDR start
, stop
;
2612 if (current_trace_status ()->running
2613 && current_trace_status ()->filename
== NULL
)
2614 error (_("May not look at trace frames while trace is running."));
2616 if (args
== 0 || *args
== 0)
2617 { /* XXX FIXME: what should default behavior be? */
2618 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2622 if (0 != (tmp
= strchr (args
, ',')))
2624 *tmp
++ = '\0'; /* Terminate start address. */
2625 tmp
= skip_spaces (tmp
);
2626 start
= parse_and_eval_address (args
);
2627 stop
= parse_and_eval_address (tmp
);
2630 { /* No explicit end address? */
2631 start
= parse_and_eval_address (args
);
2632 stop
= start
+ 1; /* ??? */
2635 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2638 /* tfind outside command */
2640 trace_find_outside_command (char *args
, int from_tty
)
2642 CORE_ADDR start
, stop
;
2645 if (current_trace_status ()->running
2646 && current_trace_status ()->filename
== NULL
)
2647 error (_("May not look at trace frames while trace is running."));
2649 if (args
== 0 || *args
== 0)
2650 { /* XXX FIXME: what should default behavior be? */
2651 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2655 if (0 != (tmp
= strchr (args
, ',')))
2657 *tmp
++ = '\0'; /* Terminate start address. */
2658 tmp
= skip_spaces (tmp
);
2659 start
= parse_and_eval_address (args
);
2660 stop
= parse_and_eval_address (tmp
);
2663 { /* No explicit end address? */
2664 start
= parse_and_eval_address (args
);
2665 stop
= start
+ 1; /* ??? */
2668 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2671 /* info scope command: list the locals for a scope. */
2673 scope_info (char *args
, int from_tty
)
2675 struct symtabs_and_lines sals
;
2677 struct minimal_symbol
*msym
;
2678 struct block
*block
;
2679 const char *symname
;
2680 char *save_args
= args
;
2681 struct block_iterator iter
;
2683 struct gdbarch
*gdbarch
;
2686 if (args
== 0 || *args
== 0)
2687 error (_("requires an argument (function, "
2688 "line or *addr) to define a scope"));
2690 sals
= decode_line_1 (&args
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2691 if (sals
.nelts
== 0)
2692 return; /* Presumably decode_line_1 has already warned. */
2694 /* Resolve line numbers to PC. */
2695 resolve_sal_pc (&sals
.sals
[0]);
2696 block
= block_for_pc (sals
.sals
[0].pc
);
2700 QUIT
; /* Allow user to bail out with ^C. */
2701 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2703 QUIT
; /* Allow user to bail out with ^C. */
2705 printf_filtered ("Scope for %s:\n", save_args
);
2708 symname
= SYMBOL_PRINT_NAME (sym
);
2709 if (symname
== NULL
|| *symname
== '\0')
2710 continue; /* Probably botched, certainly useless. */
2712 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2714 printf_filtered ("Symbol %s is ", symname
);
2716 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
2717 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2718 BLOCK_START (block
),
2722 switch (SYMBOL_CLASS (sym
))
2725 case LOC_UNDEF
: /* Messed up symbol? */
2726 printf_filtered ("a bogus symbol, class %d.\n",
2727 SYMBOL_CLASS (sym
));
2728 count
--; /* Don't count this one. */
2731 printf_filtered ("a constant with value %s (%s)",
2732 plongest (SYMBOL_VALUE (sym
)),
2733 hex_string (SYMBOL_VALUE (sym
)));
2735 case LOC_CONST_BYTES
:
2736 printf_filtered ("constant bytes: ");
2737 if (SYMBOL_TYPE (sym
))
2738 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2739 fprintf_filtered (gdb_stdout
, " %02x",
2740 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2743 printf_filtered ("in static storage at address ");
2744 printf_filtered ("%s", paddress (gdbarch
,
2745 SYMBOL_VALUE_ADDRESS (sym
)));
2748 /* GDBARCH is the architecture associated with the objfile
2749 the symbol is defined in; the target architecture may be
2750 different, and may provide additional registers. However,
2751 we do not know the target architecture at this point.
2752 We assume the objfile architecture will contain all the
2753 standard registers that occur in debug info in that
2755 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2758 if (SYMBOL_IS_ARGUMENT (sym
))
2759 printf_filtered ("an argument in register $%s",
2760 gdbarch_register_name (gdbarch
, regno
));
2762 printf_filtered ("a local variable in register $%s",
2763 gdbarch_register_name (gdbarch
, regno
));
2766 printf_filtered ("an argument at stack/frame offset %s",
2767 plongest (SYMBOL_VALUE (sym
)));
2770 printf_filtered ("a local variable at frame offset %s",
2771 plongest (SYMBOL_VALUE (sym
)));
2774 printf_filtered ("a reference argument at offset %s",
2775 plongest (SYMBOL_VALUE (sym
)));
2777 case LOC_REGPARM_ADDR
:
2778 /* Note comment at LOC_REGISTER. */
2779 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2781 printf_filtered ("the address of an argument, in register $%s",
2782 gdbarch_register_name (gdbarch
, regno
));
2785 printf_filtered ("a typedef.\n");
2788 printf_filtered ("a label at address ");
2789 printf_filtered ("%s", paddress (gdbarch
,
2790 SYMBOL_VALUE_ADDRESS (sym
)));
2793 printf_filtered ("a function at address ");
2794 printf_filtered ("%s",
2795 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2797 case LOC_UNRESOLVED
:
2798 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2801 printf_filtered ("Unresolved Static");
2804 printf_filtered ("static storage at address ");
2805 printf_filtered ("%s",
2807 SYMBOL_VALUE_ADDRESS (msym
)));
2810 case LOC_OPTIMIZED_OUT
:
2811 printf_filtered ("optimized out.\n");
2814 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2817 if (SYMBOL_TYPE (sym
))
2818 printf_filtered (", length %d.\n",
2819 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2821 if (BLOCK_FUNCTION (block
))
2824 block
= BLOCK_SUPERBLOCK (block
);
2827 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2831 /* Helper for trace_dump_command. Dump the action list starting at
2832 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2833 actions of the body of a while-stepping action. STEPPING_FRAME is
2834 set if the current traceframe was determined to be a while-stepping
2838 trace_dump_actions (struct command_line
*action
,
2839 int stepping_actions
, int stepping_frame
,
2842 const char *action_exp
, *next_comma
;
2844 for (; action
!= NULL
; action
= action
->next
)
2846 struct cmd_list_element
*cmd
;
2848 QUIT
; /* Allow user to bail out with ^C. */
2849 action_exp
= action
->line
;
2850 action_exp
= skip_spaces_const (action_exp
);
2852 /* The collection actions to be done while stepping are
2853 bracketed by the commands "while-stepping" and "end". */
2855 if (*action_exp
== '#') /* comment line */
2858 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2860 error (_("Bad action list item: %s"), action_exp
);
2862 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2866 for (i
= 0; i
< action
->body_count
; ++i
)
2867 trace_dump_actions (action
->body_list
[i
],
2868 1, stepping_frame
, from_tty
);
2870 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2872 /* Display the collected data.
2873 For the trap frame, display only what was collected at
2874 the trap. Likewise for stepping frames, display only
2875 what was collected while stepping. This means that the
2876 two boolean variables, STEPPING_FRAME and
2877 STEPPING_ACTIONS should be equal. */
2878 if (stepping_frame
== stepping_actions
)
2881 struct cleanup
*old_chain
2882 = make_cleanup (free_current_contents
, &cmd
);
2883 int trace_string
= 0;
2885 if (*action_exp
== '/')
2886 action_exp
= decode_agent_options (action_exp
, &trace_string
);
2889 { /* Repeat over a comma-separated list. */
2890 QUIT
; /* Allow user to bail out with ^C. */
2891 if (*action_exp
== ',')
2893 action_exp
= skip_spaces_const (action_exp
);
2895 next_comma
= strchr (action_exp
, ',');
2897 if (0 == strncasecmp (action_exp
, "$reg", 4))
2898 registers_info (NULL
, from_tty
);
2899 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2901 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2902 locals_info (NULL
, from_tty
);
2903 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2904 args_info (NULL
, from_tty
);
2907 if (next_comma
!= NULL
)
2909 size_t len
= next_comma
- action_exp
;
2911 cmd
= xrealloc (cmd
, len
+ 1);
2912 memcpy (cmd
, action_exp
, len
);
2917 size_t len
= strlen (action_exp
);
2919 cmd
= xrealloc (cmd
, len
+ 1);
2920 memcpy (cmd
, action_exp
, len
+ 1);
2923 printf_filtered ("%s = ", cmd
);
2924 output_command_const (cmd
, from_tty
);
2925 printf_filtered ("\n");
2927 action_exp
= next_comma
;
2929 while (action_exp
&& *action_exp
== ',');
2931 do_cleanups (old_chain
);
2937 /* Return bp_location of the tracepoint associated with the current
2938 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2939 is a stepping traceframe. */
2941 static struct bp_location
*
2942 get_traceframe_location (int *stepping_frame_p
)
2944 struct tracepoint
*t
;
2945 struct bp_location
*tloc
;
2946 struct regcache
*regcache
;
2948 if (tracepoint_number
== -1)
2949 error (_("No current trace frame."));
2951 t
= get_tracepoint (tracepoint_number
);
2954 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2957 /* The current frame is a trap frame if the frame PC is equal to the
2958 tracepoint PC. If not, then the current frame was collected
2959 during single-stepping. */
2960 regcache
= get_current_regcache ();
2962 /* If the traceframe's address matches any of the tracepoint's
2963 locations, assume it is a direct hit rather than a while-stepping
2964 frame. (FIXME this is not reliable, should record each frame's
2966 for (tloc
= t
->base
.loc
; tloc
; tloc
= tloc
->next
)
2967 if (tloc
->address
== regcache_read_pc (regcache
))
2969 *stepping_frame_p
= 0;
2973 /* If this is a stepping frame, we don't know which location
2974 triggered. The first is as good (or bad) a guess as any... */
2975 *stepping_frame_p
= 1;
2979 /* Return all the actions, including default collect, of a tracepoint
2980 T. It constructs cleanups into the chain, and leaves the caller to
2981 handle them (call do_cleanups). */
2983 static struct command_line
*
2984 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
)
2986 struct command_line
*actions
;
2988 actions
= breakpoint_commands (t
);
2990 /* If there are default expressions to collect, make up a collect
2991 action and prepend to the action list to encode. Note that since
2992 validation is per-tracepoint (local var "xyz" might be valid for
2993 one tracepoint and not another, etc), we make up the action on
2994 the fly, and don't cache it. */
2995 if (*default_collect
)
2997 struct command_line
*default_collect_action
;
2998 char *default_collect_line
;
3000 default_collect_line
= xstrprintf ("collect %s", default_collect
);
3001 make_cleanup (xfree
, default_collect_line
);
3003 validate_actionline (default_collect_line
, t
);
3004 default_collect_action
= xmalloc (sizeof (struct command_line
));
3005 make_cleanup (xfree
, default_collect_action
);
3006 default_collect_action
->next
= actions
;
3007 default_collect_action
->line
= default_collect_line
;
3008 actions
= default_collect_action
;
3014 /* The tdump command. */
3017 trace_dump_command (char *args
, int from_tty
)
3019 int stepping_frame
= 0;
3020 struct bp_location
*loc
;
3021 struct cleanup
*old_chain
;
3022 struct command_line
*actions
;
3024 /* This throws an error is not inspecting a trace frame. */
3025 loc
= get_traceframe_location (&stepping_frame
);
3027 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
3028 tracepoint_number
, traceframe_number
);
3030 old_chain
= make_cleanup (null_cleanup
, NULL
);
3031 actions
= all_tracepoint_actions_and_cleanup (loc
->owner
);
3033 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
3035 do_cleanups (old_chain
);
3038 /* Encode a piece of a tracepoint's source-level definition in a form
3039 that is suitable for both protocol and saving in files. */
3040 /* This version does not do multiple encodes for long strings; it should
3041 return an offset to the next piece to encode. FIXME */
3044 encode_source_string (int tpnum
, ULONGEST addr
,
3045 char *srctype
, char *src
, char *buf
, int buf_size
)
3047 if (80 + strlen (srctype
) > buf_size
)
3048 error (_("Buffer too small for source encoding"));
3049 sprintf (buf
, "%x:%s:%s:%x:%x:",
3050 tpnum
, phex_nz (addr
, sizeof (addr
)),
3051 srctype
, 0, (int) strlen (src
));
3052 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
3053 error (_("Source string too long for buffer"));
3054 bin2hex ((gdb_byte
*) src
, buf
+ strlen (buf
), 0);
3058 /* Free trace file writer. */
3061 trace_file_writer_xfree (void *arg
)
3063 struct trace_file_writer
*writer
= arg
;
3065 writer
->ops
->dtor (writer
);
3069 /* TFILE trace writer. */
3071 struct tfile_trace_file_writer
3073 struct trace_file_writer base
;
3075 /* File pointer to tfile trace file. */
3077 /* Path name of the tfile trace file. */
3081 /* This is the implementation of trace_file_write_ops method
3082 target_save. We just call the generic target
3083 target_save_trace_data to do target-side saving. */
3086 tfile_target_save (struct trace_file_writer
*self
,
3087 const char *filename
)
3089 int err
= target_save_trace_data (filename
);
3094 /* This is the implementation of trace_file_write_ops method
3098 tfile_dtor (struct trace_file_writer
*self
)
3100 struct tfile_trace_file_writer
*writer
3101 = (struct tfile_trace_file_writer
*) self
;
3103 xfree (writer
->pathname
);
3105 if (writer
->fp
!= NULL
)
3106 fclose (writer
->fp
);
3109 /* This is the implementation of trace_file_write_ops method
3110 start. It creates the trace file FILENAME and registers some
3114 tfile_start (struct trace_file_writer
*self
, const char *filename
)
3116 struct tfile_trace_file_writer
*writer
3117 = (struct tfile_trace_file_writer
*) self
;
3119 writer
->pathname
= tilde_expand (filename
);
3120 writer
->fp
= gdb_fopen_cloexec (writer
->pathname
, "wb");
3121 if (writer
->fp
== NULL
)
3122 error (_("Unable to open file '%s' for saving trace data (%s)"),
3123 filename
, safe_strerror (errno
));
3126 /* This is the implementation of trace_file_write_ops method
3127 write_header. Write the TFILE header. */
3130 tfile_write_header (struct trace_file_writer
*self
)
3132 struct tfile_trace_file_writer
*writer
3133 = (struct tfile_trace_file_writer
*) self
;
3136 /* Write a file header, with a high-bit-set char to indicate a
3137 binary file, plus a hint as what this file is, and a version
3138 number in case of future needs. */
3139 written
= fwrite ("\x7fTRACE0\n", 8, 1, writer
->fp
);
3141 perror_with_name (writer
->pathname
);
3144 /* This is the implementation of trace_file_write_ops method
3145 write_regblock_type. Write the size of register block. */
3148 tfile_write_regblock_type (struct trace_file_writer
*self
, int size
)
3150 struct tfile_trace_file_writer
*writer
3151 = (struct tfile_trace_file_writer
*) self
;
3153 fprintf (writer
->fp
, "R %x\n", size
);
3156 /* This is the implementation of trace_file_write_ops method
3160 tfile_write_status (struct trace_file_writer
*self
,
3161 struct trace_status
*ts
)
3163 struct tfile_trace_file_writer
*writer
3164 = (struct tfile_trace_file_writer
*) self
;
3166 fprintf (writer
->fp
, "status %c;%s",
3167 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
3168 if (ts
->stop_reason
== tracepoint_error
3169 || ts
->stop_reason
== tstop_command
)
3171 char *buf
= (char *) alloca (strlen (ts
->stop_desc
) * 2 + 1);
3173 bin2hex ((gdb_byte
*) ts
->stop_desc
, buf
, 0);
3174 fprintf (writer
->fp
, ":%s", buf
);
3176 fprintf (writer
->fp
, ":%x", ts
->stopping_tracepoint
);
3177 if (ts
->traceframe_count
>= 0)
3178 fprintf (writer
->fp
, ";tframes:%x", ts
->traceframe_count
);
3179 if (ts
->traceframes_created
>= 0)
3180 fprintf (writer
->fp
, ";tcreated:%x", ts
->traceframes_created
);
3181 if (ts
->buffer_free
>= 0)
3182 fprintf (writer
->fp
, ";tfree:%x", ts
->buffer_free
);
3183 if (ts
->buffer_size
>= 0)
3184 fprintf (writer
->fp
, ";tsize:%x", ts
->buffer_size
);
3185 if (ts
->disconnected_tracing
)
3186 fprintf (writer
->fp
, ";disconn:%x", ts
->disconnected_tracing
);
3187 if (ts
->circular_buffer
)
3188 fprintf (writer
->fp
, ";circular:%x", ts
->circular_buffer
);
3189 if (ts
->notes
!= NULL
)
3191 char *buf
= (char *) alloca (strlen (ts
->notes
) * 2 + 1);
3193 bin2hex ((gdb_byte
*) ts
->notes
, buf
, 0);
3194 fprintf (writer
->fp
, ";notes:%s", buf
);
3196 if (ts
->user_name
!= NULL
)
3198 char *buf
= (char *) alloca (strlen (ts
->user_name
) * 2 + 1);
3200 bin2hex ((gdb_byte
*) ts
->user_name
, buf
, 0);
3201 fprintf (writer
->fp
, ";username:%s", buf
);
3203 fprintf (writer
->fp
, "\n");
3206 /* This is the implementation of trace_file_write_ops method
3207 write_uploaded_tsv. */
3210 tfile_write_uploaded_tsv (struct trace_file_writer
*self
,
3211 struct uploaded_tsv
*utsv
)
3214 struct tfile_trace_file_writer
*writer
3215 = (struct tfile_trace_file_writer
*) self
;
3219 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
3220 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
3223 fprintf (writer
->fp
, "tsv %x:%s:%x:%s\n",
3224 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
3225 utsv
->builtin
, buf
);
3231 #define MAX_TRACE_UPLOAD 2000
3233 /* This is the implementation of trace_file_write_ops method
3234 write_uploaded_tp. */
3237 tfile_write_uploaded_tp (struct trace_file_writer
*self
,
3238 struct uploaded_tp
*utp
)
3240 struct tfile_trace_file_writer
*writer
3241 = (struct tfile_trace_file_writer
*) self
;
3244 char buf
[MAX_TRACE_UPLOAD
];
3246 fprintf (writer
->fp
, "tp T%x:%s:%c:%x:%x",
3247 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3248 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
3249 if (utp
->type
== bp_fast_tracepoint
)
3250 fprintf (writer
->fp
, ":F%x", utp
->orig_size
);
3252 fprintf (writer
->fp
,
3253 ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
3255 fprintf (writer
->fp
, "\n");
3256 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
3257 fprintf (writer
->fp
, "tp A%x:%s:%s\n",
3258 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3259 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
3260 fprintf (writer
->fp
, "tp S%x:%s:%s\n",
3261 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3264 encode_source_string (utp
->number
, utp
->addr
,
3265 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
3266 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3268 if (utp
->cond_string
)
3270 encode_source_string (utp
->number
, utp
->addr
,
3271 "cond", utp
->cond_string
,
3272 buf
, MAX_TRACE_UPLOAD
);
3273 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3275 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
3277 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
3278 buf
, MAX_TRACE_UPLOAD
);
3279 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3281 fprintf (writer
->fp
, "tp V%x:%s:%x:%s\n",
3282 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3284 phex_nz (utp
->traceframe_usage
,
3285 sizeof (utp
->traceframe_usage
)));
3288 /* This is the implementation of trace_file_write_ops method
3289 write_definition_end. */
3292 tfile_write_definition_end (struct trace_file_writer
*self
)
3294 struct tfile_trace_file_writer
*writer
3295 = (struct tfile_trace_file_writer
*) self
;
3297 fprintf (writer
->fp
, "\n");
3300 /* This is the implementation of trace_file_write_ops method
3304 tfile_write_raw_data (struct trace_file_writer
*self
, gdb_byte
*buf
,
3307 struct tfile_trace_file_writer
*writer
3308 = (struct tfile_trace_file_writer
*) self
;
3310 if (fwrite (buf
, len
, 1, writer
->fp
) < 1)
3311 perror_with_name (writer
->pathname
);
3314 /* This is the implementation of trace_file_write_ops method
3318 tfile_end (struct trace_file_writer
*self
)
3320 struct tfile_trace_file_writer
*writer
3321 = (struct tfile_trace_file_writer
*) self
;
3322 uint32_t gotten
= 0;
3324 /* Mark the end of trace data. */
3325 if (fwrite (&gotten
, 4, 1, writer
->fp
) < 1)
3326 perror_with_name (writer
->pathname
);
3329 /* Operations to write trace buffers into TFILE format. */
3331 static const struct trace_file_write_ops tfile_write_ops
=
3337 tfile_write_regblock_type
,
3339 tfile_write_uploaded_tsv
,
3340 tfile_write_uploaded_tp
,
3341 tfile_write_definition_end
,
3342 tfile_write_raw_data
,
3347 /* Helper macros. */
3349 #define TRACE_WRITE_R_BLOCK(writer, buf, size) \
3350 writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
3351 #define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
3352 writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
3354 #define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
3355 writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
3357 #define TRACE_WRITE_V_BLOCK(writer, num, val) \
3358 writer->ops->frame_ops->write_v_block ((writer), (num), (val))
3360 /* Save tracepoint data to file named FILENAME through WRITER. WRITER
3361 determines the trace file format. If TARGET_DOES_SAVE is non-zero,
3362 the save is performed on the target, otherwise GDB obtains all trace
3363 data and saves it locally. */
3366 trace_save (const char *filename
, struct trace_file_writer
*writer
,
3367 int target_does_save
)
3369 struct trace_status
*ts
= current_trace_status ();
3371 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
3372 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
3374 ULONGEST offset
= 0;
3375 gdb_byte buf
[MAX_TRACE_UPLOAD
];
3376 #define MAX_TRACE_UPLOAD 2000
3378 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
3380 /* If the target is to save the data to a file on its own, then just
3381 send the command and be done with it. */
3382 if (target_does_save
)
3384 if (!writer
->ops
->target_save (writer
, filename
))
3385 error (_("Target failed to save trace data to '%s'."),
3390 /* Get the trace status first before opening the file, so if the
3391 target is losing, we can get out without touching files. */
3392 status
= target_get_trace_status (ts
);
3394 writer
->ops
->start (writer
, filename
);
3396 writer
->ops
->write_header (writer
);
3398 /* Write descriptive info. */
3400 /* Write out the size of a register block. */
3401 writer
->ops
->write_regblock_type (writer
, trace_regblock_size
);
3403 /* Write out status of the tracing run (aka "tstatus" info). */
3404 writer
->ops
->write_status (writer
, ts
);
3406 /* Note that we want to upload tracepoints and save those, rather
3407 than simply writing out the local ones, because the user may have
3408 changed tracepoints in GDB in preparation for a future tracing
3409 run, or maybe just mass-deleted all types of breakpoints as part
3410 of cleaning up. So as not to contaminate the session, leave the
3411 data in its uploaded form, don't make into real tracepoints. */
3413 /* Get trace state variables first, they may be checked when parsing
3414 uploaded commands. */
3416 target_upload_trace_state_variables (&uploaded_tsvs
);
3418 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3419 writer
->ops
->write_uploaded_tsv (writer
, utsv
);
3421 free_uploaded_tsvs (&uploaded_tsvs
);
3423 target_upload_tracepoints (&uploaded_tps
);
3425 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3426 target_get_tracepoint_status (NULL
, utp
);
3428 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3429 writer
->ops
->write_uploaded_tp (writer
, utp
);
3431 free_uploaded_tps (&uploaded_tps
);
3433 /* Mark the end of the definition section. */
3434 writer
->ops
->write_definition_end (writer
);
3436 /* Get and write the trace data proper. */
3441 /* The writer supports writing the contents of trace buffer
3442 directly to trace file. Don't parse the contents of trace
3444 if (writer
->ops
->write_trace_buffer
!= NULL
)
3446 /* We ask for big blocks, in the hopes of efficiency, but
3447 will take less if the target has packet size limitations
3449 gotten
= target_get_raw_trace_data (buf
, offset
,
3452 error (_("Failure to get requested trace buffer data"));
3453 /* No more data is forthcoming, we're done. */
3457 writer
->ops
->write_trace_buffer (writer
, buf
, gotten
);
3465 /* Parse the trace buffers according to how data are stored
3466 in trace buffer in GDBserver. */
3468 gotten
= target_get_raw_trace_data (buf
, offset
, 6);
3473 /* Read the first six bytes in, which is the tracepoint
3474 number and trace frame size. */
3476 extract_unsigned_integer (&buf
[0], 2, byte_order
);
3478 tf_size
= (uint32_t)
3479 extract_unsigned_integer (&buf
[2], 4, byte_order
);
3481 writer
->ops
->frame_ops
->start (writer
, tp_num
);
3490 for (block
= 0; block
< tf_size
; )
3492 gdb_byte block_type
;
3494 /* We'll fetch one block each time, in order to
3495 handle the extremely large 'M' block. We first
3496 fetch one byte to get the type of the block. */
3497 gotten
= target_get_raw_trace_data (buf
, offset
, 1);
3499 error (_("Failure to get requested trace buffer data"));
3505 block_type
= buf
[0];
3510 = target_get_raw_trace_data (buf
, offset
,
3511 trace_regblock_size
);
3512 if (gotten
< trace_regblock_size
)
3513 error (_("Failure to get requested trace"
3516 TRACE_WRITE_R_BLOCK (writer
, buf
,
3517 trace_regblock_size
);
3521 unsigned short mlen
;
3526 t
= target_get_raw_trace_data (buf
,offset
, 10);
3528 error (_("Failure to get requested trace"
3536 extract_unsigned_integer (buf
, 8,
3538 mlen
= (unsigned short)
3539 extract_unsigned_integer (&buf
[8], 2,
3542 TRACE_WRITE_M_BLOCK_HEADER (writer
, addr
,
3545 /* The memory contents in 'M' block may be
3546 very large. Fetch the data from the target
3547 and write them into file one by one. */
3548 for (j
= 0; j
< mlen
; )
3550 unsigned int read_length
;
3552 if (mlen
- j
> MAX_TRACE_UPLOAD
)
3553 read_length
= MAX_TRACE_UPLOAD
;
3555 read_length
= mlen
- j
;
3557 t
= target_get_raw_trace_data (buf
,
3560 if (t
< read_length
)
3561 error (_("Failure to get requested"
3562 " trace buffer data"));
3564 TRACE_WRITE_M_BLOCK_MEMORY (writer
, buf
,
3568 gotten
+= read_length
;
3579 = target_get_raw_trace_data (buf
, offset
,
3582 error (_("Failure to get requested"
3583 " trace buffer data"));
3585 vnum
= (int) extract_signed_integer (buf
,
3589 = extract_signed_integer (&buf
[4], 8,
3592 TRACE_WRITE_V_BLOCK (writer
, vnum
, val
);
3596 error (_("Unknown block type '%c' (0x%x) in"
3598 block_type
, block_type
);
3608 writer
->ops
->frame_ops
->end (writer
);
3612 writer
->ops
->end (writer
);
3615 /* Return a trace writer for TFILE format. */
3617 static struct trace_file_writer
*
3618 tfile_trace_file_writer_new (void)
3620 struct tfile_trace_file_writer
*writer
3621 = xmalloc (sizeof (struct tfile_trace_file_writer
));
3623 writer
->base
.ops
= &tfile_write_ops
;
3625 writer
->pathname
= NULL
;
3627 return (struct trace_file_writer
*) writer
;
3631 trace_save_command (char *args
, int from_tty
)
3633 int target_does_save
= 0;
3635 char *filename
= NULL
;
3636 struct cleanup
*back_to
;
3637 int generate_ctf
= 0;
3638 struct trace_file_writer
*writer
= NULL
;
3641 error_no_arg (_("file in which to save trace data"));
3643 argv
= gdb_buildargv (args
);
3644 back_to
= make_cleanup_freeargv (argv
);
3646 for (; *argv
; ++argv
)
3648 if (strcmp (*argv
, "-r") == 0)
3649 target_does_save
= 1;
3650 if (strcmp (*argv
, "-ctf") == 0)
3652 else if (**argv
== '-')
3653 error (_("unknown option `%s'"), *argv
);
3659 error_no_arg (_("file in which to save trace data"));
3662 writer
= ctf_trace_file_writer_new ();
3664 writer
= tfile_trace_file_writer_new ();
3666 make_cleanup (trace_file_writer_xfree
, writer
);
3668 trace_save (filename
, writer
, target_does_save
);
3671 printf_filtered (_("Trace data saved to %s '%s'.\n"),
3672 generate_ctf
? "directory" : "file", filename
);
3674 do_cleanups (back_to
);
3677 /* Save the trace data to file FILENAME of tfile format. */
3680 trace_save_tfile (const char *filename
, int target_does_save
)
3682 struct trace_file_writer
*writer
;
3683 struct cleanup
*back_to
;
3685 writer
= tfile_trace_file_writer_new ();
3686 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
3687 trace_save (filename
, writer
, target_does_save
);
3688 do_cleanups (back_to
);
3691 /* Save the trace data to dir DIRNAME of ctf format. */
3694 trace_save_ctf (const char *dirname
, int target_does_save
)
3696 struct trace_file_writer
*writer
;
3697 struct cleanup
*back_to
;
3699 writer
= ctf_trace_file_writer_new ();
3700 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
3702 trace_save (dirname
, writer
, target_does_save
);
3703 do_cleanups (back_to
);
3706 /* Tell the target what to do with an ongoing tracing run if GDB
3707 disconnects for some reason. */
3710 set_disconnected_tracing (char *args
, int from_tty
,
3711 struct cmd_list_element
*c
)
3713 target_set_disconnected_tracing (disconnected_tracing
);
3717 set_circular_trace_buffer (char *args
, int from_tty
,
3718 struct cmd_list_element
*c
)
3720 target_set_circular_trace_buffer (circular_trace_buffer
);
3724 set_trace_buffer_size (char *args
, int from_tty
,
3725 struct cmd_list_element
*c
)
3727 target_set_trace_buffer_size (trace_buffer_size
);
3731 set_trace_user (char *args
, int from_tty
,
3732 struct cmd_list_element
*c
)
3736 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3739 warning (_("Target does not support trace notes, user ignored"));
3743 set_trace_notes (char *args
, int from_tty
,
3744 struct cmd_list_element
*c
)
3748 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3751 warning (_("Target does not support trace notes, note ignored"));
3755 set_trace_stop_notes (char *args
, int from_tty
,
3756 struct cmd_list_element
*c
)
3760 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3763 warning (_("Target does not support trace notes, stop note ignored"));
3766 /* Convert the memory pointed to by mem into hex, placing result in buf.
3767 * Return a pointer to the last char put in buf (null)
3768 * "stolen" from sparc-stub.c
3771 static const char hexchars
[] = "0123456789abcdef";
3774 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3782 *buf
++ = hexchars
[ch
>> 4];
3783 *buf
++ = hexchars
[ch
& 0xf];
3792 get_traceframe_number (void)
3794 return traceframe_number
;
3798 get_tracepoint_number (void)
3800 return tracepoint_number
;
3803 /* Make the traceframe NUM be the current trace frame. Does nothing
3804 if NUM is already current. */
3807 set_current_traceframe (int num
)
3811 if (traceframe_number
== num
)
3813 /* Nothing to do. */
3817 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3820 warning (_("could not change traceframe"));
3822 set_traceframe_num (newnum
);
3824 /* Changing the traceframe changes our view of registers and of the
3826 registers_changed ();
3828 clear_traceframe_info ();
3831 /* Make the traceframe NUM be the current trace frame, and do nothing
3835 set_traceframe_number (int num
)
3837 traceframe_number
= num
;
3840 /* A cleanup used when switching away and back from tfind mode. */
3842 struct current_traceframe_cleanup
3844 /* The traceframe we were inspecting. */
3845 int traceframe_number
;
3849 do_restore_current_traceframe_cleanup (void *arg
)
3851 struct current_traceframe_cleanup
*old
= arg
;
3853 set_current_traceframe (old
->traceframe_number
);
3857 restore_current_traceframe_cleanup_dtor (void *arg
)
3859 struct current_traceframe_cleanup
*old
= arg
;
3865 make_cleanup_restore_current_traceframe (void)
3867 struct current_traceframe_cleanup
*old
;
3869 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3870 old
->traceframe_number
= traceframe_number
;
3872 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3873 restore_current_traceframe_cleanup_dtor
);
3877 make_cleanup_restore_traceframe_number (void)
3879 return make_cleanup_restore_integer (&traceframe_number
);
3882 /* Given a number and address, return an uploaded tracepoint with that
3883 number, creating if necessary. */
3885 struct uploaded_tp
*
3886 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3888 struct uploaded_tp
*utp
;
3890 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3891 if (utp
->number
== num
&& utp
->addr
== addr
)
3893 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3894 memset (utp
, 0, sizeof (struct uploaded_tp
));
3897 utp
->actions
= NULL
;
3898 utp
->step_actions
= NULL
;
3899 utp
->cmd_strings
= NULL
;
3906 free_uploaded_tps (struct uploaded_tp
**utpp
)
3908 struct uploaded_tp
*next_one
;
3912 next_one
= (*utpp
)->next
;
3918 /* Given a number and address, return an uploaded tracepoint with that
3919 number, creating if necessary. */
3921 struct uploaded_tsv
*
3922 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3924 struct uploaded_tsv
*utsv
;
3926 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3927 if (utsv
->number
== num
)
3929 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3930 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3932 utsv
->next
= *utsvp
;
3938 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3940 struct uploaded_tsv
*next_one
;
3944 next_one
= (*utsvp
)->next
;
3950 /* FIXME this function is heuristic and will miss the cases where the
3951 conditional is semantically identical but differs in whitespace,
3952 such as "x == 0" vs "x==0". */
3955 cond_string_is_same (char *str1
, char *str2
)
3957 if (str1
== NULL
|| str2
== NULL
)
3958 return (str1
== str2
);
3960 return (strcmp (str1
, str2
) == 0);
3963 /* Look for an existing tracepoint that seems similar enough to the
3964 uploaded one. Enablement isn't compared, because the user can
3965 toggle that freely, and may have done so in anticipation of the
3966 next trace run. Return the location of matched tracepoint. */
3968 static struct bp_location
*
3969 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3971 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3973 struct breakpoint
*b
;
3974 struct bp_location
*loc
;
3976 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3978 struct tracepoint
*t
= (struct tracepoint
*) b
;
3980 if (b
->type
== utp
->type
3981 && t
->step_count
== utp
->step
3982 && t
->pass_count
== utp
->pass
3983 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3984 /* FIXME also test actions. */
3987 /* Scan the locations for an address match. */
3988 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3990 if (loc
->address
== utp
->addr
)
3998 /* Given a list of tracepoints uploaded from a target, attempt to
3999 match them up with existing tracepoints, and create new ones if not
4003 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
4005 struct uploaded_tp
*utp
;
4006 /* A set of tracepoints which are modified. */
4007 VEC(breakpoint_p
) *modified_tp
= NULL
;
4009 struct breakpoint
*b
;
4011 /* Look for GDB tracepoints that match up with our uploaded versions. */
4012 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
4014 struct bp_location
*loc
;
4015 struct tracepoint
*t
;
4017 loc
= find_matching_tracepoint_location (utp
);
4022 /* Mark this location as already inserted. */
4024 t
= (struct tracepoint
*) loc
->owner
;
4025 printf_filtered (_("Assuming tracepoint %d is same "
4026 "as target's tracepoint %d at %s.\n"),
4027 loc
->owner
->number
, utp
->number
,
4028 paddress (loc
->gdbarch
, utp
->addr
));
4030 /* The tracepoint LOC->owner was modified (the location LOC
4031 was marked as inserted in the target). Save it in
4032 MODIFIED_TP if not there yet. The 'breakpoint-modified'
4033 observers will be notified later once for each tracepoint
4034 saved in MODIFIED_TP. */
4036 VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
);
4038 if (b
== loc
->owner
)
4044 VEC_safe_push (breakpoint_p
, modified_tp
, loc
->owner
);
4048 t
= create_tracepoint_from_upload (utp
);
4050 printf_filtered (_("Created tracepoint %d for "
4051 "target's tracepoint %d at %s.\n"),
4052 t
->base
.number
, utp
->number
,
4053 paddress (get_current_arch (), utp
->addr
));
4055 printf_filtered (_("Failed to create tracepoint for target's "
4056 "tracepoint %d at %s, skipping it.\n"),
4058 paddress (get_current_arch (), utp
->addr
));
4060 /* Whether found or created, record the number used by the
4061 target, to help with mapping target tracepoints back to their
4062 counterparts here. */
4064 t
->number_on_target
= utp
->number
;
4067 /* Notify 'breakpoint-modified' observer that at least one of B's
4068 locations was changed. */
4069 for (ix
= 0; VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
); ix
++)
4070 observer_notify_breakpoint_modified (b
);
4072 VEC_free (breakpoint_p
, modified_tp
);
4073 free_uploaded_tps (uploaded_tps
);
4076 /* Trace state variables don't have much to identify them beyond their
4077 name, so just use that to detect matches. */
4079 static struct trace_state_variable
*
4080 find_matching_tsv (struct uploaded_tsv
*utsv
)
4085 return find_trace_state_variable (utsv
->name
);
4088 static struct trace_state_variable
*
4089 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
4091 const char *namebase
;
4094 struct trace_state_variable
*tsv
;
4095 struct cleanup
*old_chain
;
4099 namebase
= utsv
->name
;
4100 buf
= xstrprintf ("%s", namebase
);
4105 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
4108 /* Fish for a name that is not in use. */
4109 /* (should check against all internal vars?) */
4110 while (find_trace_state_variable (buf
))
4113 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
4116 old_chain
= make_cleanup (xfree
, buf
);
4118 /* We have an available name, create the variable. */
4119 tsv
= create_trace_state_variable (buf
);
4120 tsv
->initial_value
= utsv
->initial_value
;
4121 tsv
->builtin
= utsv
->builtin
;
4123 observer_notify_tsv_created (tsv
);
4125 do_cleanups (old_chain
);
4130 /* Given a list of uploaded trace state variables, try to match them
4131 up with existing variables, or create additional ones. */
4134 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
4137 struct uploaded_tsv
*utsv
;
4138 struct trace_state_variable
*tsv
;
4141 /* Most likely some numbers will have to be reassigned as part of
4142 the merge, so clear them all in anticipation. */
4143 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4146 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
4148 tsv
= find_matching_tsv (utsv
);
4152 printf_filtered (_("Assuming trace state variable $%s "
4153 "is same as target's variable %d.\n"),
4154 tsv
->name
, utsv
->number
);
4158 tsv
= create_tsv_from_upload (utsv
);
4160 printf_filtered (_("Created trace state variable "
4161 "$%s for target's variable %d.\n"),
4162 tsv
->name
, utsv
->number
);
4164 /* Give precedence to numberings that come from the target. */
4166 tsv
->number
= utsv
->number
;
4169 /* Renumber everything that didn't get a target-assigned number. */
4171 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4172 if (tsv
->number
> highest
)
4173 highest
= tsv
->number
;
4176 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4177 if (tsv
->number
== 0)
4178 tsv
->number
= highest
++;
4180 free_uploaded_tsvs (uploaded_tsvs
);
4183 /* target tfile command */
4185 static struct target_ops tfile_ops
;
4187 /* Fill in tfile_ops with its defined operations and properties. */
4189 #define TRACE_HEADER_SIZE 8
4191 static char *trace_filename
;
4192 static int trace_fd
= -1;
4193 static off_t trace_frames_offset
;
4194 static off_t cur_offset
;
4195 static int cur_data_size
;
4196 int trace_regblock_size
;
4198 static void tfile_interp_line (char *line
,
4199 struct uploaded_tp
**utpp
,
4200 struct uploaded_tsv
**utsvp
);
4202 /* Read SIZE bytes into READBUF from the trace frame, starting at
4203 TRACE_FD's current position. Note that this call `read'
4204 underneath, hence it advances the file's seek position. Throws an
4205 error if the `read' syscall fails, or less than SIZE bytes are
4209 tfile_read (gdb_byte
*readbuf
, int size
)
4213 gotten
= read (trace_fd
, readbuf
, size
);
4215 perror_with_name (trace_filename
);
4216 else if (gotten
< size
)
4217 error (_("Premature end of file while reading trace file"));
4221 tfile_open (char *filename
, int from_tty
)
4223 volatile struct gdb_exception ex
;
4225 struct cleanup
*old_chain
;
4228 char header
[TRACE_HEADER_SIZE
];
4229 char linebuf
[1000]; /* Should be max remote packet size or so. */
4232 struct trace_status
*ts
;
4233 struct uploaded_tp
*uploaded_tps
= NULL
;
4234 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4236 target_preopen (from_tty
);
4238 error (_("No trace file specified."));
4240 filename
= tilde_expand (filename
);
4241 if (!IS_ABSOLUTE_PATH(filename
))
4243 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
4248 old_chain
= make_cleanup (xfree
, filename
);
4250 flags
= O_BINARY
| O_LARGEFILE
;
4252 scratch_chan
= gdb_open_cloexec (filename
, flags
, 0);
4253 if (scratch_chan
< 0)
4254 perror_with_name (filename
);
4256 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
4258 discard_cleanups (old_chain
); /* Don't free filename any more. */
4259 unpush_target (&tfile_ops
);
4261 trace_filename
= xstrdup (filename
);
4262 trace_fd
= scratch_chan
;
4265 /* Read the file header and test for validity. */
4266 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
4268 bytes
+= TRACE_HEADER_SIZE
;
4269 if (!(header
[0] == 0x7f
4270 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
4271 error (_("File is not a valid trace file."));
4273 push_target (&tfile_ops
);
4275 trace_regblock_size
= 0;
4276 ts
= current_trace_status ();
4277 /* We know we're working with a file. Record its name. */
4278 ts
->filename
= trace_filename
;
4279 /* Set defaults in case there is no status line. */
4280 ts
->running_known
= 0;
4281 ts
->stop_reason
= trace_stop_reason_unknown
;
4282 ts
->traceframe_count
= -1;
4283 ts
->buffer_free
= 0;
4284 ts
->disconnected_tracing
= 0;
4285 ts
->circular_buffer
= 0;
4287 TRY_CATCH (ex
, RETURN_MASK_ALL
)
4289 /* Read through a section of newline-terminated lines that
4290 define things like tracepoints. */
4294 tfile_read (&byte
, 1);
4299 /* Empty line marks end of the definition section. */
4304 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
4307 linebuf
[i
++] = byte
;
4309 error (_("Excessively long lines in trace file"));
4312 /* Record the starting offset of the binary trace data. */
4313 trace_frames_offset
= bytes
;
4315 /* If we don't have a blocksize, we can't interpret the
4317 if (trace_regblock_size
== 0)
4318 error (_("No register block size recorded in trace file"));
4322 /* Pop the partially set up target. */
4324 throw_exception (ex
);
4327 if (ts
->traceframe_count
<= 0)
4328 warning (_("No traceframes present in this file."));
4330 /* Add the file's tracepoints and variables into the current mix. */
4332 /* Get trace state variables first, they may be checked when parsing
4333 uploaded commands. */
4334 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4336 merge_uploaded_tracepoints (&uploaded_tps
);
4339 /* Interpret the given line from the definitions part of the trace
4343 tfile_interp_line (char *line
, struct uploaded_tp
**utpp
,
4344 struct uploaded_tsv
**utsvp
)
4348 if (strncmp (p
, "R ", strlen ("R ")) == 0)
4351 trace_regblock_size
= strtol (p
, &p
, 16);
4353 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
4355 p
+= strlen ("status ");
4356 parse_trace_status (p
, current_trace_status ());
4358 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
4360 p
+= strlen ("tp ");
4361 parse_tracepoint_definition (p
, utpp
);
4363 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
4365 p
+= strlen ("tsv ");
4366 parse_tsv_definition (p
, utsvp
);
4369 warning (_("Ignoring trace file definition \"%s\""), line
);
4372 /* Parse the part of trace status syntax that is shared between
4373 the remote protocol and the trace file reader. */
4376 parse_trace_status (char *line
, struct trace_status
*ts
)
4378 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
4382 ts
->running_known
= 1;
4383 ts
->running
= (*p
++ == '1');
4384 ts
->stop_reason
= trace_stop_reason_unknown
;
4385 xfree (ts
->stop_desc
);
4386 ts
->stop_desc
= NULL
;
4387 ts
->traceframe_count
= -1;
4388 ts
->traceframes_created
= -1;
4389 ts
->buffer_free
= -1;
4390 ts
->buffer_size
= -1;
4391 ts
->disconnected_tracing
= 0;
4392 ts
->circular_buffer
= 0;
4393 xfree (ts
->user_name
);
4394 ts
->user_name
= NULL
;
4397 ts
->start_time
= ts
->stop_time
= 0;
4401 p1
= strchr (p
, ':');
4403 error (_("Malformed trace status, at %s\n\
4404 Status line: '%s'\n"), p
, line
);
4405 p3
= strchr (p
, ';');
4407 p3
= p
+ strlen (p
);
4408 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
4410 p
= unpack_varlen_hex (++p1
, &val
);
4411 ts
->stop_reason
= trace_buffer_full
;
4413 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
4415 p
= unpack_varlen_hex (++p1
, &val
);
4416 ts
->stop_reason
= trace_never_run
;
4418 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
4421 p
= unpack_varlen_hex (++p1
, &val
);
4422 ts
->stop_reason
= tracepoint_passcount
;
4423 ts
->stopping_tracepoint
= val
;
4425 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
4427 p2
= strchr (++p1
, ':');
4435 ts
->stop_desc
= xmalloc (strlen (line
));
4436 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
4437 ts
->stop_desc
[end
] = '\0';
4440 ts
->stop_desc
= xstrdup ("");
4442 p
= unpack_varlen_hex (++p2
, &val
);
4443 ts
->stop_reason
= tstop_command
;
4445 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
4447 p
= unpack_varlen_hex (++p1
, &val
);
4448 ts
->stop_reason
= trace_disconnected
;
4450 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
4452 p2
= strchr (++p1
, ':');
4455 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
4456 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
4457 ts
->stop_desc
[end
] = '\0';
4460 ts
->stop_desc
= xstrdup ("");
4462 p
= unpack_varlen_hex (++p2
, &val
);
4463 ts
->stopping_tracepoint
= val
;
4464 ts
->stop_reason
= tracepoint_error
;
4466 else if (strncmp (p
, "tframes", p1
- p
) == 0)
4468 p
= unpack_varlen_hex (++p1
, &val
);
4469 ts
->traceframe_count
= val
;
4471 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
4473 p
= unpack_varlen_hex (++p1
, &val
);
4474 ts
->traceframes_created
= val
;
4476 else if (strncmp (p
, "tfree", p1
- p
) == 0)
4478 p
= unpack_varlen_hex (++p1
, &val
);
4479 ts
->buffer_free
= val
;
4481 else if (strncmp (p
, "tsize", p1
- p
) == 0)
4483 p
= unpack_varlen_hex (++p1
, &val
);
4484 ts
->buffer_size
= val
;
4486 else if (strncmp (p
, "disconn", p1
- p
) == 0)
4488 p
= unpack_varlen_hex (++p1
, &val
);
4489 ts
->disconnected_tracing
= val
;
4491 else if (strncmp (p
, "circular", p1
- p
) == 0)
4493 p
= unpack_varlen_hex (++p1
, &val
);
4494 ts
->circular_buffer
= val
;
4496 else if (strncmp (p
, "starttime", p1
- p
) == 0)
4498 p
= unpack_varlen_hex (++p1
, &val
);
4499 ts
->start_time
= val
;
4501 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
4503 p
= unpack_varlen_hex (++p1
, &val
);
4504 ts
->stop_time
= val
;
4506 else if (strncmp (p
, "username", p1
- p
) == 0)
4509 ts
->user_name
= xmalloc (strlen (p
) / 2);
4510 end
= hex2bin (p1
, (gdb_byte
*) ts
->user_name
, (p3
- p1
) / 2);
4511 ts
->user_name
[end
] = '\0';
4514 else if (strncmp (p
, "notes", p1
- p
) == 0)
4517 ts
->notes
= xmalloc (strlen (p
) / 2);
4518 end
= hex2bin (p1
, (gdb_byte
*) ts
->notes
, (p3
- p1
) / 2);
4519 ts
->notes
[end
] = '\0';
4524 /* Silently skip unknown optional info. */
4525 p_temp
= strchr (p1
+ 1, ';');
4529 /* Must be at the end. */
4536 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
4537 struct uploaded_tp
*utp
)
4540 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
4542 p
= unpack_varlen_hex (p
, &uval
);
4544 tp
->base
.hit_count
+= uval
;
4546 utp
->hit_count
+= uval
;
4547 p
= unpack_varlen_hex (p
+ 1, &uval
);
4549 tp
->traceframe_usage
+= uval
;
4551 utp
->traceframe_usage
+= uval
;
4552 /* Ignore any extra, allowing for future extensions. */
4555 /* Given a line of text defining a part of a tracepoint, parse it into
4556 an "uploaded tracepoint". */
4559 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
4563 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
4566 char *cond
, *srctype
, *buf
;
4567 struct uploaded_tp
*utp
= NULL
;
4570 /* Both tracepoint and action definitions start with the same number
4571 and address sequence. */
4573 p
= unpack_varlen_hex (p
, &num
);
4574 p
++; /* skip a colon */
4575 p
= unpack_varlen_hex (p
, &addr
);
4576 p
++; /* skip a colon */
4579 enabled
= (*p
++ == 'E');
4580 p
++; /* skip a colon */
4581 p
= unpack_varlen_hex (p
, &step
);
4582 p
++; /* skip a colon */
4583 p
= unpack_varlen_hex (p
, &pass
);
4584 type
= bp_tracepoint
;
4586 /* Thumb through optional fields. */
4589 p
++; /* skip a colon */
4592 type
= bp_fast_tracepoint
;
4594 p
= unpack_varlen_hex (p
, &orig_size
);
4598 type
= bp_static_tracepoint
;
4604 p
= unpack_varlen_hex (p
, &xlen
);
4605 p
++; /* skip a comma */
4606 cond
= (char *) xmalloc (2 * xlen
+ 1);
4607 strncpy (cond
, p
, 2 * xlen
);
4608 cond
[2 * xlen
] = '\0';
4612 warning (_("Unrecognized char '%c' in tracepoint "
4613 "definition, skipping rest"), *p
);
4615 utp
= get_uploaded_tp (num
, addr
, utpp
);
4617 utp
->enabled
= enabled
;
4622 else if (piece
== 'A')
4624 utp
= get_uploaded_tp (num
, addr
, utpp
);
4625 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
4627 else if (piece
== 'S')
4629 utp
= get_uploaded_tp (num
, addr
, utpp
);
4630 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
4632 else if (piece
== 'Z')
4634 /* Parse a chunk of source form definition. */
4635 utp
= get_uploaded_tp (num
, addr
, utpp
);
4637 p
= strchr (p
, ':');
4638 p
++; /* skip a colon */
4639 p
= unpack_varlen_hex (p
, &start
);
4640 p
++; /* skip a colon */
4641 p
= unpack_varlen_hex (p
, &xlen
);
4642 p
++; /* skip a colon */
4644 buf
= alloca (strlen (line
));
4646 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4649 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
4650 utp
->at_string
= xstrdup (buf
);
4651 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
4652 utp
->cond_string
= xstrdup (buf
);
4653 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
4654 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
4656 else if (piece
== 'V')
4658 utp
= get_uploaded_tp (num
, addr
, utpp
);
4660 parse_tracepoint_status (p
, NULL
, utp
);
4664 /* Don't error out, the target might be sending us optional
4665 info that we don't care about. */
4666 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
4670 /* Convert a textual description of a trace state variable into an
4674 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
4677 ULONGEST num
, initval
, builtin
;
4679 struct uploaded_tsv
*utsv
= NULL
;
4681 buf
= alloca (strlen (line
));
4684 p
= unpack_varlen_hex (p
, &num
);
4685 p
++; /* skip a colon */
4686 p
= unpack_varlen_hex (p
, &initval
);
4687 p
++; /* skip a colon */
4688 p
= unpack_varlen_hex (p
, &builtin
);
4689 p
++; /* skip a colon */
4690 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4693 utsv
= get_uploaded_tsv (num
, utsvp
);
4694 utsv
->initial_value
= initval
;
4695 utsv
->builtin
= builtin
;
4696 utsv
->name
= xstrdup (buf
);
4699 /* Close the trace file and generally clean up. */
4711 xfree (trace_filename
);
4712 trace_filename
= NULL
;
4714 trace_reset_local_state ();
4718 tfile_files_info (struct target_ops
*t
)
4720 printf_filtered ("\t`%s'\n", trace_filename
);
4723 /* The trace status for a file is that tracing can never be run. */
4726 tfile_get_trace_status (struct trace_status
*ts
)
4728 /* Other bits of trace status were collected as part of opening the
4729 trace files, so nothing to do here. */
4735 tfile_get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
4737 /* Other bits of trace status were collected as part of opening the
4738 trace files, so nothing to do here. */
4741 /* Given the position of a traceframe in the file, figure out what
4742 address the frame was collected at. This would normally be the
4743 value of a collected PC register, but if not available, we
4747 tfile_get_traceframe_address (off_t tframe_offset
)
4751 struct tracepoint
*tp
;
4752 off_t saved_offset
= cur_offset
;
4754 /* FIXME dig pc out of collected registers. */
4756 /* Fall back to using tracepoint address. */
4757 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
4758 tfile_read ((gdb_byte
*) &tpnum
, 2);
4759 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4761 (target_gdbarch ()));
4763 tp
= get_tracepoint_by_number_on_target (tpnum
);
4764 /* FIXME this is a poor heuristic if multiple locations. */
4765 if (tp
&& tp
->base
.loc
)
4766 addr
= tp
->base
.loc
->address
;
4768 /* Restore our seek position. */
4769 cur_offset
= saved_offset
;
4770 lseek (trace_fd
, cur_offset
, SEEK_SET
);
4774 /* Given a type of search and some parameters, scan the collection of
4775 traceframes in the file looking for a match. When found, return
4776 both the traceframe and tracepoint number, otherwise -1 for
4780 tfile_trace_find (enum trace_find_type type
, int num
,
4781 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
)
4784 int tfnum
= 0, found
= 0;
4785 unsigned int data_size
;
4786 struct tracepoint
*tp
;
4787 off_t offset
, tframe_offset
;
4797 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
4798 offset
= trace_frames_offset
;
4801 tframe_offset
= offset
;
4802 tfile_read ((gdb_byte
*) &tpnum
, 2);
4803 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4805 (target_gdbarch ()));
4809 tfile_read ((gdb_byte
*) &data_size
, 4);
4810 data_size
= (unsigned int) extract_unsigned_integer
4811 ((gdb_byte
*) &data_size
, 4,
4812 gdbarch_byte_order (target_gdbarch ()));
4815 if (type
== tfind_number
)
4817 /* Looking for a specific trace frame. */
4823 /* Start from the _next_ trace frame. */
4824 if (tfnum
> traceframe_number
)
4829 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4830 if (tfaddr
== addr1
)
4834 tp
= get_tracepoint (num
);
4835 if (tp
&& tpnum
== tp
->number_on_target
)
4839 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4840 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
4844 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4845 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
4849 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
4858 cur_offset
= offset
;
4859 cur_data_size
= data_size
;
4863 /* Skip past the traceframe's data. */
4864 lseek (trace_fd
, data_size
, SEEK_CUR
);
4865 offset
+= data_size
;
4866 /* Update our own count of traceframes. */
4869 /* Did not find what we were looking for. */
4875 /* Prototype of the callback passed to tframe_walk_blocks. */
4876 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
4878 /* Callback for traceframe_walk_blocks, used to find a given block
4879 type in a traceframe. */
4882 match_blocktype (char blocktype
, void *data
)
4884 char *wantedp
= data
;
4886 if (*wantedp
== blocktype
)
4892 /* Walk over all traceframe block starting at POS offset from
4893 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4894 unmodified. If CALLBACK returns true, this returns the position in
4895 the traceframe where the block is found, relative to the start of
4896 the traceframe (cur_offset). Returns -1 if no callback call
4897 returned true, indicating that all blocks have been walked. */
4900 traceframe_walk_blocks (walk_blocks_callback_func callback
,
4901 int pos
, void *data
)
4903 /* Iterate through a traceframe's blocks, looking for a block of the
4906 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
4907 while (pos
< cur_data_size
)
4909 unsigned short mlen
;
4912 tfile_read ((gdb_byte
*) &block_type
, 1);
4916 if ((*callback
) (block_type
, data
))
4922 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4923 pos
+= trace_regblock_size
;
4926 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4927 tfile_read ((gdb_byte
*) &mlen
, 2);
4928 mlen
= (unsigned short)
4929 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4931 (target_gdbarch ()));
4932 lseek (trace_fd
, mlen
, SEEK_CUR
);
4933 pos
+= (8 + 2 + mlen
);
4936 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
4940 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4941 block_type
, block_type
);
4949 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4950 position offset of a block of type TYPE_WANTED in the current trace
4951 frame, starting at POS. Returns -1 if no such block was found. */
4954 traceframe_find_block_type (char type_wanted
, int pos
)
4956 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
4959 /* Look for a block of saved registers in the traceframe, and get the
4960 requested register from it. */
4963 tfile_fetch_registers (struct target_ops
*ops
,
4964 struct regcache
*regcache
, int regno
)
4966 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4967 int offset
, regn
, regsize
, pc_regno
;
4970 /* An uninitialized reg size says we're not going to be
4971 successful at getting register blocks. */
4972 if (!trace_regblock_size
)
4975 regs
= alloca (trace_regblock_size
);
4977 if (traceframe_find_block_type ('R', 0) >= 0)
4979 tfile_read (regs
, trace_regblock_size
);
4981 /* Assume the block is laid out in GDB register number order,
4982 each register with the size that it has in GDB. */
4984 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4986 regsize
= register_size (gdbarch
, regn
);
4987 /* Make sure we stay within block bounds. */
4988 if (offset
+ regsize
>= trace_regblock_size
)
4990 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
4994 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
4997 else if (regno
== -1)
4999 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
5007 /* We get here if no register data has been found. Mark registers
5009 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
5010 regcache_raw_supply (regcache
, regn
, NULL
);
5012 /* We can often usefully guess that the PC is going to be the same
5013 as the address of the tracepoint. */
5014 pc_regno
= gdbarch_pc_regnum (gdbarch
);
5015 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
5017 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
5019 if (tp
&& tp
->base
.loc
)
5021 /* But don't try to guess if tracepoint is multi-location... */
5022 if (tp
->base
.loc
->next
)
5024 warning (_("Tracepoint %d has multiple "
5025 "locations, cannot infer $pc"),
5029 /* ... or does while-stepping. */
5030 if (tp
->step_count
> 0)
5032 warning (_("Tracepoint %d does while-stepping, "
5033 "cannot infer $pc"),
5038 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
5039 gdbarch_byte_order (gdbarch
),
5040 tp
->base
.loc
->address
);
5041 regcache_raw_supply (regcache
, pc_regno
, regs
);
5047 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5048 const char *annex
, gdb_byte
*readbuf
,
5049 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5051 /* We're only doing regular memory for now. */
5052 if (object
!= TARGET_OBJECT_MEMORY
)
5055 if (readbuf
== NULL
)
5056 error (_("tfile_xfer_partial: trace file is read-only"));
5058 if (traceframe_number
!= -1)
5062 /* Iterate through the traceframe's blocks, looking for
5064 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
5066 ULONGEST maddr
, amt
;
5067 unsigned short mlen
;
5068 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
5070 tfile_read ((gdb_byte
*) &maddr
, 8);
5071 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
5073 tfile_read ((gdb_byte
*) &mlen
, 2);
5074 mlen
= (unsigned short)
5075 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
5077 /* If the block includes the first part of the desired
5078 range, return as much it has; GDB will re-request the
5079 remainder, which might be in a different block of this
5081 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
5083 amt
= (maddr
+ mlen
) - offset
;
5087 if (maddr
!= offset
)
5088 lseek (trace_fd
, offset
- maddr
, SEEK_CUR
);
5089 tfile_read (readbuf
, amt
);
5093 /* Skip over this block. */
5094 pos
+= (8 + 2 + mlen
);
5098 /* It's unduly pedantic to refuse to look at the executable for
5099 read-only pieces; so do the equivalent of readonly regions aka
5101 /* FIXME account for relocation at some point. */
5108 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5110 if ((s
->flags
& SEC_LOAD
) == 0
5111 || (s
->flags
& SEC_READONLY
) == 0)
5115 size
= bfd_get_section_size (s
);
5116 if (vma
<= offset
&& offset
< (vma
+ size
))
5120 amt
= (vma
+ size
) - offset
;
5124 amt
= bfd_get_section_contents (exec_bfd
, s
,
5125 readbuf
, offset
- vma
, amt
);
5131 /* Indicate failure to find the requested memory block. */
5135 /* Iterate through the blocks of a trace frame, looking for a 'V'
5136 block with a matching tsv number. */
5139 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
5144 /* Iterate over blocks in current frame and find the last 'V'
5145 block in which tsv number is TSVNUM. In one trace frame, there
5146 may be multiple 'V' blocks created for a given trace variable,
5147 and the last matched 'V' block contains the updated value. */
5149 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
5153 tfile_read ((gdb_byte
*) &vnum
, 4);
5154 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
5156 (target_gdbarch ()));
5159 tfile_read ((gdb_byte
*) val
, 8);
5160 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
5162 (target_gdbarch ()));
5172 tfile_has_all_memory (struct target_ops
*ops
)
5178 tfile_has_memory (struct target_ops
*ops
)
5184 tfile_has_stack (struct target_ops
*ops
)
5186 return traceframe_number
!= -1;
5190 tfile_has_registers (struct target_ops
*ops
)
5192 return traceframe_number
!= -1;
5195 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
5196 object for the tfile target's current traceframe. */
5199 build_traceframe_info (char blocktype
, void *data
)
5201 struct traceframe_info
*info
= data
;
5207 struct mem_range
*r
;
5209 unsigned short mlen
;
5211 tfile_read ((gdb_byte
*) &maddr
, 8);
5212 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
5214 (target_gdbarch ()));
5215 tfile_read ((gdb_byte
*) &mlen
, 2);
5216 mlen
= (unsigned short)
5217 extract_unsigned_integer ((gdb_byte
*) &mlen
,
5218 2, gdbarch_byte_order
5219 (target_gdbarch ()));
5221 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5231 tfile_read ((gdb_byte
*) &vnum
, 4);
5232 VEC_safe_push (int, info
->tvars
, vnum
);
5240 warning (_("Unhandled trace block type (%d) '%c ' "
5241 "while building trace frame info."),
5242 blocktype
, blocktype
);
5249 static struct traceframe_info
*
5250 tfile_traceframe_info (void)
5252 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
5254 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
5259 init_tfile_ops (void)
5261 tfile_ops
.to_shortname
= "tfile";
5262 tfile_ops
.to_longname
= "Local trace dump file";
5264 = "Use a trace file as a target. Specify the filename of the trace file.";
5265 tfile_ops
.to_open
= tfile_open
;
5266 tfile_ops
.to_close
= tfile_close
;
5267 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
5268 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
5269 tfile_ops
.to_files_info
= tfile_files_info
;
5270 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
5271 tfile_ops
.to_get_tracepoint_status
= tfile_get_tracepoint_status
;
5272 tfile_ops
.to_trace_find
= tfile_trace_find
;
5273 tfile_ops
.to_get_trace_state_variable_value
5274 = tfile_get_trace_state_variable_value
;
5275 tfile_ops
.to_stratum
= process_stratum
;
5276 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
5277 tfile_ops
.to_has_memory
= tfile_has_memory
;
5278 tfile_ops
.to_has_stack
= tfile_has_stack
;
5279 tfile_ops
.to_has_registers
= tfile_has_registers
;
5280 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
5281 tfile_ops
.to_magic
= OPS_MAGIC
;
5285 free_current_marker (void *arg
)
5287 struct static_tracepoint_marker
**marker_p
= arg
;
5289 if (*marker_p
!= NULL
)
5291 release_static_tracepoint_marker (*marker_p
);
5298 /* Given a line of text defining a static tracepoint marker, parse it
5299 into a "static tracepoint marker" object. Throws an error is
5300 parsing fails. If PP is non-null, it points to one past the end of
5301 the parsed marker definition. */
5304 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
5305 struct static_tracepoint_marker
*marker
)
5312 p
= unpack_varlen_hex (p
, &addr
);
5313 p
++; /* skip a colon */
5315 marker
->gdbarch
= target_gdbarch ();
5316 marker
->address
= (CORE_ADDR
) addr
;
5318 endp
= strchr (p
, ':');
5320 error (_("bad marker definition: %s"), line
);
5322 marker
->str_id
= xmalloc (endp
- p
+ 1);
5323 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
5324 marker
->str_id
[end
] = '\0';
5327 p
++; /* skip a colon */
5329 marker
->extra
= xmalloc (strlen (p
) + 1);
5330 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
5331 marker
->extra
[end
] = '\0';
5337 /* Release a static tracepoint marker's contents. Note that the
5338 object itself isn't released here. There objects are usually on
5342 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
5344 xfree (marker
->str_id
);
5345 marker
->str_id
= NULL
;
5348 /* Print MARKER to gdb_stdout. */
5351 print_one_static_tracepoint_marker (int count
,
5352 struct static_tracepoint_marker
*marker
)
5354 struct command_line
*l
;
5357 char wrap_indent
[80];
5358 char extra_field_indent
[80];
5359 struct ui_out
*uiout
= current_uiout
;
5360 struct cleanup
*bkpt_chain
;
5361 VEC(breakpoint_p
) *tracepoints
;
5363 struct symtab_and_line sal
;
5367 sal
.pc
= marker
->address
;
5369 tracepoints
= static_tracepoints_here (marker
->address
);
5371 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
5373 /* A counter field to help readability. This is not a stable
5375 ui_out_field_int (uiout
, "count", count
);
5377 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
5379 ui_out_field_fmt (uiout
, "enabled", "%c",
5380 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
5381 ui_out_spaces (uiout
, 2);
5383 strcpy (wrap_indent
, " ");
5385 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
5386 strcat (wrap_indent
, " ");
5388 strcat (wrap_indent
, " ");
5390 strcpy (extra_field_indent
, " ");
5392 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
5394 sal
= find_pc_line (marker
->address
, 0);
5395 sym
= find_pc_sect_function (marker
->address
, NULL
);
5398 ui_out_text (uiout
, "in ");
5399 ui_out_field_string (uiout
, "func",
5400 SYMBOL_PRINT_NAME (sym
));
5401 ui_out_wrap_hint (uiout
, wrap_indent
);
5402 ui_out_text (uiout
, " at ");
5405 ui_out_field_skip (uiout
, "func");
5407 if (sal
.symtab
!= NULL
)
5409 ui_out_field_string (uiout
, "file",
5410 symtab_to_filename_for_display (sal
.symtab
));
5411 ui_out_text (uiout
, ":");
5413 if (ui_out_is_mi_like_p (uiout
))
5415 const char *fullname
= symtab_to_fullname (sal
.symtab
);
5417 ui_out_field_string (uiout
, "fullname", fullname
);
5420 ui_out_field_skip (uiout
, "fullname");
5422 ui_out_field_int (uiout
, "line", sal
.line
);
5426 ui_out_field_skip (uiout
, "fullname");
5427 ui_out_field_skip (uiout
, "line");
5430 ui_out_text (uiout
, "\n");
5431 ui_out_text (uiout
, extra_field_indent
);
5432 ui_out_text (uiout
, _("Data: \""));
5433 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
5434 ui_out_text (uiout
, "\"\n");
5436 if (!VEC_empty (breakpoint_p
, tracepoints
))
5438 struct cleanup
*cleanup_chain
;
5440 struct breakpoint
*b
;
5442 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
5445 ui_out_text (uiout
, extra_field_indent
);
5446 ui_out_text (uiout
, _("Probed by static tracepoints: "));
5447 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
5450 ui_out_text (uiout
, ", ");
5451 ui_out_text (uiout
, "#");
5452 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
5455 do_cleanups (cleanup_chain
);
5457 if (ui_out_is_mi_like_p (uiout
))
5458 ui_out_field_int (uiout
, "number-of-tracepoints",
5459 VEC_length(breakpoint_p
, tracepoints
));
5461 ui_out_text (uiout
, "\n");
5463 VEC_free (breakpoint_p
, tracepoints
);
5465 do_cleanups (bkpt_chain
);
5469 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
5471 VEC(static_tracepoint_marker_p
) *markers
;
5472 struct cleanup
*old_chain
;
5473 struct static_tracepoint_marker
*marker
;
5474 struct ui_out
*uiout
= current_uiout
;
5477 /* We don't have to check target_can_use_agent and agent's capability on
5478 static tracepoint here, in order to be compatible with older GDBserver.
5479 We don't check USE_AGENT is true or not, because static tracepoints
5480 don't work without in-process agent, so we don't bother users to type
5481 `set agent on' when to use static tracepoint. */
5484 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
5485 "StaticTracepointMarkersTable");
5487 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
5489 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
5491 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
5492 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
5493 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
5495 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
5496 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
5498 ui_out_table_body (uiout
);
5500 markers
= target_static_tracepoint_markers_by_strid (NULL
);
5501 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
5504 VEC_iterate (static_tracepoint_marker_p
,
5505 markers
, i
, marker
);
5508 print_one_static_tracepoint_marker (i
+ 1, marker
);
5509 release_static_tracepoint_marker (marker
);
5512 do_cleanups (old_chain
);
5515 /* The $_sdata convenience variable is a bit special. We don't know
5516 for sure type of the value until we actually have a chance to fetch
5517 the data --- the size of the object depends on what has been
5518 collected. We solve this by making $_sdata be an internalvar that
5519 creates a new value on access. */
5521 /* Return a new value with the correct type for the sdata object of
5522 the current trace frame. Return a void value if there's no object
5525 static struct value
*
5526 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
5532 /* We need to read the whole object before we know its size. */
5533 size
= target_read_alloc (¤t_target
,
5534 TARGET_OBJECT_STATIC_TRACE_DATA
,
5541 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
5543 v
= allocate_value (type
);
5544 memcpy (value_contents_raw (v
), buf
, size
);
5549 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
5552 #if !defined(HAVE_LIBEXPAT)
5554 struct traceframe_info
*
5555 parse_traceframe_info (const char *tframe_info
)
5557 static int have_warned
;
5562 warning (_("Can not parse XML trace frame info; XML support "
5563 "was disabled at compile time"));
5569 #else /* HAVE_LIBEXPAT */
5571 #include "xml-support.h"
5573 /* Handle the start of a <memory> element. */
5576 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
5577 const struct gdb_xml_element
*element
,
5578 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
5580 struct traceframe_info
*info
= user_data
;
5581 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5582 ULONGEST
*start_p
, *length_p
;
5584 start_p
= xml_find_attribute (attributes
, "start")->value
;
5585 length_p
= xml_find_attribute (attributes
, "length")->value
;
5587 r
->start
= *start_p
;
5588 r
->length
= *length_p
;
5591 /* Handle the start of a <tvar> element. */
5594 traceframe_info_start_tvar (struct gdb_xml_parser
*parser
,
5595 const struct gdb_xml_element
*element
,
5597 VEC(gdb_xml_value_s
) *attributes
)
5599 struct traceframe_info
*info
= user_data
;
5600 const char *id_attrib
= xml_find_attribute (attributes
, "id")->value
;
5601 int id
= gdb_xml_parse_ulongest (parser
, id_attrib
);
5603 VEC_safe_push (int, info
->tvars
, id
);
5606 /* Discard the constructed trace frame info (if an error occurs). */
5609 free_result (void *p
)
5611 struct traceframe_info
*result
= p
;
5613 free_traceframe_info (result
);
5616 /* The allowed elements and attributes for an XML memory map. */
5618 static const struct gdb_xml_attribute memory_attributes
[] = {
5619 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5620 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5621 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5624 static const struct gdb_xml_attribute tvar_attributes
[] = {
5625 { "id", GDB_XML_AF_NONE
, NULL
, NULL
},
5626 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5629 static const struct gdb_xml_element traceframe_info_children
[] = {
5630 { "memory", memory_attributes
, NULL
,
5631 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5632 traceframe_info_start_memory
, NULL
},
5633 { "tvar", tvar_attributes
, NULL
,
5634 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5635 traceframe_info_start_tvar
, NULL
},
5636 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5639 static const struct gdb_xml_element traceframe_info_elements
[] = {
5640 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
5642 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5645 /* Parse a traceframe-info XML document. */
5647 struct traceframe_info
*
5648 parse_traceframe_info (const char *tframe_info
)
5650 struct traceframe_info
*result
;
5651 struct cleanup
*back_to
;
5653 result
= XCNEW (struct traceframe_info
);
5654 back_to
= make_cleanup (free_result
, result
);
5656 if (gdb_xml_parse_quick (_("trace frame info"),
5657 "traceframe-info.dtd", traceframe_info_elements
,
5658 tframe_info
, result
) == 0)
5660 /* Parsed successfully, keep the result. */
5661 discard_cleanups (back_to
);
5666 do_cleanups (back_to
);
5670 #endif /* HAVE_LIBEXPAT */
5672 /* Returns the traceframe_info object for the current traceframe.
5673 This is where we avoid re-fetching the object from the target if we
5674 already have it cached. */
5676 static struct traceframe_info
*
5677 get_traceframe_info (void)
5679 if (traceframe_info
== NULL
)
5680 traceframe_info
= target_traceframe_info ();
5682 return traceframe_info
;
5685 /* If the target supports the query, return in RESULT the set of
5686 collected memory in the current traceframe, found within the LEN
5687 bytes range starting at MEMADDR. Returns true if the target
5688 supports the query, otherwise returns false, and RESULT is left
5692 traceframe_available_memory (VEC(mem_range_s
) **result
,
5693 CORE_ADDR memaddr
, ULONGEST len
)
5695 struct traceframe_info
*info
= get_traceframe_info ();
5699 struct mem_range
*r
;
5704 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
5705 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
5707 ULONGEST lo1
, hi1
, lo2
, hi2
;
5708 struct mem_range
*nr
;
5711 hi1
= memaddr
+ len
;
5714 hi2
= r
->start
+ r
->length
;
5716 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
5718 nr
->start
= max (lo1
, lo2
);
5719 nr
->length
= min (hi1
, hi2
) - nr
->start
;
5722 normalize_mem_ranges (*result
);
5729 /* Implementation of `sdata' variable. */
5731 static const struct internalvar_funcs sdata_funcs
=
5738 /* module initialization */
5740 _initialize_tracepoint (void)
5742 struct cmd_list_element
*c
;
5744 /* Explicitly create without lookup, since that tries to create a
5745 value with a void typed value, and when we get here, gdbarch
5746 isn't initialized yet. At this point, we're quite sure there
5747 isn't another convenience variable of the same name. */
5748 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
5750 traceframe_number
= -1;
5751 tracepoint_number
= -1;
5753 add_info ("scope", scope_info
,
5754 _("List the variables local to a scope"));
5756 add_cmd ("tracepoints", class_trace
, NULL
,
5757 _("Tracing of program execution without stopping the program."),
5760 add_com ("tdump", class_trace
, trace_dump_command
,
5761 _("Print everything collected at the current tracepoint."));
5763 add_com ("tsave", class_trace
, trace_save_command
, _("\
5764 Save the trace data to a file.\n\
5765 Use the '-ctf' option to save the data to CTF format.\n\
5766 Use the '-r' option to direct the target to save directly to the file,\n\
5767 using its own filesystem."));
5769 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
5770 Define a trace state variable.\n\
5771 Argument is a $-prefixed name, optionally followed\n\
5772 by '=' and an expression that sets the initial value\n\
5773 at the start of tracing."));
5774 set_cmd_completer (c
, expression_completer
);
5776 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
5777 Delete one or more trace state variables.\n\
5778 Arguments are the names of the variables to delete.\n\
5779 If no arguments are supplied, delete all variables."), &deletelist
);
5780 /* FIXME add a trace variable completer. */
5782 add_info ("tvariables", tvariables_info
, _("\
5783 Status of trace state variables and their values.\n\
5786 add_info ("static-tracepoint-markers",
5787 info_static_tracepoint_markers_command
, _("\
5788 List target static tracepoints markers.\n\
5791 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
5792 Select a trace frame;\n\
5793 No argument means forward by one frame; '-' means backward by one frame."),
5794 &tfindlist
, "tfind ", 1, &cmdlist
);
5796 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
5797 Select a trace frame whose PC is outside the given range (exclusive).\n\
5798 Usage: tfind outside addr1, addr2"),
5801 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
5802 Select a trace frame whose PC is in the given range (inclusive).\n\
5803 Usage: tfind range addr1,addr2"),
5806 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
5807 Select a trace frame by source line.\n\
5808 Argument can be a line number (with optional source file),\n\
5809 a function name, or '*' followed by an address.\n\
5810 Default argument is 'the next source line that was traced'."),
5813 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
5814 Select a trace frame by tracepoint number.\n\
5815 Default is the tracepoint for the current trace frame."),
5818 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
5819 Select a trace frame by PC.\n\
5820 Default is the current PC, or the PC of the current trace frame."),
5823 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
5824 De-select any trace frame and resume 'live' debugging."),
5827 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
5829 add_cmd ("start", class_trace
, trace_find_start_command
,
5830 _("Select the first trace frame in the trace buffer."),
5833 add_com ("tstatus", class_trace
, trace_status_command
,
5834 _("Display the status of the current trace data collection."));
5836 add_com ("tstop", class_trace
, trace_stop_command
, _("\
5837 Stop trace data collection.\n\
5838 Usage: tstop [ <notes> ... ]\n\
5839 Any arguments supplied are recorded with the trace as a stop reason and\n\
5840 reported by tstatus (if the target supports trace notes)."));
5842 add_com ("tstart", class_trace
, trace_start_command
, _("\
5843 Start trace data collection.\n\
5844 Usage: tstart [ <notes> ... ]\n\
5845 Any arguments supplied are recorded with the trace as a note and\n\
5846 reported by tstatus (if the target supports trace notes)."));
5848 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
5849 Ends a list of commands or actions.\n\
5850 Several GDB commands allow you to enter a list of commands or actions.\n\
5851 Entering \"end\" on a line by itself is the normal way to terminate\n\
5853 Note: the \"end\" command cannot be used at the gdb prompt."));
5855 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
5856 Specify single-stepping behavior at a tracepoint.\n\
5857 Argument is number of instructions to trace in single-step mode\n\
5858 following the tracepoint. This command is normally followed by\n\
5859 one or more \"collect\" commands, to specify what to collect\n\
5860 while single-stepping.\n\n\
5861 Note: this command can only be used in a tracepoint \"actions\" list."));
5863 add_com_alias ("ws", "while-stepping", class_alias
, 0);
5864 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
5866 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
5867 Specify one or more data items to be collected at a tracepoint.\n\
5868 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5869 collect all data (variables, registers) referenced by that expression.\n\
5870 Also accepts the following special arguments:\n\
5871 $regs -- all registers.\n\
5872 $args -- all function arguments.\n\
5873 $locals -- all variables local to the block/function scope.\n\
5874 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5875 Note: this command can only be used in a tracepoint \"actions\" list."));
5877 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
5878 Specify one or more expressions to be evaluated at a tracepoint.\n\
5879 Accepts a comma-separated list of (one or more) expressions.\n\
5880 The result of each evaluation will be discarded.\n\
5881 Note: this command can only be used in a tracepoint \"actions\" list."));
5883 add_com ("actions", class_trace
, trace_actions_command
, _("\
5884 Specify the actions to be taken at a tracepoint.\n\
5885 Tracepoint actions may include collecting of specified data,\n\
5886 single-stepping, or enabling/disabling other tracepoints,\n\
5887 depending on target's capabilities."));
5889 default_collect
= xstrdup ("");
5890 add_setshow_string_cmd ("default-collect", class_trace
,
5891 &default_collect
, _("\
5892 Set the list of expressions to collect by default"), _("\
5893 Show the list of expressions to collect by default"), NULL
,
5895 &setlist
, &showlist
);
5897 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
5898 &disconnected_tracing
, _("\
5899 Set whether tracing continues after GDB disconnects."), _("\
5900 Show whether tracing continues after GDB disconnects."), _("\
5901 Use this to continue a tracing run even if GDB disconnects\n\
5902 or detaches from the target. You can reconnect later and look at\n\
5903 trace data collected in the meantime."),
5904 set_disconnected_tracing
,
5909 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
5910 &circular_trace_buffer
, _("\
5911 Set target's use of circular trace buffer."), _("\
5912 Show target's use of circular trace buffer."), _("\
5913 Use this to make the trace buffer into a circular buffer,\n\
5914 which will discard traceframes (oldest first) instead of filling\n\
5915 up and stopping the trace run."),
5916 set_circular_trace_buffer
,
5921 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class
,
5922 &trace_buffer_size
, _("\
5923 Set requested size of trace buffer."), _("\
5924 Show requested size of trace buffer."), _("\
5925 Use this to choose a size for the trace buffer. Some targets\n\
5926 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
5927 disables any attempt to set the buffer size and lets the target choose."),
5928 set_trace_buffer_size
, NULL
,
5929 &setlist
, &showlist
);
5931 add_setshow_string_cmd ("trace-user", class_trace
,
5933 Set the user name to use for current and future trace runs"), _("\
5934 Show the user name to use for current and future trace runs"), NULL
,
5935 set_trace_user
, NULL
,
5936 &setlist
, &showlist
);
5938 add_setshow_string_cmd ("trace-notes", class_trace
,
5940 Set notes string to use for current and future trace runs"), _("\
5941 Show the notes string to use for current and future trace runs"), NULL
,
5942 set_trace_notes
, NULL
,
5943 &setlist
, &showlist
);
5945 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
5946 &trace_stop_notes
, _("\
5947 Set notes string to use for future tstop commands"), _("\
5948 Show the notes string to use for future tstop commands"), NULL
,
5949 set_trace_stop_notes
, NULL
,
5950 &setlist
, &showlist
);
5954 add_target_with_completer (&tfile_ops
, filename_completer
);