1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
25 #include "expression.h"
30 #include "gdb_string.h"
32 #include "breakpoint.h"
33 #include "tracepoint.h"
36 #include "completer.h"
38 #include "dictionary.h"
40 #include "user-regs.h"
44 #include "filenames.h"
45 #include "gdbthread.h"
53 #include "exceptions.h"
54 #include "cli/cli-utils.h"
57 #include "completer.h"
58 #include "filestuff.h"
60 /* readline include files */
61 #include "readline/readline.h"
62 #include "readline/history.h"
64 /* readline defines this. */
75 /* Maximum length of an agent aexpression.
76 This accounts for the fact that packets are limited to 400 bytes
77 (which includes everything -- including the checksum), and assumes
78 the worst case of maximum length for each of the pieces of a
81 NOTE: expressions get mem2hex'ed otherwise this would be twice as
82 large. (400 - 31)/2 == 184 */
83 #define MAX_AGENT_EXPR_LEN 184
85 /* A hook used to notify the UI of tracepoint operations. */
87 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
88 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
90 extern void (*deprecated_readline_begin_hook
) (char *, ...);
91 extern char *(*deprecated_readline_hook
) (char *);
92 extern void (*deprecated_readline_end_hook
) (void);
97 This module defines the following debugger commands:
98 trace : set a tracepoint on a function, line, or address.
99 info trace : list all debugger-defined tracepoints.
100 delete trace : delete one or more tracepoints.
101 enable trace : enable one or more tracepoints.
102 disable trace : disable one or more tracepoints.
103 actions : specify actions to be taken at a tracepoint.
104 passcount : specify a pass count for a tracepoint.
105 tstart : start a trace experiment.
106 tstop : stop a trace experiment.
107 tstatus : query the status of a trace experiment.
108 tfind : find a trace frame in the trace buffer.
109 tdump : print everything collected at the current tracepoint.
110 save-tracepoints : write tracepoint setup into a file.
112 This module defines the following user-visible debugger variables:
113 $trace_frame : sequence number of trace frame currently being debugged.
114 $trace_line : source line of trace frame currently being debugged.
115 $trace_file : source file of trace frame currently being debugged.
116 $tracepoint : tracepoint number of trace frame currently being debugged.
120 /* ======= Important global variables: ======= */
122 /* The list of all trace state variables. We don't retain pointers to
123 any of these for any reason - API is by name or number only - so it
124 works to have a vector of objects. */
126 typedef struct trace_state_variable tsv_s
;
129 static VEC(tsv_s
) *tvariables
;
131 /* The next integer to assign to a variable. */
133 static int next_tsv_number
= 1;
135 /* Number of last traceframe collected. */
136 static int traceframe_number
;
138 /* Tracepoint for last traceframe collected. */
139 static int tracepoint_number
;
141 /* Symbol for function for last traceframe collected. */
142 static struct symbol
*traceframe_fun
;
144 /* Symtab and line for last traceframe collected. */
145 static struct symtab_and_line traceframe_sal
;
147 /* The traceframe info of the current traceframe. NULL if we haven't
148 yet attempted to fetch it, or if the target does not support
149 fetching this object, or if we're not inspecting a traceframe
151 static struct traceframe_info
*traceframe_info
;
153 /* Tracing command lists. */
154 static struct cmd_list_element
*tfindlist
;
156 /* List of expressions to collect by default at each tracepoint hit. */
157 char *default_collect
= "";
159 static int disconnected_tracing
;
161 /* This variable controls whether we ask the target for a linear or
162 circular trace buffer. */
164 static int circular_trace_buffer
;
166 /* This variable is the requested trace buffer size, or -1 to indicate
167 that we don't care and leave it up to the target to set a size. */
169 static int trace_buffer_size
= -1;
171 /* Textual notes applying to the current and/or future trace runs. */
173 char *trace_user
= NULL
;
175 /* Textual notes applying to the current and/or future trace runs. */
177 char *trace_notes
= NULL
;
179 /* Textual notes applying to the stopping of a trace. */
181 char *trace_stop_notes
= NULL
;
183 /* ======= Important command functions: ======= */
184 static void trace_actions_command (char *, int);
185 static void trace_start_command (char *, int);
186 static void trace_stop_command (char *, int);
187 static void trace_status_command (char *, int);
188 static void trace_find_command (char *, int);
189 static void trace_find_pc_command (char *, int);
190 static void trace_find_tracepoint_command (char *, int);
191 static void trace_find_line_command (char *, int);
192 static void trace_find_range_command (char *, int);
193 static void trace_find_outside_command (char *, int);
194 static void trace_dump_command (char *, int);
196 /* support routines */
198 struct collection_list
;
199 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
200 static char *mem2hex (gdb_byte
*, char *, int);
201 static void add_register (struct collection_list
*collection
,
204 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
205 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
207 static struct command_line
*
208 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
);
210 extern void _initialize_tracepoint (void);
212 static struct trace_status trace_status
;
214 char *stop_reason_names
[] = {
224 struct trace_status
*
225 current_trace_status (void)
227 return &trace_status
;
233 free_traceframe_info (struct traceframe_info
*info
)
237 VEC_free (mem_range_s
, info
->memory
);
243 /* Free and clear the traceframe info cache of the current
247 clear_traceframe_info (void)
249 free_traceframe_info (traceframe_info
);
250 traceframe_info
= NULL
;
253 /* Set traceframe number to NUM. */
255 set_traceframe_num (int num
)
257 traceframe_number
= num
;
258 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
261 /* Set tracepoint number to NUM. */
263 set_tracepoint_num (int num
)
265 tracepoint_number
= num
;
266 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
269 /* Set externally visible debug variables for querying/printing
270 the traceframe context (line, function, file). */
273 set_traceframe_context (struct frame_info
*trace_frame
)
277 /* Save as globals for internal use. */
278 if (trace_frame
!= NULL
279 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
281 traceframe_sal
= find_pc_line (trace_pc
, 0);
282 traceframe_fun
= find_pc_function (trace_pc
);
284 /* Save linenumber as "$trace_line", a debugger variable visible to
286 set_internalvar_integer (lookup_internalvar ("trace_line"),
287 traceframe_sal
.line
);
291 init_sal (&traceframe_sal
);
292 traceframe_fun
= NULL
;
293 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
296 /* Save func name as "$trace_func", a debugger variable visible to
298 if (traceframe_fun
== NULL
299 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
300 clear_internalvar (lookup_internalvar ("trace_func"));
302 set_internalvar_string (lookup_internalvar ("trace_func"),
303 SYMBOL_LINKAGE_NAME (traceframe_fun
));
305 /* Save file name as "$trace_file", a debugger variable visible to
307 if (traceframe_sal
.symtab
== NULL
)
308 clear_internalvar (lookup_internalvar ("trace_file"));
310 set_internalvar_string (lookup_internalvar ("trace_file"),
311 symtab_to_filename_for_display (traceframe_sal
.symtab
));
314 /* Create a new trace state variable with the given name. */
316 struct trace_state_variable
*
317 create_trace_state_variable (const char *name
)
319 struct trace_state_variable tsv
;
321 memset (&tsv
, 0, sizeof (tsv
));
322 tsv
.name
= xstrdup (name
);
323 tsv
.number
= next_tsv_number
++;
324 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
327 /* Look for a trace state variable of the given name. */
329 struct trace_state_variable
*
330 find_trace_state_variable (const char *name
)
332 struct trace_state_variable
*tsv
;
335 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
336 if (strcmp (name
, tsv
->name
) == 0)
343 delete_trace_state_variable (const char *name
)
345 struct trace_state_variable
*tsv
;
348 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
349 if (strcmp (name
, tsv
->name
) == 0)
351 observer_notify_tsv_deleted (tsv
);
353 xfree ((void *)tsv
->name
);
354 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
359 warning (_("No trace variable named \"$%s\", not deleting"), name
);
362 /* Throws an error if NAME is not valid syntax for a trace state
366 validate_trace_state_variable_name (const char *name
)
371 error (_("Must supply a non-empty variable name"));
373 /* All digits in the name is reserved for value history
375 for (p
= name
; isdigit (*p
); p
++)
378 error (_("$%s is not a valid trace state variable name"), name
);
380 for (p
= name
; isalnum (*p
) || *p
== '_'; p
++)
383 error (_("$%s is not a valid trace state variable name"), name
);
386 /* The 'tvariable' command collects a name and optional expression to
387 evaluate into an initial value. */
390 trace_variable_command (char *args
, int from_tty
)
392 struct cleanup
*old_chain
;
394 struct trace_state_variable
*tsv
;
398 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
400 /* Only allow two syntaxes; "$name" and "$name=value". */
401 p
= skip_spaces (args
);
404 error (_("Name of trace variable should start with '$'"));
407 while (isalnum (*p
) || *p
== '_')
409 name
= savestring (name
, p
- name
);
410 old_chain
= make_cleanup (xfree
, name
);
413 if (*p
!= '=' && *p
!= '\0')
414 error (_("Syntax must be $NAME [ = EXPR ]"));
416 validate_trace_state_variable_name (name
);
419 initval
= value_as_long (parse_and_eval (++p
));
421 /* If the variable already exists, just change its initial value. */
422 tsv
= find_trace_state_variable (name
);
425 if (tsv
->initial_value
!= initval
)
427 tsv
->initial_value
= initval
;
428 observer_notify_tsv_modified (tsv
);
430 printf_filtered (_("Trace state variable $%s "
431 "now has initial value %s.\n"),
432 tsv
->name
, plongest (tsv
->initial_value
));
433 do_cleanups (old_chain
);
437 /* Create a new variable. */
438 tsv
= create_trace_state_variable (name
);
439 tsv
->initial_value
= initval
;
441 observer_notify_tsv_created (tsv
);
443 printf_filtered (_("Trace state variable $%s "
444 "created, with initial value %s.\n"),
445 tsv
->name
, plongest (tsv
->initial_value
));
447 do_cleanups (old_chain
);
451 delete_trace_variable_command (char *args
, int from_tty
)
455 struct cleanup
*back_to
;
459 if (query (_("Delete all trace state variables? ")))
460 VEC_free (tsv_s
, tvariables
);
462 observer_notify_tsv_deleted (NULL
);
466 argv
= gdb_buildargv (args
);
467 back_to
= make_cleanup_freeargv (argv
);
469 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
471 if (*argv
[ix
] == '$')
472 delete_trace_state_variable (argv
[ix
] + 1);
474 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
477 do_cleanups (back_to
);
483 tvariables_info_1 (void)
485 struct trace_state_variable
*tsv
;
488 struct cleanup
*back_to
;
489 struct ui_out
*uiout
= current_uiout
;
491 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
493 printf_filtered (_("No trace state variables.\n"));
497 /* Try to acquire values from the target. */
498 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
499 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
502 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
503 count
, "trace-variables");
504 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
505 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
506 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
508 ui_out_table_body (uiout
);
510 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
512 struct cleanup
*back_to2
;
516 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
518 name
= concat ("$", tsv
->name
, (char *) NULL
);
519 make_cleanup (xfree
, name
);
520 ui_out_field_string (uiout
, "name", name
);
521 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
523 if (tsv
->value_known
)
524 c
= plongest (tsv
->value
);
525 else if (ui_out_is_mi_like_p (uiout
))
526 /* For MI, we prefer not to use magic string constants, but rather
527 omit the field completely. The difference between unknown and
528 undefined does not seem important enough to represent. */
530 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
531 /* The value is/was defined, but we don't have it. */
534 /* It is not meaningful to ask about the value. */
537 ui_out_field_string (uiout
, "current", c
);
538 ui_out_text (uiout
, "\n");
540 do_cleanups (back_to2
);
543 do_cleanups (back_to
);
546 /* List all the trace state variables. */
549 tvariables_info (char *args
, int from_tty
)
551 tvariables_info_1 ();
554 /* Stash definitions of tsvs into the given file. */
557 save_trace_state_variables (struct ui_file
*fp
)
559 struct trace_state_variable
*tsv
;
562 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
564 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
565 if (tsv
->initial_value
)
566 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
567 fprintf_unfiltered (fp
, "\n");
571 /* ACTIONS functions: */
573 /* The three functions:
574 collect_pseudocommand,
575 while_stepping_pseudocommand, and
576 end_actions_pseudocommand
577 are placeholders for "commands" that are actually ONLY to be used
578 within a tracepoint action list. If the actual function is ever called,
579 it means that somebody issued the "command" at the top level,
580 which is always an error. */
583 end_actions_pseudocommand (char *args
, int from_tty
)
585 error (_("This command cannot be used at the top level."));
589 while_stepping_pseudocommand (char *args
, int from_tty
)
591 error (_("This command can only be used in a tracepoint actions list."));
595 collect_pseudocommand (char *args
, int from_tty
)
597 error (_("This command can only be used in a tracepoint actions list."));
601 teval_pseudocommand (char *args
, int from_tty
)
603 error (_("This command can only be used in a tracepoint actions list."));
606 /* Parse any collection options, such as /s for strings. */
609 decode_agent_options (const char *exp
, int *trace_string
)
611 struct value_print_options opts
;
618 /* Call this to borrow the print elements default for collection
620 get_user_print_options (&opts
);
625 if (target_supports_string_tracing ())
627 /* Allow an optional decimal number giving an explicit maximum
628 string length, defaulting it to the "print elements" value;
629 so "collect/s80 mystr" gets at most 80 bytes of string. */
630 *trace_string
= opts
.print_max
;
632 if (*exp
>= '0' && *exp
<= '9')
633 *trace_string
= atoi (exp
);
634 while (*exp
>= '0' && *exp
<= '9')
638 error (_("Target does not support \"/s\" option for string tracing."));
641 error (_("Undefined collection format \"%c\"."), *exp
);
643 exp
= skip_spaces_const (exp
);
648 /* Enter a list of actions for a tracepoint. */
650 trace_actions_command (char *args
, int from_tty
)
652 struct tracepoint
*t
;
653 struct command_line
*l
;
655 t
= get_tracepoint_by_number (&args
, NULL
, 1);
659 xstrprintf ("Enter actions for tracepoint %d, one per line.",
661 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
663 l
= read_command_lines (tmpbuf
, from_tty
, 1,
664 check_tracepoint_command
, t
);
665 do_cleanups (cleanups
);
666 breakpoint_set_commands (&t
->base
, l
);
668 /* else just return */
671 /* Report the results of checking the agent expression, as errors or
675 report_agent_reqs_errors (struct agent_expr
*aexpr
)
677 /* All of the "flaws" are serious bytecode generation issues that
678 should never occur. */
679 if (aexpr
->flaw
!= agent_flaw_none
)
680 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
682 /* If analysis shows a stack underflow, GDB must have done something
683 badly wrong in its bytecode generation. */
684 if (aexpr
->min_height
< 0)
685 internal_error (__FILE__
, __LINE__
,
686 _("expression has min height < 0"));
688 /* Issue this error if the stack is predicted to get too deep. The
689 limit is rather arbitrary; a better scheme might be for the
690 target to report how much stack it will have available. The
691 depth roughly corresponds to parenthesization, so a limit of 20
692 amounts to 20 levels of expression nesting, which is actually
693 a pretty big hairy expression. */
694 if (aexpr
->max_height
> 20)
695 error (_("Expression is too complicated."));
698 /* worker function */
700 validate_actionline (const char *line
, struct breakpoint
*b
)
702 struct cmd_list_element
*c
;
703 struct expression
*exp
= NULL
;
704 struct cleanup
*old_chain
= NULL
;
707 struct bp_location
*loc
;
708 struct agent_expr
*aexpr
;
709 struct tracepoint
*t
= (struct tracepoint
*) b
;
711 /* If EOF is typed, *line is NULL. */
715 p
= skip_spaces_const (line
);
717 /* Symbol lookup etc. */
718 if (*p
== '\0') /* empty line: just prompt for another line. */
721 if (*p
== '#') /* comment line */
724 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
726 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
728 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
730 int trace_string
= 0;
733 p
= decode_agent_options (p
, &trace_string
);
736 { /* Repeat over a comma-separated list. */
737 QUIT
; /* Allow user to bail out with ^C. */
738 p
= skip_spaces_const (p
);
740 if (*p
== '$') /* Look for special pseudo-symbols. */
742 if (0 == strncasecmp ("reg", p
+ 1, 3)
743 || 0 == strncasecmp ("arg", p
+ 1, 3)
744 || 0 == strncasecmp ("loc", p
+ 1, 3)
745 || 0 == strncasecmp ("_ret", p
+ 1, 4)
746 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
751 /* else fall thru, treat p as an expression and parse it! */
754 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
757 exp
= parse_exp_1 (&p
, loc
->address
,
758 block_for_pc (loc
->address
), 1);
759 old_chain
= make_cleanup (free_current_contents
, &exp
);
761 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
763 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
765 error (_("constant `%s' (value %s) "
766 "will not be collected."),
767 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
768 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
770 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
771 == LOC_OPTIMIZED_OUT
)
773 error (_("`%s' is optimized away "
774 "and cannot be collected."),
775 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
779 /* We have something to collect, make sure that the expr to
780 bytecode translator can handle it and that it's not too
782 aexpr
= gen_trace_for_expr (loc
->address
, exp
, trace_string
);
783 make_cleanup_free_agent_expr (aexpr
);
785 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
786 error (_("Expression is too complicated."));
790 report_agent_reqs_errors (aexpr
);
792 do_cleanups (old_chain
);
795 while (p
&& *p
++ == ',');
798 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
801 { /* Repeat over a comma-separated list. */
802 QUIT
; /* Allow user to bail out with ^C. */
803 p
= skip_spaces_const (p
);
806 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
810 /* Only expressions are allowed for this action. */
811 exp
= parse_exp_1 (&p
, loc
->address
,
812 block_for_pc (loc
->address
), 1);
813 old_chain
= make_cleanup (free_current_contents
, &exp
);
815 /* We have something to evaluate, make sure that the expr to
816 bytecode translator can handle it and that it's not too
818 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
819 make_cleanup_free_agent_expr (aexpr
);
821 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
822 error (_("Expression is too complicated."));
825 report_agent_reqs_errors (aexpr
);
827 do_cleanups (old_chain
);
830 while (p
&& *p
++ == ',');
833 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
837 p
= skip_spaces_const (p
);
838 t
->step_count
= strtol (p
, &endp
, 0);
839 if (endp
== p
|| t
->step_count
== 0)
840 error (_("while-stepping step count `%s' is malformed."), line
);
844 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
848 error (_("`%s' is not a supported tracepoint action."), line
);
852 memrange_absolute
= -1
857 int type
; /* memrange_absolute for absolute memory range,
858 else basereg number. */
859 bfd_signed_vma start
;
863 struct collection_list
865 unsigned char regs_mask
[32]; /* room for up to 256 regs */
868 struct memrange
*list
;
869 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
871 struct agent_expr
**aexpr_list
;
873 /* True is the user requested a collection of "$_sdata", "static
878 /* MEMRANGE functions: */
880 static int memrange_cmp (const void *, const void *);
882 /* Compare memranges for qsort. */
884 memrange_cmp (const void *va
, const void *vb
)
886 const struct memrange
*a
= va
, *b
= vb
;
888 if (a
->type
< b
->type
)
890 if (a
->type
> b
->type
)
892 if (a
->type
== memrange_absolute
)
894 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
896 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
901 if (a
->start
< b
->start
)
903 if (a
->start
> b
->start
)
909 /* Sort the memrange list using qsort, and merge adjacent memranges. */
911 memrange_sortmerge (struct collection_list
*memranges
)
915 qsort (memranges
->list
, memranges
->next_memrange
,
916 sizeof (struct memrange
), memrange_cmp
);
917 if (memranges
->next_memrange
> 0)
919 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
921 /* If memrange b overlaps or is adjacent to memrange a,
923 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
924 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
926 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
927 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
928 continue; /* next b, same a */
932 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
933 sizeof (struct memrange
));
935 memranges
->next_memrange
= a
+ 1;
939 /* Add a register to a collection list. */
941 add_register (struct collection_list
*collection
, unsigned int regno
)
944 printf_filtered ("collect register %d\n", regno
);
945 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
946 error (_("Internal: register number %d too large for tracepoint"),
948 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
951 /* Add a memrange to a collection list. */
953 add_memrange (struct collection_list
*memranges
,
954 int type
, bfd_signed_vma base
,
959 printf_filtered ("(%d,", type
);
961 printf_filtered (",%ld)\n", len
);
964 /* type: memrange_absolute == memory, other n == basereg */
965 memranges
->list
[memranges
->next_memrange
].type
= type
;
966 /* base: addr if memory, offset if reg relative. */
967 memranges
->list
[memranges
->next_memrange
].start
= base
;
968 /* len: we actually save end (base + len) for convenience */
969 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
970 memranges
->next_memrange
++;
971 if (memranges
->next_memrange
>= memranges
->listsize
)
973 memranges
->listsize
*= 2;
974 memranges
->list
= xrealloc (memranges
->list
,
975 memranges
->listsize
);
978 if (type
!= memrange_absolute
) /* Better collect the base register! */
979 add_register (memranges
, type
);
982 /* Add a symbol to a collection list. */
984 collect_symbol (struct collection_list
*collect
,
986 struct gdbarch
*gdbarch
,
987 long frame_regno
, long frame_offset
,
993 bfd_signed_vma offset
;
994 int treat_as_expr
= 0;
996 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
997 switch (SYMBOL_CLASS (sym
))
1000 printf_filtered ("%s: don't know symbol class %d\n",
1001 SYMBOL_PRINT_NAME (sym
),
1002 SYMBOL_CLASS (sym
));
1005 printf_filtered ("constant %s (value %s) will not be collected.\n",
1006 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
1009 offset
= SYMBOL_VALUE_ADDRESS (sym
);
1014 sprintf_vma (tmp
, offset
);
1015 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1016 SYMBOL_PRINT_NAME (sym
), len
,
1019 /* A struct may be a C++ class with static fields, go to general
1020 expression handling. */
1021 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
1024 add_memrange (collect
, memrange_absolute
, offset
, len
);
1027 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1029 printf_filtered ("LOC_REG[parm] %s: ",
1030 SYMBOL_PRINT_NAME (sym
));
1031 add_register (collect
, reg
);
1032 /* Check for doubles stored in two registers. */
1033 /* FIXME: how about larger types stored in 3 or more regs? */
1034 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1035 len
> register_size (gdbarch
, reg
))
1036 add_register (collect
, reg
+ 1);
1039 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1040 printf_filtered (" (will not collect %s)\n",
1041 SYMBOL_PRINT_NAME (sym
));
1045 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1048 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1049 SYMBOL_PRINT_NAME (sym
), len
);
1050 printf_vma (offset
);
1051 printf_filtered (" from frame ptr reg %d\n", reg
);
1053 add_memrange (collect
, reg
, offset
, len
);
1055 case LOC_REGPARM_ADDR
:
1056 reg
= SYMBOL_VALUE (sym
);
1060 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1061 SYMBOL_PRINT_NAME (sym
), len
);
1062 printf_vma (offset
);
1063 printf_filtered (" from reg %d\n", reg
);
1065 add_memrange (collect
, reg
, offset
, len
);
1069 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1072 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1073 SYMBOL_PRINT_NAME (sym
), len
);
1074 printf_vma (offset
);
1075 printf_filtered (" from frame ptr reg %d\n", reg
);
1077 add_memrange (collect
, reg
, offset
, len
);
1080 case LOC_UNRESOLVED
:
1084 case LOC_OPTIMIZED_OUT
:
1085 printf_filtered ("%s has been optimized out of existence.\n",
1086 SYMBOL_PRINT_NAME (sym
));
1094 /* Expressions are the most general case. */
1097 struct agent_expr
*aexpr
;
1098 struct cleanup
*old_chain1
= NULL
;
1100 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
, trace_string
);
1102 /* It can happen that the symbol is recorded as a computed
1103 location, but it's been optimized away and doesn't actually
1104 have a location expression. */
1107 printf_filtered ("%s has been optimized out of existence.\n",
1108 SYMBOL_PRINT_NAME (sym
));
1112 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1116 report_agent_reqs_errors (aexpr
);
1118 discard_cleanups (old_chain1
);
1119 add_aexpr (collect
, aexpr
);
1121 /* Take care of the registers. */
1122 if (aexpr
->reg_mask_len
> 0)
1126 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1128 QUIT
; /* Allow user to bail out with ^C. */
1129 if (aexpr
->reg_mask
[ndx1
] != 0)
1131 /* Assume chars have 8 bits. */
1132 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1133 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1134 /* It's used -- record it. */
1135 add_register (collect
, ndx1
* 8 + ndx2
);
1142 /* Data to be passed around in the calls to the locals and args
1145 struct add_local_symbols_data
1147 struct collection_list
*collect
;
1148 struct gdbarch
*gdbarch
;
1156 /* The callback for the locals and args iterators. */
1159 do_collect_symbol (const char *print_name
,
1163 struct add_local_symbols_data
*p
= cb_data
;
1165 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1166 p
->frame_offset
, p
->pc
, p
->trace_string
);
1170 /* Add all locals (or args) symbols to collection list. */
1172 add_local_symbols (struct collection_list
*collect
,
1173 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1174 long frame_regno
, long frame_offset
, int type
,
1177 struct block
*block
;
1178 struct add_local_symbols_data cb_data
;
1180 cb_data
.collect
= collect
;
1181 cb_data
.gdbarch
= gdbarch
;
1183 cb_data
.frame_regno
= frame_regno
;
1184 cb_data
.frame_offset
= frame_offset
;
1186 cb_data
.trace_string
= trace_string
;
1190 block
= block_for_pc (pc
);
1193 warning (_("Can't collect locals; "
1194 "no symbol table info available.\n"));
1198 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1199 if (cb_data
.count
== 0)
1200 warning (_("No locals found in scope."));
1204 pc
= get_pc_function_start (pc
);
1205 block
= block_for_pc (pc
);
1208 warning (_("Can't collect args; no symbol table info available."));
1212 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1213 if (cb_data
.count
== 0)
1214 warning (_("No args found in scope."));
1219 add_static_trace_data (struct collection_list
*collection
)
1222 printf_filtered ("collect static trace data\n");
1223 collection
->strace_data
= 1;
1226 /* worker function */
1228 clear_collection_list (struct collection_list
*list
)
1232 list
->next_memrange
= 0;
1233 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1235 free_agent_expr (list
->aexpr_list
[ndx
]);
1236 list
->aexpr_list
[ndx
] = NULL
;
1238 list
->next_aexpr_elt
= 0;
1239 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1240 list
->strace_data
= 0;
1242 xfree (list
->aexpr_list
);
1246 /* A cleanup wrapper for function clear_collection_list. */
1249 do_clear_collection_list (void *list
)
1251 struct collection_list
*l
= list
;
1253 clear_collection_list (l
);
1256 /* Initialize collection_list CLIST. */
1259 init_collection_list (struct collection_list
*clist
)
1261 memset (clist
, 0, sizeof *clist
);
1263 clist
->listsize
= 128;
1264 clist
->list
= xcalloc (clist
->listsize
,
1265 sizeof (struct memrange
));
1267 clist
->aexpr_listsize
= 128;
1268 clist
->aexpr_list
= xcalloc (clist
->aexpr_listsize
,
1269 sizeof (struct agent_expr
*));
1272 /* Reduce a collection list to string form (for gdb protocol). */
1274 stringify_collection_list (struct collection_list
*list
)
1276 char temp_buf
[2048];
1280 char *(*str_list
)[];
1284 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1285 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1287 if (list
->strace_data
)
1290 printf_filtered ("\nCollecting static trace data\n");
1293 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1297 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1298 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1300 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1303 printf_filtered ("\nCollecting registers (mask): 0x");
1308 QUIT
; /* Allow user to bail out with ^C. */
1310 printf_filtered ("%02X", list
->regs_mask
[i
]);
1311 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1314 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1318 printf_filtered ("\n");
1319 if (list
->next_memrange
> 0 && info_verbose
)
1320 printf_filtered ("Collecting memranges: \n");
1321 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1323 QUIT
; /* Allow user to bail out with ^C. */
1324 sprintf_vma (tmp2
, list
->list
[i
].start
);
1327 printf_filtered ("(%d, %s, %ld)\n",
1330 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1332 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1334 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1341 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1343 /* The "%X" conversion specifier expects an unsigned argument,
1344 so passing -1 (memrange_absolute) to it directly gives you
1345 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1347 if (list
->list
[i
].type
== memrange_absolute
)
1348 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1350 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1353 count
+= strlen (end
);
1354 end
= temp_buf
+ count
;
1357 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1359 QUIT
; /* Allow user to bail out with ^C. */
1360 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1362 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1367 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1368 end
+= 10; /* 'X' + 8 hex digits + ',' */
1371 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1372 end
, list
->aexpr_list
[i
]->len
);
1373 count
+= 2 * list
->aexpr_list
[i
]->len
;
1378 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1383 (*str_list
)[ndx
] = NULL
;
1396 encode_actions_1 (struct command_line
*action
,
1397 struct bp_location
*tloc
,
1399 LONGEST frame_offset
,
1400 struct collection_list
*collect
,
1401 struct collection_list
*stepping_list
)
1403 const char *action_exp
;
1404 struct expression
*exp
= NULL
;
1406 struct value
*tempval
;
1407 struct cmd_list_element
*cmd
;
1408 struct agent_expr
*aexpr
;
1410 for (; action
; action
= action
->next
)
1412 QUIT
; /* Allow user to bail out with ^C. */
1413 action_exp
= action
->line
;
1414 action_exp
= skip_spaces_const (action_exp
);
1416 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1418 error (_("Bad action list item: %s"), action_exp
);
1420 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1422 int trace_string
= 0;
1424 if (*action_exp
== '/')
1425 action_exp
= decode_agent_options (action_exp
, &trace_string
);
1428 { /* Repeat over a comma-separated list. */
1429 QUIT
; /* Allow user to bail out with ^C. */
1430 action_exp
= skip_spaces_const (action_exp
);
1432 if (0 == strncasecmp ("$reg", action_exp
, 4))
1434 for (i
= 0; i
< gdbarch_num_regs (tloc
->gdbarch
); i
++)
1435 add_register (collect
, i
);
1436 action_exp
= strchr (action_exp
, ','); /* more? */
1438 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1440 add_local_symbols (collect
,
1447 action_exp
= strchr (action_exp
, ','); /* more? */
1449 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1451 add_local_symbols (collect
,
1458 action_exp
= strchr (action_exp
, ','); /* more? */
1460 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1462 struct cleanup
*old_chain1
= NULL
;
1464 aexpr
= gen_trace_for_return_address (tloc
->address
,
1468 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1471 report_agent_reqs_errors (aexpr
);
1473 discard_cleanups (old_chain1
);
1474 add_aexpr (collect
, aexpr
);
1476 /* take care of the registers */
1477 if (aexpr
->reg_mask_len
> 0)
1481 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1483 QUIT
; /* allow user to bail out with ^C */
1484 if (aexpr
->reg_mask
[ndx1
] != 0)
1486 /* assume chars have 8 bits */
1487 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1488 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1489 /* it's used -- record it */
1490 add_register (collect
,
1496 action_exp
= strchr (action_exp
, ','); /* more? */
1498 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1500 add_static_trace_data (collect
);
1501 action_exp
= strchr (action_exp
, ','); /* more? */
1506 struct cleanup
*old_chain
= NULL
;
1507 struct cleanup
*old_chain1
= NULL
;
1509 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1510 block_for_pc (tloc
->address
), 1);
1511 old_chain
= make_cleanup (free_current_contents
, &exp
);
1513 switch (exp
->elts
[0].opcode
)
1517 const char *name
= &exp
->elts
[2].string
;
1519 i
= user_reg_map_name_to_regnum (tloc
->gdbarch
,
1520 name
, strlen (name
));
1522 internal_error (__FILE__
, __LINE__
,
1523 _("Register $%s not available"),
1526 printf_filtered ("OP_REGISTER: ");
1527 add_register (collect
, i
);
1532 /* Safe because we know it's a simple expression. */
1533 tempval
= evaluate_expression (exp
);
1534 addr
= value_address (tempval
);
1535 /* Initialize the TYPE_LENGTH if it is a typedef. */
1536 check_typedef (exp
->elts
[1].type
);
1537 add_memrange (collect
, memrange_absolute
, addr
,
1538 TYPE_LENGTH (exp
->elts
[1].type
));
1542 collect_symbol (collect
,
1543 exp
->elts
[2].symbol
,
1551 default: /* Full-fledged expression. */
1552 aexpr
= gen_trace_for_expr (tloc
->address
, exp
,
1555 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1559 report_agent_reqs_errors (aexpr
);
1561 discard_cleanups (old_chain1
);
1562 add_aexpr (collect
, aexpr
);
1564 /* Take care of the registers. */
1565 if (aexpr
->reg_mask_len
> 0)
1570 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1572 QUIT
; /* Allow user to bail out with ^C. */
1573 if (aexpr
->reg_mask
[ndx1
] != 0)
1575 /* Assume chars have 8 bits. */
1576 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1577 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1578 /* It's used -- record it. */
1579 add_register (collect
,
1586 do_cleanups (old_chain
);
1589 while (action_exp
&& *action_exp
++ == ',');
1591 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1594 { /* Repeat over a comma-separated list. */
1595 QUIT
; /* Allow user to bail out with ^C. */
1596 action_exp
= skip_spaces_const (action_exp
);
1599 struct cleanup
*old_chain
= NULL
;
1600 struct cleanup
*old_chain1
= NULL
;
1602 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1603 block_for_pc (tloc
->address
), 1);
1604 old_chain
= make_cleanup (free_current_contents
, &exp
);
1606 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1607 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1610 report_agent_reqs_errors (aexpr
);
1612 discard_cleanups (old_chain1
);
1613 /* Even though we're not officially collecting, add
1614 to the collect list anyway. */
1615 add_aexpr (collect
, aexpr
);
1617 do_cleanups (old_chain
);
1620 while (action_exp
&& *action_exp
++ == ',');
1622 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1624 /* We check against nested while-stepping when setting
1625 breakpoint action, so no way to run into nested
1627 gdb_assert (stepping_list
);
1629 encode_actions_1 (action
->body_list
[0], tloc
, frame_reg
,
1630 frame_offset
, stepping_list
, NULL
);
1633 error (_("Invalid tracepoint command '%s'"), action
->line
);
1637 /* Render all actions into gdb protocol. */
1640 encode_actions (struct bp_location
*tloc
, char ***tdp_actions
,
1641 char ***stepping_actions
)
1643 char *default_collect_line
= NULL
;
1644 struct command_line
*actions
;
1645 struct command_line
*default_collect_action
= NULL
;
1647 LONGEST frame_offset
;
1648 struct cleanup
*back_to
;
1649 struct collection_list tracepoint_list
, stepping_list
;
1651 back_to
= make_cleanup (null_cleanup
, NULL
);
1653 init_collection_list (&tracepoint_list
);
1654 init_collection_list (&stepping_list
);
1656 make_cleanup (do_clear_collection_list
, &tracepoint_list
);
1657 make_cleanup (do_clear_collection_list
, &stepping_list
);
1659 *tdp_actions
= NULL
;
1660 *stepping_actions
= NULL
;
1662 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1663 tloc
->address
, &frame_reg
, &frame_offset
);
1665 actions
= all_tracepoint_actions_and_cleanup (tloc
->owner
);
1667 encode_actions_1 (actions
, tloc
, frame_reg
, frame_offset
,
1668 &tracepoint_list
, &stepping_list
);
1670 memrange_sortmerge (&tracepoint_list
);
1671 memrange_sortmerge (&stepping_list
);
1673 *tdp_actions
= stringify_collection_list (&tracepoint_list
);
1674 *stepping_actions
= stringify_collection_list (&stepping_list
);
1676 do_cleanups (back_to
);
1680 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1682 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1684 collect
->aexpr_list
=
1685 xrealloc (collect
->aexpr_list
,
1686 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1687 collect
->aexpr_listsize
*= 2;
1689 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1690 collect
->next_aexpr_elt
++;
1694 process_tracepoint_on_disconnect (void)
1696 VEC(breakpoint_p
) *tp_vec
= NULL
;
1698 struct breakpoint
*b
;
1699 int has_pending_p
= 0;
1701 /* Check whether we still have pending tracepoint. If we have, warn the
1702 user that pending tracepoint will no longer work. */
1703 tp_vec
= all_tracepoints ();
1704 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1713 struct bp_location
*loc1
;
1715 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1717 if (loc1
->shlib_disabled
)
1728 VEC_free (breakpoint_p
, tp_vec
);
1731 warning (_("Pending tracepoints will not be resolved while"
1732 " GDB is disconnected\n"));
1735 /* Reset local state of tracing. */
1738 trace_reset_local_state (void)
1740 set_traceframe_num (-1);
1741 set_tracepoint_num (-1);
1742 set_traceframe_context (NULL
);
1743 clear_traceframe_info ();
1747 start_tracing (char *notes
)
1749 VEC(breakpoint_p
) *tp_vec
= NULL
;
1751 struct breakpoint
*b
;
1752 struct trace_state_variable
*tsv
;
1753 int any_enabled
= 0, num_to_download
= 0;
1756 tp_vec
= all_tracepoints ();
1758 /* No point in tracing without any tracepoints... */
1759 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1761 VEC_free (breakpoint_p
, tp_vec
);
1762 error (_("No tracepoints defined, not starting trace"));
1765 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1767 struct tracepoint
*t
= (struct tracepoint
*) b
;
1768 struct bp_location
*loc
;
1770 if (b
->enable_state
== bp_enabled
)
1773 if ((b
->type
== bp_fast_tracepoint
1774 ? may_insert_fast_tracepoints
1775 : may_insert_tracepoints
))
1778 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1779 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1784 if (target_supports_enable_disable_tracepoint ())
1785 warning (_("No tracepoints enabled"));
1788 /* No point in tracing with only disabled tracepoints that
1789 cannot be re-enabled. */
1790 VEC_free (breakpoint_p
, tp_vec
);
1791 error (_("No tracepoints enabled, not starting trace"));
1795 if (num_to_download
<= 0)
1797 VEC_free (breakpoint_p
, tp_vec
);
1798 error (_("No tracepoints that may be downloaded, not starting trace"));
1801 target_trace_init ();
1803 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1805 struct tracepoint
*t
= (struct tracepoint
*) b
;
1806 struct bp_location
*loc
;
1807 int bp_location_downloaded
= 0;
1809 /* Clear `inserted' flag. */
1810 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1813 if ((b
->type
== bp_fast_tracepoint
1814 ? !may_insert_fast_tracepoints
1815 : !may_insert_tracepoints
))
1818 t
->number_on_target
= 0;
1820 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1822 /* Since tracepoint locations are never duplicated, `inserted'
1823 flag should be zero. */
1824 gdb_assert (!loc
->inserted
);
1826 target_download_tracepoint (loc
);
1829 bp_location_downloaded
= 1;
1832 t
->number_on_target
= b
->number
;
1834 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1835 if (loc
->probe
!= NULL
)
1836 loc
->probe
->pops
->set_semaphore (loc
->probe
, loc
->gdbarch
);
1838 if (bp_location_downloaded
)
1839 observer_notify_breakpoint_modified (b
);
1841 VEC_free (breakpoint_p
, tp_vec
);
1843 /* Send down all the trace state variables too. */
1844 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1846 target_download_trace_state_variable (tsv
);
1849 /* Tell target to treat text-like sections as transparent. */
1850 target_trace_set_readonly_regions ();
1851 /* Set some mode flags. */
1852 target_set_disconnected_tracing (disconnected_tracing
);
1853 target_set_circular_trace_buffer (circular_trace_buffer
);
1854 target_set_trace_buffer_size (trace_buffer_size
);
1857 notes
= trace_notes
;
1858 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1860 if (!ret
&& (trace_user
|| notes
))
1861 warning (_("Target does not support trace user/notes, info ignored"));
1863 /* Now insert traps and begin collecting data. */
1864 target_trace_start ();
1866 /* Reset our local state. */
1867 trace_reset_local_state ();
1868 current_trace_status()->running
= 1;
1871 /* The tstart command requests the target to start a new trace run.
1872 The command passes any arguments it has to the target verbatim, as
1873 an optional "trace note". This is useful as for instance a warning
1874 to other users if the trace runs disconnected, and you don't want
1875 anybody else messing with the target. */
1878 trace_start_command (char *args
, int from_tty
)
1880 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1882 if (current_trace_status ()->running
)
1885 && !query (_("A trace is running already. Start a new run? ")))
1886 error (_("New trace run not started."));
1889 start_tracing (args
);
1892 /* The tstop command stops the tracing run. The command passes any
1893 supplied arguments to the target verbatim as a "stop note"; if the
1894 target supports trace notes, then it will be reported back as part
1895 of the trace run's status. */
1898 trace_stop_command (char *args
, int from_tty
)
1900 if (!current_trace_status ()->running
)
1901 error (_("Trace is not running."));
1903 stop_tracing (args
);
1907 stop_tracing (char *note
)
1910 VEC(breakpoint_p
) *tp_vec
= NULL
;
1912 struct breakpoint
*t
;
1914 target_trace_stop ();
1916 tp_vec
= all_tracepoints ();
1917 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1919 struct bp_location
*loc
;
1921 if ((t
->type
== bp_fast_tracepoint
1922 ? !may_insert_fast_tracepoints
1923 : !may_insert_tracepoints
))
1926 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1928 /* GDB can be totally absent in some disconnected trace scenarios,
1929 but we don't really care if this semaphore goes out of sync.
1930 That's why we are decrementing it here, but not taking care
1932 if (loc
->probe
!= NULL
)
1933 loc
->probe
->pops
->clear_semaphore (loc
->probe
, loc
->gdbarch
);
1937 VEC_free (breakpoint_p
, tp_vec
);
1940 note
= trace_stop_notes
;
1941 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1944 warning (_("Target does not support trace notes, note ignored"));
1946 /* Should change in response to reply? */
1947 current_trace_status ()->running
= 0;
1950 /* tstatus command */
1952 trace_status_command (char *args
, int from_tty
)
1954 struct trace_status
*ts
= current_trace_status ();
1956 VEC(breakpoint_p
) *tp_vec
= NULL
;
1957 struct breakpoint
*t
;
1959 status
= target_get_trace_status (ts
);
1963 if (ts
->filename
!= NULL
)
1964 printf_filtered (_("Using a trace file.\n"));
1967 printf_filtered (_("Trace can not be run on this target.\n"));
1972 if (!ts
->running_known
)
1974 printf_filtered (_("Run/stop status is unknown.\n"));
1976 else if (ts
->running
)
1978 printf_filtered (_("Trace is running on the target.\n"));
1982 switch (ts
->stop_reason
)
1984 case trace_never_run
:
1985 printf_filtered (_("No trace has been run on the target.\n"));
1989 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1992 printf_filtered (_("Trace stopped by a tstop command.\n"));
1994 case trace_buffer_full
:
1995 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1997 case trace_disconnected
:
1998 printf_filtered (_("Trace stopped because of disconnection.\n"));
2000 case tracepoint_passcount
:
2001 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
2002 ts
->stopping_tracepoint
);
2004 case tracepoint_error
:
2005 if (ts
->stopping_tracepoint
)
2006 printf_filtered (_("Trace stopped by an "
2007 "error (%s, tracepoint %d).\n"),
2008 ts
->stop_desc
, ts
->stopping_tracepoint
);
2010 printf_filtered (_("Trace stopped by an error (%s).\n"),
2013 case trace_stop_reason_unknown
:
2014 printf_filtered (_("Trace stopped for an unknown reason.\n"));
2017 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
2023 if (ts
->traceframes_created
>= 0
2024 && ts
->traceframe_count
!= ts
->traceframes_created
)
2026 printf_filtered (_("Buffer contains %d trace "
2027 "frames (of %d created total).\n"),
2028 ts
->traceframe_count
, ts
->traceframes_created
);
2030 else if (ts
->traceframe_count
>= 0)
2032 printf_filtered (_("Collected %d trace frames.\n"),
2033 ts
->traceframe_count
);
2036 if (ts
->buffer_free
>= 0)
2038 if (ts
->buffer_size
>= 0)
2040 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2041 ts
->buffer_free
, ts
->buffer_size
);
2042 if (ts
->buffer_size
> 0)
2043 printf_filtered (_(" (%d%% full)"),
2044 ((int) ((((long long) (ts
->buffer_size
2045 - ts
->buffer_free
)) * 100)
2046 / ts
->buffer_size
)));
2047 printf_filtered (_(".\n"));
2050 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2054 if (ts
->disconnected_tracing
)
2055 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2057 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2059 if (ts
->circular_buffer
)
2060 printf_filtered (_("Trace buffer is circular.\n"));
2062 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
2063 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
2065 if (ts
->notes
&& strlen (ts
->notes
) > 0)
2066 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
2068 /* Now report on what we're doing with tfind. */
2069 if (traceframe_number
>= 0)
2070 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2071 traceframe_number
, tracepoint_number
);
2073 printf_filtered (_("Not looking at any trace frame.\n"));
2075 /* Report start/stop times if supplied. */
2080 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
2082 /* Reporting a run time is more readable than two long numbers. */
2083 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2084 (long int) ts
->start_time
/ 1000000,
2085 (long int) ts
->start_time
% 1000000,
2086 (long int) run_time
/ 1000000,
2087 (long int) run_time
% 1000000);
2090 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2091 (long int) ts
->start_time
/ 1000000,
2092 (long int) ts
->start_time
% 1000000);
2094 else if (ts
->stop_time
)
2095 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2096 (long int) ts
->stop_time
/ 1000000,
2097 (long int) ts
->stop_time
% 1000000);
2099 /* Now report any per-tracepoint status available. */
2100 tp_vec
= all_tracepoints ();
2102 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2103 target_get_tracepoint_status (t
, NULL
);
2105 VEC_free (breakpoint_p
, tp_vec
);
2108 /* Report the trace status to uiout, in a way suitable for MI, and not
2109 suitable for CLI. If ON_STOP is true, suppress a few fields that
2110 are not meaningful in the -trace-stop response.
2112 The implementation is essentially parallel to trace_status_command, but
2113 merging them will result in unreadable code. */
2115 trace_status_mi (int on_stop
)
2117 struct ui_out
*uiout
= current_uiout
;
2118 struct trace_status
*ts
= current_trace_status ();
2121 status
= target_get_trace_status (ts
);
2123 if (status
== -1 && ts
->filename
== NULL
)
2125 ui_out_field_string (uiout
, "supported", "0");
2129 if (ts
->filename
!= NULL
)
2130 ui_out_field_string (uiout
, "supported", "file");
2132 ui_out_field_string (uiout
, "supported", "1");
2134 if (ts
->filename
!= NULL
)
2135 ui_out_field_string (uiout
, "trace-file", ts
->filename
);
2137 gdb_assert (ts
->running_known
);
2141 ui_out_field_string (uiout
, "running", "1");
2143 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2144 Given that the frontend gets the status either on -trace-stop, or from
2145 -trace-status after re-connection, it does not seem like this
2146 information is necessary for anything. It is not necessary for either
2147 figuring the vital state of the target nor for navigation of trace
2148 frames. If the frontend wants to show the current state is some
2149 configure dialog, it can request the value when such dialog is
2150 invoked by the user. */
2154 char *stop_reason
= NULL
;
2155 int stopping_tracepoint
= -1;
2158 ui_out_field_string (uiout
, "running", "0");
2160 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2162 switch (ts
->stop_reason
)
2165 stop_reason
= "request";
2167 case trace_buffer_full
:
2168 stop_reason
= "overflow";
2170 case trace_disconnected
:
2171 stop_reason
= "disconnection";
2173 case tracepoint_passcount
:
2174 stop_reason
= "passcount";
2175 stopping_tracepoint
= ts
->stopping_tracepoint
;
2177 case tracepoint_error
:
2178 stop_reason
= "error";
2179 stopping_tracepoint
= ts
->stopping_tracepoint
;
2185 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2186 if (stopping_tracepoint
!= -1)
2187 ui_out_field_int (uiout
, "stopping-tracepoint",
2188 stopping_tracepoint
);
2189 if (ts
->stop_reason
== tracepoint_error
)
2190 ui_out_field_string (uiout
, "error-description",
2196 if (ts
->traceframe_count
!= -1)
2197 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2198 if (ts
->traceframes_created
!= -1)
2199 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2200 if (ts
->buffer_size
!= -1)
2201 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2202 if (ts
->buffer_free
!= -1)
2203 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2205 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2206 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2208 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2209 ui_out_field_string (uiout
, "notes", ts
->notes
);
2214 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2215 (long int) ts
->start_time
/ 1000000,
2216 (long int) ts
->start_time
% 1000000);
2217 ui_out_field_string (uiout
, "start-time", buf
);
2218 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2219 (long int) ts
->stop_time
/ 1000000,
2220 (long int) ts
->stop_time
% 1000000);
2221 ui_out_field_string (uiout
, "stop-time", buf
);
2225 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2226 user if she really wants to detach. */
2229 query_if_trace_running (int from_tty
)
2234 /* It can happen that the target that was tracing went away on its
2235 own, and we didn't notice. Get a status update, and if the
2236 current target doesn't even do tracing, then assume it's not
2238 if (target_get_trace_status (current_trace_status ()) < 0)
2239 current_trace_status ()->running
= 0;
2241 /* If running interactively, give the user the option to cancel and
2242 then decide what to do differently with the run. Scripts are
2243 just going to disconnect and let the target deal with it,
2244 according to how it's been instructed previously via
2245 disconnected-tracing. */
2246 if (current_trace_status ()->running
)
2248 process_tracepoint_on_disconnect ();
2250 if (current_trace_status ()->disconnected_tracing
)
2252 if (!query (_("Trace is running and will "
2253 "continue after detach; detach anyway? ")))
2254 error (_("Not confirmed."));
2258 if (!query (_("Trace is running but will "
2259 "stop on detach; detach anyway? ")))
2260 error (_("Not confirmed."));
2265 /* This function handles the details of what to do about an ongoing
2266 tracing run if the user has asked to detach or otherwise disconnect
2270 disconnect_tracing (void)
2272 /* Also we want to be out of tfind mode, otherwise things can get
2273 confusing upon reconnection. Just use these calls instead of
2274 full tfind_1 behavior because we're in the middle of detaching,
2275 and there's no point to updating current stack frame etc. */
2276 trace_reset_local_state ();
2279 /* Worker function for the various flavors of the tfind command. */
2281 tfind_1 (enum trace_find_type type
, int num
,
2282 CORE_ADDR addr1
, CORE_ADDR addr2
,
2285 int target_frameno
= -1, target_tracept
= -1;
2286 struct frame_id old_frame_id
= null_frame_id
;
2287 struct tracepoint
*tp
;
2288 struct ui_out
*uiout
= current_uiout
;
2290 /* Only try to get the current stack frame if we have a chance of
2291 succeeding. In particular, if we're trying to get a first trace
2292 frame while all threads are running, it's not going to succeed,
2293 so leave it with a default value and let the frame comparison
2294 below (correctly) decide to print out the source location of the
2296 if (!(type
== tfind_number
&& num
== -1)
2297 && (has_stack_frames () || traceframe_number
>= 0))
2298 old_frame_id
= get_frame_id (get_current_frame ());
2300 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2303 if (type
== tfind_number
2305 && target_frameno
== -1)
2307 /* We told the target to get out of tfind mode, and it did. */
2309 else if (target_frameno
== -1)
2311 /* A request for a non-existent trace frame has failed.
2312 Our response will be different, depending on FROM_TTY:
2314 If FROM_TTY is true, meaning that this command was
2315 typed interactively by the user, then give an error
2316 and DO NOT change the state of traceframe_number etc.
2318 However if FROM_TTY is false, meaning that we're either
2319 in a script, a loop, or a user-defined command, then
2320 DON'T give an error, but DO change the state of
2321 traceframe_number etc. to invalid.
2323 The rationalle is that if you typed the command, you
2324 might just have committed a typo or something, and you'd
2325 like to NOT lose your current debugging state. However
2326 if you're in a user-defined command or especially in a
2327 loop, then you need a way to detect that the command
2328 failed WITHOUT aborting. This allows you to write
2329 scripts that search thru the trace buffer until the end,
2330 and then continue on to do something else. */
2333 error (_("Target failed to find requested trace frame."));
2337 printf_filtered ("End of trace buffer.\n");
2338 #if 0 /* dubious now? */
2339 /* The following will not recurse, since it's
2341 trace_find_command ("-1", from_tty
);
2346 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2348 reinit_frame_cache ();
2349 target_dcache_invalidate ();
2351 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2353 if (target_frameno
!= get_traceframe_number ())
2354 observer_notify_traceframe_changed (target_frameno
, tracepoint_number
);
2356 set_current_traceframe (target_frameno
);
2358 if (target_frameno
== -1)
2359 set_traceframe_context (NULL
);
2361 set_traceframe_context (get_current_frame ());
2363 if (traceframe_number
>= 0)
2365 /* Use different branches for MI and CLI to make CLI messages
2367 if (ui_out_is_mi_like_p (uiout
))
2369 ui_out_field_string (uiout
, "found", "1");
2370 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2371 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2375 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2376 traceframe_number
, tracepoint_number
);
2381 if (ui_out_is_mi_like_p (uiout
))
2382 ui_out_field_string (uiout
, "found", "0");
2383 else if (type
== tfind_number
&& num
== -1)
2384 printf_unfiltered (_("No longer looking at any trace frame\n"));
2385 else /* This case may never occur, check. */
2386 printf_unfiltered (_("No trace frame found\n"));
2389 /* If we're in nonstop mode and getting out of looking at trace
2390 frames, there won't be any current frame to go back to and
2393 && (has_stack_frames () || traceframe_number
>= 0))
2395 enum print_what print_what
;
2397 /* NOTE: in imitation of the step command, try to determine
2398 whether we have made a transition from one function to
2399 another. If so, we'll print the "stack frame" (ie. the new
2400 function and it's arguments) -- otherwise we'll just show the
2403 if (frame_id_eq (old_frame_id
,
2404 get_frame_id (get_current_frame ())))
2405 print_what
= SRC_LINE
;
2407 print_what
= SRC_AND_LOC
;
2409 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2414 /* trace_find_command takes a trace frame number n,
2415 sends "QTFrame:<n>" to the target,
2416 and accepts a reply that may contain several optional pieces
2417 of information: a frame number, a tracepoint number, and an
2418 indication of whether this is a trap frame or a stepping frame.
2420 The minimal response is just "OK" (which indicates that the
2421 target does not give us a frame number or a tracepoint number).
2422 Instead of that, the target may send us a string containing
2424 F<hexnum> (gives the selected frame number)
2425 T<hexnum> (gives the selected tracepoint number)
2430 trace_find_command (char *args
, int from_tty
)
2431 { /* This should only be called with a numeric argument. */
2434 if (current_trace_status ()->running
2435 && current_trace_status ()->filename
== NULL
)
2436 error (_("May not look at trace frames while trace is running."));
2438 if (args
== 0 || *args
== 0)
2439 { /* TFIND with no args means find NEXT trace frame. */
2440 if (traceframe_number
== -1)
2441 frameno
= 0; /* "next" is first one. */
2443 frameno
= traceframe_number
+ 1;
2445 else if (0 == strcmp (args
, "-"))
2447 if (traceframe_number
== -1)
2448 error (_("not debugging trace buffer"));
2449 else if (from_tty
&& traceframe_number
== 0)
2450 error (_("already at start of trace buffer"));
2452 frameno
= traceframe_number
- 1;
2454 /* A hack to work around eval's need for fp to have been collected. */
2455 else if (0 == strcmp (args
, "-1"))
2458 frameno
= parse_and_eval_long (args
);
2461 error (_("invalid input (%d is less than zero)"), frameno
);
2463 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2468 trace_find_end_command (char *args
, int from_tty
)
2470 trace_find_command ("-1", from_tty
);
2475 trace_find_start_command (char *args
, int from_tty
)
2477 trace_find_command ("0", from_tty
);
2480 /* tfind pc command */
2482 trace_find_pc_command (char *args
, int from_tty
)
2486 if (current_trace_status ()->running
2487 && current_trace_status ()->filename
== NULL
)
2488 error (_("May not look at trace frames while trace is running."));
2490 if (args
== 0 || *args
== 0)
2491 pc
= regcache_read_pc (get_current_regcache ());
2493 pc
= parse_and_eval_address (args
);
2495 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2498 /* tfind tracepoint command */
2500 trace_find_tracepoint_command (char *args
, int from_tty
)
2503 struct tracepoint
*tp
;
2505 if (current_trace_status ()->running
2506 && current_trace_status ()->filename
== NULL
)
2507 error (_("May not look at trace frames while trace is running."));
2509 if (args
== 0 || *args
== 0)
2511 if (tracepoint_number
== -1)
2512 error (_("No current tracepoint -- please supply an argument."));
2514 tdp
= tracepoint_number
; /* Default is current TDP. */
2517 tdp
= parse_and_eval_long (args
);
2519 /* If we have the tracepoint on hand, use the number that the
2520 target knows about (which may be different if we disconnected
2521 and reconnected). */
2522 tp
= get_tracepoint (tdp
);
2524 tdp
= tp
->number_on_target
;
2526 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2529 /* TFIND LINE command:
2531 This command will take a sourceline for argument, just like BREAK
2532 or TRACE (ie. anything that "decode_line_1" can handle).
2534 With no argument, this command will find the next trace frame
2535 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2538 trace_find_line_command (char *args
, int from_tty
)
2540 static CORE_ADDR start_pc
, end_pc
;
2541 struct symtabs_and_lines sals
;
2542 struct symtab_and_line sal
;
2543 struct cleanup
*old_chain
;
2545 if (current_trace_status ()->running
2546 && current_trace_status ()->filename
== NULL
)
2547 error (_("May not look at trace frames while trace is running."));
2549 if (args
== 0 || *args
== 0)
2551 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2553 sals
.sals
= (struct symtab_and_line
*)
2554 xmalloc (sizeof (struct symtab_and_line
));
2559 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2563 old_chain
= make_cleanup (xfree
, sals
.sals
);
2564 if (sal
.symtab
== 0)
2565 error (_("No line number information available."));
2567 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2569 if (start_pc
== end_pc
)
2571 printf_filtered ("Line %d of \"%s\"",
2573 symtab_to_filename_for_display (sal
.symtab
));
2575 printf_filtered (" is at address ");
2576 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2578 printf_filtered (" but contains no code.\n");
2579 sal
= find_pc_line (start_pc
, 0);
2581 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2582 && start_pc
!= end_pc
)
2583 printf_filtered ("Attempting to find line %d instead.\n",
2586 error (_("Cannot find a good line."));
2590 /* Is there any case in which we get here, and have an address
2591 which the user would want to see? If we have debugging
2592 symbols and no line numbers? */
2593 error (_("Line number %d is out of range for \"%s\"."),
2594 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2596 /* Find within range of stated line. */
2598 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2600 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2601 do_cleanups (old_chain
);
2604 /* tfind range command */
2606 trace_find_range_command (char *args
, int from_tty
)
2608 static CORE_ADDR start
, stop
;
2611 if (current_trace_status ()->running
2612 && current_trace_status ()->filename
== NULL
)
2613 error (_("May not look at trace frames while trace is running."));
2615 if (args
== 0 || *args
== 0)
2616 { /* XXX FIXME: what should default behavior be? */
2617 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2621 if (0 != (tmp
= strchr (args
, ',')))
2623 *tmp
++ = '\0'; /* Terminate start address. */
2624 tmp
= skip_spaces (tmp
);
2625 start
= parse_and_eval_address (args
);
2626 stop
= parse_and_eval_address (tmp
);
2629 { /* No explicit end address? */
2630 start
= parse_and_eval_address (args
);
2631 stop
= start
+ 1; /* ??? */
2634 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2637 /* tfind outside command */
2639 trace_find_outside_command (char *args
, int from_tty
)
2641 CORE_ADDR start
, stop
;
2644 if (current_trace_status ()->running
2645 && current_trace_status ()->filename
== NULL
)
2646 error (_("May not look at trace frames while trace is running."));
2648 if (args
== 0 || *args
== 0)
2649 { /* XXX FIXME: what should default behavior be? */
2650 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2654 if (0 != (tmp
= strchr (args
, ',')))
2656 *tmp
++ = '\0'; /* Terminate start address. */
2657 tmp
= skip_spaces (tmp
);
2658 start
= parse_and_eval_address (args
);
2659 stop
= parse_and_eval_address (tmp
);
2662 { /* No explicit end address? */
2663 start
= parse_and_eval_address (args
);
2664 stop
= start
+ 1; /* ??? */
2667 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2670 /* info scope command: list the locals for a scope. */
2672 scope_info (char *args
, int from_tty
)
2674 struct symtabs_and_lines sals
;
2676 struct minimal_symbol
*msym
;
2677 struct block
*block
;
2678 const char *symname
;
2679 char *save_args
= args
;
2680 struct block_iterator iter
;
2682 struct gdbarch
*gdbarch
;
2685 if (args
== 0 || *args
== 0)
2686 error (_("requires an argument (function, "
2687 "line or *addr) to define a scope"));
2689 sals
= decode_line_1 (&args
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2690 if (sals
.nelts
== 0)
2691 return; /* Presumably decode_line_1 has already warned. */
2693 /* Resolve line numbers to PC. */
2694 resolve_sal_pc (&sals
.sals
[0]);
2695 block
= block_for_pc (sals
.sals
[0].pc
);
2699 QUIT
; /* Allow user to bail out with ^C. */
2700 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2702 QUIT
; /* Allow user to bail out with ^C. */
2704 printf_filtered ("Scope for %s:\n", save_args
);
2707 symname
= SYMBOL_PRINT_NAME (sym
);
2708 if (symname
== NULL
|| *symname
== '\0')
2709 continue; /* Probably botched, certainly useless. */
2711 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2713 printf_filtered ("Symbol %s is ", symname
);
2715 if (SYMBOL_COMPUTED_OPS (sym
) != NULL
)
2716 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2717 BLOCK_START (block
),
2721 switch (SYMBOL_CLASS (sym
))
2724 case LOC_UNDEF
: /* Messed up symbol? */
2725 printf_filtered ("a bogus symbol, class %d.\n",
2726 SYMBOL_CLASS (sym
));
2727 count
--; /* Don't count this one. */
2730 printf_filtered ("a constant with value %s (%s)",
2731 plongest (SYMBOL_VALUE (sym
)),
2732 hex_string (SYMBOL_VALUE (sym
)));
2734 case LOC_CONST_BYTES
:
2735 printf_filtered ("constant bytes: ");
2736 if (SYMBOL_TYPE (sym
))
2737 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2738 fprintf_filtered (gdb_stdout
, " %02x",
2739 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2742 printf_filtered ("in static storage at address ");
2743 printf_filtered ("%s", paddress (gdbarch
,
2744 SYMBOL_VALUE_ADDRESS (sym
)));
2747 /* GDBARCH is the architecture associated with the objfile
2748 the symbol is defined in; the target architecture may be
2749 different, and may provide additional registers. However,
2750 we do not know the target architecture at this point.
2751 We assume the objfile architecture will contain all the
2752 standard registers that occur in debug info in that
2754 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2757 if (SYMBOL_IS_ARGUMENT (sym
))
2758 printf_filtered ("an argument in register $%s",
2759 gdbarch_register_name (gdbarch
, regno
));
2761 printf_filtered ("a local variable in register $%s",
2762 gdbarch_register_name (gdbarch
, regno
));
2765 printf_filtered ("an argument at stack/frame offset %s",
2766 plongest (SYMBOL_VALUE (sym
)));
2769 printf_filtered ("a local variable at frame offset %s",
2770 plongest (SYMBOL_VALUE (sym
)));
2773 printf_filtered ("a reference argument at offset %s",
2774 plongest (SYMBOL_VALUE (sym
)));
2776 case LOC_REGPARM_ADDR
:
2777 /* Note comment at LOC_REGISTER. */
2778 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2780 printf_filtered ("the address of an argument, in register $%s",
2781 gdbarch_register_name (gdbarch
, regno
));
2784 printf_filtered ("a typedef.\n");
2787 printf_filtered ("a label at address ");
2788 printf_filtered ("%s", paddress (gdbarch
,
2789 SYMBOL_VALUE_ADDRESS (sym
)));
2792 printf_filtered ("a function at address ");
2793 printf_filtered ("%s",
2794 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2796 case LOC_UNRESOLVED
:
2797 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2800 printf_filtered ("Unresolved Static");
2803 printf_filtered ("static storage at address ");
2804 printf_filtered ("%s",
2806 SYMBOL_VALUE_ADDRESS (msym
)));
2809 case LOC_OPTIMIZED_OUT
:
2810 printf_filtered ("optimized out.\n");
2813 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2816 if (SYMBOL_TYPE (sym
))
2817 printf_filtered (", length %d.\n",
2818 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2820 if (BLOCK_FUNCTION (block
))
2823 block
= BLOCK_SUPERBLOCK (block
);
2826 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2830 /* Helper for trace_dump_command. Dump the action list starting at
2831 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2832 actions of the body of a while-stepping action. STEPPING_FRAME is
2833 set if the current traceframe was determined to be a while-stepping
2837 trace_dump_actions (struct command_line
*action
,
2838 int stepping_actions
, int stepping_frame
,
2841 const char *action_exp
, *next_comma
;
2843 for (; action
!= NULL
; action
= action
->next
)
2845 struct cmd_list_element
*cmd
;
2847 QUIT
; /* Allow user to bail out with ^C. */
2848 action_exp
= action
->line
;
2849 action_exp
= skip_spaces_const (action_exp
);
2851 /* The collection actions to be done while stepping are
2852 bracketed by the commands "while-stepping" and "end". */
2854 if (*action_exp
== '#') /* comment line */
2857 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2859 error (_("Bad action list item: %s"), action_exp
);
2861 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2865 for (i
= 0; i
< action
->body_count
; ++i
)
2866 trace_dump_actions (action
->body_list
[i
],
2867 1, stepping_frame
, from_tty
);
2869 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2871 /* Display the collected data.
2872 For the trap frame, display only what was collected at
2873 the trap. Likewise for stepping frames, display only
2874 what was collected while stepping. This means that the
2875 two boolean variables, STEPPING_FRAME and
2876 STEPPING_ACTIONS should be equal. */
2877 if (stepping_frame
== stepping_actions
)
2880 struct cleanup
*old_chain
2881 = make_cleanup (free_current_contents
, &cmd
);
2882 int trace_string
= 0;
2884 if (*action_exp
== '/')
2885 action_exp
= decode_agent_options (action_exp
, &trace_string
);
2888 { /* Repeat over a comma-separated list. */
2889 QUIT
; /* Allow user to bail out with ^C. */
2890 if (*action_exp
== ',')
2892 action_exp
= skip_spaces_const (action_exp
);
2894 next_comma
= strchr (action_exp
, ',');
2896 if (0 == strncasecmp (action_exp
, "$reg", 4))
2897 registers_info (NULL
, from_tty
);
2898 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2900 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2901 locals_info (NULL
, from_tty
);
2902 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2903 args_info (NULL
, from_tty
);
2906 if (next_comma
!= NULL
)
2908 size_t len
= next_comma
- action_exp
;
2910 cmd
= xrealloc (cmd
, len
+ 1);
2911 memcpy (cmd
, action_exp
, len
);
2916 size_t len
= strlen (action_exp
);
2918 cmd
= xrealloc (cmd
, len
+ 1);
2919 memcpy (cmd
, action_exp
, len
+ 1);
2922 printf_filtered ("%s = ", cmd
);
2923 output_command_const (cmd
, from_tty
);
2924 printf_filtered ("\n");
2926 action_exp
= next_comma
;
2928 while (action_exp
&& *action_exp
== ',');
2930 do_cleanups (old_chain
);
2936 /* Return bp_location of the tracepoint associated with the current
2937 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2938 is a stepping traceframe. */
2940 static struct bp_location
*
2941 get_traceframe_location (int *stepping_frame_p
)
2943 struct tracepoint
*t
;
2944 struct bp_location
*tloc
;
2945 struct regcache
*regcache
;
2947 if (tracepoint_number
== -1)
2948 error (_("No current trace frame."));
2950 t
= get_tracepoint (tracepoint_number
);
2953 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2956 /* The current frame is a trap frame if the frame PC is equal to the
2957 tracepoint PC. If not, then the current frame was collected
2958 during single-stepping. */
2959 regcache
= get_current_regcache ();
2961 /* If the traceframe's address matches any of the tracepoint's
2962 locations, assume it is a direct hit rather than a while-stepping
2963 frame. (FIXME this is not reliable, should record each frame's
2965 for (tloc
= t
->base
.loc
; tloc
; tloc
= tloc
->next
)
2966 if (tloc
->address
== regcache_read_pc (regcache
))
2968 *stepping_frame_p
= 0;
2972 /* If this is a stepping frame, we don't know which location
2973 triggered. The first is as good (or bad) a guess as any... */
2974 *stepping_frame_p
= 1;
2978 /* Return all the actions, including default collect, of a tracepoint
2979 T. It constructs cleanups into the chain, and leaves the caller to
2980 handle them (call do_cleanups). */
2982 static struct command_line
*
2983 all_tracepoint_actions_and_cleanup (struct breakpoint
*t
)
2985 struct command_line
*actions
;
2987 actions
= breakpoint_commands (t
);
2989 /* If there are default expressions to collect, make up a collect
2990 action and prepend to the action list to encode. Note that since
2991 validation is per-tracepoint (local var "xyz" might be valid for
2992 one tracepoint and not another, etc), we make up the action on
2993 the fly, and don't cache it. */
2994 if (*default_collect
)
2996 struct command_line
*default_collect_action
;
2997 char *default_collect_line
;
2999 default_collect_line
= xstrprintf ("collect %s", default_collect
);
3000 make_cleanup (xfree
, default_collect_line
);
3002 validate_actionline (default_collect_line
, t
);
3003 default_collect_action
= xmalloc (sizeof (struct command_line
));
3004 make_cleanup (xfree
, default_collect_action
);
3005 default_collect_action
->next
= actions
;
3006 default_collect_action
->line
= default_collect_line
;
3007 actions
= default_collect_action
;
3013 /* The tdump command. */
3016 trace_dump_command (char *args
, int from_tty
)
3018 int stepping_frame
= 0;
3019 struct bp_location
*loc
;
3020 struct cleanup
*old_chain
;
3021 struct command_line
*actions
;
3023 /* This throws an error is not inspecting a trace frame. */
3024 loc
= get_traceframe_location (&stepping_frame
);
3026 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
3027 tracepoint_number
, traceframe_number
);
3029 old_chain
= make_cleanup (null_cleanup
, NULL
);
3030 actions
= all_tracepoint_actions_and_cleanup (loc
->owner
);
3032 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
3034 do_cleanups (old_chain
);
3037 /* Encode a piece of a tracepoint's source-level definition in a form
3038 that is suitable for both protocol and saving in files. */
3039 /* This version does not do multiple encodes for long strings; it should
3040 return an offset to the next piece to encode. FIXME */
3043 encode_source_string (int tpnum
, ULONGEST addr
,
3044 char *srctype
, char *src
, char *buf
, int buf_size
)
3046 if (80 + strlen (srctype
) > buf_size
)
3047 error (_("Buffer too small for source encoding"));
3048 sprintf (buf
, "%x:%s:%s:%x:%x:",
3049 tpnum
, phex_nz (addr
, sizeof (addr
)),
3050 srctype
, 0, (int) strlen (src
));
3051 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
3052 error (_("Source string too long for buffer"));
3053 bin2hex ((gdb_byte
*) src
, buf
+ strlen (buf
), 0);
3057 /* Free trace file writer. */
3060 trace_file_writer_xfree (void *arg
)
3062 struct trace_file_writer
*writer
= arg
;
3064 writer
->ops
->dtor (writer
);
3068 /* TFILE trace writer. */
3070 struct tfile_trace_file_writer
3072 struct trace_file_writer base
;
3074 /* File pointer to tfile trace file. */
3076 /* Path name of the tfile trace file. */
3080 /* This is the implementation of trace_file_write_ops method
3081 target_save. We just call the generic target
3082 target_save_trace_data to do target-side saving. */
3085 tfile_target_save (struct trace_file_writer
*self
,
3086 const char *filename
)
3088 int err
= target_save_trace_data (filename
);
3093 /* This is the implementation of trace_file_write_ops method
3097 tfile_dtor (struct trace_file_writer
*self
)
3099 struct tfile_trace_file_writer
*writer
3100 = (struct tfile_trace_file_writer
*) self
;
3102 xfree (writer
->pathname
);
3104 if (writer
->fp
!= NULL
)
3105 fclose (writer
->fp
);
3108 /* This is the implementation of trace_file_write_ops method
3109 start. It creates the trace file FILENAME and registers some
3113 tfile_start (struct trace_file_writer
*self
, const char *filename
)
3115 struct tfile_trace_file_writer
*writer
3116 = (struct tfile_trace_file_writer
*) self
;
3118 writer
->pathname
= tilde_expand (filename
);
3119 writer
->fp
= gdb_fopen_cloexec (writer
->pathname
, "wb");
3120 if (writer
->fp
== NULL
)
3121 error (_("Unable to open file '%s' for saving trace data (%s)"),
3122 filename
, safe_strerror (errno
));
3125 /* This is the implementation of trace_file_write_ops method
3126 write_header. Write the TFILE header. */
3129 tfile_write_header (struct trace_file_writer
*self
)
3131 struct tfile_trace_file_writer
*writer
3132 = (struct tfile_trace_file_writer
*) self
;
3135 /* Write a file header, with a high-bit-set char to indicate a
3136 binary file, plus a hint as what this file is, and a version
3137 number in case of future needs. */
3138 written
= fwrite ("\x7fTRACE0\n", 8, 1, writer
->fp
);
3140 perror_with_name (writer
->pathname
);
3143 /* This is the implementation of trace_file_write_ops method
3144 write_regblock_type. Write the size of register block. */
3147 tfile_write_regblock_type (struct trace_file_writer
*self
, int size
)
3149 struct tfile_trace_file_writer
*writer
3150 = (struct tfile_trace_file_writer
*) self
;
3152 fprintf (writer
->fp
, "R %x\n", size
);
3155 /* This is the implementation of trace_file_write_ops method
3159 tfile_write_status (struct trace_file_writer
*self
,
3160 struct trace_status
*ts
)
3162 struct tfile_trace_file_writer
*writer
3163 = (struct tfile_trace_file_writer
*) self
;
3165 fprintf (writer
->fp
, "status %c;%s",
3166 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
3167 if (ts
->stop_reason
== tracepoint_error
3168 || ts
->stop_reason
== tstop_command
)
3170 char *buf
= (char *) alloca (strlen (ts
->stop_desc
) * 2 + 1);
3172 bin2hex ((gdb_byte
*) ts
->stop_desc
, buf
, 0);
3173 fprintf (writer
->fp
, ":%s", buf
);
3175 fprintf (writer
->fp
, ":%x", ts
->stopping_tracepoint
);
3176 if (ts
->traceframe_count
>= 0)
3177 fprintf (writer
->fp
, ";tframes:%x", ts
->traceframe_count
);
3178 if (ts
->traceframes_created
>= 0)
3179 fprintf (writer
->fp
, ";tcreated:%x", ts
->traceframes_created
);
3180 if (ts
->buffer_free
>= 0)
3181 fprintf (writer
->fp
, ";tfree:%x", ts
->buffer_free
);
3182 if (ts
->buffer_size
>= 0)
3183 fprintf (writer
->fp
, ";tsize:%x", ts
->buffer_size
);
3184 if (ts
->disconnected_tracing
)
3185 fprintf (writer
->fp
, ";disconn:%x", ts
->disconnected_tracing
);
3186 if (ts
->circular_buffer
)
3187 fprintf (writer
->fp
, ";circular:%x", ts
->circular_buffer
);
3188 if (ts
->notes
!= NULL
)
3190 char *buf
= (char *) alloca (strlen (ts
->notes
) * 2 + 1);
3192 bin2hex ((gdb_byte
*) ts
->notes
, buf
, 0);
3193 fprintf (writer
->fp
, ";notes:%s", buf
);
3195 if (ts
->user_name
!= NULL
)
3197 char *buf
= (char *) alloca (strlen (ts
->user_name
) * 2 + 1);
3199 bin2hex ((gdb_byte
*) ts
->user_name
, buf
, 0);
3200 fprintf (writer
->fp
, ";username:%s", buf
);
3202 fprintf (writer
->fp
, "\n");
3205 /* This is the implementation of trace_file_write_ops method
3206 write_uploaded_tsv. */
3209 tfile_write_uploaded_tsv (struct trace_file_writer
*self
,
3210 struct uploaded_tsv
*utsv
)
3213 struct tfile_trace_file_writer
*writer
3214 = (struct tfile_trace_file_writer
*) self
;
3218 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
3219 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
3222 fprintf (writer
->fp
, "tsv %x:%s:%x:%s\n",
3223 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
3224 utsv
->builtin
, buf
);
3230 #define MAX_TRACE_UPLOAD 2000
3232 /* This is the implementation of trace_file_write_ops method
3233 write_uploaded_tp. */
3236 tfile_write_uploaded_tp (struct trace_file_writer
*self
,
3237 struct uploaded_tp
*utp
)
3239 struct tfile_trace_file_writer
*writer
3240 = (struct tfile_trace_file_writer
*) self
;
3243 char buf
[MAX_TRACE_UPLOAD
];
3245 fprintf (writer
->fp
, "tp T%x:%s:%c:%x:%x",
3246 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3247 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
3248 if (utp
->type
== bp_fast_tracepoint
)
3249 fprintf (writer
->fp
, ":F%x", utp
->orig_size
);
3251 fprintf (writer
->fp
,
3252 ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
3254 fprintf (writer
->fp
, "\n");
3255 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
3256 fprintf (writer
->fp
, "tp A%x:%s:%s\n",
3257 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3258 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
3259 fprintf (writer
->fp
, "tp S%x:%s:%s\n",
3260 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3263 encode_source_string (utp
->number
, utp
->addr
,
3264 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
3265 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3267 if (utp
->cond_string
)
3269 encode_source_string (utp
->number
, utp
->addr
,
3270 "cond", utp
->cond_string
,
3271 buf
, MAX_TRACE_UPLOAD
);
3272 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3274 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
3276 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
3277 buf
, MAX_TRACE_UPLOAD
);
3278 fprintf (writer
->fp
, "tp Z%s\n", buf
);
3280 fprintf (writer
->fp
, "tp V%x:%s:%x:%s\n",
3281 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3283 phex_nz (utp
->traceframe_usage
,
3284 sizeof (utp
->traceframe_usage
)));
3287 /* This is the implementation of trace_file_write_ops method
3288 write_definition_end. */
3291 tfile_write_definition_end (struct trace_file_writer
*self
)
3293 struct tfile_trace_file_writer
*writer
3294 = (struct tfile_trace_file_writer
*) self
;
3296 fprintf (writer
->fp
, "\n");
3299 /* This is the implementation of trace_file_write_ops method
3303 tfile_write_raw_data (struct trace_file_writer
*self
, gdb_byte
*buf
,
3306 struct tfile_trace_file_writer
*writer
3307 = (struct tfile_trace_file_writer
*) self
;
3309 if (fwrite (buf
, len
, 1, writer
->fp
) < 1)
3310 perror_with_name (writer
->pathname
);
3313 /* This is the implementation of trace_file_write_ops method
3317 tfile_end (struct trace_file_writer
*self
)
3319 struct tfile_trace_file_writer
*writer
3320 = (struct tfile_trace_file_writer
*) self
;
3321 uint32_t gotten
= 0;
3323 /* Mark the end of trace data. */
3324 if (fwrite (&gotten
, 4, 1, writer
->fp
) < 1)
3325 perror_with_name (writer
->pathname
);
3328 /* Operations to write trace buffers into TFILE format. */
3330 static const struct trace_file_write_ops tfile_write_ops
=
3336 tfile_write_regblock_type
,
3338 tfile_write_uploaded_tsv
,
3339 tfile_write_uploaded_tp
,
3340 tfile_write_definition_end
,
3341 tfile_write_raw_data
,
3346 /* Helper macros. */
3348 #define TRACE_WRITE_R_BLOCK(writer, buf, size) \
3349 writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
3350 #define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
3351 writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
3353 #define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
3354 writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
3356 #define TRACE_WRITE_V_BLOCK(writer, num, val) \
3357 writer->ops->frame_ops->write_v_block ((writer), (num), (val))
3359 /* Save tracepoint data to file named FILENAME through WRITER. WRITER
3360 determines the trace file format. If TARGET_DOES_SAVE is non-zero,
3361 the save is performed on the target, otherwise GDB obtains all trace
3362 data and saves it locally. */
3365 trace_save (const char *filename
, struct trace_file_writer
*writer
,
3366 int target_does_save
)
3368 struct trace_status
*ts
= current_trace_status ();
3370 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
3371 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
3373 ULONGEST offset
= 0;
3374 gdb_byte buf
[MAX_TRACE_UPLOAD
];
3375 #define MAX_TRACE_UPLOAD 2000
3377 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
3379 /* If the target is to save the data to a file on its own, then just
3380 send the command and be done with it. */
3381 if (target_does_save
)
3383 if (!writer
->ops
->target_save (writer
, filename
))
3384 error (_("Target failed to save trace data to '%s'."),
3389 /* Get the trace status first before opening the file, so if the
3390 target is losing, we can get out without touching files. */
3391 status
= target_get_trace_status (ts
);
3393 writer
->ops
->start (writer
, filename
);
3395 writer
->ops
->write_header (writer
);
3397 /* Write descriptive info. */
3399 /* Write out the size of a register block. */
3400 writer
->ops
->write_regblock_type (writer
, trace_regblock_size
);
3402 /* Write out status of the tracing run (aka "tstatus" info). */
3403 writer
->ops
->write_status (writer
, ts
);
3405 /* Note that we want to upload tracepoints and save those, rather
3406 than simply writing out the local ones, because the user may have
3407 changed tracepoints in GDB in preparation for a future tracing
3408 run, or maybe just mass-deleted all types of breakpoints as part
3409 of cleaning up. So as not to contaminate the session, leave the
3410 data in its uploaded form, don't make into real tracepoints. */
3412 /* Get trace state variables first, they may be checked when parsing
3413 uploaded commands. */
3415 target_upload_trace_state_variables (&uploaded_tsvs
);
3417 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3418 writer
->ops
->write_uploaded_tsv (writer
, utsv
);
3420 free_uploaded_tsvs (&uploaded_tsvs
);
3422 target_upload_tracepoints (&uploaded_tps
);
3424 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3425 target_get_tracepoint_status (NULL
, utp
);
3427 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3428 writer
->ops
->write_uploaded_tp (writer
, utp
);
3430 free_uploaded_tps (&uploaded_tps
);
3432 /* Mark the end of the definition section. */
3433 writer
->ops
->write_definition_end (writer
);
3435 /* Get and write the trace data proper. */
3440 /* The writer supports writing the contents of trace buffer
3441 directly to trace file. Don't parse the contents of trace
3443 if (writer
->ops
->write_trace_buffer
!= NULL
)
3445 /* We ask for big blocks, in the hopes of efficiency, but
3446 will take less if the target has packet size limitations
3448 gotten
= target_get_raw_trace_data (buf
, offset
,
3451 error (_("Failure to get requested trace buffer data"));
3452 /* No more data is forthcoming, we're done. */
3456 writer
->ops
->write_trace_buffer (writer
, buf
, gotten
);
3464 /* Parse the trace buffers according to how data are stored
3465 in trace buffer in GDBserver. */
3467 gotten
= target_get_raw_trace_data (buf
, offset
, 6);
3472 /* Read the first six bytes in, which is the tracepoint
3473 number and trace frame size. */
3475 extract_unsigned_integer (&buf
[0], 2, byte_order
);
3477 tf_size
= (uint32_t)
3478 extract_unsigned_integer (&buf
[2], 4, byte_order
);
3480 writer
->ops
->frame_ops
->start (writer
, tp_num
);
3489 for (block
= 0; block
< tf_size
; )
3491 gdb_byte block_type
;
3493 /* We'll fetch one block each time, in order to
3494 handle the extremely large 'M' block. We first
3495 fetch one byte to get the type of the block. */
3496 gotten
= target_get_raw_trace_data (buf
, offset
, 1);
3498 error (_("Failure to get requested trace buffer data"));
3504 block_type
= buf
[0];
3509 = target_get_raw_trace_data (buf
, offset
,
3510 trace_regblock_size
);
3511 if (gotten
< trace_regblock_size
)
3512 error (_("Failure to get requested trace"
3515 TRACE_WRITE_R_BLOCK (writer
, buf
,
3516 trace_regblock_size
);
3520 unsigned short mlen
;
3525 t
= target_get_raw_trace_data (buf
,offset
, 10);
3527 error (_("Failure to get requested trace"
3535 extract_unsigned_integer (buf
, 8,
3537 mlen
= (unsigned short)
3538 extract_unsigned_integer (&buf
[8], 2,
3541 TRACE_WRITE_M_BLOCK_HEADER (writer
, addr
,
3544 /* The memory contents in 'M' block may be
3545 very large. Fetch the data from the target
3546 and write them into file one by one. */
3547 for (j
= 0; j
< mlen
; )
3549 unsigned int read_length
;
3551 if (mlen
- j
> MAX_TRACE_UPLOAD
)
3552 read_length
= MAX_TRACE_UPLOAD
;
3554 read_length
= mlen
- j
;
3556 t
= target_get_raw_trace_data (buf
,
3559 if (t
< read_length
)
3560 error (_("Failure to get requested"
3561 " trace buffer data"));
3563 TRACE_WRITE_M_BLOCK_MEMORY (writer
, buf
,
3567 gotten
+= read_length
;
3578 = target_get_raw_trace_data (buf
, offset
,
3581 error (_("Failure to get requested"
3582 " trace buffer data"));
3584 vnum
= (int) extract_signed_integer (buf
,
3588 = extract_signed_integer (&buf
[4], 8,
3591 TRACE_WRITE_V_BLOCK (writer
, vnum
, val
);
3595 error (_("Unknown block type '%c' (0x%x) in"
3597 block_type
, block_type
);
3607 writer
->ops
->frame_ops
->end (writer
);
3611 writer
->ops
->end (writer
);
3614 /* Return a trace writer for TFILE format. */
3616 static struct trace_file_writer
*
3617 tfile_trace_file_writer_new (void)
3619 struct tfile_trace_file_writer
*writer
3620 = xmalloc (sizeof (struct tfile_trace_file_writer
));
3622 writer
->base
.ops
= &tfile_write_ops
;
3624 writer
->pathname
= NULL
;
3626 return (struct trace_file_writer
*) writer
;
3630 trace_save_command (char *args
, int from_tty
)
3632 int target_does_save
= 0;
3634 char *filename
= NULL
;
3635 struct cleanup
*back_to
;
3636 int generate_ctf
= 0;
3637 struct trace_file_writer
*writer
= NULL
;
3640 error_no_arg (_("file in which to save trace data"));
3642 argv
= gdb_buildargv (args
);
3643 back_to
= make_cleanup_freeargv (argv
);
3645 for (; *argv
; ++argv
)
3647 if (strcmp (*argv
, "-r") == 0)
3648 target_does_save
= 1;
3649 if (strcmp (*argv
, "-ctf") == 0)
3651 else if (**argv
== '-')
3652 error (_("unknown option `%s'"), *argv
);
3658 error_no_arg (_("file in which to save trace data"));
3661 writer
= ctf_trace_file_writer_new ();
3663 writer
= tfile_trace_file_writer_new ();
3665 make_cleanup (trace_file_writer_xfree
, writer
);
3667 trace_save (filename
, writer
, target_does_save
);
3670 printf_filtered (_("Trace data saved to %s '%s'.\n"),
3671 generate_ctf
? "directory" : "file", filename
);
3673 do_cleanups (back_to
);
3676 /* Save the trace data to file FILENAME of tfile format. */
3679 trace_save_tfile (const char *filename
, int target_does_save
)
3681 struct trace_file_writer
*writer
;
3682 struct cleanup
*back_to
;
3684 writer
= tfile_trace_file_writer_new ();
3685 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
3686 trace_save (filename
, writer
, target_does_save
);
3687 do_cleanups (back_to
);
3690 /* Save the trace data to dir DIRNAME of ctf format. */
3693 trace_save_ctf (const char *dirname
, int target_does_save
)
3695 struct trace_file_writer
*writer
;
3696 struct cleanup
*back_to
;
3698 writer
= ctf_trace_file_writer_new ();
3699 back_to
= make_cleanup (trace_file_writer_xfree
, writer
);
3701 trace_save (dirname
, writer
, target_does_save
);
3702 do_cleanups (back_to
);
3705 /* Tell the target what to do with an ongoing tracing run if GDB
3706 disconnects for some reason. */
3709 set_disconnected_tracing (char *args
, int from_tty
,
3710 struct cmd_list_element
*c
)
3712 target_set_disconnected_tracing (disconnected_tracing
);
3716 set_circular_trace_buffer (char *args
, int from_tty
,
3717 struct cmd_list_element
*c
)
3719 target_set_circular_trace_buffer (circular_trace_buffer
);
3723 set_trace_buffer_size (char *args
, int from_tty
,
3724 struct cmd_list_element
*c
)
3726 target_set_trace_buffer_size (trace_buffer_size
);
3730 set_trace_user (char *args
, int from_tty
,
3731 struct cmd_list_element
*c
)
3735 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3738 warning (_("Target does not support trace notes, user ignored"));
3742 set_trace_notes (char *args
, int from_tty
,
3743 struct cmd_list_element
*c
)
3747 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3750 warning (_("Target does not support trace notes, note ignored"));
3754 set_trace_stop_notes (char *args
, int from_tty
,
3755 struct cmd_list_element
*c
)
3759 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3762 warning (_("Target does not support trace notes, stop note ignored"));
3765 /* Convert the memory pointed to by mem into hex, placing result in buf.
3766 * Return a pointer to the last char put in buf (null)
3767 * "stolen" from sparc-stub.c
3770 static const char hexchars
[] = "0123456789abcdef";
3773 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3781 *buf
++ = hexchars
[ch
>> 4];
3782 *buf
++ = hexchars
[ch
& 0xf];
3791 get_traceframe_number (void)
3793 return traceframe_number
;
3797 get_tracepoint_number (void)
3799 return tracepoint_number
;
3802 /* Make the traceframe NUM be the current trace frame. Does nothing
3803 if NUM is already current. */
3806 set_current_traceframe (int num
)
3810 if (traceframe_number
== num
)
3812 /* Nothing to do. */
3816 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3819 warning (_("could not change traceframe"));
3821 set_traceframe_num (newnum
);
3823 /* Changing the traceframe changes our view of registers and of the
3825 registers_changed ();
3827 clear_traceframe_info ();
3830 /* Make the traceframe NUM be the current trace frame, and do nothing
3834 set_traceframe_number (int num
)
3836 traceframe_number
= num
;
3839 /* A cleanup used when switching away and back from tfind mode. */
3841 struct current_traceframe_cleanup
3843 /* The traceframe we were inspecting. */
3844 int traceframe_number
;
3848 do_restore_current_traceframe_cleanup (void *arg
)
3850 struct current_traceframe_cleanup
*old
= arg
;
3852 set_current_traceframe (old
->traceframe_number
);
3856 restore_current_traceframe_cleanup_dtor (void *arg
)
3858 struct current_traceframe_cleanup
*old
= arg
;
3864 make_cleanup_restore_current_traceframe (void)
3866 struct current_traceframe_cleanup
*old
;
3868 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3869 old
->traceframe_number
= traceframe_number
;
3871 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3872 restore_current_traceframe_cleanup_dtor
);
3876 make_cleanup_restore_traceframe_number (void)
3878 return make_cleanup_restore_integer (&traceframe_number
);
3881 /* Given a number and address, return an uploaded tracepoint with that
3882 number, creating if necessary. */
3884 struct uploaded_tp
*
3885 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3887 struct uploaded_tp
*utp
;
3889 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3890 if (utp
->number
== num
&& utp
->addr
== addr
)
3892 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3893 memset (utp
, 0, sizeof (struct uploaded_tp
));
3896 utp
->actions
= NULL
;
3897 utp
->step_actions
= NULL
;
3898 utp
->cmd_strings
= NULL
;
3905 free_uploaded_tps (struct uploaded_tp
**utpp
)
3907 struct uploaded_tp
*next_one
;
3911 next_one
= (*utpp
)->next
;
3917 /* Given a number and address, return an uploaded tracepoint with that
3918 number, creating if necessary. */
3920 struct uploaded_tsv
*
3921 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3923 struct uploaded_tsv
*utsv
;
3925 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3926 if (utsv
->number
== num
)
3928 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3929 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3931 utsv
->next
= *utsvp
;
3937 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3939 struct uploaded_tsv
*next_one
;
3943 next_one
= (*utsvp
)->next
;
3949 /* FIXME this function is heuristic and will miss the cases where the
3950 conditional is semantically identical but differs in whitespace,
3951 such as "x == 0" vs "x==0". */
3954 cond_string_is_same (char *str1
, char *str2
)
3956 if (str1
== NULL
|| str2
== NULL
)
3957 return (str1
== str2
);
3959 return (strcmp (str1
, str2
) == 0);
3962 /* Look for an existing tracepoint that seems similar enough to the
3963 uploaded one. Enablement isn't compared, because the user can
3964 toggle that freely, and may have done so in anticipation of the
3965 next trace run. Return the location of matched tracepoint. */
3967 static struct bp_location
*
3968 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3970 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3972 struct breakpoint
*b
;
3973 struct bp_location
*loc
;
3975 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3977 struct tracepoint
*t
= (struct tracepoint
*) b
;
3979 if (b
->type
== utp
->type
3980 && t
->step_count
== utp
->step
3981 && t
->pass_count
== utp
->pass
3982 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3983 /* FIXME also test actions. */
3986 /* Scan the locations for an address match. */
3987 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3989 if (loc
->address
== utp
->addr
)
3997 /* Given a list of tracepoints uploaded from a target, attempt to
3998 match them up with existing tracepoints, and create new ones if not
4002 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
4004 struct uploaded_tp
*utp
;
4005 /* A set of tracepoints which are modified. */
4006 VEC(breakpoint_p
) *modified_tp
= NULL
;
4008 struct breakpoint
*b
;
4010 /* Look for GDB tracepoints that match up with our uploaded versions. */
4011 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
4013 struct bp_location
*loc
;
4014 struct tracepoint
*t
;
4016 loc
= find_matching_tracepoint_location (utp
);
4021 /* Mark this location as already inserted. */
4023 t
= (struct tracepoint
*) loc
->owner
;
4024 printf_filtered (_("Assuming tracepoint %d is same "
4025 "as target's tracepoint %d at %s.\n"),
4026 loc
->owner
->number
, utp
->number
,
4027 paddress (loc
->gdbarch
, utp
->addr
));
4029 /* The tracepoint LOC->owner was modified (the location LOC
4030 was marked as inserted in the target). Save it in
4031 MODIFIED_TP if not there yet. The 'breakpoint-modified'
4032 observers will be notified later once for each tracepoint
4033 saved in MODIFIED_TP. */
4035 VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
);
4037 if (b
== loc
->owner
)
4043 VEC_safe_push (breakpoint_p
, modified_tp
, loc
->owner
);
4047 t
= create_tracepoint_from_upload (utp
);
4049 printf_filtered (_("Created tracepoint %d for "
4050 "target's tracepoint %d at %s.\n"),
4051 t
->base
.number
, utp
->number
,
4052 paddress (get_current_arch (), utp
->addr
));
4054 printf_filtered (_("Failed to create tracepoint for target's "
4055 "tracepoint %d at %s, skipping it.\n"),
4057 paddress (get_current_arch (), utp
->addr
));
4059 /* Whether found or created, record the number used by the
4060 target, to help with mapping target tracepoints back to their
4061 counterparts here. */
4063 t
->number_on_target
= utp
->number
;
4066 /* Notify 'breakpoint-modified' observer that at least one of B's
4067 locations was changed. */
4068 for (ix
= 0; VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
); ix
++)
4069 observer_notify_breakpoint_modified (b
);
4071 VEC_free (breakpoint_p
, modified_tp
);
4072 free_uploaded_tps (uploaded_tps
);
4075 /* Trace state variables don't have much to identify them beyond their
4076 name, so just use that to detect matches. */
4078 static struct trace_state_variable
*
4079 find_matching_tsv (struct uploaded_tsv
*utsv
)
4084 return find_trace_state_variable (utsv
->name
);
4087 static struct trace_state_variable
*
4088 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
4090 const char *namebase
;
4093 struct trace_state_variable
*tsv
;
4094 struct cleanup
*old_chain
;
4098 namebase
= utsv
->name
;
4099 buf
= xstrprintf ("%s", namebase
);
4104 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
4107 /* Fish for a name that is not in use. */
4108 /* (should check against all internal vars?) */
4109 while (find_trace_state_variable (buf
))
4112 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
4115 old_chain
= make_cleanup (xfree
, buf
);
4117 /* We have an available name, create the variable. */
4118 tsv
= create_trace_state_variable (buf
);
4119 tsv
->initial_value
= utsv
->initial_value
;
4120 tsv
->builtin
= utsv
->builtin
;
4122 observer_notify_tsv_created (tsv
);
4124 do_cleanups (old_chain
);
4129 /* Given a list of uploaded trace state variables, try to match them
4130 up with existing variables, or create additional ones. */
4133 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
4136 struct uploaded_tsv
*utsv
;
4137 struct trace_state_variable
*tsv
;
4140 /* Most likely some numbers will have to be reassigned as part of
4141 the merge, so clear them all in anticipation. */
4142 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4145 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
4147 tsv
= find_matching_tsv (utsv
);
4151 printf_filtered (_("Assuming trace state variable $%s "
4152 "is same as target's variable %d.\n"),
4153 tsv
->name
, utsv
->number
);
4157 tsv
= create_tsv_from_upload (utsv
);
4159 printf_filtered (_("Created trace state variable "
4160 "$%s for target's variable %d.\n"),
4161 tsv
->name
, utsv
->number
);
4163 /* Give precedence to numberings that come from the target. */
4165 tsv
->number
= utsv
->number
;
4168 /* Renumber everything that didn't get a target-assigned number. */
4170 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4171 if (tsv
->number
> highest
)
4172 highest
= tsv
->number
;
4175 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
4176 if (tsv
->number
== 0)
4177 tsv
->number
= highest
++;
4179 free_uploaded_tsvs (uploaded_tsvs
);
4182 /* target tfile command */
4184 static struct target_ops tfile_ops
;
4186 /* Fill in tfile_ops with its defined operations and properties. */
4188 #define TRACE_HEADER_SIZE 8
4190 static char *trace_filename
;
4191 static int trace_fd
= -1;
4192 static off_t trace_frames_offset
;
4193 static off_t cur_offset
;
4194 static int cur_data_size
;
4195 int trace_regblock_size
;
4197 static void tfile_interp_line (char *line
,
4198 struct uploaded_tp
**utpp
,
4199 struct uploaded_tsv
**utsvp
);
4201 /* Read SIZE bytes into READBUF from the trace frame, starting at
4202 TRACE_FD's current position. Note that this call `read'
4203 underneath, hence it advances the file's seek position. Throws an
4204 error if the `read' syscall fails, or less than SIZE bytes are
4208 tfile_read (gdb_byte
*readbuf
, int size
)
4212 gotten
= read (trace_fd
, readbuf
, size
);
4214 perror_with_name (trace_filename
);
4215 else if (gotten
< size
)
4216 error (_("Premature end of file while reading trace file"));
4220 tfile_open (char *filename
, int from_tty
)
4222 volatile struct gdb_exception ex
;
4224 struct cleanup
*old_chain
;
4227 char header
[TRACE_HEADER_SIZE
];
4228 char linebuf
[1000]; /* Should be max remote packet size or so. */
4231 struct trace_status
*ts
;
4232 struct uploaded_tp
*uploaded_tps
= NULL
;
4233 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
4235 target_preopen (from_tty
);
4237 error (_("No trace file specified."));
4239 filename
= tilde_expand (filename
);
4240 if (!IS_ABSOLUTE_PATH(filename
))
4242 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
4247 old_chain
= make_cleanup (xfree
, filename
);
4249 flags
= O_BINARY
| O_LARGEFILE
;
4251 scratch_chan
= gdb_open_cloexec (filename
, flags
, 0);
4252 if (scratch_chan
< 0)
4253 perror_with_name (filename
);
4255 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
4257 discard_cleanups (old_chain
); /* Don't free filename any more. */
4258 unpush_target (&tfile_ops
);
4260 trace_filename
= xstrdup (filename
);
4261 trace_fd
= scratch_chan
;
4264 /* Read the file header and test for validity. */
4265 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
4267 bytes
+= TRACE_HEADER_SIZE
;
4268 if (!(header
[0] == 0x7f
4269 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
4270 error (_("File is not a valid trace file."));
4272 push_target (&tfile_ops
);
4274 trace_regblock_size
= 0;
4275 ts
= current_trace_status ();
4276 /* We know we're working with a file. Record its name. */
4277 ts
->filename
= trace_filename
;
4278 /* Set defaults in case there is no status line. */
4279 ts
->running_known
= 0;
4280 ts
->stop_reason
= trace_stop_reason_unknown
;
4281 ts
->traceframe_count
= -1;
4282 ts
->buffer_free
= 0;
4283 ts
->disconnected_tracing
= 0;
4284 ts
->circular_buffer
= 0;
4286 TRY_CATCH (ex
, RETURN_MASK_ALL
)
4288 /* Read through a section of newline-terminated lines that
4289 define things like tracepoints. */
4293 tfile_read (&byte
, 1);
4298 /* Empty line marks end of the definition section. */
4303 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
4306 linebuf
[i
++] = byte
;
4308 error (_("Excessively long lines in trace file"));
4311 /* Record the starting offset of the binary trace data. */
4312 trace_frames_offset
= bytes
;
4314 /* If we don't have a blocksize, we can't interpret the
4316 if (trace_regblock_size
== 0)
4317 error (_("No register block size recorded in trace file"));
4321 /* Pop the partially set up target. */
4323 throw_exception (ex
);
4326 if (ts
->traceframe_count
<= 0)
4327 warning (_("No traceframes present in this file."));
4329 /* Add the file's tracepoints and variables into the current mix. */
4331 /* Get trace state variables first, they may be checked when parsing
4332 uploaded commands. */
4333 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
4335 merge_uploaded_tracepoints (&uploaded_tps
);
4338 /* Interpret the given line from the definitions part of the trace
4342 tfile_interp_line (char *line
, struct uploaded_tp
**utpp
,
4343 struct uploaded_tsv
**utsvp
)
4347 if (strncmp (p
, "R ", strlen ("R ")) == 0)
4350 trace_regblock_size
= strtol (p
, &p
, 16);
4352 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
4354 p
+= strlen ("status ");
4355 parse_trace_status (p
, current_trace_status ());
4357 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
4359 p
+= strlen ("tp ");
4360 parse_tracepoint_definition (p
, utpp
);
4362 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
4364 p
+= strlen ("tsv ");
4365 parse_tsv_definition (p
, utsvp
);
4368 warning (_("Ignoring trace file definition \"%s\""), line
);
4371 /* Parse the part of trace status syntax that is shared between
4372 the remote protocol and the trace file reader. */
4375 parse_trace_status (char *line
, struct trace_status
*ts
)
4377 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
4381 ts
->running_known
= 1;
4382 ts
->running
= (*p
++ == '1');
4383 ts
->stop_reason
= trace_stop_reason_unknown
;
4384 xfree (ts
->stop_desc
);
4385 ts
->stop_desc
= NULL
;
4386 ts
->traceframe_count
= -1;
4387 ts
->traceframes_created
= -1;
4388 ts
->buffer_free
= -1;
4389 ts
->buffer_size
= -1;
4390 ts
->disconnected_tracing
= 0;
4391 ts
->circular_buffer
= 0;
4392 xfree (ts
->user_name
);
4393 ts
->user_name
= NULL
;
4396 ts
->start_time
= ts
->stop_time
= 0;
4400 p1
= strchr (p
, ':');
4402 error (_("Malformed trace status, at %s\n\
4403 Status line: '%s'\n"), p
, line
);
4404 p3
= strchr (p
, ';');
4406 p3
= p
+ strlen (p
);
4407 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
4409 p
= unpack_varlen_hex (++p1
, &val
);
4410 ts
->stop_reason
= trace_buffer_full
;
4412 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
4414 p
= unpack_varlen_hex (++p1
, &val
);
4415 ts
->stop_reason
= trace_never_run
;
4417 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
4420 p
= unpack_varlen_hex (++p1
, &val
);
4421 ts
->stop_reason
= tracepoint_passcount
;
4422 ts
->stopping_tracepoint
= val
;
4424 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
4426 p2
= strchr (++p1
, ':');
4434 ts
->stop_desc
= xmalloc (strlen (line
));
4435 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
4436 ts
->stop_desc
[end
] = '\0';
4439 ts
->stop_desc
= xstrdup ("");
4441 p
= unpack_varlen_hex (++p2
, &val
);
4442 ts
->stop_reason
= tstop_command
;
4444 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
4446 p
= unpack_varlen_hex (++p1
, &val
);
4447 ts
->stop_reason
= trace_disconnected
;
4449 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
4451 p2
= strchr (++p1
, ':');
4454 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
4455 end
= hex2bin (p1
, (gdb_byte
*) ts
->stop_desc
, (p2
- p1
) / 2);
4456 ts
->stop_desc
[end
] = '\0';
4459 ts
->stop_desc
= xstrdup ("");
4461 p
= unpack_varlen_hex (++p2
, &val
);
4462 ts
->stopping_tracepoint
= val
;
4463 ts
->stop_reason
= tracepoint_error
;
4465 else if (strncmp (p
, "tframes", p1
- p
) == 0)
4467 p
= unpack_varlen_hex (++p1
, &val
);
4468 ts
->traceframe_count
= val
;
4470 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
4472 p
= unpack_varlen_hex (++p1
, &val
);
4473 ts
->traceframes_created
= val
;
4475 else if (strncmp (p
, "tfree", p1
- p
) == 0)
4477 p
= unpack_varlen_hex (++p1
, &val
);
4478 ts
->buffer_free
= val
;
4480 else if (strncmp (p
, "tsize", p1
- p
) == 0)
4482 p
= unpack_varlen_hex (++p1
, &val
);
4483 ts
->buffer_size
= val
;
4485 else if (strncmp (p
, "disconn", p1
- p
) == 0)
4487 p
= unpack_varlen_hex (++p1
, &val
);
4488 ts
->disconnected_tracing
= val
;
4490 else if (strncmp (p
, "circular", p1
- p
) == 0)
4492 p
= unpack_varlen_hex (++p1
, &val
);
4493 ts
->circular_buffer
= val
;
4495 else if (strncmp (p
, "starttime", p1
- p
) == 0)
4497 p
= unpack_varlen_hex (++p1
, &val
);
4498 ts
->start_time
= val
;
4500 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
4502 p
= unpack_varlen_hex (++p1
, &val
);
4503 ts
->stop_time
= val
;
4505 else if (strncmp (p
, "username", p1
- p
) == 0)
4508 ts
->user_name
= xmalloc (strlen (p
) / 2);
4509 end
= hex2bin (p1
, (gdb_byte
*) ts
->user_name
, (p3
- p1
) / 2);
4510 ts
->user_name
[end
] = '\0';
4513 else if (strncmp (p
, "notes", p1
- p
) == 0)
4516 ts
->notes
= xmalloc (strlen (p
) / 2);
4517 end
= hex2bin (p1
, (gdb_byte
*) ts
->notes
, (p3
- p1
) / 2);
4518 ts
->notes
[end
] = '\0';
4523 /* Silently skip unknown optional info. */
4524 p_temp
= strchr (p1
+ 1, ';');
4528 /* Must be at the end. */
4535 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
4536 struct uploaded_tp
*utp
)
4539 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
4541 p
= unpack_varlen_hex (p
, &uval
);
4543 tp
->base
.hit_count
+= uval
;
4545 utp
->hit_count
+= uval
;
4546 p
= unpack_varlen_hex (p
+ 1, &uval
);
4548 tp
->traceframe_usage
+= uval
;
4550 utp
->traceframe_usage
+= uval
;
4551 /* Ignore any extra, allowing for future extensions. */
4554 /* Given a line of text defining a part of a tracepoint, parse it into
4555 an "uploaded tracepoint". */
4558 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
4562 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
4565 char *cond
, *srctype
, *buf
;
4566 struct uploaded_tp
*utp
= NULL
;
4569 /* Both tracepoint and action definitions start with the same number
4570 and address sequence. */
4572 p
= unpack_varlen_hex (p
, &num
);
4573 p
++; /* skip a colon */
4574 p
= unpack_varlen_hex (p
, &addr
);
4575 p
++; /* skip a colon */
4578 enabled
= (*p
++ == 'E');
4579 p
++; /* skip a colon */
4580 p
= unpack_varlen_hex (p
, &step
);
4581 p
++; /* skip a colon */
4582 p
= unpack_varlen_hex (p
, &pass
);
4583 type
= bp_tracepoint
;
4585 /* Thumb through optional fields. */
4588 p
++; /* skip a colon */
4591 type
= bp_fast_tracepoint
;
4593 p
= unpack_varlen_hex (p
, &orig_size
);
4597 type
= bp_static_tracepoint
;
4603 p
= unpack_varlen_hex (p
, &xlen
);
4604 p
++; /* skip a comma */
4605 cond
= (char *) xmalloc (2 * xlen
+ 1);
4606 strncpy (cond
, p
, 2 * xlen
);
4607 cond
[2 * xlen
] = '\0';
4611 warning (_("Unrecognized char '%c' in tracepoint "
4612 "definition, skipping rest"), *p
);
4614 utp
= get_uploaded_tp (num
, addr
, utpp
);
4616 utp
->enabled
= enabled
;
4621 else if (piece
== 'A')
4623 utp
= get_uploaded_tp (num
, addr
, utpp
);
4624 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
4626 else if (piece
== 'S')
4628 utp
= get_uploaded_tp (num
, addr
, utpp
);
4629 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
4631 else if (piece
== 'Z')
4633 /* Parse a chunk of source form definition. */
4634 utp
= get_uploaded_tp (num
, addr
, utpp
);
4636 p
= strchr (p
, ':');
4637 p
++; /* skip a colon */
4638 p
= unpack_varlen_hex (p
, &start
);
4639 p
++; /* skip a colon */
4640 p
= unpack_varlen_hex (p
, &xlen
);
4641 p
++; /* skip a colon */
4643 buf
= alloca (strlen (line
));
4645 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4648 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
4649 utp
->at_string
= xstrdup (buf
);
4650 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
4651 utp
->cond_string
= xstrdup (buf
);
4652 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
4653 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
4655 else if (piece
== 'V')
4657 utp
= get_uploaded_tp (num
, addr
, utpp
);
4659 parse_tracepoint_status (p
, NULL
, utp
);
4663 /* Don't error out, the target might be sending us optional
4664 info that we don't care about. */
4665 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
4669 /* Convert a textual description of a trace state variable into an
4673 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
4676 ULONGEST num
, initval
, builtin
;
4678 struct uploaded_tsv
*utsv
= NULL
;
4680 buf
= alloca (strlen (line
));
4683 p
= unpack_varlen_hex (p
, &num
);
4684 p
++; /* skip a colon */
4685 p
= unpack_varlen_hex (p
, &initval
);
4686 p
++; /* skip a colon */
4687 p
= unpack_varlen_hex (p
, &builtin
);
4688 p
++; /* skip a colon */
4689 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4692 utsv
= get_uploaded_tsv (num
, utsvp
);
4693 utsv
->initial_value
= initval
;
4694 utsv
->builtin
= builtin
;
4695 utsv
->name
= xstrdup (buf
);
4698 /* Close the trace file and generally clean up. */
4710 xfree (trace_filename
);
4711 trace_filename
= NULL
;
4713 trace_reset_local_state ();
4717 tfile_files_info (struct target_ops
*t
)
4719 printf_filtered ("\t`%s'\n", trace_filename
);
4722 /* The trace status for a file is that tracing can never be run. */
4725 tfile_get_trace_status (struct trace_status
*ts
)
4727 /* Other bits of trace status were collected as part of opening the
4728 trace files, so nothing to do here. */
4734 tfile_get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
4736 /* Other bits of trace status were collected as part of opening the
4737 trace files, so nothing to do here. */
4740 /* Given the position of a traceframe in the file, figure out what
4741 address the frame was collected at. This would normally be the
4742 value of a collected PC register, but if not available, we
4746 tfile_get_traceframe_address (off_t tframe_offset
)
4750 struct tracepoint
*tp
;
4751 off_t saved_offset
= cur_offset
;
4753 /* FIXME dig pc out of collected registers. */
4755 /* Fall back to using tracepoint address. */
4756 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
4757 tfile_read ((gdb_byte
*) &tpnum
, 2);
4758 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4760 (target_gdbarch ()));
4762 tp
= get_tracepoint_by_number_on_target (tpnum
);
4763 /* FIXME this is a poor heuristic if multiple locations. */
4764 if (tp
&& tp
->base
.loc
)
4765 addr
= tp
->base
.loc
->address
;
4767 /* Restore our seek position. */
4768 cur_offset
= saved_offset
;
4769 lseek (trace_fd
, cur_offset
, SEEK_SET
);
4773 /* Given a type of search and some parameters, scan the collection of
4774 traceframes in the file looking for a match. When found, return
4775 both the traceframe and tracepoint number, otherwise -1 for
4779 tfile_trace_find (enum trace_find_type type
, int num
,
4780 CORE_ADDR addr1
, CORE_ADDR addr2
, int *tpp
)
4783 int tfnum
= 0, found
= 0;
4784 unsigned int data_size
;
4785 struct tracepoint
*tp
;
4786 off_t offset
, tframe_offset
;
4796 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
4797 offset
= trace_frames_offset
;
4800 tframe_offset
= offset
;
4801 tfile_read ((gdb_byte
*) &tpnum
, 2);
4802 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4804 (target_gdbarch ()));
4808 tfile_read ((gdb_byte
*) &data_size
, 4);
4809 data_size
= (unsigned int) extract_unsigned_integer
4810 ((gdb_byte
*) &data_size
, 4,
4811 gdbarch_byte_order (target_gdbarch ()));
4814 if (type
== tfind_number
)
4816 /* Looking for a specific trace frame. */
4822 /* Start from the _next_ trace frame. */
4823 if (tfnum
> traceframe_number
)
4828 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4829 if (tfaddr
== addr1
)
4833 tp
= get_tracepoint (num
);
4834 if (tp
&& tpnum
== tp
->number_on_target
)
4838 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4839 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
4843 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4844 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
4848 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
4857 cur_offset
= offset
;
4858 cur_data_size
= data_size
;
4862 /* Skip past the traceframe's data. */
4863 lseek (trace_fd
, data_size
, SEEK_CUR
);
4864 offset
+= data_size
;
4865 /* Update our own count of traceframes. */
4868 /* Did not find what we were looking for. */
4874 /* Prototype of the callback passed to tframe_walk_blocks. */
4875 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
4877 /* Callback for traceframe_walk_blocks, used to find a given block
4878 type in a traceframe. */
4881 match_blocktype (char blocktype
, void *data
)
4883 char *wantedp
= data
;
4885 if (*wantedp
== blocktype
)
4891 /* Walk over all traceframe block starting at POS offset from
4892 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4893 unmodified. If CALLBACK returns true, this returns the position in
4894 the traceframe where the block is found, relative to the start of
4895 the traceframe (cur_offset). Returns -1 if no callback call
4896 returned true, indicating that all blocks have been walked. */
4899 traceframe_walk_blocks (walk_blocks_callback_func callback
,
4900 int pos
, void *data
)
4902 /* Iterate through a traceframe's blocks, looking for a block of the
4905 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
4906 while (pos
< cur_data_size
)
4908 unsigned short mlen
;
4911 tfile_read ((gdb_byte
*) &block_type
, 1);
4915 if ((*callback
) (block_type
, data
))
4921 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4922 pos
+= trace_regblock_size
;
4925 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4926 tfile_read ((gdb_byte
*) &mlen
, 2);
4927 mlen
= (unsigned short)
4928 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4930 (target_gdbarch ()));
4931 lseek (trace_fd
, mlen
, SEEK_CUR
);
4932 pos
+= (8 + 2 + mlen
);
4935 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
4939 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4940 block_type
, block_type
);
4948 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4949 position offset of a block of type TYPE_WANTED in the current trace
4950 frame, starting at POS. Returns -1 if no such block was found. */
4953 traceframe_find_block_type (char type_wanted
, int pos
)
4955 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
4958 /* Look for a block of saved registers in the traceframe, and get the
4959 requested register from it. */
4962 tfile_fetch_registers (struct target_ops
*ops
,
4963 struct regcache
*regcache
, int regno
)
4965 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4966 int offset
, regn
, regsize
, pc_regno
;
4969 /* An uninitialized reg size says we're not going to be
4970 successful at getting register blocks. */
4971 if (!trace_regblock_size
)
4974 regs
= alloca (trace_regblock_size
);
4976 if (traceframe_find_block_type ('R', 0) >= 0)
4978 tfile_read (regs
, trace_regblock_size
);
4980 /* Assume the block is laid out in GDB register number order,
4981 each register with the size that it has in GDB. */
4983 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4985 regsize
= register_size (gdbarch
, regn
);
4986 /* Make sure we stay within block bounds. */
4987 if (offset
+ regsize
>= trace_regblock_size
)
4989 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
4993 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
4996 else if (regno
== -1)
4998 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
5006 /* We get here if no register data has been found. Mark registers
5008 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
5009 regcache_raw_supply (regcache
, regn
, NULL
);
5011 /* We can often usefully guess that the PC is going to be the same
5012 as the address of the tracepoint. */
5013 pc_regno
= gdbarch_pc_regnum (gdbarch
);
5014 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
5016 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
5018 if (tp
&& tp
->base
.loc
)
5020 /* But don't try to guess if tracepoint is multi-location... */
5021 if (tp
->base
.loc
->next
)
5023 warning (_("Tracepoint %d has multiple "
5024 "locations, cannot infer $pc"),
5028 /* ... or does while-stepping. */
5029 if (tp
->step_count
> 0)
5031 warning (_("Tracepoint %d does while-stepping, "
5032 "cannot infer $pc"),
5037 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
5038 gdbarch_byte_order (gdbarch
),
5039 tp
->base
.loc
->address
);
5040 regcache_raw_supply (regcache
, pc_regno
, regs
);
5046 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
5047 const char *annex
, gdb_byte
*readbuf
,
5048 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
5050 /* We're only doing regular memory for now. */
5051 if (object
!= TARGET_OBJECT_MEMORY
)
5054 if (readbuf
== NULL
)
5055 error (_("tfile_xfer_partial: trace file is read-only"));
5057 if (traceframe_number
!= -1)
5061 /* Iterate through the traceframe's blocks, looking for
5063 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
5065 ULONGEST maddr
, amt
;
5066 unsigned short mlen
;
5067 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
5069 tfile_read ((gdb_byte
*) &maddr
, 8);
5070 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
5072 tfile_read ((gdb_byte
*) &mlen
, 2);
5073 mlen
= (unsigned short)
5074 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
5076 /* If the block includes the first part of the desired
5077 range, return as much it has; GDB will re-request the
5078 remainder, which might be in a different block of this
5080 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
5082 amt
= (maddr
+ mlen
) - offset
;
5086 if (maddr
!= offset
)
5087 lseek (trace_fd
, offset
- maddr
, SEEK_CUR
);
5088 tfile_read (readbuf
, amt
);
5092 /* Skip over this block. */
5093 pos
+= (8 + 2 + mlen
);
5097 /* It's unduly pedantic to refuse to look at the executable for
5098 read-only pieces; so do the equivalent of readonly regions aka
5100 /* FIXME account for relocation at some point. */
5107 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
5109 if ((s
->flags
& SEC_LOAD
) == 0
5110 || (s
->flags
& SEC_READONLY
) == 0)
5114 size
= bfd_get_section_size (s
);
5115 if (vma
<= offset
&& offset
< (vma
+ size
))
5119 amt
= (vma
+ size
) - offset
;
5123 amt
= bfd_get_section_contents (exec_bfd
, s
,
5124 readbuf
, offset
- vma
, amt
);
5130 /* Indicate failure to find the requested memory block. */
5134 /* Iterate through the blocks of a trace frame, looking for a 'V'
5135 block with a matching tsv number. */
5138 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
5143 /* Iterate over blocks in current frame and find the last 'V'
5144 block in which tsv number is TSVNUM. In one trace frame, there
5145 may be multiple 'V' blocks created for a given trace variable,
5146 and the last matched 'V' block contains the updated value. */
5148 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
5152 tfile_read ((gdb_byte
*) &vnum
, 4);
5153 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
5155 (target_gdbarch ()));
5158 tfile_read ((gdb_byte
*) val
, 8);
5159 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
5161 (target_gdbarch ()));
5171 tfile_has_all_memory (struct target_ops
*ops
)
5177 tfile_has_memory (struct target_ops
*ops
)
5183 tfile_has_stack (struct target_ops
*ops
)
5185 return traceframe_number
!= -1;
5189 tfile_has_registers (struct target_ops
*ops
)
5191 return traceframe_number
!= -1;
5194 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
5195 object for the tfile target's current traceframe. */
5198 build_traceframe_info (char blocktype
, void *data
)
5200 struct traceframe_info
*info
= data
;
5206 struct mem_range
*r
;
5208 unsigned short mlen
;
5210 tfile_read ((gdb_byte
*) &maddr
, 8);
5211 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
5213 (target_gdbarch ()));
5214 tfile_read ((gdb_byte
*) &mlen
, 2);
5215 mlen
= (unsigned short)
5216 extract_unsigned_integer ((gdb_byte
*) &mlen
,
5217 2, gdbarch_byte_order
5218 (target_gdbarch ()));
5220 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5233 warning (_("Unhandled trace block type (%d) '%c ' "
5234 "while building trace frame info."),
5235 blocktype
, blocktype
);
5242 static struct traceframe_info
*
5243 tfile_traceframe_info (void)
5245 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
5247 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
5252 init_tfile_ops (void)
5254 tfile_ops
.to_shortname
= "tfile";
5255 tfile_ops
.to_longname
= "Local trace dump file";
5257 = "Use a trace file as a target. Specify the filename of the trace file.";
5258 tfile_ops
.to_open
= tfile_open
;
5259 tfile_ops
.to_close
= tfile_close
;
5260 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
5261 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
5262 tfile_ops
.to_files_info
= tfile_files_info
;
5263 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
5264 tfile_ops
.to_get_tracepoint_status
= tfile_get_tracepoint_status
;
5265 tfile_ops
.to_trace_find
= tfile_trace_find
;
5266 tfile_ops
.to_get_trace_state_variable_value
5267 = tfile_get_trace_state_variable_value
;
5268 tfile_ops
.to_stratum
= process_stratum
;
5269 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
5270 tfile_ops
.to_has_memory
= tfile_has_memory
;
5271 tfile_ops
.to_has_stack
= tfile_has_stack
;
5272 tfile_ops
.to_has_registers
= tfile_has_registers
;
5273 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
5274 tfile_ops
.to_magic
= OPS_MAGIC
;
5278 free_current_marker (void *arg
)
5280 struct static_tracepoint_marker
**marker_p
= arg
;
5282 if (*marker_p
!= NULL
)
5284 release_static_tracepoint_marker (*marker_p
);
5291 /* Given a line of text defining a static tracepoint marker, parse it
5292 into a "static tracepoint marker" object. Throws an error is
5293 parsing fails. If PP is non-null, it points to one past the end of
5294 the parsed marker definition. */
5297 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
5298 struct static_tracepoint_marker
*marker
)
5305 p
= unpack_varlen_hex (p
, &addr
);
5306 p
++; /* skip a colon */
5308 marker
->gdbarch
= target_gdbarch ();
5309 marker
->address
= (CORE_ADDR
) addr
;
5311 endp
= strchr (p
, ':');
5313 error (_("bad marker definition: %s"), line
);
5315 marker
->str_id
= xmalloc (endp
- p
+ 1);
5316 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
5317 marker
->str_id
[end
] = '\0';
5320 p
++; /* skip a colon */
5322 marker
->extra
= xmalloc (strlen (p
) + 1);
5323 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
5324 marker
->extra
[end
] = '\0';
5330 /* Release a static tracepoint marker's contents. Note that the
5331 object itself isn't released here. There objects are usually on
5335 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
5337 xfree (marker
->str_id
);
5338 marker
->str_id
= NULL
;
5341 /* Print MARKER to gdb_stdout. */
5344 print_one_static_tracepoint_marker (int count
,
5345 struct static_tracepoint_marker
*marker
)
5347 struct command_line
*l
;
5350 char wrap_indent
[80];
5351 char extra_field_indent
[80];
5352 struct ui_out
*uiout
= current_uiout
;
5353 struct cleanup
*bkpt_chain
;
5354 VEC(breakpoint_p
) *tracepoints
;
5356 struct symtab_and_line sal
;
5360 sal
.pc
= marker
->address
;
5362 tracepoints
= static_tracepoints_here (marker
->address
);
5364 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
5366 /* A counter field to help readability. This is not a stable
5368 ui_out_field_int (uiout
, "count", count
);
5370 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
5372 ui_out_field_fmt (uiout
, "enabled", "%c",
5373 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
5374 ui_out_spaces (uiout
, 2);
5376 strcpy (wrap_indent
, " ");
5378 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
5379 strcat (wrap_indent
, " ");
5381 strcat (wrap_indent
, " ");
5383 strcpy (extra_field_indent
, " ");
5385 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
5387 sal
= find_pc_line (marker
->address
, 0);
5388 sym
= find_pc_sect_function (marker
->address
, NULL
);
5391 ui_out_text (uiout
, "in ");
5392 ui_out_field_string (uiout
, "func",
5393 SYMBOL_PRINT_NAME (sym
));
5394 ui_out_wrap_hint (uiout
, wrap_indent
);
5395 ui_out_text (uiout
, " at ");
5398 ui_out_field_skip (uiout
, "func");
5400 if (sal
.symtab
!= NULL
)
5402 ui_out_field_string (uiout
, "file",
5403 symtab_to_filename_for_display (sal
.symtab
));
5404 ui_out_text (uiout
, ":");
5406 if (ui_out_is_mi_like_p (uiout
))
5408 const char *fullname
= symtab_to_fullname (sal
.symtab
);
5410 ui_out_field_string (uiout
, "fullname", fullname
);
5413 ui_out_field_skip (uiout
, "fullname");
5415 ui_out_field_int (uiout
, "line", sal
.line
);
5419 ui_out_field_skip (uiout
, "fullname");
5420 ui_out_field_skip (uiout
, "line");
5423 ui_out_text (uiout
, "\n");
5424 ui_out_text (uiout
, extra_field_indent
);
5425 ui_out_text (uiout
, _("Data: \""));
5426 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
5427 ui_out_text (uiout
, "\"\n");
5429 if (!VEC_empty (breakpoint_p
, tracepoints
))
5431 struct cleanup
*cleanup_chain
;
5433 struct breakpoint
*b
;
5435 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
5438 ui_out_text (uiout
, extra_field_indent
);
5439 ui_out_text (uiout
, _("Probed by static tracepoints: "));
5440 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
5443 ui_out_text (uiout
, ", ");
5444 ui_out_text (uiout
, "#");
5445 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
5448 do_cleanups (cleanup_chain
);
5450 if (ui_out_is_mi_like_p (uiout
))
5451 ui_out_field_int (uiout
, "number-of-tracepoints",
5452 VEC_length(breakpoint_p
, tracepoints
));
5454 ui_out_text (uiout
, "\n");
5456 VEC_free (breakpoint_p
, tracepoints
);
5458 do_cleanups (bkpt_chain
);
5462 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
5464 VEC(static_tracepoint_marker_p
) *markers
;
5465 struct cleanup
*old_chain
;
5466 struct static_tracepoint_marker
*marker
;
5467 struct ui_out
*uiout
= current_uiout
;
5470 /* We don't have to check target_can_use_agent and agent's capability on
5471 static tracepoint here, in order to be compatible with older GDBserver.
5472 We don't check USE_AGENT is true or not, because static tracepoints
5473 don't work without in-process agent, so we don't bother users to type
5474 `set agent on' when to use static tracepoint. */
5477 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
5478 "StaticTracepointMarkersTable");
5480 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
5482 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
5484 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
5485 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
5486 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
5488 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
5489 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
5491 ui_out_table_body (uiout
);
5493 markers
= target_static_tracepoint_markers_by_strid (NULL
);
5494 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
5497 VEC_iterate (static_tracepoint_marker_p
,
5498 markers
, i
, marker
);
5501 print_one_static_tracepoint_marker (i
+ 1, marker
);
5502 release_static_tracepoint_marker (marker
);
5505 do_cleanups (old_chain
);
5508 /* The $_sdata convenience variable is a bit special. We don't know
5509 for sure type of the value until we actually have a chance to fetch
5510 the data --- the size of the object depends on what has been
5511 collected. We solve this by making $_sdata be an internalvar that
5512 creates a new value on access. */
5514 /* Return a new value with the correct type for the sdata object of
5515 the current trace frame. Return a void value if there's no object
5518 static struct value
*
5519 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
5525 /* We need to read the whole object before we know its size. */
5526 size
= target_read_alloc (¤t_target
,
5527 TARGET_OBJECT_STATIC_TRACE_DATA
,
5534 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
5536 v
= allocate_value (type
);
5537 memcpy (value_contents_raw (v
), buf
, size
);
5542 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
5545 #if !defined(HAVE_LIBEXPAT)
5547 struct traceframe_info
*
5548 parse_traceframe_info (const char *tframe_info
)
5550 static int have_warned
;
5555 warning (_("Can not parse XML trace frame info; XML support "
5556 "was disabled at compile time"));
5562 #else /* HAVE_LIBEXPAT */
5564 #include "xml-support.h"
5566 /* Handle the start of a <memory> element. */
5569 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
5570 const struct gdb_xml_element
*element
,
5571 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
5573 struct traceframe_info
*info
= user_data
;
5574 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5575 ULONGEST
*start_p
, *length_p
;
5577 start_p
= xml_find_attribute (attributes
, "start")->value
;
5578 length_p
= xml_find_attribute (attributes
, "length")->value
;
5580 r
->start
= *start_p
;
5581 r
->length
= *length_p
;
5584 /* Discard the constructed trace frame info (if an error occurs). */
5587 free_result (void *p
)
5589 struct traceframe_info
*result
= p
;
5591 free_traceframe_info (result
);
5594 /* The allowed elements and attributes for an XML memory map. */
5596 static const struct gdb_xml_attribute memory_attributes
[] = {
5597 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5598 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5599 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5602 static const struct gdb_xml_element traceframe_info_children
[] = {
5603 { "memory", memory_attributes
, NULL
,
5604 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5605 traceframe_info_start_memory
, NULL
},
5606 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5609 static const struct gdb_xml_element traceframe_info_elements
[] = {
5610 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
5612 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5615 /* Parse a traceframe-info XML document. */
5617 struct traceframe_info
*
5618 parse_traceframe_info (const char *tframe_info
)
5620 struct traceframe_info
*result
;
5621 struct cleanup
*back_to
;
5623 result
= XCNEW (struct traceframe_info
);
5624 back_to
= make_cleanup (free_result
, result
);
5626 if (gdb_xml_parse_quick (_("trace frame info"),
5627 "traceframe-info.dtd", traceframe_info_elements
,
5628 tframe_info
, result
) == 0)
5630 /* Parsed successfully, keep the result. */
5631 discard_cleanups (back_to
);
5636 do_cleanups (back_to
);
5640 #endif /* HAVE_LIBEXPAT */
5642 /* Returns the traceframe_info object for the current traceframe.
5643 This is where we avoid re-fetching the object from the target if we
5644 already have it cached. */
5646 static struct traceframe_info
*
5647 get_traceframe_info (void)
5649 if (traceframe_info
== NULL
)
5650 traceframe_info
= target_traceframe_info ();
5652 return traceframe_info
;
5655 /* If the target supports the query, return in RESULT the set of
5656 collected memory in the current traceframe, found within the LEN
5657 bytes range starting at MEMADDR. Returns true if the target
5658 supports the query, otherwise returns false, and RESULT is left
5662 traceframe_available_memory (VEC(mem_range_s
) **result
,
5663 CORE_ADDR memaddr
, ULONGEST len
)
5665 struct traceframe_info
*info
= get_traceframe_info ();
5669 struct mem_range
*r
;
5674 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
5675 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
5677 ULONGEST lo1
, hi1
, lo2
, hi2
;
5678 struct mem_range
*nr
;
5681 hi1
= memaddr
+ len
;
5684 hi2
= r
->start
+ r
->length
;
5686 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
5688 nr
->start
= max (lo1
, lo2
);
5689 nr
->length
= min (hi1
, hi2
) - nr
->start
;
5692 normalize_mem_ranges (*result
);
5699 /* Implementation of `sdata' variable. */
5701 static const struct internalvar_funcs sdata_funcs
=
5708 /* module initialization */
5710 _initialize_tracepoint (void)
5712 struct cmd_list_element
*c
;
5714 /* Explicitly create without lookup, since that tries to create a
5715 value with a void typed value, and when we get here, gdbarch
5716 isn't initialized yet. At this point, we're quite sure there
5717 isn't another convenience variable of the same name. */
5718 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
5720 traceframe_number
= -1;
5721 tracepoint_number
= -1;
5723 add_info ("scope", scope_info
,
5724 _("List the variables local to a scope"));
5726 add_cmd ("tracepoints", class_trace
, NULL
,
5727 _("Tracing of program execution without stopping the program."),
5730 add_com ("tdump", class_trace
, trace_dump_command
,
5731 _("Print everything collected at the current tracepoint."));
5733 add_com ("tsave", class_trace
, trace_save_command
, _("\
5734 Save the trace data to a file.\n\
5735 Use the '-ctf' option to save the data to CTF format.\n\
5736 Use the '-r' option to direct the target to save directly to the file,\n\
5737 using its own filesystem."));
5739 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
5740 Define a trace state variable.\n\
5741 Argument is a $-prefixed name, optionally followed\n\
5742 by '=' and an expression that sets the initial value\n\
5743 at the start of tracing."));
5744 set_cmd_completer (c
, expression_completer
);
5746 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
5747 Delete one or more trace state variables.\n\
5748 Arguments are the names of the variables to delete.\n\
5749 If no arguments are supplied, delete all variables."), &deletelist
);
5750 /* FIXME add a trace variable completer. */
5752 add_info ("tvariables", tvariables_info
, _("\
5753 Status of trace state variables and their values.\n\
5756 add_info ("static-tracepoint-markers",
5757 info_static_tracepoint_markers_command
, _("\
5758 List target static tracepoints markers.\n\
5761 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
5762 Select a trace frame;\n\
5763 No argument means forward by one frame; '-' means backward by one frame."),
5764 &tfindlist
, "tfind ", 1, &cmdlist
);
5766 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
5767 Select a trace frame whose PC is outside the given range (exclusive).\n\
5768 Usage: tfind outside addr1, addr2"),
5771 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
5772 Select a trace frame whose PC is in the given range (inclusive).\n\
5773 Usage: tfind range addr1,addr2"),
5776 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
5777 Select a trace frame by source line.\n\
5778 Argument can be a line number (with optional source file),\n\
5779 a function name, or '*' followed by an address.\n\
5780 Default argument is 'the next source line that was traced'."),
5783 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
5784 Select a trace frame by tracepoint number.\n\
5785 Default is the tracepoint for the current trace frame."),
5788 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
5789 Select a trace frame by PC.\n\
5790 Default is the current PC, or the PC of the current trace frame."),
5793 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
5794 De-select any trace frame and resume 'live' debugging."),
5797 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
5799 add_cmd ("start", class_trace
, trace_find_start_command
,
5800 _("Select the first trace frame in the trace buffer."),
5803 add_com ("tstatus", class_trace
, trace_status_command
,
5804 _("Display the status of the current trace data collection."));
5806 add_com ("tstop", class_trace
, trace_stop_command
, _("\
5807 Stop trace data collection.\n\
5808 Usage: tstop [ <notes> ... ]\n\
5809 Any arguments supplied are recorded with the trace as a stop reason and\n\
5810 reported by tstatus (if the target supports trace notes)."));
5812 add_com ("tstart", class_trace
, trace_start_command
, _("\
5813 Start trace data collection.\n\
5814 Usage: tstart [ <notes> ... ]\n\
5815 Any arguments supplied are recorded with the trace as a note and\n\
5816 reported by tstatus (if the target supports trace notes)."));
5818 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
5819 Ends a list of commands or actions.\n\
5820 Several GDB commands allow you to enter a list of commands or actions.\n\
5821 Entering \"end\" on a line by itself is the normal way to terminate\n\
5823 Note: the \"end\" command cannot be used at the gdb prompt."));
5825 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
5826 Specify single-stepping behavior at a tracepoint.\n\
5827 Argument is number of instructions to trace in single-step mode\n\
5828 following the tracepoint. This command is normally followed by\n\
5829 one or more \"collect\" commands, to specify what to collect\n\
5830 while single-stepping.\n\n\
5831 Note: this command can only be used in a tracepoint \"actions\" list."));
5833 add_com_alias ("ws", "while-stepping", class_alias
, 0);
5834 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
5836 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
5837 Specify one or more data items to be collected at a tracepoint.\n\
5838 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5839 collect all data (variables, registers) referenced by that expression.\n\
5840 Also accepts the following special arguments:\n\
5841 $regs -- all registers.\n\
5842 $args -- all function arguments.\n\
5843 $locals -- all variables local to the block/function scope.\n\
5844 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5845 Note: this command can only be used in a tracepoint \"actions\" list."));
5847 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
5848 Specify one or more expressions to be evaluated at a tracepoint.\n\
5849 Accepts a comma-separated list of (one or more) expressions.\n\
5850 The result of each evaluation will be discarded.\n\
5851 Note: this command can only be used in a tracepoint \"actions\" list."));
5853 add_com ("actions", class_trace
, trace_actions_command
, _("\
5854 Specify the actions to be taken at a tracepoint.\n\
5855 Tracepoint actions may include collecting of specified data,\n\
5856 single-stepping, or enabling/disabling other tracepoints,\n\
5857 depending on target's capabilities."));
5859 default_collect
= xstrdup ("");
5860 add_setshow_string_cmd ("default-collect", class_trace
,
5861 &default_collect
, _("\
5862 Set the list of expressions to collect by default"), _("\
5863 Show the list of expressions to collect by default"), NULL
,
5865 &setlist
, &showlist
);
5867 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
5868 &disconnected_tracing
, _("\
5869 Set whether tracing continues after GDB disconnects."), _("\
5870 Show whether tracing continues after GDB disconnects."), _("\
5871 Use this to continue a tracing run even if GDB disconnects\n\
5872 or detaches from the target. You can reconnect later and look at\n\
5873 trace data collected in the meantime."),
5874 set_disconnected_tracing
,
5879 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
5880 &circular_trace_buffer
, _("\
5881 Set target's use of circular trace buffer."), _("\
5882 Show target's use of circular trace buffer."), _("\
5883 Use this to make the trace buffer into a circular buffer,\n\
5884 which will discard traceframes (oldest first) instead of filling\n\
5885 up and stopping the trace run."),
5886 set_circular_trace_buffer
,
5891 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class
,
5892 &trace_buffer_size
, _("\
5893 Set requested size of trace buffer."), _("\
5894 Show requested size of trace buffer."), _("\
5895 Use this to choose a size for the trace buffer. Some targets\n\
5896 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
5897 disables any attempt to set the buffer size and lets the target choose."),
5898 set_trace_buffer_size
, NULL
,
5899 &setlist
, &showlist
);
5901 add_setshow_string_cmd ("trace-user", class_trace
,
5903 Set the user name to use for current and future trace runs"), _("\
5904 Show the user name to use for current and future trace runs"), NULL
,
5905 set_trace_user
, NULL
,
5906 &setlist
, &showlist
);
5908 add_setshow_string_cmd ("trace-notes", class_trace
,
5910 Set notes string to use for current and future trace runs"), _("\
5911 Show the notes string to use for current and future trace runs"), NULL
,
5912 set_trace_notes
, NULL
,
5913 &setlist
, &showlist
);
5915 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
5916 &trace_stop_notes
, _("\
5917 Set notes string to use for future tstop commands"), _("\
5918 Show the notes string to use for future tstop commands"), NULL
,
5919 set_trace_stop_notes
, NULL
,
5920 &setlist
, &showlist
);
5924 add_target_with_completer (&tfile_ops
, filename_completer
);