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"
53 /* readline include files */
54 #include "readline/readline.h"
55 #include "readline/history.h"
57 /* readline defines this. */
68 extern int hex2bin (const char *hex
, gdb_byte
*bin
, int count
);
69 extern int bin2hex (const gdb_byte
*bin
, char *hex
, int count
);
71 extern void stop_tracing ();
73 /* Maximum length of an agent aexpression.
74 This accounts for the fact that packets are limited to 400 bytes
75 (which includes everything -- including the checksum), and assumes
76 the worst case of maximum length for each of the pieces of a
79 NOTE: expressions get mem2hex'ed otherwise this would be twice as
80 large. (400 - 31)/2 == 184 */
81 #define MAX_AGENT_EXPR_LEN 184
83 /* A hook used to notify the UI of tracepoint operations. */
85 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
86 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
88 extern void (*deprecated_readline_begin_hook
) (char *, ...);
89 extern char *(*deprecated_readline_hook
) (char *);
90 extern void (*deprecated_readline_end_hook
) (void);
92 /* GDB commands implemented in other modules:
95 extern void output_command (char *, int);
100 This module defines the following debugger commands:
101 trace : set a tracepoint on a function, line, or address.
102 info trace : list all debugger-defined tracepoints.
103 delete trace : delete one or more tracepoints.
104 enable trace : enable one or more tracepoints.
105 disable trace : disable one or more tracepoints.
106 actions : specify actions to be taken at a tracepoint.
107 passcount : specify a pass count for a tracepoint.
108 tstart : start a trace experiment.
109 tstop : stop a trace experiment.
110 tstatus : query the status of a trace experiment.
111 tfind : find a trace frame in the trace buffer.
112 tdump : print everything collected at the current tracepoint.
113 save-tracepoints : write tracepoint setup into a file.
115 This module defines the following user-visible debugger variables:
116 $trace_frame : sequence number of trace frame currently being debugged.
117 $trace_line : source line of trace frame currently being debugged.
118 $trace_file : source file of trace frame currently being debugged.
119 $tracepoint : tracepoint number of trace frame currently being debugged.
123 /* ======= Important global variables: ======= */
125 /* The list of all trace state variables. We don't retain pointers to
126 any of these for any reason - API is by name or number only - so it
127 works to have a vector of objects. */
129 typedef struct trace_state_variable tsv_s
;
132 static VEC(tsv_s
) *tvariables
;
134 /* The next integer to assign to a variable. */
136 static int next_tsv_number
= 1;
138 /* Number of last traceframe collected. */
139 static int traceframe_number
;
141 /* Tracepoint for last traceframe collected. */
142 static int tracepoint_number
;
144 /* Symbol for function for last traceframe collected */
145 static struct symbol
*traceframe_fun
;
147 /* Symtab and line for last traceframe collected */
148 static struct symtab_and_line traceframe_sal
;
150 /* Tracing command lists */
151 static struct cmd_list_element
*tfindlist
;
153 /* List of expressions to collect by default at each tracepoint hit. */
154 char *default_collect
= "";
156 static int disconnected_tracing
;
158 /* This variable controls whether we ask the target for a linear or
159 circular trace buffer. */
161 static int circular_trace_buffer
;
163 /* ======= Important command functions: ======= */
164 static void trace_actions_command (char *, int);
165 static void trace_start_command (char *, int);
166 static void trace_stop_command (char *, int);
167 static void trace_status_command (char *, int);
168 static void trace_find_command (char *, int);
169 static void trace_find_pc_command (char *, int);
170 static void trace_find_tracepoint_command (char *, int);
171 static void trace_find_line_command (char *, int);
172 static void trace_find_range_command (char *, int);
173 static void trace_find_outside_command (char *, int);
174 static void trace_dump_command (char *, int);
176 /* support routines */
178 struct collection_list
;
179 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
180 static char *mem2hex (gdb_byte
*, char *, int);
181 static void add_register (struct collection_list
*collection
,
184 extern void send_disconnected_tracing_value (int value
);
186 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
187 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
190 extern void _initialize_tracepoint (void);
192 static struct trace_status trace_status
;
194 char *stop_reason_names
[] = {
204 struct trace_status
*
205 current_trace_status ()
207 return &trace_status
;
210 /* Set traceframe number to NUM. */
212 set_traceframe_num (int num
)
214 traceframe_number
= num
;
215 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
218 /* Set tracepoint number to NUM. */
220 set_tracepoint_num (int num
)
222 tracepoint_number
= num
;
223 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
226 /* Set externally visible debug variables for querying/printing
227 the traceframe context (line, function, file) */
230 set_traceframe_context (struct frame_info
*trace_frame
)
234 if (trace_frame
== NULL
) /* Cease debugging any trace buffers. */
237 traceframe_sal
.pc
= traceframe_sal
.line
= 0;
238 traceframe_sal
.symtab
= NULL
;
239 clear_internalvar (lookup_internalvar ("trace_func"));
240 clear_internalvar (lookup_internalvar ("trace_file"));
241 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
245 /* Save as globals for internal use. */
246 trace_pc
= get_frame_pc (trace_frame
);
247 traceframe_sal
= find_pc_line (trace_pc
, 0);
248 traceframe_fun
= find_pc_function (trace_pc
);
250 /* Save linenumber as "$trace_line", a debugger variable visible to
252 set_internalvar_integer (lookup_internalvar ("trace_line"),
253 traceframe_sal
.line
);
255 /* Save func name as "$trace_func", a debugger variable visible to
257 if (traceframe_fun
== NULL
258 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
259 clear_internalvar (lookup_internalvar ("trace_func"));
261 set_internalvar_string (lookup_internalvar ("trace_func"),
262 SYMBOL_LINKAGE_NAME (traceframe_fun
));
264 /* Save file name as "$trace_file", a debugger variable visible to
266 if (traceframe_sal
.symtab
== NULL
267 || traceframe_sal
.symtab
->filename
== NULL
)
268 clear_internalvar (lookup_internalvar ("trace_file"));
270 set_internalvar_string (lookup_internalvar ("trace_file"),
271 traceframe_sal
.symtab
->filename
);
274 /* Create a new trace state variable with the given name. */
276 struct trace_state_variable
*
277 create_trace_state_variable (const char *name
)
279 struct trace_state_variable tsv
;
281 memset (&tsv
, 0, sizeof (tsv
));
282 tsv
.name
= xstrdup (name
);
283 tsv
.number
= next_tsv_number
++;
284 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
287 /* Look for a trace state variable of the given name. */
289 struct trace_state_variable
*
290 find_trace_state_variable (const char *name
)
292 struct trace_state_variable
*tsv
;
295 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
296 if (strcmp (name
, tsv
->name
) == 0)
303 delete_trace_state_variable (const char *name
)
305 struct trace_state_variable
*tsv
;
308 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
309 if (strcmp (name
, tsv
->name
) == 0)
311 xfree ((void *)tsv
->name
);
312 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
316 warning (_("No trace variable named \"$%s\", not deleting"), name
);
319 /* The 'tvariable' command collects a name and optional expression to
320 evaluate into an initial value. */
323 trace_variable_command (char *args
, int from_tty
)
325 struct expression
*expr
;
326 struct cleanup
*old_chain
;
327 struct internalvar
*intvar
= NULL
;
329 struct trace_state_variable
*tsv
;
332 error_no_arg (_("trace state variable name"));
334 /* All the possible valid arguments are expressions. */
335 expr
= parse_expression (args
);
336 old_chain
= make_cleanup (free_current_contents
, &expr
);
338 if (expr
->nelts
== 0)
339 error (_("No expression?"));
341 /* Only allow two syntaxes; "$name" and "$name=value". */
342 if (expr
->elts
[0].opcode
== OP_INTERNALVAR
)
344 intvar
= expr
->elts
[1].internalvar
;
346 else if (expr
->elts
[0].opcode
== BINOP_ASSIGN
347 && expr
->elts
[1].opcode
== OP_INTERNALVAR
)
349 intvar
= expr
->elts
[2].internalvar
;
350 initval
= value_as_long (evaluate_subexpression_type (expr
, 4));
353 error (_("Syntax must be $NAME [ = EXPR ]"));
356 error (_("No name given"));
358 if (strlen (internalvar_name (intvar
)) <= 0)
359 error (_("Must supply a non-empty variable name"));
361 /* If the variable already exists, just change its initial value. */
362 tsv
= find_trace_state_variable (internalvar_name (intvar
));
365 tsv
->initial_value
= initval
;
366 printf_filtered (_("Trace state variable $%s now has initial value %s.\n"),
367 tsv
->name
, plongest (tsv
->initial_value
));
368 do_cleanups (old_chain
);
372 /* Create a new variable. */
373 tsv
= create_trace_state_variable (internalvar_name (intvar
));
374 tsv
->initial_value
= initval
;
376 printf_filtered (_("Trace state variable $%s created, with initial value %s.\n"),
377 tsv
->name
, plongest (tsv
->initial_value
));
379 do_cleanups (old_chain
);
383 delete_trace_variable_command (char *args
, int from_tty
)
387 struct cleanup
*back_to
;
388 struct trace_state_variable
*tsv
;
392 if (query (_("Delete all trace state variables? ")))
393 VEC_free (tsv_s
, tvariables
);
398 argv
= gdb_buildargv (args
);
399 back_to
= make_cleanup_freeargv (argv
);
401 for (i
= 0; argv
[i
] != NULL
; i
++)
404 delete_trace_state_variable (argv
[i
] + 1);
406 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[i
]);
409 do_cleanups (back_to
);
415 tvariables_info_1 (void)
417 struct trace_state_variable
*tsv
;
420 struct cleanup
*back_to
;
422 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
424 printf_filtered (_("No trace state variables.\n"));
428 /* Try to acquire values from the target. */
429 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
430 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
433 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
434 count
, "trace-variables");
435 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
436 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
437 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
439 ui_out_table_body (uiout
);
441 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
443 struct cleanup
*back_to2
;
447 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
449 name
= concat ("$", tsv
->name
, (char *) NULL
);
450 make_cleanup (xfree
, name
);
451 ui_out_field_string (uiout
, "name", name
);
452 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
454 if (tsv
->value_known
)
455 c
= plongest (tsv
->value
);
456 else if (ui_out_is_mi_like_p (uiout
))
457 /* For MI, we prefer not to use magic string constants, but rather
458 omit the field completely. The difference between unknown and
459 undefined does not seem important enough to represent. */
461 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
462 /* The value is/was defined, but we don't have it. */
465 /* It is not meaningful to ask about the value. */
468 ui_out_field_string (uiout
, "current", c
);
469 ui_out_text (uiout
, "\n");
471 do_cleanups (back_to2
);
474 do_cleanups (back_to
);
477 /* List all the trace state variables. */
480 tvariables_info (char *args
, int from_tty
)
482 tvariables_info_1 ();
485 /* Stash definitions of tsvs into the given file. */
488 save_trace_state_variables (struct ui_file
*fp
)
490 struct trace_state_variable
*tsv
;
493 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
495 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
496 if (tsv
->initial_value
)
497 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
498 fprintf_unfiltered (fp
, "\n");
502 /* ACTIONS functions: */
504 /* The three functions:
505 collect_pseudocommand,
506 while_stepping_pseudocommand, and
507 end_actions_pseudocommand
508 are placeholders for "commands" that are actually ONLY to be used
509 within a tracepoint action list. If the actual function is ever called,
510 it means that somebody issued the "command" at the top level,
511 which is always an error. */
514 end_actions_pseudocommand (char *args
, int from_tty
)
516 error (_("This command cannot be used at the top level."));
520 while_stepping_pseudocommand (char *args
, int from_tty
)
522 error (_("This command can only be used in a tracepoint actions list."));
526 collect_pseudocommand (char *args
, int from_tty
)
528 error (_("This command can only be used in a tracepoint actions list."));
532 teval_pseudocommand (char *args
, int from_tty
)
534 error (_("This command can only be used in a tracepoint actions list."));
537 /* Enter a list of actions for a tracepoint. */
539 trace_actions_command (char *args
, int from_tty
)
541 struct breakpoint
*t
;
542 struct command_line
*l
;
544 t
= get_tracepoint_by_number (&args
, 0, 1);
548 xstrprintf ("Enter actions for tracepoint %d, one per line.",
550 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
552 l
= read_command_lines (tmpbuf
, from_tty
, 1, check_tracepoint_command
, t
);
553 do_cleanups (cleanups
);
554 breakpoint_set_commands (t
, l
);
556 /* else just return */
559 /* Report the results of checking the agent expression, as errors or
563 report_agent_reqs_errors (struct agent_expr
*aexpr
)
565 /* All of the "flaws" are serious bytecode generation issues that
566 should never occur. */
567 if (aexpr
->flaw
!= agent_flaw_none
)
568 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
570 /* If analysis shows a stack underflow, GDB must have done something
571 badly wrong in its bytecode generation. */
572 if (aexpr
->min_height
< 0)
573 internal_error (__FILE__
, __LINE__
,
574 _("expression has min height < 0"));
576 /* Issue this error if the stack is predicted to get too deep. The
577 limit is rather arbitrary; a better scheme might be for the
578 target to report how much stack it will have available. The
579 depth roughly corresponds to parenthesization, so a limit of 20
580 amounts to 20 levels of expression nesting, which is actually
581 a pretty big hairy expression. */
582 if (aexpr
->max_height
> 20)
583 error (_("Expression is too complicated."));
586 /* worker function */
588 validate_actionline (char **line
, struct breakpoint
*t
)
590 struct cmd_list_element
*c
;
591 struct expression
*exp
= NULL
;
592 struct cleanup
*old_chain
= NULL
;
594 struct bp_location
*loc
;
595 struct agent_expr
*aexpr
;
597 /* if EOF is typed, *line is NULL */
601 for (p
= *line
; isspace ((int) *p
);)
604 /* Symbol lookup etc. */
605 if (*p
== '\0') /* empty line: just prompt for another line. */
608 if (*p
== '#') /* comment line */
611 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
613 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
615 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
618 { /* repeat over a comma-separated list */
619 QUIT
; /* allow user to bail out with ^C */
620 while (isspace ((int) *p
))
623 if (*p
== '$') /* look for special pseudo-symbols */
625 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
626 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
627 (0 == strncasecmp ("loc", p
+ 1, 3)))
632 /* else fall thru, treat p as an expression and parse it! */
635 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
638 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
639 old_chain
= make_cleanup (free_current_contents
, &exp
);
641 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
643 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
645 error (_("constant `%s' (value %ld) will not be collected."),
646 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
647 SYMBOL_VALUE (exp
->elts
[2].symbol
));
649 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
651 error (_("`%s' is optimized away and cannot be collected."),
652 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
656 /* We have something to collect, make sure that the expr to
657 bytecode translator can handle it and that it's not too
659 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
660 make_cleanup_free_agent_expr (aexpr
);
662 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
663 error (_("Expression is too complicated."));
667 report_agent_reqs_errors (aexpr
);
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."));
701 report_agent_reqs_errors (aexpr
);
703 do_cleanups (old_chain
);
706 while (p
&& *p
++ == ',');
709 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
711 char *steparg
; /* in case warning is necessary */
713 while (isspace ((int) *p
))
717 if (*p
== '\0' || (t
->step_count
= strtol (p
, &p
, 0)) == 0)
718 error (_("while-stepping step count `%s' is malformed."), *line
);
721 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
725 error (_("`%s' is not a supported tracepoint action."), *line
);
729 memrange_absolute
= -1
734 int type
; /* memrange_absolute for absolute memory range,
735 else basereg number */
736 bfd_signed_vma start
;
740 struct collection_list
742 unsigned char regs_mask
[32]; /* room for up to 256 regs */
745 struct memrange
*list
;
746 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
748 struct agent_expr
**aexpr_list
;
751 tracepoint_list
, stepping_list
;
753 /* MEMRANGE functions: */
755 static int memrange_cmp (const void *, const void *);
757 /* compare memranges for qsort */
759 memrange_cmp (const void *va
, const void *vb
)
761 const struct memrange
*a
= va
, *b
= vb
;
763 if (a
->type
< b
->type
)
765 if (a
->type
> b
->type
)
767 if (a
->type
== memrange_absolute
)
769 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
771 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
776 if (a
->start
< b
->start
)
778 if (a
->start
> b
->start
)
784 /* Sort the memrange list using qsort, and merge adjacent memranges. */
786 memrange_sortmerge (struct collection_list
*memranges
)
790 qsort (memranges
->list
, memranges
->next_memrange
,
791 sizeof (struct memrange
), memrange_cmp
);
792 if (memranges
->next_memrange
> 0)
794 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
796 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
797 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
800 /* memrange b starts before memrange a ends; merge them. */
801 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
802 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
803 continue; /* next b, same a */
807 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
808 sizeof (struct memrange
));
810 memranges
->next_memrange
= a
+ 1;
814 /* Add a register to a collection list. */
816 add_register (struct collection_list
*collection
, unsigned int regno
)
819 printf_filtered ("collect register %d\n", regno
);
820 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
821 error (_("Internal: register number %d too large for tracepoint"),
823 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
826 /* Add a memrange to a collection list */
828 add_memrange (struct collection_list
*memranges
,
829 int type
, bfd_signed_vma base
,
834 printf_filtered ("(%d,", type
);
836 printf_filtered (",%ld)\n", len
);
839 /* type: memrange_absolute == memory, other n == basereg */
840 memranges
->list
[memranges
->next_memrange
].type
= type
;
841 /* base: addr if memory, offset if reg relative. */
842 memranges
->list
[memranges
->next_memrange
].start
= base
;
843 /* len: we actually save end (base + len) for convenience */
844 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
845 memranges
->next_memrange
++;
846 if (memranges
->next_memrange
>= memranges
->listsize
)
848 memranges
->listsize
*= 2;
849 memranges
->list
= xrealloc (memranges
->list
,
850 memranges
->listsize
);
853 if (type
!= memrange_absolute
) /* Better collect the base register! */
854 add_register (memranges
, type
);
857 /* Add a symbol to a collection list. */
859 collect_symbol (struct collection_list
*collect
,
861 struct gdbarch
*gdbarch
,
862 long frame_regno
, long frame_offset
,
867 bfd_signed_vma offset
;
868 int treat_as_expr
= 0;
870 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
871 switch (SYMBOL_CLASS (sym
))
874 printf_filtered ("%s: don't know symbol class %d\n",
875 SYMBOL_PRINT_NAME (sym
),
879 printf_filtered ("constant %s (value %ld) will not be collected.\n",
880 SYMBOL_PRINT_NAME (sym
), SYMBOL_VALUE (sym
));
883 offset
= SYMBOL_VALUE_ADDRESS (sym
);
888 sprintf_vma (tmp
, offset
);
889 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
890 SYMBOL_PRINT_NAME (sym
), len
,
893 /* A struct may be a C++ class with static fields, go to general
894 expression handling. */
895 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
898 add_memrange (collect
, memrange_absolute
, offset
, len
);
901 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
903 printf_filtered ("LOC_REG[parm] %s: ",
904 SYMBOL_PRINT_NAME (sym
));
905 add_register (collect
, reg
);
906 /* Check for doubles stored in two registers. */
907 /* FIXME: how about larger types stored in 3 or more regs? */
908 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
909 len
> register_size (gdbarch
, reg
))
910 add_register (collect
, reg
+ 1);
913 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
914 printf_filtered (" (will not collect %s)\n",
915 SYMBOL_PRINT_NAME (sym
));
919 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
922 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
923 SYMBOL_PRINT_NAME (sym
), len
);
925 printf_filtered (" from frame ptr reg %d\n", reg
);
927 add_memrange (collect
, reg
, offset
, len
);
929 case LOC_REGPARM_ADDR
:
930 reg
= SYMBOL_VALUE (sym
);
934 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
935 SYMBOL_PRINT_NAME (sym
), len
);
937 printf_filtered (" from reg %d\n", reg
);
939 add_memrange (collect
, reg
, offset
, len
);
943 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
946 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
947 SYMBOL_PRINT_NAME (sym
), len
);
949 printf_filtered (" from frame ptr reg %d\n", reg
);
951 add_memrange (collect
, reg
, offset
, len
);
958 case LOC_OPTIMIZED_OUT
:
959 printf_filtered ("%s has been optimized out of existence.\n",
960 SYMBOL_PRINT_NAME (sym
));
968 /* Expressions are the most general case. */
971 struct agent_expr
*aexpr
;
972 struct cleanup
*old_chain1
= NULL
;
974 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
976 /* It can happen that the symbol is recorded as a computed
977 location, but it's been optimized away and doesn't actually
978 have a location expression. */
981 printf_filtered ("%s has been optimized out of existence.\n",
982 SYMBOL_PRINT_NAME (sym
));
986 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
990 report_agent_reqs_errors (aexpr
);
992 discard_cleanups (old_chain1
);
993 add_aexpr (collect
, aexpr
);
995 /* take care of the registers */
996 if (aexpr
->reg_mask_len
> 0)
1000 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1002 QUIT
; /* allow user to bail out with ^C */
1003 if (aexpr
->reg_mask
[ndx1
] != 0)
1005 /* assume chars have 8 bits */
1006 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1007 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1008 /* it's used -- record it */
1009 add_register (collect
, ndx1
* 8 + ndx2
);
1016 /* Data to be passed around in the calls to the locals and args
1019 struct add_local_symbols_data
1021 struct collection_list
*collect
;
1022 struct gdbarch
*gdbarch
;
1029 /* The callback for the locals and args iterators */
1032 do_collect_symbol (const char *print_name
,
1036 struct add_local_symbols_data
*p
= cb_data
;
1038 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1039 p
->frame_offset
, p
->pc
);
1043 /* Add all locals (or args) symbols to collection list */
1045 add_local_symbols (struct collection_list
*collect
,
1046 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1047 long frame_regno
, long frame_offset
, int type
)
1049 struct block
*block
;
1050 struct add_local_symbols_data cb_data
;
1052 cb_data
.collect
= collect
;
1053 cb_data
.gdbarch
= gdbarch
;
1055 cb_data
.frame_regno
= frame_regno
;
1056 cb_data
.frame_offset
= frame_offset
;
1061 block
= block_for_pc (pc
);
1064 warning (_("Can't collect locals; "
1065 "no symbol table info available.\n"));
1069 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1070 if (cb_data
.count
== 0)
1071 warning (_("No locals found in scope."));
1075 pc
= get_pc_function_start (pc
);
1076 block
= block_for_pc (pc
);
1079 warning (_("Can't collect args; no symbol table info available.\n"));
1083 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1084 if (cb_data
.count
== 0)
1085 warning (_("No args found in scope."));
1089 /* worker function */
1091 clear_collection_list (struct collection_list
*list
)
1095 list
->next_memrange
= 0;
1096 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1098 free_agent_expr (list
->aexpr_list
[ndx
]);
1099 list
->aexpr_list
[ndx
] = NULL
;
1101 list
->next_aexpr_elt
= 0;
1102 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1105 /* reduce a collection list to string form (for gdb protocol) */
1107 stringify_collection_list (struct collection_list
*list
, char *string
)
1109 char temp_buf
[2048];
1113 char *(*str_list
)[];
1117 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1118 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1120 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1121 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1123 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1126 printf_filtered ("\nCollecting registers (mask): 0x");
1131 QUIT
; /* allow user to bail out with ^C */
1133 printf_filtered ("%02X", list
->regs_mask
[i
]);
1134 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1137 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1141 printf_filtered ("\n");
1142 if (list
->next_memrange
> 0 && info_verbose
)
1143 printf_filtered ("Collecting memranges: \n");
1144 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1146 QUIT
; /* allow user to bail out with ^C */
1147 sprintf_vma (tmp2
, list
->list
[i
].start
);
1150 printf_filtered ("(%d, %s, %ld)\n",
1153 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1155 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1157 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1164 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1166 /* The "%X" conversion specifier expects an unsigned argument,
1167 so passing -1 (memrange_absolute) to it directly gives you
1168 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1170 if (list
->list
[i
].type
== memrange_absolute
)
1171 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1173 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1176 count
+= strlen (end
);
1177 end
= temp_buf
+ count
;
1180 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1182 QUIT
; /* allow user to bail out with ^C */
1183 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1185 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1190 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1191 end
+= 10; /* 'X' + 8 hex digits + ',' */
1194 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1195 end
, list
->aexpr_list
[i
]->len
);
1196 count
+= 2 * list
->aexpr_list
[i
]->len
;
1201 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1206 (*str_list
)[ndx
] = NULL
;
1219 encode_actions_1 (struct command_line
*action
,
1220 struct breakpoint
*t
,
1221 struct bp_location
*tloc
,
1223 LONGEST frame_offset
,
1224 struct collection_list
*collect
,
1225 struct collection_list
*stepping_list
)
1228 struct expression
*exp
= NULL
;
1229 struct command_line
*actions
;
1231 struct value
*tempval
;
1232 struct cmd_list_element
*cmd
;
1233 struct agent_expr
*aexpr
;
1235 for (; action
; action
= action
->next
)
1237 QUIT
; /* allow user to bail out with ^C */
1238 action_exp
= action
->line
;
1239 while (isspace ((int) *action_exp
))
1242 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1244 error (_("Bad action list item: %s"), action_exp
);
1246 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1249 { /* repeat over a comma-separated list */
1250 QUIT
; /* allow user to bail out with ^C */
1251 while (isspace ((int) *action_exp
))
1254 if (0 == strncasecmp ("$reg", action_exp
, 4))
1256 for (i
= 0; i
< gdbarch_num_regs (t
->gdbarch
); i
++)
1257 add_register (collect
, i
);
1258 action_exp
= strchr (action_exp
, ','); /* more? */
1260 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1262 add_local_symbols (collect
,
1268 action_exp
= strchr (action_exp
, ','); /* more? */
1270 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1272 add_local_symbols (collect
,
1278 action_exp
= strchr (action_exp
, ','); /* more? */
1282 unsigned long addr
, len
;
1283 struct cleanup
*old_chain
= NULL
;
1284 struct cleanup
*old_chain1
= NULL
;
1286 exp
= parse_exp_1 (&action_exp
,
1287 block_for_pc (tloc
->address
), 1);
1288 old_chain
= make_cleanup (free_current_contents
, &exp
);
1290 switch (exp
->elts
[0].opcode
)
1294 const char *name
= &exp
->elts
[2].string
;
1296 i
= user_reg_map_name_to_regnum (t
->gdbarch
,
1297 name
, strlen (name
));
1299 internal_error (__FILE__
, __LINE__
,
1300 _("Register $%s not available"),
1303 printf_filtered ("OP_REGISTER: ");
1304 add_register (collect
, i
);
1309 /* safe because we know it's a simple expression */
1310 tempval
= evaluate_expression (exp
);
1311 addr
= value_address (tempval
);
1312 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1313 add_memrange (collect
, memrange_absolute
, addr
, len
);
1317 collect_symbol (collect
,
1318 exp
->elts
[2].symbol
,
1325 default: /* full-fledged expression */
1326 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1328 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1332 report_agent_reqs_errors (aexpr
);
1334 discard_cleanups (old_chain1
);
1335 add_aexpr (collect
, aexpr
);
1337 /* take care of the registers */
1338 if (aexpr
->reg_mask_len
> 0)
1343 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1345 QUIT
; /* allow user to bail out with ^C */
1346 if (aexpr
->reg_mask
[ndx1
] != 0)
1348 /* assume chars have 8 bits */
1349 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1350 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1351 /* it's used -- record it */
1352 add_register (collect
,
1359 do_cleanups (old_chain
);
1362 while (action_exp
&& *action_exp
++ == ',');
1364 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1367 { /* repeat over a comma-separated list */
1368 QUIT
; /* allow user to bail out with ^C */
1369 while (isspace ((int) *action_exp
))
1373 unsigned long addr
, len
;
1374 struct cleanup
*old_chain
= NULL
;
1375 struct cleanup
*old_chain1
= NULL
;
1377 exp
= parse_exp_1 (&action_exp
,
1378 block_for_pc (tloc
->address
), 1);
1379 old_chain
= make_cleanup (free_current_contents
, &exp
);
1381 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1382 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1385 report_agent_reqs_errors (aexpr
);
1387 discard_cleanups (old_chain1
);
1388 /* Even though we're not officially collecting, add
1389 to the collect list anyway. */
1390 add_aexpr (collect
, aexpr
);
1392 do_cleanups (old_chain
);
1395 while (action_exp
&& *action_exp
++ == ',');
1397 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1399 /* We check against nested while-stepping when setting
1400 breakpoint action, so no way to run into nested
1402 gdb_assert (stepping_list
);
1404 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
, frame_offset
,
1405 stepping_list
, NULL
);
1408 error (_("Invalid tracepoint command '%s'"), action
->line
);
1412 /* Render all actions into gdb protocol. */
1414 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1415 char ***tdp_actions
, char ***stepping_actions
)
1417 static char tdp_buff
[2048], step_buff
[2048];
1418 char *default_collect_line
= NULL
;
1419 struct command_line
*actions
;
1420 struct command_line
*default_collect_action
= NULL
;
1422 LONGEST frame_offset
;
1423 struct cleanup
*back_to
;
1425 back_to
= make_cleanup (null_cleanup
, NULL
);
1427 clear_collection_list (&tracepoint_list
);
1428 clear_collection_list (&stepping_list
);
1430 *tdp_actions
= NULL
;
1431 *stepping_actions
= NULL
;
1433 gdbarch_virtual_frame_pointer (t
->gdbarch
,
1434 t
->loc
->address
, &frame_reg
, &frame_offset
);
1436 actions
= breakpoint_commands (t
);
1438 /* If there are default expressions to collect, make up a collect
1439 action and prepend to the action list to encode. Note that since
1440 validation is per-tracepoint (local var "xyz" might be valid for
1441 one tracepoint and not another, etc), we make up the action on
1442 the fly, and don't cache it. */
1443 if (*default_collect
)
1447 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1448 make_cleanup (xfree
, default_collect_line
);
1450 line
= default_collect_line
;
1451 validate_actionline (&line
, t
);
1453 default_collect_action
= xmalloc (sizeof (struct command_line
));
1454 make_cleanup (xfree
, default_collect_action
);
1455 default_collect_action
->next
= actions
;
1456 default_collect_action
->line
= line
;
1457 actions
= default_collect_action
;
1459 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1460 &tracepoint_list
, &stepping_list
);
1462 memrange_sortmerge (&tracepoint_list
);
1463 memrange_sortmerge (&stepping_list
);
1465 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1467 *stepping_actions
= stringify_collection_list (&stepping_list
,
1470 do_cleanups (back_to
);
1474 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1476 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1478 collect
->aexpr_list
=
1479 xrealloc (collect
->aexpr_list
,
1480 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1481 collect
->aexpr_listsize
*= 2;
1483 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1484 collect
->next_aexpr_elt
++;
1489 start_tracing (void)
1492 VEC(breakpoint_p
) *tp_vec
= NULL
;
1494 struct breakpoint
*t
;
1495 struct trace_state_variable
*tsv
;
1496 int any_enabled
= 0;
1498 tp_vec
= all_tracepoints ();
1500 /* No point in tracing without any tracepoints... */
1501 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1503 VEC_free (breakpoint_p
, tp_vec
);
1504 error (_("No tracepoints defined, not starting trace"));
1507 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1509 if (t
->enable_state
== bp_enabled
)
1516 /* No point in tracing with only disabled tracepoints. */
1519 VEC_free (breakpoint_p
, tp_vec
);
1520 error (_("No tracepoints enabled, not starting trace"));
1523 target_trace_init ();
1525 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1527 t
->number_on_target
= 0;
1528 target_download_tracepoint (t
);
1529 t
->number_on_target
= t
->number
;
1531 VEC_free (breakpoint_p
, tp_vec
);
1533 /* Send down all the trace state variables too. */
1534 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1536 target_download_trace_state_variable (tsv
);
1539 /* Tell target to treat text-like sections as transparent. */
1540 target_trace_set_readonly_regions ();
1541 /* Set some mode flags. */
1542 target_set_disconnected_tracing (disconnected_tracing
);
1543 target_set_circular_trace_buffer (circular_trace_buffer
);
1545 /* Now insert traps and begin collecting data. */
1546 target_trace_start ();
1548 /* Reset our local state. */
1549 set_traceframe_num (-1);
1550 set_tracepoint_num (-1);
1551 set_traceframe_context (NULL
);
1552 current_trace_status()->running
= 1;
1557 Tell target to clear any previous trace experiment.
1558 Walk the list of tracepoints, and send them (and their actions)
1559 to the target. If no errors,
1560 Tell target to start a new trace experiment. */
1563 trace_start_command (char *args
, int from_tty
)
1565 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1567 if (current_trace_status ()->running
)
1570 && !query (_("A trace is running already. Start a new run? ")))
1571 error (_("New trace run not started."));
1579 trace_stop_command (char *args
, int from_tty
)
1581 if (!current_trace_status ()->running
)
1582 error (_("Trace is not running."));
1590 target_trace_stop ();
1591 /* should change in response to reply? */
1592 current_trace_status ()->running
= 0;
1595 /* tstatus command */
1597 trace_status_command (char *args
, int from_tty
)
1599 struct trace_status
*ts
= current_trace_status ();
1602 status
= target_get_trace_status (ts
);
1607 printf_filtered (_("Using a trace file.\n"));
1610 printf_filtered (_("Trace can not be run on this target.\n"));
1615 if (!ts
->running_known
)
1617 printf_filtered (_("Run/stop status is unknown.\n"));
1619 else if (ts
->running
)
1621 printf_filtered (_("Trace is running on the target.\n"));
1625 switch (ts
->stop_reason
)
1627 case trace_never_run
:
1628 printf_filtered (_("No trace has been run on the target.\n"));
1631 printf_filtered (_("Trace stopped by a tstop command.\n"));
1633 case trace_buffer_full
:
1634 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1636 case trace_disconnected
:
1637 printf_filtered (_("Trace stopped because of disconnection.\n"));
1639 case tracepoint_passcount
:
1640 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1641 ts
->stopping_tracepoint
);
1643 case tracepoint_error
:
1644 if (ts
->stopping_tracepoint
)
1645 printf_filtered (_("Trace stopped by an error (%s, tracepoint %d).\n"),
1646 ts
->error_desc
, ts
->stopping_tracepoint
);
1648 printf_filtered (_("Trace stopped by an error (%s).\n"),
1651 case trace_stop_reason_unknown
:
1652 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1655 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1661 if (ts
->traceframes_created
>= 0
1662 && ts
->traceframe_count
!= ts
->traceframes_created
)
1664 printf_filtered (_("Buffer contains %d trace frames (of %d created total).\n"),
1665 ts
->traceframe_count
, ts
->traceframes_created
);
1667 else if (ts
->traceframe_count
>= 0)
1669 printf_filtered (_("Collected %d trace frames.\n"),
1670 ts
->traceframe_count
);
1673 if (ts
->buffer_free
>= 0)
1675 if (ts
->buffer_size
>= 0)
1677 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1678 ts
->buffer_free
, ts
->buffer_size
);
1679 if (ts
->buffer_size
> 0)
1680 printf_filtered (_(" (%d%% full)"),
1681 ((int) ((((long long) (ts
->buffer_size
1682 - ts
->buffer_free
)) * 100)
1683 / ts
->buffer_size
)));
1684 printf_filtered (_(".\n"));
1687 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1691 if (ts
->disconnected_tracing
)
1692 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1694 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1696 if (ts
->circular_buffer
)
1697 printf_filtered (_("Trace buffer is circular.\n"));
1699 /* Now report on what we're doing with tfind. */
1700 if (traceframe_number
>= 0)
1701 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1702 traceframe_number
, tracepoint_number
);
1704 printf_filtered (_("Not looking at any trace frame.\n"));
1707 /* Report the trace status to uiout, in a way suitable for MI, and not
1708 suitable for CLI. If ON_STOP is true, suppress a few fields that
1709 are not meaningful in the -trace-stop response.
1711 The implementation is essentially parallel to trace_status_command, but
1712 merging them will result in unreadable code. */
1714 trace_status_mi (int on_stop
)
1716 struct trace_status
*ts
= current_trace_status ();
1718 char *string_status
;
1720 status
= target_get_trace_status (ts
);
1722 if (status
== -1 && !ts
->from_file
)
1724 ui_out_field_string (uiout
, "supported", "0");
1729 ui_out_field_string (uiout
, "supported", "file");
1731 ui_out_field_string (uiout
, "supported", "1");
1733 gdb_assert (ts
->running_known
);
1737 ui_out_field_string (uiout
, "running", "1");
1739 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1740 Given that the frontend gets the status either on -trace-stop, or from
1741 -trace-status after re-connection, it does not seem like this
1742 information is necessary for anything. It is not necessary for either
1743 figuring the vital state of the target nor for navigation of trace
1744 frames. If the frontend wants to show the current state is some
1745 configure dialog, it can request the value when such dialog is
1746 invoked by the user. */
1750 char *stop_reason
= NULL
;
1751 int stopping_tracepoint
= -1;
1754 ui_out_field_string (uiout
, "running", "0");
1756 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
1758 switch (ts
->stop_reason
)
1761 stop_reason
= "request";
1763 case trace_buffer_full
:
1764 stop_reason
= "overflow";
1766 case trace_disconnected
:
1767 stop_reason
= "disconnection";
1769 case tracepoint_passcount
:
1770 stop_reason
= "passcount";
1771 stopping_tracepoint
= ts
->stopping_tracepoint
;
1773 case tracepoint_error
:
1774 stop_reason
= "error";
1775 stopping_tracepoint
= ts
->stopping_tracepoint
;
1781 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
1782 if (stopping_tracepoint
!= -1)
1783 ui_out_field_int (uiout
, "stopping-tracepoint",
1784 stopping_tracepoint
);
1785 if (ts
->stop_reason
== tracepoint_error
)
1786 ui_out_field_string (uiout
, "error-description",
1792 if (ts
->traceframe_count
!= -1)
1793 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
1794 if (ts
->traceframes_created
!= -1)
1795 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
1796 if (ts
->buffer_size
!= -1)
1797 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
1798 if (ts
->buffer_free
!= -1)
1799 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
1801 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
1802 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
1805 /* This function handles the details of what to do about an ongoing
1806 tracing run if the user has asked to detach or otherwise disconnect
1809 disconnect_tracing (int from_tty
)
1811 /* It can happen that the target that was tracing went away on its
1812 own, and we didn't notice. Get a status update, and if the
1813 current target doesn't even do tracing, then assume it's not
1815 if (target_get_trace_status (current_trace_status ()) < 0)
1816 current_trace_status ()->running
= 0;
1818 /* If running interactively, give the user the option to cancel and
1819 then decide what to do differently with the run. Scripts are
1820 just going to disconnect and let the target deal with it,
1821 according to how it's been instructed previously via
1822 disconnected-tracing. */
1823 if (current_trace_status ()->running
&& from_tty
)
1825 if (current_trace_status ()->disconnected_tracing
)
1827 if (!query (_("Trace is running and will continue after detach; detach anyway? ")))
1828 error (_("Not confirmed."));
1832 if (!query (_("Trace is running but will stop on detach; detach anyway? ")))
1833 error (_("Not confirmed."));
1837 /* Also we want to be out of tfind mode, otherwise things can get
1838 confusing upon reconnection. Just use these calls instead of
1839 full tfind_1 behavior because we're in the middle of detaching,
1840 and there's no point to updating current stack frame etc. */
1841 set_traceframe_number (-1);
1842 set_traceframe_context (NULL
);
1845 /* Worker function for the various flavors of the tfind command. */
1847 tfind_1 (enum trace_find_type type
, int num
,
1848 ULONGEST addr1
, ULONGEST addr2
,
1851 int target_frameno
= -1, target_tracept
= -1;
1852 struct frame_id old_frame_id
= null_frame_id
;
1854 struct breakpoint
*tp
;
1856 /* Only try to get the current stack frame if we have a chance of
1857 succeeding. In particular, if we're trying to get a first trace
1858 frame while all threads are running, it's not going to succeed,
1859 so leave it with a default value and let the frame comparison
1860 below (correctly) decide to print out the source location of the
1862 if (!(type
== tfind_number
&& num
== -1)
1863 && (has_stack_frames () || traceframe_number
>= 0))
1864 old_frame_id
= get_frame_id (get_current_frame ());
1866 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
1869 if (type
== tfind_number
1871 && target_frameno
== -1)
1873 /* We told the target to get out of tfind mode, and it did. */
1875 else if (target_frameno
== -1)
1877 /* A request for a non-existent trace frame has failed.
1878 Our response will be different, depending on FROM_TTY:
1880 If FROM_TTY is true, meaning that this command was
1881 typed interactively by the user, then give an error
1882 and DO NOT change the state of traceframe_number etc.
1884 However if FROM_TTY is false, meaning that we're either
1885 in a script, a loop, or a user-defined command, then
1886 DON'T give an error, but DO change the state of
1887 traceframe_number etc. to invalid.
1889 The rationalle is that if you typed the command, you
1890 might just have committed a typo or something, and you'd
1891 like to NOT lose your current debugging state. However
1892 if you're in a user-defined command or especially in a
1893 loop, then you need a way to detect that the command
1894 failed WITHOUT aborting. This allows you to write
1895 scripts that search thru the trace buffer until the end,
1896 and then continue on to do something else. */
1899 error (_("Target failed to find requested trace frame."));
1903 printf_filtered ("End of trace buffer.\n");
1904 #if 0 /* dubious now? */
1905 /* The following will not recurse, since it's
1907 trace_find_command ("-1", from_tty
);
1912 tp
= get_tracepoint_by_number_on_target (target_tracept
);
1914 reinit_frame_cache ();
1915 registers_changed ();
1916 target_dcache_invalidate ();
1917 set_traceframe_num (target_frameno
);
1918 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
1919 if (target_frameno
== -1)
1920 set_traceframe_context (NULL
);
1922 set_traceframe_context (get_current_frame ());
1924 if (traceframe_number
>= 0)
1926 /* Use different branches for MI and CLI to make CLI messages
1928 if (ui_out_is_mi_like_p (uiout
))
1930 ui_out_field_string (uiout
, "found", "1");
1931 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
1932 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
1936 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
1937 traceframe_number
, tracepoint_number
);
1942 if (ui_out_is_mi_like_p (uiout
))
1943 ui_out_field_string (uiout
, "found", "0");
1944 else if (type
== tfind_number
&& num
== -1)
1945 printf_unfiltered (_("No longer looking at any trace frame\n"));
1946 else /* this case may never occur, check */
1947 printf_unfiltered (_("No trace frame found\n"));
1950 /* If we're in nonstop mode and getting out of looking at trace
1951 frames, there won't be any current frame to go back to and
1954 && (has_stack_frames () || traceframe_number
>= 0))
1956 enum print_what print_what
;
1958 /* NOTE: in imitation of the step command, try to determine
1959 whether we have made a transition from one function to
1960 another. If so, we'll print the "stack frame" (ie. the new
1961 function and it's arguments) -- otherwise we'll just show the
1964 if (frame_id_eq (old_frame_id
,
1965 get_frame_id (get_current_frame ())))
1966 print_what
= SRC_LINE
;
1968 print_what
= SRC_AND_LOC
;
1970 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
1975 /* trace_find_command takes a trace frame number n,
1976 sends "QTFrame:<n>" to the target,
1977 and accepts a reply that may contain several optional pieces
1978 of information: a frame number, a tracepoint number, and an
1979 indication of whether this is a trap frame or a stepping frame.
1981 The minimal response is just "OK" (which indicates that the
1982 target does not give us a frame number or a tracepoint number).
1983 Instead of that, the target may send us a string containing
1985 F<hexnum> (gives the selected frame number)
1986 T<hexnum> (gives the selected tracepoint number)
1991 trace_find_command (char *args
, int from_tty
)
1992 { /* this should only be called with a numeric argument */
1995 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1996 error ("May not look at trace frames while trace is running.");
1998 if (args
== 0 || *args
== 0)
1999 { /* TFIND with no args means find NEXT trace frame. */
2000 if (traceframe_number
== -1)
2001 frameno
= 0; /* "next" is first one */
2003 frameno
= traceframe_number
+ 1;
2005 else if (0 == strcmp (args
, "-"))
2007 if (traceframe_number
== -1)
2008 error (_("not debugging trace buffer"));
2009 else if (from_tty
&& traceframe_number
== 0)
2010 error (_("already at start of trace buffer"));
2012 frameno
= traceframe_number
- 1;
2014 /* A hack to work around eval's need for fp to have been collected. */
2015 else if (0 == strcmp (args
, "-1"))
2018 frameno
= parse_and_eval_long (args
);
2021 error (_("invalid input (%d is less than zero)"), frameno
);
2023 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2028 trace_find_end_command (char *args
, int from_tty
)
2030 trace_find_command ("-1", from_tty
);
2035 trace_find_none_command (char *args
, int from_tty
)
2037 trace_find_command ("-1", from_tty
);
2042 trace_find_start_command (char *args
, int from_tty
)
2044 trace_find_command ("0", from_tty
);
2047 /* tfind pc command */
2049 trace_find_pc_command (char *args
, int from_tty
)
2054 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2055 error ("May not look at trace frames while trace is running.");
2057 if (args
== 0 || *args
== 0)
2058 pc
= regcache_read_pc (get_current_regcache ());
2060 pc
= parse_and_eval_address (args
);
2062 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2065 /* tfind tracepoint command */
2067 trace_find_tracepoint_command (char *args
, int from_tty
)
2070 struct breakpoint
*tp
;
2072 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2073 error ("May not look at trace frames while trace is running.");
2075 if (args
== 0 || *args
== 0)
2077 if (tracepoint_number
== -1)
2078 error (_("No current tracepoint -- please supply an argument."));
2080 tdp
= tracepoint_number
; /* default is current TDP */
2083 tdp
= parse_and_eval_long (args
);
2085 /* If we have the tracepoint on hand, use the number that the
2086 target knows about (which may be different if we disconnected
2087 and reconnected). */
2088 tp
= get_tracepoint (tdp
);
2090 tdp
= tp
->number_on_target
;
2092 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2095 /* TFIND LINE command:
2097 This command will take a sourceline for argument, just like BREAK
2098 or TRACE (ie. anything that "decode_line_1" can handle).
2100 With no argument, this command will find the next trace frame
2101 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2104 trace_find_line_command (char *args
, int from_tty
)
2106 static CORE_ADDR start_pc
, end_pc
;
2107 struct symtabs_and_lines sals
;
2108 struct symtab_and_line sal
;
2109 struct cleanup
*old_chain
;
2110 char startpc_str
[40], endpc_str
[40];
2112 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2113 error ("May not look at trace frames while trace is running.");
2115 if (args
== 0 || *args
== 0)
2117 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2119 sals
.sals
= (struct symtab_and_line
*)
2120 xmalloc (sizeof (struct symtab_and_line
));
2125 sals
= decode_line_spec (args
, 1);
2129 old_chain
= make_cleanup (xfree
, sals
.sals
);
2130 if (sal
.symtab
== 0)
2131 error (_("No line number information available."));
2133 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2135 if (start_pc
== end_pc
)
2137 printf_filtered ("Line %d of \"%s\"",
2138 sal
.line
, sal
.symtab
->filename
);
2140 printf_filtered (" is at address ");
2141 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2143 printf_filtered (" but contains no code.\n");
2144 sal
= find_pc_line (start_pc
, 0);
2146 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2147 && start_pc
!= end_pc
)
2148 printf_filtered ("Attempting to find line %d instead.\n",
2151 error (_("Cannot find a good line."));
2155 /* Is there any case in which we get here, and have an address
2156 which the user would want to see? If we have debugging
2157 symbols and no line numbers? */
2158 error (_("Line number %d is out of range for \"%s\"."),
2159 sal
.line
, sal
.symtab
->filename
);
2161 /* Find within range of stated line. */
2163 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2165 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2166 do_cleanups (old_chain
);
2169 /* tfind range command */
2171 trace_find_range_command (char *args
, int from_tty
)
2173 static CORE_ADDR start
, stop
;
2174 char start_str
[40], stop_str
[40];
2177 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2178 error ("May not look at trace frames while trace is running.");
2180 if (args
== 0 || *args
== 0)
2181 { /* XXX FIXME: what should default behavior be? */
2182 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2186 if (0 != (tmp
= strchr (args
, ',')))
2188 *tmp
++ = '\0'; /* terminate start address */
2189 while (isspace ((int) *tmp
))
2191 start
= parse_and_eval_address (args
);
2192 stop
= parse_and_eval_address (tmp
);
2195 { /* no explicit end address? */
2196 start
= parse_and_eval_address (args
);
2197 stop
= start
+ 1; /* ??? */
2200 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2203 /* tfind outside command */
2205 trace_find_outside_command (char *args
, int from_tty
)
2207 CORE_ADDR start
, stop
;
2208 char start_str
[40], stop_str
[40];
2211 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2212 error ("May not look at trace frames while trace is running.");
2214 if (args
== 0 || *args
== 0)
2215 { /* XXX FIXME: what should default behavior be? */
2216 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2220 if (0 != (tmp
= strchr (args
, ',')))
2222 *tmp
++ = '\0'; /* terminate start address */
2223 while (isspace ((int) *tmp
))
2225 start
= parse_and_eval_address (args
);
2226 stop
= parse_and_eval_address (tmp
);
2229 { /* no explicit end address? */
2230 start
= parse_and_eval_address (args
);
2231 stop
= start
+ 1; /* ??? */
2234 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2237 /* info scope command: list the locals for a scope. */
2239 scope_info (char *args
, int from_tty
)
2241 struct symtabs_and_lines sals
;
2243 struct minimal_symbol
*msym
;
2244 struct block
*block
;
2245 char **canonical
, *symname
, *save_args
= args
;
2246 struct dict_iterator iter
;
2248 struct gdbarch
*gdbarch
;
2251 if (args
== 0 || *args
== 0)
2252 error (_("requires an argument (function, line or *addr) to define a scope"));
2254 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2255 if (sals
.nelts
== 0)
2256 return; /* presumably decode_line_1 has already warned */
2258 /* Resolve line numbers to PC */
2259 resolve_sal_pc (&sals
.sals
[0]);
2260 block
= block_for_pc (sals
.sals
[0].pc
);
2264 QUIT
; /* allow user to bail out with ^C */
2265 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2267 QUIT
; /* allow user to bail out with ^C */
2269 printf_filtered ("Scope for %s:\n", save_args
);
2272 symname
= SYMBOL_PRINT_NAME (sym
);
2273 if (symname
== NULL
|| *symname
== '\0')
2274 continue; /* probably botched, certainly useless */
2276 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2278 printf_filtered ("Symbol %s is ", symname
);
2279 switch (SYMBOL_CLASS (sym
))
2282 case LOC_UNDEF
: /* messed up symbol? */
2283 printf_filtered ("a bogus symbol, class %d.\n",
2284 SYMBOL_CLASS (sym
));
2285 count
--; /* don't count this one */
2288 printf_filtered ("a constant with value %ld (0x%lx)",
2289 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2291 case LOC_CONST_BYTES
:
2292 printf_filtered ("constant bytes: ");
2293 if (SYMBOL_TYPE (sym
))
2294 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2295 fprintf_filtered (gdb_stdout
, " %02x",
2296 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2299 printf_filtered ("in static storage at address ");
2300 printf_filtered ("%s", paddress (gdbarch
,
2301 SYMBOL_VALUE_ADDRESS (sym
)));
2304 /* GDBARCH is the architecture associated with the objfile
2305 the symbol is defined in; the target architecture may be
2306 different, and may provide additional registers. However,
2307 we do not know the target architecture at this point.
2308 We assume the objfile architecture will contain all the
2309 standard registers that occur in debug info in that
2311 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2313 if (SYMBOL_IS_ARGUMENT (sym
))
2314 printf_filtered ("an argument in register $%s",
2315 gdbarch_register_name (gdbarch
, regno
));
2317 printf_filtered ("a local variable in register $%s",
2318 gdbarch_register_name (gdbarch
, regno
));
2321 printf_filtered ("an argument at stack/frame offset %ld",
2322 SYMBOL_VALUE (sym
));
2325 printf_filtered ("a local variable at frame offset %ld",
2326 SYMBOL_VALUE (sym
));
2329 printf_filtered ("a reference argument at offset %ld",
2330 SYMBOL_VALUE (sym
));
2332 case LOC_REGPARM_ADDR
:
2333 /* Note comment at LOC_REGISTER. */
2334 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2335 printf_filtered ("the address of an argument, in register $%s",
2336 gdbarch_register_name (gdbarch
, regno
));
2339 printf_filtered ("a typedef.\n");
2342 printf_filtered ("a label at address ");
2343 printf_filtered ("%s", paddress (gdbarch
,
2344 SYMBOL_VALUE_ADDRESS (sym
)));
2347 printf_filtered ("a function at address ");
2348 printf_filtered ("%s",
2349 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2351 case LOC_UNRESOLVED
:
2352 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2355 printf_filtered ("Unresolved Static");
2358 printf_filtered ("static storage at address ");
2359 printf_filtered ("%s",
2360 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2363 case LOC_OPTIMIZED_OUT
:
2364 printf_filtered ("optimized out.\n");
2367 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2368 BLOCK_START (block
),
2372 if (SYMBOL_TYPE (sym
))
2373 printf_filtered (", length %d.\n",
2374 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2376 if (BLOCK_FUNCTION (block
))
2379 block
= BLOCK_SUPERBLOCK (block
);
2382 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2386 /* worker function (cleanup) */
2388 replace_comma (void *data
)
2395 /* Helper for trace_dump_command. Dump the action list starting at
2396 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2397 actions of the body of a while-stepping action. STEPPING_FRAME is
2398 set if the current traceframe was determined to be a while-stepping
2402 trace_dump_actions (struct command_line
*action
,
2403 int stepping_actions
, int stepping_frame
,
2406 char *action_exp
, *next_comma
;
2408 for (; action
!= NULL
; action
= action
->next
)
2410 struct cmd_list_element
*cmd
;
2412 QUIT
; /* allow user to bail out with ^C */
2413 action_exp
= action
->line
;
2414 while (isspace ((int) *action_exp
))
2417 /* The collection actions to be done while stepping are
2418 bracketed by the commands "while-stepping" and "end". */
2420 if (*action_exp
== '#') /* comment line */
2423 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2425 error (_("Bad action list item: %s"), action_exp
);
2427 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2431 for (i
= 0; i
< action
->body_count
; ++i
)
2432 trace_dump_actions (action
->body_list
[i
],
2433 1, stepping_frame
, from_tty
);
2435 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2437 /* Display the collected data.
2438 For the trap frame, display only what was collected at
2439 the trap. Likewise for stepping frames, display only
2440 what was collected while stepping. This means that the
2441 two boolean variables, STEPPING_FRAME and
2442 STEPPING_ACTIONS should be equal. */
2443 if (stepping_frame
== stepping_actions
)
2446 { /* repeat over a comma-separated list */
2447 QUIT
; /* allow user to bail out with ^C */
2448 if (*action_exp
== ',')
2450 while (isspace ((int) *action_exp
))
2453 next_comma
= strchr (action_exp
, ',');
2455 if (0 == strncasecmp (action_exp
, "$reg", 4))
2456 registers_info (NULL
, from_tty
);
2457 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2458 locals_info (NULL
, from_tty
);
2459 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2460 args_info (NULL
, from_tty
);
2465 make_cleanup (replace_comma
, next_comma
);
2468 printf_filtered ("%s = ", action_exp
);
2469 output_command (action_exp
, from_tty
);
2470 printf_filtered ("\n");
2474 action_exp
= next_comma
;
2476 while (action_exp
&& *action_exp
== ',');
2482 /* The tdump command. */
2485 trace_dump_command (char *args
, int from_tty
)
2487 struct regcache
*regcache
;
2488 struct breakpoint
*t
;
2489 int stepping_frame
= 0;
2490 struct bp_location
*loc
;
2491 char *line
, *default_collect_line
= NULL
;
2492 struct command_line
*actions
, *default_collect_action
= NULL
;
2493 struct cleanup
*old_chain
= NULL
;
2495 if (tracepoint_number
== -1)
2497 warning (_("No current trace frame."));
2501 t
= get_tracepoint (tracepoint_number
);
2504 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2507 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2508 tracepoint_number
, traceframe_number
);
2510 /* The current frame is a trap frame if the frame PC is equal
2511 to the tracepoint PC. If not, then the current frame was
2512 collected during single-stepping. */
2514 regcache
= get_current_regcache ();
2516 /* If the traceframe's address matches any of the tracepoint's
2517 locations, assume it is a direct hit rather than a while-stepping
2518 frame. (FIXME this is not reliable, should record each frame's
2521 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2522 if (loc
->address
== regcache_read_pc (regcache
))
2525 actions
= breakpoint_commands (t
);
2527 /* If there is a default-collect list, make up a collect command,
2528 prepend to the tracepoint's commands, and pass the whole mess to
2529 the trace dump scanner. We need to validate because
2530 default-collect might have been junked since the trace run. */
2531 if (*default_collect
)
2533 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2534 old_chain
= make_cleanup (xfree
, default_collect_line
);
2535 line
= default_collect_line
;
2536 validate_actionline (&line
, t
);
2537 default_collect_action
= xmalloc (sizeof (struct command_line
));
2538 make_cleanup (xfree
, default_collect_action
);
2539 default_collect_action
->next
= actions
;
2540 default_collect_action
->line
= line
;
2541 actions
= default_collect_action
;
2544 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2546 if (*default_collect
)
2547 do_cleanups (old_chain
);
2550 /* Encode a piece of a tracepoint's source-level definition in a form
2551 that is suitable for both protocol and saving in files. */
2552 /* This version does not do multiple encodes for long strings; it should
2553 return an offset to the next piece to encode. FIXME */
2556 encode_source_string (int tpnum
, ULONGEST addr
,
2557 char *srctype
, char *src
, char *buf
, int buf_size
)
2559 if (80 + strlen (srctype
) > buf_size
)
2560 error (_("Buffer too small for source encoding"));
2561 sprintf (buf
, "%x:%s:%s:%x:%x:",
2562 tpnum
, phex_nz (addr
, sizeof (addr
)), srctype
, 0, (int) strlen (src
));
2563 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2564 error (_("Source string too long for buffer"));
2565 bin2hex (src
, buf
+ strlen (buf
), 0);
2569 extern int trace_regblock_size
;
2571 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2572 non-zero, the save is performed on the target, otherwise GDB obtains all
2573 trace data and saves it locally. */
2576 trace_save (const char *filename
, int target_does_save
)
2578 struct cleanup
*cleanup
;
2580 struct trace_status
*ts
= current_trace_status ();
2583 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2584 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2588 ULONGEST offset
= 0;
2589 #define MAX_TRACE_UPLOAD 2000
2590 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2593 /* If the target is to save the data to a file on its own, then just
2594 send the command and be done with it. */
2595 if (target_does_save
)
2597 err
= target_save_trace_data (filename
);
2599 error (_("Target failed to save trace data to '%s'."),
2604 /* Get the trace status first before opening the file, so if the
2605 target is losing, we can get out without touching files. */
2606 status
= target_get_trace_status (ts
);
2608 pathname
= tilde_expand (filename
);
2609 cleanup
= make_cleanup (xfree
, pathname
);
2611 fp
= fopen (pathname
, "wb");
2613 error (_("Unable to open file '%s' for saving trace data (%s)"),
2614 filename
, safe_strerror (errno
));
2615 make_cleanup_fclose (fp
);
2617 /* Write a file header, with a high-bit-set char to indicate a
2618 binary file, plus a hint as what this file is, and a version
2619 number in case of future needs. */
2620 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2622 perror_with_name (pathname
);
2624 /* Write descriptive info. */
2626 /* Write out the size of a register block. */
2627 fprintf (fp
, "R %x\n", trace_regblock_size
);
2629 /* Write out status of the tracing run (aka "tstatus" info). */
2630 fprintf (fp
, "status %c;%s",
2631 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
2632 if (ts
->stop_reason
== tracepoint_error
)
2634 char *buf
= (char *) alloca (strlen (ts
->error_desc
) * 2 + 1);
2635 bin2hex ((gdb_byte
*) ts
->error_desc
, buf
, 0);
2636 fprintf (fp
, ":%s", buf
);
2638 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
2639 if (ts
->traceframe_count
>= 0)
2640 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
2641 if (ts
->traceframes_created
>= 0)
2642 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
2643 if (ts
->buffer_free
>= 0)
2644 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
2645 if (ts
->buffer_size
>= 0)
2646 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
2647 if (ts
->disconnected_tracing
)
2648 fprintf (fp
, ";disconn:%x", ts
->disconnected_tracing
);
2649 if (ts
->circular_buffer
)
2650 fprintf (fp
, ";circular:%x", ts
->circular_buffer
);
2653 /* Note that we want to upload tracepoints and save those, rather
2654 than simply writing out the local ones, because the user may have
2655 changed tracepoints in GDB in preparation for a future tracing
2656 run, or maybe just mass-deleted all types of breakpoints as part
2657 of cleaning up. So as not to contaminate the session, leave the
2658 data in its uploaded form, don't make into real tracepoints. */
2660 /* Get trace state variables first, they may be checked when parsing
2661 uploaded commands. */
2663 target_upload_trace_state_variables (&uploaded_tsvs
);
2665 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2671 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
2672 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
2675 fprintf (fp
, "tsv %x:%s:%x:%s\n",
2676 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
2677 utsv
->builtin
, buf
);
2683 free_uploaded_tsvs (&uploaded_tsvs
);
2685 target_upload_tracepoints (&uploaded_tps
);
2687 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
2689 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
2690 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2691 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
2692 if (utp
->type
== bp_fast_tracepoint
)
2693 fprintf (fp
, ":F%x", utp
->orig_size
);
2695 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
2698 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
2699 fprintf (fp
, "tp A%x:%s:%s\n",
2700 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
2701 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
2702 fprintf (fp
, "tp S%x:%s:%s\n",
2703 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
2706 encode_source_string (utp
->number
, utp
->addr
,
2707 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
2708 fprintf (fp
, "tp Z%s\n", buf
);
2710 if (utp
->cond_string
)
2712 encode_source_string (utp
->number
, utp
->addr
,
2713 "cond", utp
->cond_string
, buf
, MAX_TRACE_UPLOAD
);
2714 fprintf (fp
, "tp Z%s\n", buf
);
2716 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
2718 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
2719 buf
, MAX_TRACE_UPLOAD
);
2720 fprintf (fp
, "tp Z%s\n", buf
);
2724 free_uploaded_tps (&uploaded_tps
);
2726 /* Mark the end of the definition section. */
2729 /* Get and write the trace data proper. We ask for big blocks, in
2730 the hopes of efficiency, but will take less if the target has
2731 packet size limitations or some such. */
2734 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
2736 error (_("Failure to get requested trace buffer data"));
2737 /* No more data is forthcoming, we're done. */
2740 written
= fwrite (buf
, gotten
, 1, fp
);
2742 perror_with_name (pathname
);
2746 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
2747 written
= fwrite (&gotten
, 4, 1, fp
);
2749 perror_with_name (pathname
);
2751 do_cleanups (cleanup
);
2755 trace_save_command (char *args
, int from_tty
)
2757 int target_does_save
= 0;
2759 char *filename
= NULL
;
2760 struct cleanup
*back_to
;
2763 error_no_arg (_("file in which to save trace data"));
2765 argv
= gdb_buildargv (args
);
2766 back_to
= make_cleanup_freeargv (argv
);
2768 for (; *argv
; ++argv
)
2770 if (strcmp (*argv
, "-r") == 0)
2771 target_does_save
= 1;
2772 else if (**argv
== '-')
2773 error (_("unknown option `%s'"), *argv
);
2779 error_no_arg (_("file in which to save trace data"));
2781 trace_save (filename
, target_does_save
);
2784 printf_filtered (_("Trace data saved to file '%s'.\n"), args
);
2786 do_cleanups (back_to
);
2789 /* Tell the target what to do with an ongoing tracing run if GDB
2790 disconnects for some reason. */
2793 send_disconnected_tracing_value (int value
)
2795 target_set_disconnected_tracing (value
);
2799 set_disconnected_tracing (char *args
, int from_tty
,
2800 struct cmd_list_element
*c
)
2802 send_disconnected_tracing_value (disconnected_tracing
);
2806 set_circular_trace_buffer (char *args
, int from_tty
,
2807 struct cmd_list_element
*c
)
2809 target_set_circular_trace_buffer (circular_trace_buffer
);
2812 /* Convert the memory pointed to by mem into hex, placing result in buf.
2813 * Return a pointer to the last char put in buf (null)
2814 * "stolen" from sparc-stub.c
2817 static const char hexchars
[] = "0123456789abcdef";
2820 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2828 *buf
++ = hexchars
[ch
>> 4];
2829 *buf
++ = hexchars
[ch
& 0xf];
2838 get_traceframe_number (void)
2840 return traceframe_number
;
2843 /* Make the traceframe NUM be the current trace frame. Does nothing
2844 if NUM is already current. */
2847 set_traceframe_number (int num
)
2851 if (traceframe_number
== num
)
2853 /* Nothing to do. */
2857 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
2860 warning (_("could not change traceframe"));
2862 traceframe_number
= newnum
;
2864 /* Changing the traceframe changes our view of registers and of the
2866 registers_changed ();
2869 /* A cleanup used when switching away and back from tfind mode. */
2871 struct current_traceframe_cleanup
2873 /* The traceframe we were inspecting. */
2874 int traceframe_number
;
2878 do_restore_current_traceframe_cleanup (void *arg
)
2880 struct current_traceframe_cleanup
*old
= arg
;
2882 set_traceframe_number (old
->traceframe_number
);
2886 restore_current_traceframe_cleanup_dtor (void *arg
)
2888 struct current_traceframe_cleanup
*old
= arg
;
2894 make_cleanup_restore_current_traceframe (void)
2896 struct current_traceframe_cleanup
*old
;
2898 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
2899 old
->traceframe_number
= traceframe_number
;
2901 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
2902 restore_current_traceframe_cleanup_dtor
);
2905 /* Given a number and address, return an uploaded tracepoint with that
2906 number, creating if necessary. */
2908 struct uploaded_tp
*
2909 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
2911 struct uploaded_tp
*utp
;
2913 for (utp
= *utpp
; utp
; utp
= utp
->next
)
2914 if (utp
->number
== num
&& utp
->addr
== addr
)
2916 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
2917 memset (utp
, 0, sizeof (struct uploaded_tp
));
2920 utp
->actions
= NULL
;
2921 utp
->step_actions
= NULL
;
2922 utp
->cmd_strings
= NULL
;
2929 free_uploaded_tps (struct uploaded_tp
**utpp
)
2931 struct uploaded_tp
*next_one
;
2935 next_one
= (*utpp
)->next
;
2941 /* Given a number and address, return an uploaded tracepoint with that
2942 number, creating if necessary. */
2944 struct uploaded_tsv
*
2945 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
2947 struct uploaded_tsv
*utsv
;
2949 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
2950 if (utsv
->number
== num
)
2952 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
2953 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
2955 utsv
->next
= *utsvp
;
2961 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
2963 struct uploaded_tsv
*next_one
;
2967 next_one
= (*utsvp
)->next
;
2973 /* Look for an existing tracepoint that seems similar enough to the
2974 uploaded one. Enablement isn't compared, because the user can
2975 toggle that freely, and may have done so in anticipation of the
2979 find_matching_tracepoint (struct uploaded_tp
*utp
)
2981 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
2983 struct breakpoint
*t
;
2984 struct bp_location
*loc
;
2986 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2988 if (t
->type
== utp
->type
2989 && t
->step_count
== utp
->step
2990 && t
->pass_count
== utp
->pass
2991 /* FIXME also test conditionals and actions */
2994 /* Scan the locations for an address match. */
2995 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2997 if (loc
->address
== utp
->addr
)
3005 /* Given a list of tracepoints uploaded from a target, attempt to
3006 match them up with existing tracepoints, and create new ones if not
3010 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3012 struct uploaded_tp
*utp
;
3013 struct breakpoint
*t
;
3015 /* Look for GDB tracepoints that match up with our uploaded versions. */
3016 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3018 t
= find_matching_tracepoint (utp
);
3020 printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
3021 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
3024 t
= create_tracepoint_from_upload (utp
);
3026 printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
3027 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
3029 printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
3030 utp
->number
, paddress (get_current_arch (), utp
->addr
));
3032 /* Whether found or created, record the number used by the
3033 target, to help with mapping target tracepoints back to their
3034 counterparts here. */
3036 t
->number_on_target
= utp
->number
;
3039 free_uploaded_tps (uploaded_tps
);
3042 /* Trace state variables don't have much to identify them beyond their
3043 name, so just use that to detect matches. */
3045 struct trace_state_variable
*
3046 find_matching_tsv (struct uploaded_tsv
*utsv
)
3051 return find_trace_state_variable (utsv
->name
);
3054 struct trace_state_variable
*
3055 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3057 const char *namebase
;
3060 struct trace_state_variable
*tsv
;
3064 namebase
= utsv
->name
;
3065 sprintf (buf
, "%s", namebase
);
3070 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3073 /* Fish for a name that is not in use. */
3074 /* (should check against all internal vars?) */
3075 while (find_trace_state_variable (buf
))
3076 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3078 /* We have an available name, create the variable. */
3079 tsv
= create_trace_state_variable (xstrdup (buf
));
3080 tsv
->initial_value
= utsv
->initial_value
;
3081 tsv
->builtin
= utsv
->builtin
;
3086 /* Given a list of uploaded trace state variables, try to match them
3087 up with existing variables, or create additional ones. */
3090 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3093 struct uploaded_tsv
*utsv
;
3094 struct trace_state_variable
*tsv
;
3097 /* Most likely some numbers will have to be reassigned as part of
3098 the merge, so clear them all in anticipation. */
3099 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3102 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3104 tsv
= find_matching_tsv (utsv
);
3106 printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
3107 tsv
->name
, utsv
->number
);
3110 tsv
= create_tsv_from_upload (utsv
);
3111 printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
3112 tsv
->name
, utsv
->number
);
3114 /* Give precedence to numberings that come from the target. */
3116 tsv
->number
= utsv
->number
;
3119 /* Renumber everything that didn't get a target-assigned number. */
3121 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3122 if (tsv
->number
> highest
)
3123 highest
= tsv
->number
;
3126 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3127 if (tsv
->number
== 0)
3128 tsv
->number
= highest
++;
3130 free_uploaded_tsvs (uploaded_tsvs
);
3133 /* target tfile command */
3135 struct target_ops tfile_ops
;
3137 /* Fill in tfile_ops with its defined operations and properties. */
3139 #define TRACE_HEADER_SIZE 8
3141 char *trace_filename
;
3143 off_t trace_frames_offset
;
3146 int trace_regblock_size
;
3148 static void tfile_interp_line (char *line
,
3149 struct uploaded_tp
**utpp
,
3150 struct uploaded_tsv
**utsvp
);
3153 tfile_open (char *filename
, int from_tty
)
3156 struct cleanup
*old_chain
;
3159 char header
[TRACE_HEADER_SIZE
];
3160 char linebuf
[1000]; /* should be max remote packet size or so */
3162 int bytes
, i
, gotten
;
3163 struct trace_status
*ts
;
3164 struct uploaded_tp
*uploaded_tps
= NULL
;
3165 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3167 target_preopen (from_tty
);
3169 error (_("No trace file specified."));
3171 filename
= tilde_expand (filename
);
3172 if (!IS_ABSOLUTE_PATH(filename
))
3174 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
3179 old_chain
= make_cleanup (xfree
, filename
);
3181 flags
= O_BINARY
| O_LARGEFILE
;
3183 scratch_chan
= open (filename
, flags
, 0);
3184 if (scratch_chan
< 0)
3185 perror_with_name (filename
);
3187 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3189 discard_cleanups (old_chain
); /* Don't free filename any more */
3190 unpush_target (&tfile_ops
);
3192 push_target (&tfile_ops
);
3194 trace_filename
= xstrdup (filename
);
3195 trace_fd
= scratch_chan
;
3198 /* Read the file header and test for validity. */
3199 gotten
= read (trace_fd
, &header
, TRACE_HEADER_SIZE
);
3201 perror_with_name (trace_filename
);
3202 else if (gotten
< TRACE_HEADER_SIZE
)
3203 error (_("Premature end of file while reading trace file"));
3205 bytes
+= TRACE_HEADER_SIZE
;
3206 if (!(header
[0] == 0x7f
3207 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3208 error (_("File is not a valid trace file."));
3210 trace_regblock_size
= 0;
3211 ts
= current_trace_status ();
3212 /* We know we're working with a file. */
3214 /* Set defaults in case there is no status line. */
3215 ts
->running_known
= 0;
3216 ts
->stop_reason
= trace_stop_reason_unknown
;
3217 ts
->traceframe_count
= -1;
3218 ts
->buffer_free
= 0;
3219 ts
->disconnected_tracing
= 0;
3220 ts
->circular_buffer
= 0;
3222 /* Read through a section of newline-terminated lines that
3223 define things like tracepoints. */
3227 gotten
= read (trace_fd
, &byte
, 1);
3229 perror_with_name (trace_filename
);
3230 else if (gotten
< 1)
3231 error (_("Premature end of file while reading trace file"));
3236 /* Empty line marks end of the definition section. */
3241 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3244 linebuf
[i
++] = byte
;
3246 error (_("Excessively long lines in trace file"));
3249 /* Add the file's tracepoints and variables into the current mix. */
3251 /* Get trace state variables first, they may be checked when parsing
3252 uploaded commands. */
3253 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3255 merge_uploaded_tracepoints (&uploaded_tps
);
3257 /* Record the starting offset of the binary trace data. */
3258 trace_frames_offset
= bytes
;
3260 /* If we don't have a blocksize, we can't interpret the
3262 if (trace_regblock_size
== 0)
3263 error (_("No register block size recorded in trace file"));
3264 if (ts
->traceframe_count
<= 0)
3266 warning ("No traceframes present in this file.");
3270 #define TFILE_PID (1)
3271 inferior_appeared (current_inferior (), TFILE_PID
);
3272 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3273 add_thread_silent (inferior_ptid
);
3275 post_create_inferior (&tfile_ops
, from_tty
);
3278 /* FIXME this will get defined in MI patch submission */
3279 tfind_1 (tfind_number
, 0, 0, 0, 0);
3283 /* Interpret the given line from the definitions part of the trace
3287 tfile_interp_line (char *line
,
3288 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3292 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3295 trace_regblock_size
= strtol (p
, &p
, 16);
3297 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3299 p
+= strlen ("status ");
3300 parse_trace_status (p
, current_trace_status ());
3302 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3304 p
+= strlen ("tp ");
3305 parse_tracepoint_definition (p
, utpp
);
3307 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3309 p
+= strlen ("tsv ");
3310 parse_tsv_definition (p
, utsvp
);
3313 warning ("Ignoring trace file definition \"%s\"", line
);
3316 /* Parse the part of trace status syntax that is shared between
3317 the remote protocol and the trace file reader. */
3319 extern char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
3322 parse_trace_status (char *line
, struct trace_status
*ts
)
3324 char *p
= line
, *p1
, *p2
, *p_temp
;
3327 ts
->running_known
= 1;
3328 ts
->running
= (*p
++ == '1');
3329 ts
->stop_reason
= trace_stop_reason_unknown
;
3330 xfree (ts
->error_desc
);
3331 ts
->error_desc
= NULL
;
3332 ts
->traceframe_count
= -1;
3333 ts
->traceframes_created
= -1;
3334 ts
->buffer_free
= -1;
3335 ts
->buffer_size
= -1;
3336 ts
->disconnected_tracing
= 0;
3337 ts
->circular_buffer
= 0;
3341 p1
= strchr (p
, ':');
3343 error (_("Malformed trace status, at %s\n\
3344 Status line: '%s'\n"), p
, line
);
3345 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3347 p
= unpack_varlen_hex (++p1
, &val
);
3348 ts
->stop_reason
= trace_buffer_full
;
3350 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3352 p
= unpack_varlen_hex (++p1
, &val
);
3353 ts
->stop_reason
= trace_never_run
;
3355 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
], p1
- p
) == 0)
3357 p
= unpack_varlen_hex (++p1
, &val
);
3358 ts
->stop_reason
= tracepoint_passcount
;
3359 ts
->stopping_tracepoint
= val
;
3361 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3363 p
= unpack_varlen_hex (++p1
, &val
);
3364 ts
->stop_reason
= tstop_command
;
3366 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3368 p
= unpack_varlen_hex (++p1
, &val
);
3369 ts
->stop_reason
= trace_disconnected
;
3371 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3373 p2
= strchr (++p1
, ':');
3378 ts
->error_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3379 end
= hex2bin (p1
, ts
->error_desc
, (p2
- p1
) / 2);
3380 ts
->error_desc
[end
] = '\0';
3383 ts
->error_desc
= xstrdup ("");
3385 p
= unpack_varlen_hex (++p2
, &val
);
3386 ts
->stopping_tracepoint
= val
;
3387 ts
->stop_reason
= tracepoint_error
;
3389 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3391 p
= unpack_varlen_hex (++p1
, &val
);
3392 ts
->traceframe_count
= val
;
3394 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3396 p
= unpack_varlen_hex (++p1
, &val
);
3397 ts
->traceframes_created
= val
;
3399 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3401 p
= unpack_varlen_hex (++p1
, &val
);
3402 ts
->buffer_free
= val
;
3404 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3406 p
= unpack_varlen_hex (++p1
, &val
);
3407 ts
->buffer_size
= val
;
3409 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3411 p
= unpack_varlen_hex (++p1
, &val
);
3412 ts
->disconnected_tracing
= val
;
3414 else if (strncmp (p
, "circular", p1
- p
) == 0)
3416 p
= unpack_varlen_hex (++p1
, &val
);
3417 ts
->circular_buffer
= val
;
3421 /* Silently skip unknown optional info. */
3422 p_temp
= strchr (p1
+ 1, ';');
3426 /* Must be at the end. */
3432 /* Given a line of text defining a part of a tracepoint, parse it into
3433 an "uploaded tracepoint". */
3436 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3440 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3441 int enabled
, i
, end
;
3443 char *cond
, *srctype
, *src
, *buf
;
3444 struct uploaded_tp
*utp
= NULL
;
3447 /* Both tracepoint and action definitions start with the same number
3448 and address sequence. */
3450 p
= unpack_varlen_hex (p
, &num
);
3451 p
++; /* skip a colon */
3452 p
= unpack_varlen_hex (p
, &addr
);
3453 p
++; /* skip a colon */
3456 enabled
= (*p
++ == 'E');
3457 p
++; /* skip a colon */
3458 p
= unpack_varlen_hex (p
, &step
);
3459 p
++; /* skip a colon */
3460 p
= unpack_varlen_hex (p
, &pass
);
3461 type
= bp_tracepoint
;
3463 /* Thumb through optional fields. */
3466 p
++; /* skip a colon */
3469 type
= bp_fast_tracepoint
;
3471 p
= unpack_varlen_hex (p
, &orig_size
);
3476 p
= unpack_varlen_hex (p
, &xlen
);
3477 p
++; /* skip a comma */
3478 cond
= (char *) xmalloc (2 * xlen
+ 1);
3479 strncpy (cond
, p
, 2 * xlen
);
3480 cond
[2 * xlen
] = '\0';
3484 warning (_("Unrecognized char '%c' in tracepoint definition, skipping rest"), *p
);
3486 utp
= get_uploaded_tp (num
, addr
, utpp
);
3488 utp
->enabled
= enabled
;
3493 else if (piece
== 'A')
3495 utp
= get_uploaded_tp (num
, addr
, utpp
);
3496 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
3498 else if (piece
== 'S')
3500 utp
= get_uploaded_tp (num
, addr
, utpp
);
3501 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
3503 else if (piece
== 'Z')
3505 /* Parse a chunk of source form definition. */
3506 utp
= get_uploaded_tp (num
, addr
, utpp
);
3508 p
= strchr (p
, ':');
3509 p
++; /* skip a colon */
3510 p
= unpack_varlen_hex (p
, &start
);
3511 p
++; /* skip a colon */
3512 p
= unpack_varlen_hex (p
, &xlen
);
3513 p
++; /* skip a colon */
3515 buf
= alloca (strlen (line
));
3517 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3520 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
3521 utp
->at_string
= xstrdup (buf
);
3522 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
3523 utp
->cond_string
= xstrdup (buf
);
3524 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
3525 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
3529 /* Don't error out, the target might be sending us optional
3530 info that we don't care about. */
3531 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3535 /* Convert a textual description of a trace state variable into an
3539 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3542 ULONGEST num
, initval
, builtin
;
3544 struct uploaded_tsv
*utsv
= NULL
;
3546 buf
= alloca (strlen (line
));
3549 p
= unpack_varlen_hex (p
, &num
);
3550 p
++; /* skip a colon */
3551 p
= unpack_varlen_hex (p
, &initval
);
3552 p
++; /* skip a colon */
3553 p
= unpack_varlen_hex (p
, &builtin
);
3554 p
++; /* skip a colon */
3555 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3558 utsv
= get_uploaded_tsv (num
, utsvp
);
3559 utsv
->initial_value
= initval
;
3560 utsv
->builtin
= builtin
;
3561 utsv
->name
= xstrdup (buf
);
3564 /* Close the trace file and generally clean up. */
3567 tfile_close (int quitting
)
3574 pid
= ptid_get_pid (inferior_ptid
);
3575 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
3576 exit_inferior_silent (pid
);
3581 xfree (trace_filename
);
3585 tfile_files_info (struct target_ops
*t
)
3587 /* (it would be useful to mention the name of the file) */
3588 printf_filtered ("Looking at a trace file.\n");
3591 /* The trace status for a file is that tracing can never be run. */
3594 tfile_get_trace_status (struct trace_status
*ts
)
3596 /* Other bits of trace status were collected as part of opening the
3597 trace files, so nothing to do here. */
3602 /* Given the position of a traceframe in the file, figure out what
3603 address the frame was collected at. This would normally be the
3604 value of a collected PC register, but if not available, we
3608 tfile_get_traceframe_address (off_t tframe_offset
)
3612 struct breakpoint
*tp
;
3613 off_t saved_offset
= cur_offset
;
3616 /* FIXME dig pc out of collected registers */
3618 /* Fall back to using tracepoint address. */
3619 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
3620 gotten
= read (trace_fd
, &tpnum
, 2);
3622 perror_with_name (trace_filename
);
3623 else if (gotten
< 2)
3624 error (_("Premature end of file while reading trace file"));
3626 tp
= get_tracepoint_by_number_on_target (tpnum
);
3627 /* FIXME this is a poor heuristic if multiple locations */
3629 addr
= tp
->loc
->address
;
3631 /* Restore our seek position. */
3632 cur_offset
= saved_offset
;
3633 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3637 /* Given a type of search and some parameters, scan the collection of
3638 traceframes in the file looking for a match. When found, return
3639 both the traceframe and tracepoint number, otherwise -1 for
3643 tfile_trace_find (enum trace_find_type type
, int num
,
3644 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
3647 int tfnum
= 0, found
= 0, gotten
;
3649 struct breakpoint
*tp
;
3650 off_t offset
, tframe_offset
;
3653 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
3654 offset
= trace_frames_offset
;
3657 tframe_offset
= offset
;
3658 gotten
= read (trace_fd
, &tpnum
, 2);
3660 perror_with_name (trace_filename
);
3661 else if (gotten
< 2)
3662 error (_("Premature end of file while reading trace file"));
3666 gotten
= read (trace_fd
, &data_size
, 4);
3668 perror_with_name (trace_filename
);
3669 else if (gotten
< 4)
3670 error (_("Premature end of file while reading trace file"));
3679 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3680 if (tfaddr
== addr1
)
3684 tp
= get_tracepoint (num
);
3685 if (tp
&& tpnum
== tp
->number_on_target
)
3689 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3690 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
3694 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3695 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
3699 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
3705 cur_offset
= offset
;
3706 cur_data_size
= data_size
;
3709 /* Skip past the traceframe's data. */
3710 lseek (trace_fd
, data_size
, SEEK_CUR
);
3711 offset
+= data_size
;
3712 /* Update our own count of traceframes. */
3715 /* Did not find what we were looking for. */
3721 /* Look for a block of saved registers in the traceframe, and get the
3722 requested register from it. */
3725 tfile_fetch_registers (struct target_ops
*ops
,
3726 struct regcache
*regcache
, int regno
)
3728 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3730 int i
, pos
, offset
, regn
, regsize
, gotten
, pc_regno
;
3731 unsigned short mlen
;
3734 /* An uninitialized reg size says we're not going to be
3735 successful at getting register blocks. */
3736 if (!trace_regblock_size
)
3739 regs
= alloca (trace_regblock_size
);
3741 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3743 while (pos
< cur_data_size
)
3745 gotten
= read (trace_fd
, &block_type
, 1);
3747 perror_with_name (trace_filename
);
3748 else if (gotten
< 1)
3749 error (_("Premature end of file while reading trace file"));
3755 gotten
= read (trace_fd
, regs
, trace_regblock_size
);
3757 perror_with_name (trace_filename
);
3758 else if (gotten
< trace_regblock_size
)
3759 error (_("Premature end of file while reading trace file"));
3761 /* Assume the block is laid out in GDB register number order,
3762 each register with the size that it has in GDB. */
3764 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3766 regsize
= register_size (gdbarch
, regn
);
3767 /* Make sure we stay within block bounds. */
3768 if (offset
+ regsize
>= trace_regblock_size
)
3770 if (!regcache_valid_p (regcache
, regn
))
3774 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
3777 else if (regno
== -1)
3779 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
3786 lseek (trace_fd
, 8, SEEK_CUR
);
3787 gotten
= read (trace_fd
, &mlen
, 2);
3789 perror_with_name (trace_filename
);
3790 else if (gotten
< 2)
3791 error (_("Premature end of file while reading trace file"));
3792 lseek (trace_fd
, mlen
, SEEK_CUR
);
3793 pos
+= (8 + 2 + mlen
);
3796 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3800 error ("Unknown block type '%c' (0x%x) in trace frame",
3801 block_type
, block_type
);
3806 /* We get here if no register data has been found. Although we
3807 don't like making up numbers, GDB has all manner of troubles when
3808 the target says some register is not available. Filling in with
3809 zeroes is a reasonable fallback. */
3810 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3811 regcache_raw_supply (regcache
, regn
, NULL
);
3813 /* We can often usefully guess that the PC is going to be the same
3814 as the address of the tracepoint. */
3815 pc_regno
= gdbarch_pc_regnum (gdbarch
);
3816 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
3818 struct breakpoint
*tp
= get_tracepoint (tracepoint_number
);
3822 /* But don't try to guess if tracepoint is multi-location... */
3825 warning ("Tracepoint %d has multiple locations, cannot infer $pc",
3829 /* ... or does while-stepping. */
3830 if (tp
->step_count
> 0)
3832 warning ("Tracepoint %d does while-stepping, cannot infer $pc",
3837 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
3838 gdbarch_byte_order (gdbarch
),
3840 regcache_raw_supply (regcache
, pc_regno
, regs
);
3846 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3847 const char *annex
, gdb_byte
*readbuf
,
3848 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3852 ULONGEST maddr
, amt
;
3853 unsigned short mlen
;
3855 /* We're only doing regular memory for now. */
3856 if (object
!= TARGET_OBJECT_MEMORY
)
3859 if (readbuf
== NULL
)
3860 error ("tfile_xfer_partial: trace file is read-only");
3862 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3864 while (pos
< cur_data_size
)
3866 gotten
= read (trace_fd
, &block_type
, 1);
3868 perror_with_name (trace_filename
);
3869 else if (gotten
< 1)
3870 error (_("Premature end of file while reading trace file"));
3875 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3876 pos
+= trace_regblock_size
;
3879 gotten
= read (trace_fd
, &maddr
, 8);
3881 perror_with_name (trace_filename
);
3882 else if (gotten
< 8)
3883 error (_("Premature end of file while reading trace file"));
3885 gotten
= read (trace_fd
, &mlen
, 2);
3887 perror_with_name (trace_filename
);
3888 else if (gotten
< 2)
3889 error (_("Premature end of file while reading trace file"));
3890 /* If the block includes the first part of the desired
3891 range, return as much it has; GDB will re-request the
3892 remainder, which might be in a different block of this
3894 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
3896 amt
= (maddr
+ mlen
) - offset
;
3900 gotten
= read (trace_fd
, readbuf
, amt
);
3902 perror_with_name (trace_filename
);
3903 /* While it's acceptable to return less than was
3904 originally asked for, it's not acceptable to return
3905 less than what this block claims to contain. */
3906 else if (gotten
< amt
)
3907 error (_("Premature end of file while reading trace file"));
3910 lseek (trace_fd
, mlen
, SEEK_CUR
);
3911 pos
+= (8 + 2 + mlen
);
3914 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3918 error ("Unknown block type '%c' (0x%x) in traceframe",
3919 block_type
, block_type
);
3924 /* It's unduly pedantic to refuse to look at the executable for
3925 read-only pieces; so do the equivalent of readonly regions aka
3927 /* FIXME account for relocation at some point */
3934 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
3936 if ((s
->flags
& SEC_LOAD
) == 0 ||
3937 (s
->flags
& SEC_READONLY
) == 0)
3941 size
= bfd_get_section_size (s
);
3942 if (lma
<= offset
&& offset
< (lma
+ size
))
3944 amt
= (lma
+ size
) - offset
;
3948 amt
= bfd_get_section_contents (exec_bfd
, s
,
3949 readbuf
, offset
- lma
, amt
);
3955 /* Indicate failure to find the requested memory block. */
3959 /* Iterate through the blocks of a trace frame, looking for a 'V'
3960 block with a matching tsv number. */
3963 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
3966 int pos
, vnum
, gotten
;
3967 unsigned short mlen
;
3969 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3971 while (pos
< cur_data_size
)
3973 gotten
= read (trace_fd
, &block_type
, 1);
3975 perror_with_name (trace_filename
);
3976 else if (gotten
< 1)
3977 error (_("Premature end of file while reading trace file"));
3982 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3983 pos
+= trace_regblock_size
;
3986 lseek (trace_fd
, 8, SEEK_CUR
);
3987 gotten
= read (trace_fd
, &mlen
, 2);
3989 perror_with_name (trace_filename
);
3990 else if (gotten
< 2)
3991 error (_("Premature end of file while reading trace file"));
3992 lseek (trace_fd
, mlen
, SEEK_CUR
);
3993 pos
+= (8 + 2 + mlen
);
3996 gotten
= read (trace_fd
, &vnum
, 4);
3998 perror_with_name (trace_filename
);
3999 else if (gotten
< 4)
4000 error (_("Premature end of file while reading trace file"));
4003 gotten
= read (trace_fd
, val
, 8);
4005 perror_with_name (trace_filename
);
4006 else if (gotten
< 8)
4007 error (_("Premature end of file while reading trace file"));
4010 lseek (trace_fd
, 8, SEEK_CUR
);
4014 error ("Unknown block type '%c' (0x%x) in traceframe",
4015 block_type
, block_type
);
4019 /* Didn't find anything. */
4024 tfile_has_all_memory (struct target_ops
*ops
)
4030 tfile_has_memory (struct target_ops
*ops
)
4036 tfile_has_stack (struct target_ops
*ops
)
4042 tfile_has_registers (struct target_ops
*ops
)
4048 init_tfile_ops (void)
4050 tfile_ops
.to_shortname
= "tfile";
4051 tfile_ops
.to_longname
= "Local trace dump file";
4053 "Use a trace file as a target. Specify the filename of the trace file.";
4054 tfile_ops
.to_open
= tfile_open
;
4055 tfile_ops
.to_close
= tfile_close
;
4056 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
4057 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
4058 tfile_ops
.to_files_info
= tfile_files_info
;
4059 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
4060 tfile_ops
.to_trace_find
= tfile_trace_find
;
4061 tfile_ops
.to_get_trace_state_variable_value
= tfile_get_trace_state_variable_value
;
4062 /* core_stratum might seem more logical, but GDB doesn't like having
4063 more than one core_stratum vector. */
4064 tfile_ops
.to_stratum
= process_stratum
;
4065 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
4066 tfile_ops
.to_has_memory
= tfile_has_memory
;
4067 tfile_ops
.to_has_stack
= tfile_has_stack
;
4068 tfile_ops
.to_has_registers
= tfile_has_registers
;
4069 tfile_ops
.to_magic
= OPS_MAGIC
;
4072 /* module initialization */
4074 _initialize_tracepoint (void)
4076 struct cmd_list_element
*c
;
4078 traceframe_number
= -1;
4079 tracepoint_number
= -1;
4081 if (tracepoint_list
.list
== NULL
)
4083 tracepoint_list
.listsize
= 128;
4084 tracepoint_list
.list
= xmalloc
4085 (tracepoint_list
.listsize
* sizeof (struct memrange
));
4087 if (tracepoint_list
.aexpr_list
== NULL
)
4089 tracepoint_list
.aexpr_listsize
= 128;
4090 tracepoint_list
.aexpr_list
= xmalloc
4091 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
4094 if (stepping_list
.list
== NULL
)
4096 stepping_list
.listsize
= 128;
4097 stepping_list
.list
= xmalloc
4098 (stepping_list
.listsize
* sizeof (struct memrange
));
4101 if (stepping_list
.aexpr_list
== NULL
)
4103 stepping_list
.aexpr_listsize
= 128;
4104 stepping_list
.aexpr_list
= xmalloc
4105 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
4108 add_info ("scope", scope_info
,
4109 _("List the variables local to a scope"));
4111 add_cmd ("tracepoints", class_trace
, NULL
,
4112 _("Tracing of program execution without stopping the program."),
4115 add_com ("tdump", class_trace
, trace_dump_command
,
4116 _("Print everything collected at the current tracepoint."));
4118 add_com ("tsave", class_trace
, trace_save_command
, _("\
4119 Save the trace data to a file.\n\
4120 Use the '-r' option to direct the target to save directly to the file,\n\
4121 using its own filesystem."));
4123 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
4124 Define a trace state variable.\n\
4125 Argument is a $-prefixed name, optionally followed\n\
4126 by '=' and an expression that sets the initial value\n\
4127 at the start of tracing."));
4128 set_cmd_completer (c
, expression_completer
);
4130 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
4131 Delete one or more trace state variables.\n\
4132 Arguments are the names of the variables to delete.\n\
4133 If no arguments are supplied, delete all variables."), &deletelist
);
4134 /* FIXME add a trace variable completer */
4136 add_info ("tvariables", tvariables_info
, _("\
4137 Status of trace state variables and their values.\n\
4140 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
4141 Select a trace frame;\n\
4142 No argument means forward by one frame; '-' means backward by one frame."),
4143 &tfindlist
, "tfind ", 1, &cmdlist
);
4145 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
4146 Select a trace frame whose PC is outside the given range (exclusive).\n\
4147 Usage: tfind outside addr1, addr2"),
4150 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
4151 Select a trace frame whose PC is in the given range (inclusive).\n\
4152 Usage: tfind range addr1,addr2"),
4155 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
4156 Select a trace frame by source line.\n\
4157 Argument can be a line number (with optional source file), \n\
4158 a function name, or '*' followed by an address.\n\
4159 Default argument is 'the next source line that was traced'."),
4162 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
4163 Select a trace frame by tracepoint number.\n\
4164 Default is the tracepoint for the current trace frame."),
4167 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
4168 Select a trace frame by PC.\n\
4169 Default is the current PC, or the PC of the current trace frame."),
4172 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
4173 Synonym for 'none'.\n\
4174 De-select any trace frame and resume 'live' debugging."),
4177 add_cmd ("none", class_trace
, trace_find_none_command
,
4178 _("De-select any trace frame and resume 'live' debugging."),
4181 add_cmd ("start", class_trace
, trace_find_start_command
,
4182 _("Select the first trace frame in the trace buffer."),
4185 add_com ("tstatus", class_trace
, trace_status_command
,
4186 _("Display the status of the current trace data collection."));
4188 add_com ("tstop", class_trace
, trace_stop_command
,
4189 _("Stop trace data collection."));
4191 add_com ("tstart", class_trace
, trace_start_command
,
4192 _("Start trace data collection."));
4194 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
4195 Ends a list of commands or actions.\n\
4196 Several GDB commands allow you to enter a list of commands or actions.\n\
4197 Entering \"end\" on a line by itself is the normal way to terminate\n\
4199 Note: the \"end\" command cannot be used at the gdb prompt."));
4201 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
4202 Specify single-stepping behavior at a tracepoint.\n\
4203 Argument is number of instructions to trace in single-step mode\n\
4204 following the tracepoint. This command is normally followed by\n\
4205 one or more \"collect\" commands, to specify what to collect\n\
4206 while single-stepping.\n\n\
4207 Note: this command can only be used in a tracepoint \"actions\" list."));
4209 add_com_alias ("ws", "while-stepping", class_alias
, 0);
4210 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
4212 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
4213 Specify one or more data items to be collected at a tracepoint.\n\
4214 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4215 collect all data (variables, registers) referenced by that expression.\n\
4216 Also accepts the following special arguments:\n\
4217 $regs -- all registers.\n\
4218 $args -- all function arguments.\n\
4219 $locals -- all variables local to the block/function scope.\n\
4220 Note: this command can only be used in a tracepoint \"actions\" list."));
4222 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4223 Specify one or more expressions to be evaluated at a tracepoint.\n\
4224 Accepts a comma-separated list of (one or more) expressions.\n\
4225 The result of each evaluation will be discarded.\n\
4226 Note: this command can only be used in a tracepoint \"actions\" list."));
4228 add_com ("actions", class_trace
, trace_actions_command
, _("\
4229 Specify the actions to be taken at a tracepoint.\n\
4230 Tracepoint actions may include collecting of specified data, \n\
4231 single-stepping, or enabling/disabling other tracepoints, \n\
4232 depending on target's capabilities."));
4234 default_collect
= xstrdup ("");
4235 add_setshow_string_cmd ("default-collect", class_trace
,
4236 &default_collect
, _("\
4237 Set the list of expressions to collect by default"), _("\
4238 Show the list of expressions to collect by default"), NULL
,
4240 &setlist
, &showlist
);
4242 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4243 &disconnected_tracing
, _("\
4244 Set whether tracing continues after GDB disconnects."), _("\
4245 Show whether tracing continues after GDB disconnects."), _("\
4246 Use this to continue a tracing run even if GDB disconnects\n\
4247 or detaches from the target. You can reconnect later and look at\n\
4248 trace data collected in the meantime."),
4249 set_disconnected_tracing
,
4254 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4255 &circular_trace_buffer
, _("\
4256 Set target's use of circular trace buffer."), _("\
4257 Show target's use of circular trace buffer."), _("\
4258 Use this to make the trace buffer into a circular buffer,\n\
4259 which will discard traceframes (oldest first) instead of filling\n\
4260 up and stopping the trace run."),
4261 set_circular_trace_buffer
,
4268 add_target (&tfile_ops
);