1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
4 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "arch-utils.h"
26 #include "expression.h"
31 #include "gdb_string.h"
33 #include "breakpoint.h"
34 #include "tracepoint.h"
37 #include "completer.h"
39 #include "dictionary.h"
41 #include "user-regs.h"
45 #include "filenames.h"
46 #include "gdbthread.h"
52 /* readline include files */
53 #include "readline/readline.h"
54 #include "readline/history.h"
56 /* readline defines this. */
67 extern int hex2bin (const char *hex
, gdb_byte
*bin
, int count
);
68 extern int bin2hex (const gdb_byte
*bin
, char *hex
, int count
);
70 extern void stop_tracing ();
72 /* Maximum length of an agent aexpression.
73 This accounts for the fact that packets are limited to 400 bytes
74 (which includes everything -- including the checksum), and assumes
75 the worst case of maximum length for each of the pieces of a
78 NOTE: expressions get mem2hex'ed otherwise this would be twice as
79 large. (400 - 31)/2 == 184 */
80 #define MAX_AGENT_EXPR_LEN 184
82 /* A hook used to notify the UI of tracepoint operations. */
84 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
85 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
87 extern void (*deprecated_readline_begin_hook
) (char *, ...);
88 extern char *(*deprecated_readline_hook
) (char *);
89 extern void (*deprecated_readline_end_hook
) (void);
91 /* GDB commands implemented in other modules:
94 extern void output_command (char *, int);
99 This module defines the following debugger commands:
100 trace : set a tracepoint on a function, line, or address.
101 info trace : list all debugger-defined tracepoints.
102 delete trace : delete one or more tracepoints.
103 enable trace : enable one or more tracepoints.
104 disable trace : disable one or more tracepoints.
105 actions : specify actions to be taken at a tracepoint.
106 passcount : specify a pass count for a tracepoint.
107 tstart : start a trace experiment.
108 tstop : stop a trace experiment.
109 tstatus : query the status of a trace experiment.
110 tfind : find a trace frame in the trace buffer.
111 tdump : print everything collected at the current tracepoint.
112 save-tracepoints : write tracepoint setup into a file.
114 This module defines the following user-visible debugger variables:
115 $trace_frame : sequence number of trace frame currently being debugged.
116 $trace_line : source line of trace frame currently being debugged.
117 $trace_file : source file of trace frame currently being debugged.
118 $tracepoint : tracepoint number of trace frame currently being debugged.
122 /* ======= Important global variables: ======= */
124 /* The list of all trace state variables. We don't retain pointers to
125 any of these for any reason - API is by name or number only - so it
126 works to have a vector of objects. */
128 typedef struct trace_state_variable tsv_s
;
131 static VEC(tsv_s
) *tvariables
;
133 /* The next integer to assign to a variable. */
135 static int next_tsv_number
= 1;
137 /* Number of last traceframe collected. */
138 static int traceframe_number
;
140 /* Tracepoint for last traceframe collected. */
141 static int tracepoint_number
;
143 /* Symbol for function for last traceframe collected */
144 static struct symbol
*traceframe_fun
;
146 /* Symtab and line for last traceframe collected */
147 static struct symtab_and_line traceframe_sal
;
149 /* Tracing command lists */
150 static struct cmd_list_element
*tfindlist
;
152 /* List of expressions to collect by default at each tracepoint hit. */
153 char *default_collect
= "";
155 static int disconnected_tracing
;
157 /* This variable controls whether we ask the target for a linear or
158 circular trace buffer. */
160 static int circular_trace_buffer
;
162 /* ======= Important command functions: ======= */
163 static void trace_actions_command (char *, int);
164 static void trace_start_command (char *, int);
165 static void trace_stop_command (char *, int);
166 static void trace_status_command (char *, int);
167 static void trace_find_command (char *, int);
168 static void trace_find_pc_command (char *, int);
169 static void trace_find_tracepoint_command (char *, int);
170 static void trace_find_line_command (char *, int);
171 static void trace_find_range_command (char *, int);
172 static void trace_find_outside_command (char *, int);
173 static void trace_dump_command (char *, int);
175 /* support routines */
177 struct collection_list
;
178 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
179 static char *mem2hex (gdb_byte
*, char *, int);
180 static void add_register (struct collection_list
*collection
,
183 extern void send_disconnected_tracing_value (int value
);
185 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
186 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
189 extern void _initialize_tracepoint (void);
191 static struct trace_status trace_status
;
193 char *stop_reason_names
[] = {
203 struct trace_status
*
204 current_trace_status ()
206 return &trace_status
;
209 /* Set traceframe number to NUM. */
211 set_traceframe_num (int num
)
213 traceframe_number
= num
;
214 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
217 /* Set tracepoint number to NUM. */
219 set_tracepoint_num (int num
)
221 tracepoint_number
= num
;
222 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
225 /* Set externally visible debug variables for querying/printing
226 the traceframe context (line, function, file) */
229 set_traceframe_context (struct frame_info
*trace_frame
)
233 if (trace_frame
== NULL
) /* Cease debugging any trace buffers. */
236 traceframe_sal
.pc
= traceframe_sal
.line
= 0;
237 traceframe_sal
.symtab
= NULL
;
238 clear_internalvar (lookup_internalvar ("trace_func"));
239 clear_internalvar (lookup_internalvar ("trace_file"));
240 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
244 /* Save as globals for internal use. */
245 trace_pc
= get_frame_pc (trace_frame
);
246 traceframe_sal
= find_pc_line (trace_pc
, 0);
247 traceframe_fun
= find_pc_function (trace_pc
);
249 /* Save linenumber as "$trace_line", a debugger variable visible to
251 set_internalvar_integer (lookup_internalvar ("trace_line"),
252 traceframe_sal
.line
);
254 /* Save func name as "$trace_func", a debugger variable visible to
256 if (traceframe_fun
== NULL
257 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
258 clear_internalvar (lookup_internalvar ("trace_func"));
260 set_internalvar_string (lookup_internalvar ("trace_func"),
261 SYMBOL_LINKAGE_NAME (traceframe_fun
));
263 /* Save file name as "$trace_file", a debugger variable visible to
265 if (traceframe_sal
.symtab
== NULL
266 || traceframe_sal
.symtab
->filename
== NULL
)
267 clear_internalvar (lookup_internalvar ("trace_file"));
269 set_internalvar_string (lookup_internalvar ("trace_file"),
270 traceframe_sal
.symtab
->filename
);
273 /* Create a new trace state variable with the given name. */
275 struct trace_state_variable
*
276 create_trace_state_variable (const char *name
)
278 struct trace_state_variable tsv
;
280 memset (&tsv
, 0, sizeof (tsv
));
281 tsv
.name
= xstrdup (name
);
282 tsv
.number
= next_tsv_number
++;
283 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
286 /* Look for a trace state variable of the given name. */
288 struct trace_state_variable
*
289 find_trace_state_variable (const char *name
)
291 struct trace_state_variable
*tsv
;
294 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
295 if (strcmp (name
, tsv
->name
) == 0)
302 delete_trace_state_variable (const char *name
)
304 struct trace_state_variable
*tsv
;
307 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
308 if (strcmp (name
, tsv
->name
) == 0)
310 xfree ((void *)tsv
->name
);
311 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
315 warning (_("No trace variable named \"$%s\", not deleting"), name
);
318 /* The 'tvariable' command collects a name and optional expression to
319 evaluate into an initial value. */
322 trace_variable_command (char *args
, int from_tty
)
324 struct expression
*expr
;
325 struct cleanup
*old_chain
;
326 struct internalvar
*intvar
= NULL
;
328 struct trace_state_variable
*tsv
;
331 error_no_arg (_("trace state variable name"));
333 /* All the possible valid arguments are expressions. */
334 expr
= parse_expression (args
);
335 old_chain
= make_cleanup (free_current_contents
, &expr
);
337 if (expr
->nelts
== 0)
338 error (_("No expression?"));
340 /* Only allow two syntaxes; "$name" and "$name=value". */
341 if (expr
->elts
[0].opcode
== OP_INTERNALVAR
)
343 intvar
= expr
->elts
[1].internalvar
;
345 else if (expr
->elts
[0].opcode
== BINOP_ASSIGN
346 && expr
->elts
[1].opcode
== OP_INTERNALVAR
)
348 intvar
= expr
->elts
[2].internalvar
;
349 initval
= value_as_long (evaluate_subexpression_type (expr
, 4));
352 error (_("Syntax must be $NAME [ = EXPR ]"));
355 error (_("No name given"));
357 if (strlen (internalvar_name (intvar
)) <= 0)
358 error (_("Must supply a non-empty variable name"));
360 /* If the variable already exists, just change its initial value. */
361 tsv
= find_trace_state_variable (internalvar_name (intvar
));
364 tsv
->initial_value
= initval
;
365 printf_filtered (_("Trace state variable $%s now has initial value %s.\n"),
366 tsv
->name
, plongest (tsv
->initial_value
));
370 /* Create a new variable. */
371 tsv
= create_trace_state_variable (internalvar_name (intvar
));
372 tsv
->initial_value
= initval
;
374 printf_filtered (_("Trace state variable $%s created, with initial value %s.\n"),
375 tsv
->name
, plongest (tsv
->initial_value
));
377 do_cleanups (old_chain
);
381 delete_trace_variable_command (char *args
, int from_tty
)
385 struct cleanup
*back_to
;
386 struct trace_state_variable
*tsv
;
390 if (query (_("Delete all trace state variables? ")))
391 VEC_free (tsv_s
, tvariables
);
396 argv
= gdb_buildargv (args
);
397 back_to
= make_cleanup_freeargv (argv
);
399 for (i
= 0; argv
[i
] != NULL
; i
++)
402 delete_trace_state_variable (argv
[i
] + 1);
404 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[i
]);
407 do_cleanups (back_to
);
413 tvariables_info_1 (void)
415 struct trace_state_variable
*tsv
;
418 struct cleanup
*back_to
;
420 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
422 printf_filtered (_("No trace state variables.\n"));
426 /* Try to acquire values from the target. */
427 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
428 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
431 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
432 count
, "trace-variables");
433 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
434 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
435 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
437 ui_out_table_body (uiout
);
439 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
441 struct cleanup
*back_to2
;
445 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
447 name
= concat ("$", tsv
->name
, NULL
);
448 make_cleanup (xfree
, name
);
449 ui_out_field_string (uiout
, "name", name
);
450 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
452 if (tsv
->value_known
)
453 c
= plongest (tsv
->value
);
454 else if (ui_out_is_mi_like_p (uiout
))
455 /* For MI, we prefer not to use magic string constants, but rather
456 omit the field completely. The difference between unknown and
457 undefined does not seem important enough to represent. */
459 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
460 /* The value is/was defined, but we don't have it. */
463 /* It is not meaningful to ask about the value. */
466 ui_out_field_string (uiout
, "current", c
);
467 ui_out_text (uiout
, "\n");
469 do_cleanups (back_to2
);
472 do_cleanups (back_to
);
475 /* List all the trace state variables. */
478 tvariables_info (char *args
, int from_tty
)
480 tvariables_info_1 ();
483 /* Stash definitions of tsvs into the given file. */
486 save_trace_state_variables (struct ui_file
*fp
)
488 struct trace_state_variable
*tsv
;
491 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
493 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
494 if (tsv
->initial_value
)
495 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
496 fprintf_unfiltered (fp
, "\n");
500 /* ACTIONS functions: */
502 /* The three functions:
503 collect_pseudocommand,
504 while_stepping_pseudocommand, and
505 end_actions_pseudocommand
506 are placeholders for "commands" that are actually ONLY to be used
507 within a tracepoint action list. If the actual function is ever called,
508 it means that somebody issued the "command" at the top level,
509 which is always an error. */
512 end_actions_pseudocommand (char *args
, int from_tty
)
514 error (_("This command cannot be used at the top level."));
518 while_stepping_pseudocommand (char *args
, int from_tty
)
520 error (_("This command can only be used in a tracepoint actions list."));
524 collect_pseudocommand (char *args
, int from_tty
)
526 error (_("This command can only be used in a tracepoint actions list."));
530 teval_pseudocommand (char *args
, int from_tty
)
532 error (_("This command can only be used in a tracepoint actions list."));
535 /* Enter a list of actions for a tracepoint. */
537 trace_actions_command (char *args
, int from_tty
)
539 struct breakpoint
*t
;
540 struct command_line
*l
;
542 t
= get_tracepoint_by_number (&args
, 0, 1);
546 xstrprintf ("Enter actions for tracepoint %d, one per line.",
548 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
550 l
= read_command_lines (tmpbuf
, from_tty
, 1, check_tracepoint_command
, t
);
551 do_cleanups (cleanups
);
552 breakpoint_set_commands (t
, l
);
554 /* else just return */
557 /* Report the results of checking the agent expression, as errors or
561 report_agent_reqs_errors (struct agent_expr
*aexpr
, struct agent_reqs
*areqs
)
563 /* All of the "flaws" are serious bytecode generation issues that
564 should never occur. */
565 if (areqs
->flaw
!= agent_flaw_none
)
566 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
568 /* If analysis shows a stack underflow, GDB must have done something
569 badly wrong in its bytecode generation. */
570 if (areqs
->min_height
< 0)
571 internal_error (__FILE__
, __LINE__
,
572 _("expression has min height < 0"));
574 /* Issue this error if the stack is predicted to get too deep. The
575 limit is rather arbitrary; a better scheme might be for the
576 target to report how much stack it will have available. The
577 depth roughly corresponds to parenthesization, so a limit of 20
578 amounts to 20 levels of expression nesting, which is actually
579 a pretty big hairy expression. */
580 if (areqs
->max_height
> 20)
581 error (_("Expression is too complicated."));
584 /* worker function */
586 validate_actionline (char **line
, struct breakpoint
*t
)
588 struct cmd_list_element
*c
;
589 struct expression
*exp
= NULL
;
590 struct cleanup
*old_chain
= NULL
;
592 struct bp_location
*loc
;
593 struct agent_expr
*aexpr
;
594 struct agent_reqs areqs
;
596 /* if EOF is typed, *line is NULL */
600 for (p
= *line
; isspace ((int) *p
);)
603 /* Symbol lookup etc. */
604 if (*p
== '\0') /* empty line: just prompt for another line. */
607 if (*p
== '#') /* comment line */
610 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
612 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
614 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
617 { /* repeat over a comma-separated list */
618 QUIT
; /* allow user to bail out with ^C */
619 while (isspace ((int) *p
))
622 if (*p
== '$') /* look for special pseudo-symbols */
624 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
625 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
626 (0 == strncasecmp ("loc", p
+ 1, 3)))
631 /* else fall thru, treat p as an expression and parse it! */
634 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
637 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
638 old_chain
= make_cleanup (free_current_contents
, &exp
);
640 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
642 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
644 error (_("constant `%s' (value %ld) will not be collected."),
645 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
646 SYMBOL_VALUE (exp
->elts
[2].symbol
));
648 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
650 error (_("`%s' is optimized away and cannot be collected."),
651 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
655 /* We have something to collect, make sure that the expr to
656 bytecode translator can handle it and that it's not too
658 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
659 make_cleanup_free_agent_expr (aexpr
);
661 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
662 error (_("Expression is too complicated."));
664 ax_reqs (aexpr
, &areqs
);
665 (void) make_cleanup (xfree
, areqs
.reg_mask
);
667 report_agent_reqs_errors (aexpr
, &areqs
);
669 do_cleanups (old_chain
);
672 while (p
&& *p
++ == ',');
675 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
678 { /* repeat over a comma-separated list */
679 QUIT
; /* allow user to bail out with ^C */
680 while (isspace ((int) *p
))
684 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
687 /* Only expressions are allowed for this action. */
688 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
689 old_chain
= make_cleanup (free_current_contents
, &exp
);
691 /* We have something to evaluate, make sure that the expr to
692 bytecode translator can handle it and that it's not too
694 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
695 make_cleanup_free_agent_expr (aexpr
);
697 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
698 error (_("Expression is too complicated."));
700 ax_reqs (aexpr
, &areqs
);
701 (void) make_cleanup (xfree
, areqs
.reg_mask
);
703 report_agent_reqs_errors (aexpr
, &areqs
);
705 do_cleanups (old_chain
);
708 while (p
&& *p
++ == ',');
711 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
713 char *steparg
; /* in case warning is necessary */
715 while (isspace ((int) *p
))
719 if (*p
== '\0' || (t
->step_count
= strtol (p
, &p
, 0)) == 0)
720 error (_("while-stepping step count `%s' is malformed."), *line
);
723 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
727 error (_("`%s' is not a supported tracepoint action."), *line
);
731 memrange_absolute
= -1
736 int type
; /* memrange_absolute for absolute memory range,
737 else basereg number */
738 bfd_signed_vma start
;
742 struct collection_list
744 unsigned char regs_mask
[32]; /* room for up to 256 regs */
747 struct memrange
*list
;
748 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
750 struct agent_expr
**aexpr_list
;
753 tracepoint_list
, stepping_list
;
755 /* MEMRANGE functions: */
757 static int memrange_cmp (const void *, const void *);
759 /* compare memranges for qsort */
761 memrange_cmp (const void *va
, const void *vb
)
763 const struct memrange
*a
= va
, *b
= vb
;
765 if (a
->type
< b
->type
)
767 if (a
->type
> b
->type
)
769 if (a
->type
== memrange_absolute
)
771 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
773 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
778 if (a
->start
< b
->start
)
780 if (a
->start
> b
->start
)
786 /* Sort the memrange list using qsort, and merge adjacent memranges. */
788 memrange_sortmerge (struct collection_list
*memranges
)
792 qsort (memranges
->list
, memranges
->next_memrange
,
793 sizeof (struct memrange
), memrange_cmp
);
794 if (memranges
->next_memrange
> 0)
796 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
798 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
799 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
802 /* memrange b starts before memrange a ends; merge them. */
803 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
804 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
805 continue; /* next b, same a */
809 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
810 sizeof (struct memrange
));
812 memranges
->next_memrange
= a
+ 1;
816 /* Add a register to a collection list. */
818 add_register (struct collection_list
*collection
, unsigned int regno
)
821 printf_filtered ("collect register %d\n", regno
);
822 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
823 error (_("Internal: register number %d too large for tracepoint"),
825 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
828 /* Add a memrange to a collection list */
830 add_memrange (struct collection_list
*memranges
,
831 int type
, bfd_signed_vma base
,
836 printf_filtered ("(%d,", type
);
838 printf_filtered (",%ld)\n", len
);
841 /* type: memrange_absolute == memory, other n == basereg */
842 memranges
->list
[memranges
->next_memrange
].type
= type
;
843 /* base: addr if memory, offset if reg relative. */
844 memranges
->list
[memranges
->next_memrange
].start
= base
;
845 /* len: we actually save end (base + len) for convenience */
846 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
847 memranges
->next_memrange
++;
848 if (memranges
->next_memrange
>= memranges
->listsize
)
850 memranges
->listsize
*= 2;
851 memranges
->list
= xrealloc (memranges
->list
,
852 memranges
->listsize
);
855 if (type
!= memrange_absolute
) /* Better collect the base register! */
856 add_register (memranges
, type
);
859 /* Add a symbol to a collection list. */
861 collect_symbol (struct collection_list
*collect
,
863 struct gdbarch
*gdbarch
,
864 long frame_regno
, long frame_offset
,
869 bfd_signed_vma offset
;
870 int treat_as_expr
= 0;
872 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
873 switch (SYMBOL_CLASS (sym
))
876 printf_filtered ("%s: don't know symbol class %d\n",
877 SYMBOL_PRINT_NAME (sym
),
881 printf_filtered ("constant %s (value %ld) will not be collected.\n",
882 SYMBOL_PRINT_NAME (sym
), SYMBOL_VALUE (sym
));
885 offset
= SYMBOL_VALUE_ADDRESS (sym
);
890 sprintf_vma (tmp
, offset
);
891 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
892 SYMBOL_PRINT_NAME (sym
), len
,
895 /* A struct may be a C++ class with static fields, go to general
896 expression handling. */
897 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
900 add_memrange (collect
, memrange_absolute
, offset
, len
);
903 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
905 printf_filtered ("LOC_REG[parm] %s: ",
906 SYMBOL_PRINT_NAME (sym
));
907 add_register (collect
, reg
);
908 /* Check for doubles stored in two registers. */
909 /* FIXME: how about larger types stored in 3 or more regs? */
910 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
911 len
> register_size (gdbarch
, reg
))
912 add_register (collect
, reg
+ 1);
915 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
916 printf_filtered (" (will not collect %s)\n",
917 SYMBOL_PRINT_NAME (sym
));
921 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
924 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
925 SYMBOL_PRINT_NAME (sym
), len
);
927 printf_filtered (" from frame ptr reg %d\n", reg
);
929 add_memrange (collect
, reg
, offset
, len
);
931 case LOC_REGPARM_ADDR
:
932 reg
= SYMBOL_VALUE (sym
);
936 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
937 SYMBOL_PRINT_NAME (sym
), len
);
939 printf_filtered (" from reg %d\n", reg
);
941 add_memrange (collect
, reg
, offset
, len
);
945 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
948 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
949 SYMBOL_PRINT_NAME (sym
), len
);
951 printf_filtered (" from frame ptr reg %d\n", reg
);
953 add_memrange (collect
, reg
, offset
, len
);
960 case LOC_OPTIMIZED_OUT
:
961 printf_filtered ("%s has been optimized out of existence.\n",
962 SYMBOL_PRINT_NAME (sym
));
970 /* Expressions are the most general case. */
973 struct agent_expr
*aexpr
;
974 struct cleanup
*old_chain1
= NULL
;
975 struct agent_reqs areqs
;
977 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
979 /* It can happen that the symbol is recorded as a computed
980 location, but it's been optimized away and doesn't actually
981 have a location expression. */
984 printf_filtered ("%s has been optimized out of existence.\n",
985 SYMBOL_PRINT_NAME (sym
));
989 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
991 ax_reqs (aexpr
, &areqs
);
993 report_agent_reqs_errors (aexpr
, &areqs
);
995 discard_cleanups (old_chain1
);
996 add_aexpr (collect
, aexpr
);
998 /* take care of the registers */
999 if (areqs
.reg_mask_len
> 0)
1003 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1005 QUIT
; /* allow user to bail out with ^C */
1006 if (areqs
.reg_mask
[ndx1
] != 0)
1008 /* assume chars have 8 bits */
1009 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1010 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1011 /* it's used -- record it */
1012 add_register (collect
, ndx1
* 8 + ndx2
);
1019 /* Data to be passed around in the calls to the locals and args
1022 struct add_local_symbols_data
1024 struct collection_list
*collect
;
1025 struct gdbarch
*gdbarch
;
1032 /* The callback for the locals and args iterators */
1035 do_collect_symbol (const char *print_name
,
1039 struct add_local_symbols_data
*p
= cb_data
;
1041 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1042 p
->frame_offset
, p
->pc
);
1046 /* Add all locals (or args) symbols to collection list */
1048 add_local_symbols (struct collection_list
*collect
,
1049 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1050 long frame_regno
, long frame_offset
, int type
)
1052 struct block
*block
;
1053 struct add_local_symbols_data cb_data
;
1055 cb_data
.collect
= collect
;
1056 cb_data
.gdbarch
= gdbarch
;
1058 cb_data
.frame_regno
= frame_regno
;
1059 cb_data
.frame_offset
= frame_offset
;
1064 block
= block_for_pc (pc
);
1067 warning (_("Can't collect locals; "
1068 "no symbol table info available.\n"));
1072 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1073 if (cb_data
.count
== 0)
1074 warning (_("No locals found in scope."));
1078 pc
= get_pc_function_start (pc
);
1079 block
= block_for_pc (pc
);
1082 warning (_("Can't collect args; no symbol table info available.\n"));
1086 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1087 if (cb_data
.count
== 0)
1088 warning (_("No args found in scope."));
1092 /* worker function */
1094 clear_collection_list (struct collection_list
*list
)
1098 list
->next_memrange
= 0;
1099 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1101 free_agent_expr (list
->aexpr_list
[ndx
]);
1102 list
->aexpr_list
[ndx
] = NULL
;
1104 list
->next_aexpr_elt
= 0;
1105 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1108 /* reduce a collection list to string form (for gdb protocol) */
1110 stringify_collection_list (struct collection_list
*list
, char *string
)
1112 char temp_buf
[2048];
1116 char *(*str_list
)[];
1120 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1121 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1123 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1124 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1126 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1129 printf_filtered ("\nCollecting registers (mask): 0x");
1134 QUIT
; /* allow user to bail out with ^C */
1136 printf_filtered ("%02X", list
->regs_mask
[i
]);
1137 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1140 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1144 printf_filtered ("\n");
1145 if (list
->next_memrange
> 0 && info_verbose
)
1146 printf_filtered ("Collecting memranges: \n");
1147 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1149 QUIT
; /* allow user to bail out with ^C */
1150 sprintf_vma (tmp2
, list
->list
[i
].start
);
1153 printf_filtered ("(%d, %s, %ld)\n",
1156 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1158 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1160 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1167 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1169 /* The "%X" conversion specifier expects an unsigned argument,
1170 so passing -1 (memrange_absolute) to it directly gives you
1171 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1173 if (list
->list
[i
].type
== memrange_absolute
)
1174 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1176 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1179 count
+= strlen (end
);
1180 end
= temp_buf
+ count
;
1183 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1185 QUIT
; /* allow user to bail out with ^C */
1186 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1188 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1193 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1194 end
+= 10; /* 'X' + 8 hex digits + ',' */
1197 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1198 end
, list
->aexpr_list
[i
]->len
);
1199 count
+= 2 * list
->aexpr_list
[i
]->len
;
1204 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1209 (*str_list
)[ndx
] = NULL
;
1222 encode_actions_1 (struct command_line
*action
,
1223 struct breakpoint
*t
,
1224 struct bp_location
*tloc
,
1226 LONGEST frame_offset
,
1227 struct collection_list
*collect
,
1228 struct collection_list
*stepping_list
)
1231 struct expression
*exp
= NULL
;
1232 struct command_line
*actions
;
1234 struct value
*tempval
;
1235 struct cmd_list_element
*cmd
;
1236 struct agent_expr
*aexpr
;
1238 for (; action
; action
= action
->next
)
1240 QUIT
; /* allow user to bail out with ^C */
1241 action_exp
= action
->line
;
1242 while (isspace ((int) *action_exp
))
1245 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1247 error (_("Bad action list item: %s"), action_exp
);
1249 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1252 { /* repeat over a comma-separated list */
1253 QUIT
; /* allow user to bail out with ^C */
1254 while (isspace ((int) *action_exp
))
1257 if (0 == strncasecmp ("$reg", action_exp
, 4))
1259 for (i
= 0; i
< gdbarch_num_regs (t
->gdbarch
); i
++)
1260 add_register (collect
, i
);
1261 action_exp
= strchr (action_exp
, ','); /* more? */
1263 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1265 add_local_symbols (collect
,
1271 action_exp
= strchr (action_exp
, ','); /* more? */
1273 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1275 add_local_symbols (collect
,
1281 action_exp
= strchr (action_exp
, ','); /* more? */
1285 unsigned long addr
, len
;
1286 struct cleanup
*old_chain
= NULL
;
1287 struct cleanup
*old_chain1
= NULL
;
1288 struct agent_reqs areqs
;
1290 exp
= parse_exp_1 (&action_exp
,
1291 block_for_pc (tloc
->address
), 1);
1292 old_chain
= make_cleanup (free_current_contents
, &exp
);
1294 switch (exp
->elts
[0].opcode
)
1298 const char *name
= &exp
->elts
[2].string
;
1300 i
= user_reg_map_name_to_regnum (t
->gdbarch
,
1301 name
, strlen (name
));
1303 internal_error (__FILE__
, __LINE__
,
1304 _("Register $%s not available"),
1307 printf_filtered ("OP_REGISTER: ");
1308 add_register (collect
, i
);
1313 /* safe because we know it's a simple expression */
1314 tempval
= evaluate_expression (exp
);
1315 addr
= value_address (tempval
);
1316 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1317 add_memrange (collect
, memrange_absolute
, addr
, len
);
1321 collect_symbol (collect
,
1322 exp
->elts
[2].symbol
,
1329 default: /* full-fledged expression */
1330 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1332 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1334 ax_reqs (aexpr
, &areqs
);
1336 report_agent_reqs_errors (aexpr
, &areqs
);
1338 discard_cleanups (old_chain1
);
1339 add_aexpr (collect
, aexpr
);
1341 /* take care of the registers */
1342 if (areqs
.reg_mask_len
> 0)
1347 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1349 QUIT
; /* allow user to bail out with ^C */
1350 if (areqs
.reg_mask
[ndx1
] != 0)
1352 /* assume chars have 8 bits */
1353 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1354 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1355 /* it's used -- record it */
1356 add_register (collect
,
1363 do_cleanups (old_chain
);
1366 while (action_exp
&& *action_exp
++ == ',');
1368 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1371 { /* repeat over a comma-separated list */
1372 QUIT
; /* allow user to bail out with ^C */
1373 while (isspace ((int) *action_exp
))
1377 unsigned long addr
, len
;
1378 struct cleanup
*old_chain
= NULL
;
1379 struct cleanup
*old_chain1
= NULL
;
1380 struct agent_reqs areqs
;
1382 exp
= parse_exp_1 (&action_exp
,
1383 block_for_pc (tloc
->address
), 1);
1384 old_chain
= make_cleanup (free_current_contents
, &exp
);
1386 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1387 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1389 ax_reqs (aexpr
, &areqs
);
1391 report_agent_reqs_errors (aexpr
, &areqs
);
1393 discard_cleanups (old_chain1
);
1394 /* Even though we're not officially collecting, add
1395 to the collect list anyway. */
1396 add_aexpr (collect
, aexpr
);
1398 do_cleanups (old_chain
);
1401 while (action_exp
&& *action_exp
++ == ',');
1403 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1405 /* We check against nested while-stepping when setting
1406 breakpoint action, so no way to run into nested
1408 gdb_assert (stepping_list
);
1410 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
, frame_offset
,
1411 stepping_list
, NULL
);
1414 error (_("Invalid tracepoint command '%s'"), action
->line
);
1418 /* Render all actions into gdb protocol. */
1420 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1421 char ***tdp_actions
, char ***stepping_actions
)
1423 static char tdp_buff
[2048], step_buff
[2048];
1424 char *default_collect_line
= NULL
;
1425 struct command_line
*actions
;
1426 struct command_line
*default_collect_action
= NULL
;
1428 LONGEST frame_offset
;
1429 struct cleanup
*back_to
;
1431 back_to
= make_cleanup (null_cleanup
, NULL
);
1433 clear_collection_list (&tracepoint_list
);
1434 clear_collection_list (&stepping_list
);
1436 *tdp_actions
= NULL
;
1437 *stepping_actions
= NULL
;
1439 gdbarch_virtual_frame_pointer (t
->gdbarch
,
1440 t
->loc
->address
, &frame_reg
, &frame_offset
);
1442 actions
= breakpoint_commands (t
);
1444 /* If there are default expressions to collect, make up a collect
1445 action and prepend to the action list to encode. Note that since
1446 validation is per-tracepoint (local var "xyz" might be valid for
1447 one tracepoint and not another, etc), we make up the action on
1448 the fly, and don't cache it. */
1449 if (*default_collect
)
1453 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1454 make_cleanup (xfree
, default_collect_line
);
1456 line
= default_collect_line
;
1457 validate_actionline (&line
, t
);
1459 default_collect_action
= xmalloc (sizeof (struct command_line
));
1460 make_cleanup (xfree
, default_collect_action
);
1461 default_collect_action
->next
= actions
;
1462 default_collect_action
->line
= line
;
1463 actions
= default_collect_action
;
1465 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1466 &tracepoint_list
, &stepping_list
);
1468 memrange_sortmerge (&tracepoint_list
);
1469 memrange_sortmerge (&stepping_list
);
1471 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1473 *stepping_actions
= stringify_collection_list (&stepping_list
,
1476 do_cleanups (back_to
);
1480 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1482 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1484 collect
->aexpr_list
=
1485 xrealloc (collect
->aexpr_list
,
1486 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1487 collect
->aexpr_listsize
*= 2;
1489 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1490 collect
->next_aexpr_elt
++;
1495 start_tracing (void)
1498 VEC(breakpoint_p
) *tp_vec
= NULL
;
1500 struct breakpoint
*t
;
1501 struct trace_state_variable
*tsv
;
1502 int any_enabled
= 0;
1504 tp_vec
= all_tracepoints ();
1506 /* No point in tracing without any tracepoints... */
1507 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1509 VEC_free (breakpoint_p
, tp_vec
);
1510 error (_("No tracepoints defined, not starting trace"));
1513 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1515 if (t
->enable_state
== bp_enabled
)
1522 /* No point in tracing with only disabled tracepoints. */
1525 VEC_free (breakpoint_p
, tp_vec
);
1526 error (_("No tracepoints enabled, not starting trace"));
1529 target_trace_init ();
1531 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1533 t
->number_on_target
= 0;
1534 target_download_tracepoint (t
);
1535 t
->number_on_target
= t
->number
;
1537 VEC_free (breakpoint_p
, tp_vec
);
1539 /* Send down all the trace state variables too. */
1540 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1542 target_download_trace_state_variable (tsv
);
1545 /* Tell target to treat text-like sections as transparent. */
1546 target_trace_set_readonly_regions ();
1547 /* Set some mode flags. */
1548 target_set_disconnected_tracing (disconnected_tracing
);
1549 target_set_circular_trace_buffer (circular_trace_buffer
);
1551 /* Now insert traps and begin collecting data. */
1552 target_trace_start ();
1554 /* Reset our local state. */
1555 set_traceframe_num (-1);
1556 set_tracepoint_num (-1);
1557 set_traceframe_context (NULL
);
1558 current_trace_status()->running
= 1;
1563 Tell target to clear any previous trace experiment.
1564 Walk the list of tracepoints, and send them (and their actions)
1565 to the target. If no errors,
1566 Tell target to start a new trace experiment. */
1569 trace_start_command (char *args
, int from_tty
)
1571 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1573 if (current_trace_status ()->running
)
1576 && !query (_("A trace is running already. Start a new run? ")))
1577 error (_("New trace run not started."));
1585 trace_stop_command (char *args
, int from_tty
)
1587 if (!current_trace_status ()->running
)
1588 error (_("Trace is not running."));
1596 target_trace_stop ();
1597 /* should change in response to reply? */
1598 current_trace_status ()->running
= 0;
1601 /* tstatus command */
1603 trace_status_command (char *args
, int from_tty
)
1605 struct trace_status
*ts
= current_trace_status ();
1608 status
= target_get_trace_status (ts
);
1613 printf_filtered (_("Using a trace file.\n"));
1616 printf_filtered (_("Trace can not be run on this target.\n"));
1621 if (!ts
->running_known
)
1623 printf_filtered (_("Run/stop status is unknown.\n"));
1625 else if (ts
->running
)
1627 printf_filtered (_("Trace is running on the target.\n"));
1628 if (disconnected_tracing
)
1629 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1631 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1635 switch (ts
->stop_reason
)
1637 case trace_never_run
:
1638 printf_filtered (_("No trace has been run on the target.\n"));
1641 printf_filtered (_("Trace stopped by a tstop command.\n"));
1643 case trace_buffer_full
:
1644 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1646 case trace_disconnected
:
1647 printf_filtered (_("Trace stopped because of disconnection.\n"));
1649 case tracepoint_passcount
:
1650 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1651 ts
->stopping_tracepoint
);
1653 case tracepoint_error
:
1654 if (ts
->stopping_tracepoint
)
1655 printf_filtered (_("Trace stopped by an error (%s, tracepoint %d).\n"),
1656 ts
->error_desc
, ts
->stopping_tracepoint
);
1658 printf_filtered (_("Trace stopped by an error (%s).\n"),
1661 case trace_stop_reason_unknown
:
1662 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1665 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1671 if (ts
->traceframes_created
>= 0
1672 && ts
->traceframe_count
!= ts
->traceframes_created
)
1674 printf_filtered (_("Buffer contains %d trace frames (of %d created total).\n"),
1675 ts
->traceframe_count
, ts
->traceframes_created
);
1677 else if (ts
->traceframe_count
>= 0)
1679 printf_filtered (_("Collected %d trace frames.\n"),
1680 ts
->traceframe_count
);
1683 if (ts
->buffer_free
>= 0)
1685 if (ts
->buffer_size
>= 0)
1687 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1688 ts
->buffer_free
, ts
->buffer_size
);
1689 if (ts
->buffer_size
> 0)
1690 printf_filtered (_(" (%d%% full)"),
1691 ((int) ((((long long) (ts
->buffer_size
1692 - ts
->buffer_free
)) * 100)
1693 / ts
->buffer_size
)));
1694 printf_filtered (_(".\n"));
1697 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1701 /* Now report on what we're doing with tfind. */
1702 if (traceframe_number
>= 0)
1703 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1704 traceframe_number
, tracepoint_number
);
1706 printf_filtered (_("Not looking at any trace frame.\n"));
1709 /* Report the trace status to uiout, in a way suitable for MI, and not
1710 suitable for CLI. If ON_STOP is true, suppress a few fields that
1711 are not meaningful in the -trace-stop response.
1713 The implementation is essentially parallel to trace_status_command, but
1714 merging them will result in unreadable code. */
1716 trace_status_mi (int on_stop
)
1718 struct trace_status
*ts
= current_trace_status ();
1720 char *string_status
;
1722 status
= target_get_trace_status (ts
);
1724 if (status
== -1 && !ts
->from_file
)
1726 ui_out_field_string (uiout
, "supported", "0");
1731 ui_out_field_string (uiout
, "supported", "file");
1733 ui_out_field_string (uiout
, "supported", "1");
1735 gdb_assert (ts
->running_known
);
1739 ui_out_field_string (uiout
, "running", "1");
1741 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1742 Given that the frontend gets the status either on -trace-stop, or from
1743 -trace-status after re-connection, it does not seem like this
1744 information is necessary for anything. It is not necessary for either
1745 figuring the vital state of the target nor for navigation of trace
1746 frames. If the frontend wants to show the current state is some
1747 configure dialog, it can request the value when such dialog is
1748 invoked by the user. */
1752 char *stop_reason
= NULL
;
1753 int stopping_tracepoint
= -1;
1756 ui_out_field_string (uiout
, "running", "0");
1758 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
1760 switch (ts
->stop_reason
)
1763 stop_reason
= "request";
1765 case trace_buffer_full
:
1766 stop_reason
= "overflow";
1768 case trace_disconnected
:
1769 stop_reason
= "disconnection";
1771 case tracepoint_passcount
:
1772 stop_reason
= "passcount";
1773 stopping_tracepoint
= ts
->stopping_tracepoint
;
1775 case tracepoint_error
:
1776 stop_reason
= "error";
1777 stopping_tracepoint
= ts
->stopping_tracepoint
;
1783 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
1784 if (stopping_tracepoint
!= -1)
1785 ui_out_field_int (uiout
, "stopping-tracepoint",
1786 stopping_tracepoint
);
1787 if (ts
->stop_reason
== tracepoint_error
)
1788 ui_out_field_string (uiout
, "error-description",
1795 if ((int) ts
->traceframe_count
!= -1)
1796 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
1797 if ((int) ts
->buffer_size
!= -1)
1798 ui_out_field_int (uiout
, "buffer-size", (int) ts
->buffer_size
);
1799 if ((int) ts
->buffer_free
!= -1)
1800 ui_out_field_int (uiout
, "buffer-free", (int) ts
->buffer_free
);
1805 disconnect_or_stop_tracing (int from_tty
)
1807 /* It can happen that the target that was tracing went away on its
1808 own, and we didn't notice. Get a status update, and if the
1809 current target doesn't even do tracing, then assume it's not
1811 if (target_get_trace_status (current_trace_status ()) < 0)
1812 current_trace_status ()->running
= 0;
1814 if (current_trace_status ()->running
&& from_tty
)
1816 int cont
= query (_("Trace is running. Continue tracing after detach? "));
1817 /* Note that we send the query result without affecting the
1818 user's setting of disconnected_tracing, so that the answer is
1820 send_disconnected_tracing_value (cont
);
1822 /* Also ensure that we do the equivalent of a tstop command if
1823 tracing is not to continue after the detach. */
1828 /* Also we want to be out of tfind mode, otherwise things can get
1829 confusing upon reconnection. Just use these calls instead of
1830 full tfind_1 behavior because we're in the middle of detaching,
1831 and there's no point to updating current stack frame etc. */
1832 set_traceframe_number (-1);
1833 set_traceframe_context (NULL
);
1836 /* Worker function for the various flavors of the tfind command. */
1838 tfind_1 (enum trace_find_type type
, int num
,
1839 ULONGEST addr1
, ULONGEST addr2
,
1842 int target_frameno
= -1, target_tracept
= -1;
1843 struct frame_id old_frame_id
;
1845 struct breakpoint
*tp
;
1847 old_frame_id
= get_frame_id (get_current_frame ());
1849 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
1852 if (type
== tfind_number
1854 && target_frameno
== -1)
1856 /* We told the target to get out of tfind mode, and it did. */
1858 else if (target_frameno
== -1)
1860 /* A request for a non-existant trace frame has failed.
1861 Our response will be different, depending on FROM_TTY:
1863 If FROM_TTY is true, meaning that this command was
1864 typed interactively by the user, then give an error
1865 and DO NOT change the state of traceframe_number etc.
1867 However if FROM_TTY is false, meaning that we're either
1868 in a script, a loop, or a user-defined command, then
1869 DON'T give an error, but DO change the state of
1870 traceframe_number etc. to invalid.
1872 The rationalle is that if you typed the command, you
1873 might just have committed a typo or something, and you'd
1874 like to NOT lose your current debugging state. However
1875 if you're in a user-defined command or especially in a
1876 loop, then you need a way to detect that the command
1877 failed WITHOUT aborting. This allows you to write
1878 scripts that search thru the trace buffer until the end,
1879 and then continue on to do something else. */
1882 error (_("Target failed to find requested trace frame."));
1886 printf_filtered ("End of trace buffer.\n");
1887 #if 0 /* dubious now? */
1888 /* The following will not recurse, since it's
1890 trace_find_command ("-1", from_tty
);
1895 tp
= get_tracepoint_by_number_on_target (target_tracept
);
1897 reinit_frame_cache ();
1898 registers_changed ();
1899 target_dcache_invalidate ();
1900 set_traceframe_num (target_frameno
);
1901 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
1902 if (target_frameno
== -1)
1903 set_traceframe_context (NULL
);
1905 set_traceframe_context (get_current_frame ());
1907 if (traceframe_number
>= 0)
1909 /* Use different branches for MI and CLI to make CLI messages
1911 if (ui_out_is_mi_like_p (uiout
))
1913 ui_out_field_string (uiout
, "found", "1");
1914 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
1915 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
1919 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
1920 traceframe_number
, tracepoint_number
);
1925 if (ui_out_is_mi_like_p (uiout
))
1926 ui_out_field_string (uiout
, "found", "0");
1928 printf_unfiltered (_("No trace frame found"));
1931 /* If we're in nonstop mode and getting out of looking at trace
1932 frames, there won't be any current frame to go back to and
1935 && (has_stack_frames () || traceframe_number
>= 0))
1937 enum print_what print_what
;
1939 /* NOTE: in immitation of the step command, try to determine
1940 whether we have made a transition from one function to
1941 another. If so, we'll print the "stack frame" (ie. the new
1942 function and it's arguments) -- otherwise we'll just show the
1945 if (frame_id_eq (old_frame_id
,
1946 get_frame_id (get_current_frame ())))
1947 print_what
= SRC_LINE
;
1949 print_what
= SRC_AND_LOC
;
1951 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
1956 /* trace_find_command takes a trace frame number n,
1957 sends "QTFrame:<n>" to the target,
1958 and accepts a reply that may contain several optional pieces
1959 of information: a frame number, a tracepoint number, and an
1960 indication of whether this is a trap frame or a stepping frame.
1962 The minimal response is just "OK" (which indicates that the
1963 target does not give us a frame number or a tracepoint number).
1964 Instead of that, the target may send us a string containing
1966 F<hexnum> (gives the selected frame number)
1967 T<hexnum> (gives the selected tracepoint number)
1972 trace_find_command (char *args
, int from_tty
)
1973 { /* this should only be called with a numeric argument */
1976 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1977 error ("May not look at trace frames while trace is running.");
1979 if (args
== 0 || *args
== 0)
1980 { /* TFIND with no args means find NEXT trace frame. */
1981 if (traceframe_number
== -1)
1982 frameno
= 0; /* "next" is first one */
1984 frameno
= traceframe_number
+ 1;
1986 else if (0 == strcmp (args
, "-"))
1988 if (traceframe_number
== -1)
1989 error (_("not debugging trace buffer"));
1990 else if (from_tty
&& traceframe_number
== 0)
1991 error (_("already at start of trace buffer"));
1993 frameno
= traceframe_number
- 1;
1995 /* A hack to work around eval's need for fp to have been collected. */
1996 else if (0 == strcmp (args
, "-1"))
1999 frameno
= parse_and_eval_long (args
);
2002 error (_("invalid input (%d is less than zero)"), frameno
);
2004 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2009 trace_find_end_command (char *args
, int from_tty
)
2011 trace_find_command ("-1", from_tty
);
2016 trace_find_none_command (char *args
, int from_tty
)
2018 trace_find_command ("-1", from_tty
);
2023 trace_find_start_command (char *args
, int from_tty
)
2025 trace_find_command ("0", from_tty
);
2028 /* tfind pc command */
2030 trace_find_pc_command (char *args
, int from_tty
)
2035 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2036 error ("May not look at trace frames while trace is running.");
2038 if (args
== 0 || *args
== 0)
2039 pc
= regcache_read_pc (get_current_regcache ());
2041 pc
= parse_and_eval_address (args
);
2043 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2046 /* tfind tracepoint command */
2048 trace_find_tracepoint_command (char *args
, int from_tty
)
2051 struct breakpoint
*tp
;
2053 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2054 error ("May not look at trace frames while trace is running.");
2056 if (args
== 0 || *args
== 0)
2058 if (tracepoint_number
== -1)
2059 error (_("No current tracepoint -- please supply an argument."));
2061 tdp
= tracepoint_number
; /* default is current TDP */
2064 tdp
= parse_and_eval_long (args
);
2066 /* If we have the tracepoint on hand, use the number that the
2067 target knows about (which may be different if we disconnected
2068 and reconnected). */
2069 tp
= get_tracepoint (tdp
);
2071 tdp
= tp
->number_on_target
;
2073 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2076 /* TFIND LINE command:
2078 This command will take a sourceline for argument, just like BREAK
2079 or TRACE (ie. anything that "decode_line_1" can handle).
2081 With no argument, this command will find the next trace frame
2082 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2085 trace_find_line_command (char *args
, int from_tty
)
2087 static CORE_ADDR start_pc
, end_pc
;
2088 struct symtabs_and_lines sals
;
2089 struct symtab_and_line sal
;
2090 struct cleanup
*old_chain
;
2091 char startpc_str
[40], endpc_str
[40];
2093 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2094 error ("May not look at trace frames while trace is running.");
2096 if (args
== 0 || *args
== 0)
2098 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2100 sals
.sals
= (struct symtab_and_line
*)
2101 xmalloc (sizeof (struct symtab_and_line
));
2106 sals
= decode_line_spec (args
, 1);
2110 old_chain
= make_cleanup (xfree
, sals
.sals
);
2111 if (sal
.symtab
== 0)
2112 error (_("No line number information available."));
2114 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2116 if (start_pc
== end_pc
)
2118 printf_filtered ("Line %d of \"%s\"",
2119 sal
.line
, sal
.symtab
->filename
);
2121 printf_filtered (" is at address ");
2122 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2124 printf_filtered (" but contains no code.\n");
2125 sal
= find_pc_line (start_pc
, 0);
2127 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2128 && start_pc
!= end_pc
)
2129 printf_filtered ("Attempting to find line %d instead.\n",
2132 error (_("Cannot find a good line."));
2136 /* Is there any case in which we get here, and have an address
2137 which the user would want to see? If we have debugging
2138 symbols and no line numbers? */
2139 error (_("Line number %d is out of range for \"%s\"."),
2140 sal
.line
, sal
.symtab
->filename
);
2142 /* Find within range of stated line. */
2144 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2146 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2147 do_cleanups (old_chain
);
2150 /* tfind range command */
2152 trace_find_range_command (char *args
, int from_tty
)
2154 static CORE_ADDR start
, stop
;
2155 char start_str
[40], stop_str
[40];
2158 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2159 error ("May not look at trace frames while trace is running.");
2161 if (args
== 0 || *args
== 0)
2162 { /* XXX FIXME: what should default behavior be? */
2163 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2167 if (0 != (tmp
= strchr (args
, ',')))
2169 *tmp
++ = '\0'; /* terminate start address */
2170 while (isspace ((int) *tmp
))
2172 start
= parse_and_eval_address (args
);
2173 stop
= parse_and_eval_address (tmp
);
2176 { /* no explicit end address? */
2177 start
= parse_and_eval_address (args
);
2178 stop
= start
+ 1; /* ??? */
2181 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2184 /* tfind outside command */
2186 trace_find_outside_command (char *args
, int from_tty
)
2188 CORE_ADDR start
, stop
;
2189 char start_str
[40], stop_str
[40];
2192 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2193 error ("May not look at trace frames while trace is running.");
2195 if (args
== 0 || *args
== 0)
2196 { /* XXX FIXME: what should default behavior be? */
2197 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2201 if (0 != (tmp
= strchr (args
, ',')))
2203 *tmp
++ = '\0'; /* terminate start address */
2204 while (isspace ((int) *tmp
))
2206 start
= parse_and_eval_address (args
);
2207 stop
= parse_and_eval_address (tmp
);
2210 { /* no explicit end address? */
2211 start
= parse_and_eval_address (args
);
2212 stop
= start
+ 1; /* ??? */
2215 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2218 /* info scope command: list the locals for a scope. */
2220 scope_info (char *args
, int from_tty
)
2222 struct symtabs_and_lines sals
;
2224 struct minimal_symbol
*msym
;
2225 struct block
*block
;
2226 char **canonical
, *symname
, *save_args
= args
;
2227 struct dict_iterator iter
;
2229 struct gdbarch
*gdbarch
;
2232 if (args
== 0 || *args
== 0)
2233 error (_("requires an argument (function, line or *addr) to define a scope"));
2235 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2236 if (sals
.nelts
== 0)
2237 return; /* presumably decode_line_1 has already warned */
2239 /* Resolve line numbers to PC */
2240 resolve_sal_pc (&sals
.sals
[0]);
2241 block
= block_for_pc (sals
.sals
[0].pc
);
2245 QUIT
; /* allow user to bail out with ^C */
2246 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2248 QUIT
; /* allow user to bail out with ^C */
2250 printf_filtered ("Scope for %s:\n", save_args
);
2253 symname
= SYMBOL_PRINT_NAME (sym
);
2254 if (symname
== NULL
|| *symname
== '\0')
2255 continue; /* probably botched, certainly useless */
2257 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2259 printf_filtered ("Symbol %s is ", symname
);
2260 switch (SYMBOL_CLASS (sym
))
2263 case LOC_UNDEF
: /* messed up symbol? */
2264 printf_filtered ("a bogus symbol, class %d.\n",
2265 SYMBOL_CLASS (sym
));
2266 count
--; /* don't count this one */
2269 printf_filtered ("a constant with value %ld (0x%lx)",
2270 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2272 case LOC_CONST_BYTES
:
2273 printf_filtered ("constant bytes: ");
2274 if (SYMBOL_TYPE (sym
))
2275 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2276 fprintf_filtered (gdb_stdout
, " %02x",
2277 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2280 printf_filtered ("in static storage at address ");
2281 printf_filtered ("%s", paddress (gdbarch
,
2282 SYMBOL_VALUE_ADDRESS (sym
)));
2285 /* GDBARCH is the architecture associated with the objfile
2286 the symbol is defined in; the target architecture may be
2287 different, and may provide additional registers. However,
2288 we do not know the target architecture at this point.
2289 We assume the objfile architecture will contain all the
2290 standard registers that occur in debug info in that
2292 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2294 if (SYMBOL_IS_ARGUMENT (sym
))
2295 printf_filtered ("an argument in register $%s",
2296 gdbarch_register_name (gdbarch
, regno
));
2298 printf_filtered ("a local variable in register $%s",
2299 gdbarch_register_name (gdbarch
, regno
));
2302 printf_filtered ("an argument at stack/frame offset %ld",
2303 SYMBOL_VALUE (sym
));
2306 printf_filtered ("a local variable at frame offset %ld",
2307 SYMBOL_VALUE (sym
));
2310 printf_filtered ("a reference argument at offset %ld",
2311 SYMBOL_VALUE (sym
));
2313 case LOC_REGPARM_ADDR
:
2314 /* Note comment at LOC_REGISTER. */
2315 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2316 printf_filtered ("the address of an argument, in register $%s",
2317 gdbarch_register_name (gdbarch
, regno
));
2320 printf_filtered ("a typedef.\n");
2323 printf_filtered ("a label at address ");
2324 printf_filtered ("%s", paddress (gdbarch
,
2325 SYMBOL_VALUE_ADDRESS (sym
)));
2328 printf_filtered ("a function at address ");
2329 printf_filtered ("%s",
2330 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2332 case LOC_UNRESOLVED
:
2333 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2336 printf_filtered ("Unresolved Static");
2339 printf_filtered ("static storage at address ");
2340 printf_filtered ("%s",
2341 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2344 case LOC_OPTIMIZED_OUT
:
2345 printf_filtered ("optimized out.\n");
2348 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, gdb_stdout
);
2351 if (SYMBOL_TYPE (sym
))
2352 printf_filtered (", length %d.\n",
2353 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2355 if (BLOCK_FUNCTION (block
))
2358 block
= BLOCK_SUPERBLOCK (block
);
2361 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2365 /* worker function (cleanup) */
2367 replace_comma (void *data
)
2374 /* Helper for trace_dump_command. Dump the action list starting at
2375 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2376 actions of the body of a while-stepping action. STEPPING_FRAME is
2377 set if the current traceframe was determined to be a while-stepping
2381 trace_dump_actions (struct command_line
*action
,
2382 int stepping_actions
, int stepping_frame
,
2385 char *action_exp
, *next_comma
;
2387 for (; action
!= NULL
; action
= action
->next
)
2389 struct cmd_list_element
*cmd
;
2391 QUIT
; /* allow user to bail out with ^C */
2392 action_exp
= action
->line
;
2393 while (isspace ((int) *action_exp
))
2396 /* The collection actions to be done while stepping are
2397 bracketed by the commands "while-stepping" and "end". */
2399 if (*action_exp
== '#') /* comment line */
2402 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2404 error (_("Bad action list item: %s"), action_exp
);
2406 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2410 for (i
= 0; i
< action
->body_count
; ++i
)
2411 trace_dump_actions (action
->body_list
[i
],
2412 1, stepping_frame
, from_tty
);
2414 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2416 /* Display the collected data.
2417 For the trap frame, display only what was collected at
2418 the trap. Likewise for stepping frames, display only
2419 what was collected while stepping. This means that the
2420 two boolean variables, STEPPING_FRAME and
2421 STEPPING_ACTIONS should be equal. */
2422 if (stepping_frame
== stepping_actions
)
2425 { /* repeat over a comma-separated list */
2426 QUIT
; /* allow user to bail out with ^C */
2427 if (*action_exp
== ',')
2429 while (isspace ((int) *action_exp
))
2432 next_comma
= strchr (action_exp
, ',');
2434 if (0 == strncasecmp (action_exp
, "$reg", 4))
2435 registers_info (NULL
, from_tty
);
2436 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2437 locals_info (NULL
, from_tty
);
2438 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2439 args_info (NULL
, from_tty
);
2444 make_cleanup (replace_comma
, next_comma
);
2447 printf_filtered ("%s = ", action_exp
);
2448 output_command (action_exp
, from_tty
);
2449 printf_filtered ("\n");
2453 action_exp
= next_comma
;
2455 while (action_exp
&& *action_exp
== ',');
2461 /* The tdump command. */
2464 trace_dump_command (char *args
, int from_tty
)
2466 struct regcache
*regcache
;
2467 struct breakpoint
*t
;
2468 int stepping_frame
= 0;
2469 struct bp_location
*loc
;
2471 if (tracepoint_number
== -1)
2473 warning (_("No current trace frame."));
2477 t
= get_tracepoint (tracepoint_number
);
2480 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2483 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2484 tracepoint_number
, traceframe_number
);
2486 /* The current frame is a trap frame if the frame PC is equal
2487 to the tracepoint PC. If not, then the current frame was
2488 collected during single-stepping. */
2490 regcache
= get_current_regcache ();
2492 /* If the traceframe's address matches any of the tracepoint's
2493 locations, assume it is a direct hit rather than a while-stepping
2494 frame. (FIXME this is not reliable, should record each frame's
2497 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2498 if (loc
->address
== regcache_read_pc (regcache
))
2501 trace_dump_actions (breakpoint_commands (t
), 0, stepping_frame
, from_tty
);
2504 /* Encode a piece of a tracepoint's source-level definition in a form
2505 that is suitable for both protocol and saving in files. */
2506 /* This version does not do multiple encodes for long strings; it should
2507 return an offset to the next piece to encode. FIXME */
2510 encode_source_string (int tpnum
, ULONGEST addr
,
2511 char *srctype
, char *src
, char *buf
, int buf_size
)
2513 if (80 + strlen (srctype
) > buf_size
)
2514 error (_("Buffer too small for source encoding"));
2515 sprintf (buf
, "%x:%s:%s:%x:%x:",
2516 tpnum
, phex_nz (addr
, sizeof (addr
)), srctype
, 0, (int) strlen (src
));
2517 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2518 error (_("Source string too long for buffer"));
2519 bin2hex (src
, buf
+ strlen (buf
), 0);
2523 extern int trace_regblock_size
;
2525 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2526 non-zero, the save is performed on the target, otherwise GDB obtains all
2527 trace data and saves it locally. */
2530 trace_save (const char *filename
, int target_does_save
)
2532 struct cleanup
*cleanup
;
2534 struct trace_status
*ts
= current_trace_status ();
2537 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2538 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2540 struct uploaded_string
*cmd
;
2542 ULONGEST offset
= 0;
2543 #define MAX_TRACE_UPLOAD 2000
2544 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2547 /* If the target is to save the data to a file on its own, then just
2548 send the command and be done with it. */
2549 if (target_does_save
)
2551 err
= target_save_trace_data (filename
);
2553 error (_("Target failed to save trace data to '%s'."),
2558 /* Get the trace status first before opening the file, so if the
2559 target is losing, we can get out without touching files. */
2560 status
= target_get_trace_status (ts
);
2562 pathname
= tilde_expand (filename
);
2563 cleanup
= make_cleanup (xfree
, pathname
);
2565 fp
= fopen (pathname
, "w");
2567 error (_("Unable to open file '%s' for saving trace data (%s)"),
2568 filename
, safe_strerror (errno
));
2569 make_cleanup_fclose (fp
);
2571 /* Write a file header, with a high-bit-set char to indicate a
2572 binary file, plus a hint as what this file is, and a version
2573 number in case of future needs. */
2574 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2576 perror_with_name (pathname
);
2578 /* Write descriptive info. */
2580 /* Write out the size of a register block. */
2581 fprintf (fp
, "R %x\n", trace_regblock_size
);
2583 /* Write out status of the tracing run (aka "tstatus" info). */
2584 fprintf (fp
, "status %c;%s",
2585 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
2586 if (ts
->stop_reason
== tracepoint_error
)
2588 char *buf
= (char *) alloca (strlen (ts
->error_desc
) * 2 + 1);
2589 bin2hex ((gdb_byte
*) ts
->error_desc
, buf
, 0);
2590 fprintf (fp
, ":%s", buf
);
2592 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
2593 if (ts
->traceframe_count
>= 0)
2594 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
2595 if (ts
->traceframes_created
>= 0)
2596 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
2597 if (ts
->buffer_free
>= 0)
2598 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
2599 if (ts
->buffer_size
>= 0)
2600 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
2603 /* Note that we want to upload tracepoints and save those, rather
2604 than simply writing out the local ones, because the user may have
2605 changed tracepoints in GDB in preparation for a future tracing
2606 run, or maybe just mass-deleted all types of breakpoints as part
2607 of cleaning up. So as not to contaminate the session, leave the
2608 data in its uploaded form, don't make into real tracepoints. */
2610 /* Get trace state variables first, they may be checked when parsing
2611 uploaded commands. */
2613 target_upload_trace_state_variables (&uploaded_tsvs
);
2615 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2621 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
2622 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
2625 fprintf (fp
, "tsv %x:%s:%x:%s\n",
2626 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
2627 utsv
->builtin
, buf
);
2633 free_uploaded_tsvs (&uploaded_tsvs
);
2635 target_upload_tracepoints (&uploaded_tps
);
2637 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
2639 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
2640 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2641 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
2642 if (utp
->type
== bp_fast_tracepoint
)
2643 fprintf (fp
, ":F%x", utp
->orig_size
);
2645 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
2648 for (a
= 0; a
< utp
->numactions
; ++a
)
2649 fprintf (fp
, "tp A%x:%s:%s\n",
2650 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2652 for (a
= 0; a
< utp
->num_step_actions
; ++a
)
2653 fprintf (fp
, "tp S%x:%s:%s\n",
2654 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2655 utp
->step_actions
[a
]);
2658 encode_source_string (utp
->number
, utp
->addr
,
2659 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
2660 fprintf (fp
, "tp Z%s\n", buf
);
2662 if (utp
->cond_string
)
2664 encode_source_string (utp
->number
, utp
->addr
,
2665 "cond", utp
->cond_string
, buf
, MAX_TRACE_UPLOAD
);
2666 fprintf (fp
, "tp Z%s\n", buf
);
2668 for (cmd
= utp
->cmd_strings
; cmd
; cmd
= cmd
->next
)
2670 encode_source_string (utp
->number
, utp
->addr
, "cmd", cmd
->str
,
2671 buf
, MAX_TRACE_UPLOAD
);
2672 fprintf (fp
, "tp Z%s\n", buf
);
2676 free_uploaded_tps (&uploaded_tps
);
2678 /* Mark the end of the definition section. */
2681 /* Get and write the trace data proper. We ask for big blocks, in
2682 the hopes of efficiency, but will take less if the target has
2683 packet size limitations or some such. */
2686 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
2688 error (_("Failure to get requested trace buffer data"));
2689 /* No more data is forthcoming, we're done. */
2692 written
= fwrite (buf
, gotten
, 1, fp
);
2694 perror_with_name (pathname
);
2698 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
2699 written
= fwrite (&gotten
, 4, 1, fp
);
2701 perror_with_name (pathname
);
2703 do_cleanups (cleanup
);
2707 trace_save_command (char *args
, int from_tty
)
2709 int target_does_save
= 0;
2711 char *filename
= NULL
;
2712 struct cleanup
*back_to
;
2715 error_no_arg (_("file in which to save trace data"));
2717 argv
= gdb_buildargv (args
);
2718 back_to
= make_cleanup_freeargv (argv
);
2720 for (; *argv
; ++argv
)
2722 if (strcmp (*argv
, "-r") == 0)
2723 target_does_save
= 1;
2724 else if (**argv
== '-')
2725 error (_("unknown option `%s'"), *argv
);
2731 error_no_arg (_("file in which to save trace data"));
2733 trace_save (filename
, target_does_save
);
2736 printf_filtered (_("Trace data saved to file '%s'.\n"), args
);
2738 do_cleanups (back_to
);
2741 /* Tell the target what to do with an ongoing tracing run if GDB
2742 disconnects for some reason. */
2745 send_disconnected_tracing_value (int value
)
2747 target_set_disconnected_tracing (value
);
2751 set_disconnected_tracing (char *args
, int from_tty
,
2752 struct cmd_list_element
*c
)
2754 send_disconnected_tracing_value (disconnected_tracing
);
2758 set_circular_trace_buffer (char *args
, int from_tty
,
2759 struct cmd_list_element
*c
)
2761 target_set_circular_trace_buffer (circular_trace_buffer
);
2764 /* Convert the memory pointed to by mem into hex, placing result in buf.
2765 * Return a pointer to the last char put in buf (null)
2766 * "stolen" from sparc-stub.c
2769 static const char hexchars
[] = "0123456789abcdef";
2772 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2780 *buf
++ = hexchars
[ch
>> 4];
2781 *buf
++ = hexchars
[ch
& 0xf];
2790 get_traceframe_number (void)
2792 return traceframe_number
;
2795 /* Make the traceframe NUM be the current trace frame. Does nothing
2796 if NUM is already current. */
2799 set_traceframe_number (int num
)
2803 if (traceframe_number
== num
)
2805 /* Nothing to do. */
2809 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
2812 warning (_("could not change traceframe"));
2814 traceframe_number
= newnum
;
2816 /* Changing the traceframe changes our view of registers and of the
2818 registers_changed ();
2821 /* A cleanup used when switching away and back from tfind mode. */
2823 struct current_traceframe_cleanup
2825 /* The traceframe we were inspecting. */
2826 int traceframe_number
;
2830 do_restore_current_traceframe_cleanup (void *arg
)
2832 struct current_traceframe_cleanup
*old
= arg
;
2834 set_traceframe_number (old
->traceframe_number
);
2838 restore_current_traceframe_cleanup_dtor (void *arg
)
2840 struct current_traceframe_cleanup
*old
= arg
;
2846 make_cleanup_restore_current_traceframe (void)
2848 struct current_traceframe_cleanup
*old
;
2850 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
2851 old
->traceframe_number
= traceframe_number
;
2853 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
2854 restore_current_traceframe_cleanup_dtor
);
2857 /* Given a number and address, return an uploaded tracepoint with that
2858 number, creating if necessary. */
2860 struct uploaded_tp
*
2861 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
2863 struct uploaded_tp
*utp
;
2865 for (utp
= *utpp
; utp
; utp
= utp
->next
)
2866 if (utp
->number
== num
&& utp
->addr
== addr
)
2868 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
2869 memset (utp
, 0, sizeof (struct uploaded_tp
));
2878 free_uploaded_tps (struct uploaded_tp
**utpp
)
2880 struct uploaded_tp
*next_one
;
2884 next_one
= (*utpp
)->next
;
2890 /* Given a number and address, return an uploaded tracepoint with that
2891 number, creating if necessary. */
2893 struct uploaded_tsv
*
2894 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
2896 struct uploaded_tsv
*utsv
;
2898 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
2899 if (utsv
->number
== num
)
2901 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
2902 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
2904 utsv
->next
= *utsvp
;
2910 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
2912 struct uploaded_tsv
*next_one
;
2916 next_one
= (*utsvp
)->next
;
2922 /* Look for an existing tracepoint that seems similar enough to the
2923 uploaded one. Enablement isn't compared, because the user can
2924 toggle that freely, and may have done so in anticipation of the
2928 find_matching_tracepoint (struct uploaded_tp
*utp
)
2930 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
2932 struct breakpoint
*t
;
2933 struct bp_location
*loc
;
2935 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2937 if (t
->type
== utp
->type
2938 && t
->step_count
== utp
->step
2939 && t
->pass_count
== utp
->pass
2940 /* FIXME also test conditionals and actions */
2943 /* Scan the locations for an address match. */
2944 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2946 if (loc
->address
== utp
->addr
)
2954 /* Given a list of tracepoints uploaded from a target, attempt to
2955 match them up with existing tracepoints, and create new ones if not
2959 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
2961 struct uploaded_tp
*utp
;
2962 struct breakpoint
*t
;
2964 /* Look for GDB tracepoints that match up with our uploaded versions. */
2965 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
2967 t
= find_matching_tracepoint (utp
);
2969 printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
2970 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2973 t
= create_tracepoint_from_upload (utp
);
2975 printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
2976 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2978 printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
2979 utp
->number
, paddress (get_current_arch (), utp
->addr
));
2981 /* Whether found or created, record the number used by the
2982 target, to help with mapping target tracepoints back to their
2983 counterparts here. */
2985 t
->number_on_target
= utp
->number
;
2988 free_uploaded_tps (uploaded_tps
);
2991 /* Trace state variables don't have much to identify them beyond their
2992 name, so just use that to detect matches. */
2994 struct trace_state_variable
*
2995 find_matching_tsv (struct uploaded_tsv
*utsv
)
3000 return find_trace_state_variable (utsv
->name
);
3003 struct trace_state_variable
*
3004 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3006 const char *namebase
;
3009 struct trace_state_variable
*tsv
;
3013 namebase
= utsv
->name
;
3014 sprintf (buf
, "%s", namebase
);
3019 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3022 /* Fish for a name that is not in use. */
3023 /* (should check against all internal vars?) */
3024 while (find_trace_state_variable (buf
))
3025 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3027 /* We have an available name, create the variable. */
3028 tsv
= create_trace_state_variable (xstrdup (buf
));
3029 tsv
->initial_value
= utsv
->initial_value
;
3030 tsv
->builtin
= utsv
->builtin
;
3035 /* Given a list of uploaded trace state variables, try to match them
3036 up with existing variables, or create additional ones. */
3039 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3042 struct uploaded_tsv
*utsv
;
3043 struct trace_state_variable
*tsv
;
3046 /* Most likely some numbers will have to be reassigned as part of
3047 the merge, so clear them all in anticipation. */
3048 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3051 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3053 tsv
= find_matching_tsv (utsv
);
3055 printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
3056 tsv
->name
, utsv
->number
);
3059 tsv
= create_tsv_from_upload (utsv
);
3060 printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
3061 tsv
->name
, utsv
->number
);
3063 /* Give precedence to numberings that come from the target. */
3065 tsv
->number
= utsv
->number
;
3068 /* Renumber everything that didn't get a target-assigned number. */
3070 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3071 if (tsv
->number
> highest
)
3072 highest
= tsv
->number
;
3075 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3076 if (tsv
->number
== 0)
3077 tsv
->number
= highest
++;
3079 free_uploaded_tsvs (uploaded_tsvs
);
3082 /* target tfile command */
3084 struct target_ops tfile_ops
;
3086 /* Fill in tfile_ops with its defined operations and properties. */
3088 #define TRACE_HEADER_SIZE 8
3090 char *trace_filename
;
3092 off_t trace_frames_offset
;
3095 int trace_regblock_size
;
3097 static void tfile_interp_line (char *line
,
3098 struct uploaded_tp
**utpp
,
3099 struct uploaded_tsv
**utsvp
);
3102 tfile_open (char *filename
, int from_tty
)
3105 struct cleanup
*old_chain
;
3108 char header
[TRACE_HEADER_SIZE
];
3109 char linebuf
[1000]; /* should be max remote packet size or so */
3111 int bytes
, i
, gotten
;
3112 struct trace_status
*ts
;
3113 struct uploaded_tp
*uploaded_tps
= NULL
;
3114 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3116 target_preopen (from_tty
);
3118 error (_("No trace file specified."));
3120 filename
= tilde_expand (filename
);
3121 if (!IS_ABSOLUTE_PATH(filename
))
3123 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
3128 old_chain
= make_cleanup (xfree
, filename
);
3130 flags
= O_BINARY
| O_LARGEFILE
;
3132 scratch_chan
= open (filename
, flags
, 0);
3133 if (scratch_chan
< 0)
3134 perror_with_name (filename
);
3136 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3138 discard_cleanups (old_chain
); /* Don't free filename any more */
3139 unpush_target (&tfile_ops
);
3141 push_target (&tfile_ops
);
3143 trace_filename
= xstrdup (filename
);
3144 trace_fd
= scratch_chan
;
3147 /* Read the file header and test for validity. */
3148 gotten
= read (trace_fd
, &header
, TRACE_HEADER_SIZE
);
3150 perror_with_name (trace_filename
);
3151 else if (gotten
< TRACE_HEADER_SIZE
)
3152 error (_("Premature end of file while reading trace file"));
3154 bytes
+= TRACE_HEADER_SIZE
;
3155 if (!(header
[0] == 0x7f
3156 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3157 error (_("File is not a valid trace file."));
3159 trace_regblock_size
= 0;
3160 ts
= current_trace_status ();
3161 /* We know we're working with a file. */
3163 /* Set defaults in case there is no status line. */
3164 ts
->running_known
= 0;
3165 ts
->stop_reason
= trace_stop_reason_unknown
;
3166 ts
->traceframe_count
= -1;
3167 ts
->buffer_free
= 0;
3169 /* Read through a section of newline-terminated lines that
3170 define things like tracepoints. */
3174 gotten
= read (trace_fd
, &byte
, 1);
3176 perror_with_name (trace_filename
);
3177 else if (gotten
< 1)
3178 error (_("Premature end of file while reading trace file"));
3183 /* Empty line marks end of the definition section. */
3188 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3191 linebuf
[i
++] = byte
;
3193 error (_("Excessively long lines in trace file"));
3196 /* Add the file's tracepoints and variables into the current mix. */
3198 /* Get trace state variables first, they may be checked when parsing
3199 uploaded commands. */
3200 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3202 merge_uploaded_tracepoints (&uploaded_tps
);
3204 /* Record the starting offset of the binary trace data. */
3205 trace_frames_offset
= bytes
;
3207 /* If we don't have a blocksize, we can't interpret the
3209 if (trace_regblock_size
== 0)
3210 error (_("No register block size recorded in trace file"));
3211 if (ts
->traceframe_count
<= 0)
3213 warning ("No traceframes present in this file.");
3217 #define TFILE_PID (1)
3218 inferior_appeared (current_inferior (), TFILE_PID
);
3219 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3220 add_thread_silent (inferior_ptid
);
3222 post_create_inferior (&tfile_ops
, from_tty
);
3225 /* FIXME this will get defined in MI patch submission */
3226 tfind_1 (tfind_number
, 0, 0, 0, 0);
3230 /* Interpret the given line from the definitions part of the trace
3234 tfile_interp_line (char *line
,
3235 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3239 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3242 trace_regblock_size
= strtol (p
, &p
, 16);
3244 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3246 p
+= strlen ("status ");
3247 parse_trace_status (p
, current_trace_status ());
3249 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3251 p
+= strlen ("tp ");
3252 parse_tracepoint_definition (p
, utpp
);
3254 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3256 p
+= strlen ("tsv ");
3257 parse_tsv_definition (p
, utsvp
);
3260 warning ("Ignoring trace file definition \"%s\"", line
);
3263 /* Parse the part of trace status syntax that is shared between
3264 the remote protocol and the trace file reader. */
3266 extern char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
3269 parse_trace_status (char *line
, struct trace_status
*ts
)
3271 char *p
= line
, *p1
, *p2
, *p_temp
;
3274 ts
->running_known
= 1;
3275 ts
->running
= (*p
++ == '1');
3276 ts
->stop_reason
= trace_stop_reason_unknown
;
3277 xfree (ts
->error_desc
);
3278 ts
->error_desc
= NULL
;
3279 ts
->traceframe_count
= -1;
3280 ts
->traceframes_created
= -1;
3281 ts
->buffer_free
= -1;
3282 ts
->buffer_size
= -1;
3286 p1
= strchr (p
, ':');
3288 error (_("Malformed trace status, at %s\n\
3289 Status line: '%s'\n"), p
, line
);
3290 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3292 p
= unpack_varlen_hex (++p1
, &val
);
3293 ts
->stop_reason
= trace_buffer_full
;
3295 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3297 p
= unpack_varlen_hex (++p1
, &val
);
3298 ts
->stop_reason
= trace_never_run
;
3300 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
], p1
- p
) == 0)
3302 p
= unpack_varlen_hex (++p1
, &val
);
3303 ts
->stop_reason
= tracepoint_passcount
;
3304 ts
->stopping_tracepoint
= val
;
3306 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3308 p
= unpack_varlen_hex (++p1
, &val
);
3309 ts
->stop_reason
= tstop_command
;
3311 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3313 p2
= strchr (++p1
, ':');
3318 ts
->error_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3319 end
= hex2bin (p1
, ts
->error_desc
, (p2
- p1
) / 2);
3320 ts
->error_desc
[end
] = '\0';
3323 ts
->error_desc
= xstrdup ("");
3325 p
= unpack_varlen_hex (++p2
, &val
);
3326 ts
->stopping_tracepoint
= val
;
3327 ts
->stop_reason
= tracepoint_error
;
3329 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3331 p
= unpack_varlen_hex (++p1
, &val
);
3332 ts
->traceframe_count
= val
;
3334 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3336 p
= unpack_varlen_hex (++p1
, &val
);
3337 ts
->traceframes_created
= val
;
3339 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3341 p
= unpack_varlen_hex (++p1
, &val
);
3342 ts
->buffer_free
= val
;
3344 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3346 p
= unpack_varlen_hex (++p1
, &val
);
3347 ts
->buffer_size
= val
;
3351 /* Silently skip unknown optional info. */
3352 p_temp
= strchr (p1
+ 1, ';');
3356 /* Must be at the end. */
3362 /* Given a line of text defining a part of a tracepoint, parse it into
3363 an "uploaded tracepoint". */
3366 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3370 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3371 int enabled
, i
, end
;
3373 char *cond
, *srctype
, *src
, *buf
;
3374 struct uploaded_tp
*utp
= NULL
;
3377 /* Both tracepoint and action definitions start with the same number
3378 and address sequence. */
3380 p
= unpack_varlen_hex (p
, &num
);
3381 p
++; /* skip a colon */
3382 p
= unpack_varlen_hex (p
, &addr
);
3383 p
++; /* skip a colon */
3386 enabled
= (*p
++ == 'E');
3387 p
++; /* skip a colon */
3388 p
= unpack_varlen_hex (p
, &step
);
3389 p
++; /* skip a colon */
3390 p
= unpack_varlen_hex (p
, &pass
);
3391 type
= bp_tracepoint
;
3393 /* Thumb through optional fields. */
3396 p
++; /* skip a colon */
3399 type
= bp_fast_tracepoint
;
3401 p
= unpack_varlen_hex (p
, &orig_size
);
3406 p
= unpack_varlen_hex (p
, &xlen
);
3407 p
++; /* skip a comma */
3408 cond
= (char *) xmalloc (2 * xlen
+ 1);
3409 strncpy (cond
, p
, 2 * xlen
);
3410 cond
[2 * xlen
] = '\0';
3414 warning (_("Unrecognized char '%c' in tracepoint definition, skipping rest"), *p
);
3416 utp
= get_uploaded_tp (num
, addr
, utpp
);
3418 utp
->enabled
= enabled
;
3423 else if (piece
== 'A')
3425 utp
= get_uploaded_tp (num
, addr
, utpp
);
3426 utp
->actions
[utp
->numactions
++] = xstrdup (p
);
3428 else if (piece
== 'S')
3430 utp
= get_uploaded_tp (num
, addr
, utpp
);
3431 utp
->step_actions
[utp
->num_step_actions
++] = xstrdup (p
);
3433 else if (piece
== 'Z')
3435 /* Parse a chunk of source form definition. */
3436 utp
= get_uploaded_tp (num
, addr
, utpp
);
3438 p
= strchr (p
, ':');
3439 p
++; /* skip a colon */
3440 p
= unpack_varlen_hex (p
, &start
);
3441 p
++; /* skip a colon */
3442 p
= unpack_varlen_hex (p
, &xlen
);
3443 p
++; /* skip a colon */
3445 buf
= alloca (strlen (line
));
3447 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3450 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
3451 utp
->at_string
= xstrdup (buf
);
3452 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
3453 utp
->cond_string
= xstrdup (buf
);
3454 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
3456 /* FIXME consider using a vector? */
3457 struct uploaded_string
*last
, *newlast
;
3458 newlast
= (struct uploaded_string
*) xmalloc (sizeof (struct uploaded_string
));
3459 newlast
->str
= xstrdup (buf
);
3460 newlast
->next
= NULL
;
3461 if (utp
->cmd_strings
)
3463 for (last
= utp
->cmd_strings
; last
->next
; last
= last
->next
)
3465 last
->next
= newlast
;
3468 utp
->cmd_strings
= newlast
;
3473 /* Don't error out, the target might be sending us optional
3474 info that we don't care about. */
3475 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3479 /* Convert a textual description of a trace state variable into an
3483 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3486 ULONGEST num
, initval
, builtin
;
3488 struct uploaded_tsv
*utsv
= NULL
;
3490 buf
= alloca (strlen (line
));
3493 p
= unpack_varlen_hex (p
, &num
);
3494 p
++; /* skip a colon */
3495 p
= unpack_varlen_hex (p
, &initval
);
3496 p
++; /* skip a colon */
3497 p
= unpack_varlen_hex (p
, &builtin
);
3498 p
++; /* skip a colon */
3499 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3502 utsv
= get_uploaded_tsv (num
, utsvp
);
3503 utsv
->initial_value
= initval
;
3504 utsv
->builtin
= builtin
;
3505 utsv
->name
= xstrdup (buf
);
3508 /* Close the trace file and generally clean up. */
3511 tfile_close (int quitting
)
3518 pid
= ptid_get_pid (inferior_ptid
);
3519 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
3520 exit_inferior_silent (pid
);
3525 xfree (trace_filename
);
3529 tfile_files_info (struct target_ops
*t
)
3531 /* (it would be useful to mention the name of the file) */
3532 printf_filtered ("Looking at a trace file.\n");
3535 /* The trace status for a file is that tracing can never be run. */
3538 tfile_get_trace_status (struct trace_status
*ts
)
3540 /* Other bits of trace status were collected as part of opening the
3541 trace files, so nothing to do here. */
3546 /* Given the position of a traceframe in the file, figure out what
3547 address the frame was collected at. This would normally be the
3548 value of a collected PC register, but if not available, we
3552 tfile_get_traceframe_address (off_t tframe_offset
)
3556 struct breakpoint
*tp
;
3557 off_t saved_offset
= cur_offset
;
3560 /* FIXME dig pc out of collected registers */
3562 /* Fall back to using tracepoint address. */
3563 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
3564 gotten
= read (trace_fd
, &tpnum
, 2);
3566 perror_with_name (trace_filename
);
3567 else if (gotten
< 2)
3568 error (_("Premature end of file while reading trace file"));
3570 tp
= get_tracepoint_by_number_on_target (tpnum
);
3571 /* FIXME this is a poor heuristic if multiple locations */
3573 addr
= tp
->loc
->address
;
3575 /* Restore our seek position. */
3576 cur_offset
= saved_offset
;
3577 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3581 /* Given a type of search and some parameters, scan the collection of
3582 traceframes in the file looking for a match. When found, return
3583 both the traceframe and tracepoint number, otherwise -1 for
3587 tfile_trace_find (enum trace_find_type type
, int num
,
3588 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
3591 int tfnum
= 0, found
= 0, gotten
;
3593 struct breakpoint
*tp
;
3594 off_t offset
, tframe_offset
;
3597 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
3598 offset
= trace_frames_offset
;
3601 tframe_offset
= offset
;
3602 gotten
= read (trace_fd
, &tpnum
, 2);
3604 perror_with_name (trace_filename
);
3605 else if (gotten
< 2)
3606 error (_("Premature end of file while reading trace file"));
3610 gotten
= read (trace_fd
, &data_size
, 4);
3612 perror_with_name (trace_filename
);
3613 else if (gotten
< 4)
3614 error (_("Premature end of file while reading trace file"));
3623 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3624 if (tfaddr
== addr1
)
3628 tp
= get_tracepoint (num
);
3629 if (tp
&& tpnum
== tp
->number_on_target
)
3633 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3634 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
3638 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3639 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
3643 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
3649 cur_offset
= offset
;
3650 cur_data_size
= data_size
;
3653 /* Skip past the traceframe's data. */
3654 lseek (trace_fd
, data_size
, SEEK_CUR
);
3655 offset
+= data_size
;
3656 /* Update our own count of traceframes. */
3659 /* Did not find what we were looking for. */
3665 /* Look for a block of saved registers in the traceframe, and get the
3666 requested register from it. */
3669 tfile_fetch_registers (struct target_ops
*ops
,
3670 struct regcache
*regcache
, int regno
)
3672 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3674 int i
, pos
, offset
, regn
, regsize
, gotten
, pc_regno
;
3675 unsigned short mlen
;
3678 /* An uninitialized reg size says we're not going to be
3679 successful at getting register blocks. */
3680 if (!trace_regblock_size
)
3683 regs
= alloca (trace_regblock_size
);
3685 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3687 while (pos
< cur_data_size
)
3689 gotten
= read (trace_fd
, &block_type
, 1);
3691 perror_with_name (trace_filename
);
3692 else if (gotten
< 1)
3693 error (_("Premature end of file while reading trace file"));
3699 gotten
= read (trace_fd
, regs
, trace_regblock_size
);
3701 perror_with_name (trace_filename
);
3702 else if (gotten
< trace_regblock_size
)
3703 error (_("Premature end of file while reading trace file"));
3705 /* Assume the block is laid out in GDB register number order,
3706 each register with the size that it has in GDB. */
3708 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3710 regsize
= register_size (gdbarch
, regn
);
3711 /* Make sure we stay within block bounds. */
3712 if (offset
+ regsize
>= trace_regblock_size
)
3714 if (!regcache_valid_p (regcache
, regn
))
3718 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
3721 else if (regno
== -1)
3723 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
3730 lseek (trace_fd
, 8, SEEK_CUR
);
3731 gotten
= read (trace_fd
, &mlen
, 2);
3733 perror_with_name (trace_filename
);
3734 else if (gotten
< 2)
3735 error (_("Premature end of file while reading trace file"));
3736 lseek (trace_fd
, mlen
, SEEK_CUR
);
3737 pos
+= (8 + 2 + mlen
);
3740 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3744 error ("Unknown block type '%c' (0x%x) in trace frame",
3745 block_type
, block_type
);
3750 /* We get here if no register data has been found. Although we
3751 don't like making up numbers, GDB has all manner of troubles when
3752 the target says some register is not available. Filling in with
3753 zeroes is a reasonable fallback. */
3754 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3755 regcache_raw_supply (regcache
, regn
, NULL
);
3757 /* We can often usefully guess that the PC is going to be the same
3758 as the address of the tracepoint. */
3759 pc_regno
= gdbarch_pc_regnum (gdbarch
);
3760 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
3762 struct breakpoint
*tp
= get_tracepoint (tracepoint_number
);
3766 /* But don't try to guess if tracepoint is multi-location... */
3769 warning ("Tracepoint %d has multiple locations, cannot infer $pc",
3773 /* ... or does while-stepping. */
3774 if (tp
->step_count
> 0)
3776 warning ("Tracepoint %d does while-stepping, cannot infer $pc",
3781 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
3782 gdbarch_byte_order (gdbarch
),
3784 regcache_raw_supply (regcache
, pc_regno
, regs
);
3790 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3791 const char *annex
, gdb_byte
*readbuf
,
3792 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3797 unsigned short mlen
;
3799 /* We're only doing regular memory for now. */
3800 if (object
!= TARGET_OBJECT_MEMORY
)
3803 if (readbuf
== NULL
)
3804 error ("tfile_xfer_partial: trace file is read-only");
3806 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3808 while (pos
< cur_data_size
)
3810 gotten
= read (trace_fd
, &block_type
, 1);
3812 perror_with_name (trace_filename
);
3813 else if (gotten
< 1)
3814 error (_("Premature end of file while reading trace file"));
3819 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3820 pos
+= trace_regblock_size
;
3823 gotten
= read (trace_fd
, &maddr
, 8);
3825 perror_with_name (trace_filename
);
3826 else if (gotten
< 8)
3827 error (_("Premature end of file while reading trace file"));
3829 gotten
= read (trace_fd
, &mlen
, 2);
3831 perror_with_name (trace_filename
);
3832 else if (gotten
< 2)
3833 error (_("Premature end of file while reading trace file"));
3834 if (maddr
<= offset
&& (offset
+ len
) <= (maddr
+ mlen
))
3836 gotten
= read (trace_fd
, readbuf
, mlen
);
3838 perror_with_name (trace_filename
);
3839 else if (gotten
< mlen
)
3840 error (_("Premature end of file qwhile reading trace file"));
3844 lseek (trace_fd
, mlen
, SEEK_CUR
);
3845 pos
+= (8 + 2 + mlen
);
3848 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3852 error ("Unknown block type '%c' (0x%x) in traceframe",
3853 block_type
, block_type
);
3857 /* Indicate failure to find the requested memory block. */
3861 /* Iterate through the blocks of a trace frame, looking for a 'V'
3862 block with a matching tsv number. */
3865 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
3868 int pos
, vnum
, gotten
;
3869 unsigned short mlen
;
3871 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3873 while (pos
< cur_data_size
)
3875 gotten
= read (trace_fd
, &block_type
, 1);
3877 perror_with_name (trace_filename
);
3878 else if (gotten
< 1)
3879 error (_("Premature end of file while reading trace file"));
3884 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3885 pos
+= trace_regblock_size
;
3888 lseek (trace_fd
, 8, SEEK_CUR
);
3889 gotten
= read (trace_fd
, &mlen
, 2);
3891 perror_with_name (trace_filename
);
3892 else if (gotten
< 2)
3893 error (_("Premature end of file while reading trace file"));
3894 lseek (trace_fd
, mlen
, SEEK_CUR
);
3895 pos
+= (8 + 2 + mlen
);
3898 gotten
= read (trace_fd
, &vnum
, 4);
3900 perror_with_name (trace_filename
);
3901 else if (gotten
< 4)
3902 error (_("Premature end of file while reading trace file"));
3905 gotten
= read (trace_fd
, val
, 8);
3907 perror_with_name (trace_filename
);
3908 else if (gotten
< 8)
3909 error (_("Premature end of file while reading trace file"));
3912 lseek (trace_fd
, 8, SEEK_CUR
);
3916 error ("Unknown block type '%c' (0x%x) in traceframe",
3917 block_type
, block_type
);
3921 /* Didn't find anything. */
3926 tfile_has_memory (struct target_ops
*ops
)
3932 tfile_has_stack (struct target_ops
*ops
)
3938 tfile_has_registers (struct target_ops
*ops
)
3944 init_tfile_ops (void)
3946 tfile_ops
.to_shortname
= "tfile";
3947 tfile_ops
.to_longname
= "Local trace dump file";
3949 "Use a trace file as a target. Specify the filename of the trace file.";
3950 tfile_ops
.to_open
= tfile_open
;
3951 tfile_ops
.to_close
= tfile_close
;
3952 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
3953 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
3954 tfile_ops
.to_files_info
= tfile_files_info
;
3955 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
3956 tfile_ops
.to_trace_find
= tfile_trace_find
;
3957 tfile_ops
.to_get_trace_state_variable_value
= tfile_get_trace_state_variable_value
;
3958 /* core_stratum might seem more logical, but GDB doesn't like having
3959 more than one core_stratum vector. */
3960 tfile_ops
.to_stratum
= process_stratum
;
3961 tfile_ops
.to_has_memory
= tfile_has_memory
;
3962 tfile_ops
.to_has_stack
= tfile_has_stack
;
3963 tfile_ops
.to_has_registers
= tfile_has_registers
;
3964 tfile_ops
.to_magic
= OPS_MAGIC
;
3967 /* module initialization */
3969 _initialize_tracepoint (void)
3971 struct cmd_list_element
*c
;
3973 traceframe_number
= -1;
3974 tracepoint_number
= -1;
3976 if (tracepoint_list
.list
== NULL
)
3978 tracepoint_list
.listsize
= 128;
3979 tracepoint_list
.list
= xmalloc
3980 (tracepoint_list
.listsize
* sizeof (struct memrange
));
3982 if (tracepoint_list
.aexpr_list
== NULL
)
3984 tracepoint_list
.aexpr_listsize
= 128;
3985 tracepoint_list
.aexpr_list
= xmalloc
3986 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3989 if (stepping_list
.list
== NULL
)
3991 stepping_list
.listsize
= 128;
3992 stepping_list
.list
= xmalloc
3993 (stepping_list
.listsize
* sizeof (struct memrange
));
3996 if (stepping_list
.aexpr_list
== NULL
)
3998 stepping_list
.aexpr_listsize
= 128;
3999 stepping_list
.aexpr_list
= xmalloc
4000 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
4003 add_info ("scope", scope_info
,
4004 _("List the variables local to a scope"));
4006 add_cmd ("tracepoints", class_trace
, NULL
,
4007 _("Tracing of program execution without stopping the program."),
4010 add_com ("tdump", class_trace
, trace_dump_command
,
4011 _("Print everything collected at the current tracepoint."));
4013 add_com ("tsave", class_trace
, trace_save_command
, _("\
4014 Save the trace data to a file.\n\
4015 Use the '-r' option to direct the target to save directly to the file,\n\
4016 using its own filesystem."));
4018 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
4019 Define a trace state variable.\n\
4020 Argument is a $-prefixed name, optionally followed\n\
4021 by '=' and an expression that sets the initial value\n\
4022 at the start of tracing."));
4023 set_cmd_completer (c
, expression_completer
);
4025 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
4026 Delete one or more trace state variables.\n\
4027 Arguments are the names of the variables to delete.\n\
4028 If no arguments are supplied, delete all variables."), &deletelist
);
4029 /* FIXME add a trace variable completer */
4031 add_info ("tvariables", tvariables_info
, _("\
4032 Status of trace state variables and their values.\n\
4035 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
4036 Select a trace frame;\n\
4037 No argument means forward by one frame; '-' means backward by one frame."),
4038 &tfindlist
, "tfind ", 1, &cmdlist
);
4040 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
4041 Select a trace frame whose PC is outside the given range (exclusive).\n\
4042 Usage: tfind outside addr1, addr2"),
4045 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
4046 Select a trace frame whose PC is in the given range (inclusive).\n\
4047 Usage: tfind range addr1,addr2"),
4050 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
4051 Select a trace frame by source line.\n\
4052 Argument can be a line number (with optional source file), \n\
4053 a function name, or '*' followed by an address.\n\
4054 Default argument is 'the next source line that was traced'."),
4057 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
4058 Select a trace frame by tracepoint number.\n\
4059 Default is the tracepoint for the current trace frame."),
4062 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
4063 Select a trace frame by PC.\n\
4064 Default is the current PC, or the PC of the current trace frame."),
4067 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
4068 Synonym for 'none'.\n\
4069 De-select any trace frame and resume 'live' debugging."),
4072 add_cmd ("none", class_trace
, trace_find_none_command
,
4073 _("De-select any trace frame and resume 'live' debugging."),
4076 add_cmd ("start", class_trace
, trace_find_start_command
,
4077 _("Select the first trace frame in the trace buffer."),
4080 add_com ("tstatus", class_trace
, trace_status_command
,
4081 _("Display the status of the current trace data collection."));
4083 add_com ("tstop", class_trace
, trace_stop_command
,
4084 _("Stop trace data collection."));
4086 add_com ("tstart", class_trace
, trace_start_command
,
4087 _("Start trace data collection."));
4089 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
4090 Ends a list of commands or actions.\n\
4091 Several GDB commands allow you to enter a list of commands or actions.\n\
4092 Entering \"end\" on a line by itself is the normal way to terminate\n\
4094 Note: the \"end\" command cannot be used at the gdb prompt."));
4096 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
4097 Specify single-stepping behavior at a tracepoint.\n\
4098 Argument is number of instructions to trace in single-step mode\n\
4099 following the tracepoint. This command is normally followed by\n\
4100 one or more \"collect\" commands, to specify what to collect\n\
4101 while single-stepping.\n\n\
4102 Note: this command can only be used in a tracepoint \"actions\" list."));
4104 add_com_alias ("ws", "while-stepping", class_alias
, 0);
4105 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
4107 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
4108 Specify one or more data items to be collected at a tracepoint.\n\
4109 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4110 collect all data (variables, registers) referenced by that expression.\n\
4111 Also accepts the following special arguments:\n\
4112 $regs -- all registers.\n\
4113 $args -- all function arguments.\n\
4114 $locals -- all variables local to the block/function scope.\n\
4115 Note: this command can only be used in a tracepoint \"actions\" list."));
4117 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4118 Specify one or more expressions to be evaluated at a tracepoint.\n\
4119 Accepts a comma-separated list of (one or more) expressions.\n\
4120 The result of each evaluation will be discarded.\n\
4121 Note: this command can only be used in a tracepoint \"actions\" list."));
4123 add_com ("actions", class_trace
, trace_actions_command
, _("\
4124 Specify the actions to be taken at a tracepoint.\n\
4125 Tracepoint actions may include collecting of specified data, \n\
4126 single-stepping, or enabling/disabling other tracepoints, \n\
4127 depending on target's capabilities."));
4129 default_collect
= xstrdup ("");
4130 add_setshow_string_cmd ("default-collect", class_trace
,
4131 &default_collect
, _("\
4132 Set the list of expressions to collect by default"), _("\
4133 Show the list of expressions to collect by default"), NULL
,
4135 &setlist
, &showlist
);
4137 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4138 &disconnected_tracing
, _("\
4139 Set whether tracing continues after GDB disconnects."), _("\
4140 Show whether tracing continues after GDB disconnects."), _("\
4141 Use this to continue a tracing run even if GDB disconnects\n\
4142 or detaches from the target. You can reconnect later and look at\n\
4143 trace data collected in the meantime."),
4144 set_disconnected_tracing
,
4149 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4150 &circular_trace_buffer
, _("\
4151 Set target's use of circular trace buffer."), _("\
4152 Show target's use of circular trace buffer."), _("\
4153 Use this to make the trace buffer into a circular buffer,\n\
4154 which will discard traceframes (oldest first) instead of filling\n\
4155 up and stopping the trace run."),
4156 set_circular_trace_buffer
,
4163 add_target (&tfile_ops
);