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
, 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
, struct agent_reqs
*areqs
)
565 /* All of the "flaws" are serious bytecode generation issues that
566 should never occur. */
567 if (areqs
->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 (areqs
->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 (areqs
->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
;
596 struct agent_reqs areqs
;
598 /* if EOF is typed, *line is NULL */
602 for (p
= *line
; isspace ((int) *p
);)
605 /* Symbol lookup etc. */
606 if (*p
== '\0') /* empty line: just prompt for another line. */
609 if (*p
== '#') /* comment line */
612 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
614 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
616 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
619 { /* repeat over a comma-separated list */
620 QUIT
; /* allow user to bail out with ^C */
621 while (isspace ((int) *p
))
624 if (*p
== '$') /* look for special pseudo-symbols */
626 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
627 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
628 (0 == strncasecmp ("loc", p
+ 1, 3)))
633 /* else fall thru, treat p as an expression and parse it! */
636 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
639 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
640 old_chain
= make_cleanup (free_current_contents
, &exp
);
642 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
644 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
646 error (_("constant `%s' (value %ld) will not be collected."),
647 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
648 SYMBOL_VALUE (exp
->elts
[2].symbol
));
650 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
652 error (_("`%s' is optimized away and cannot be collected."),
653 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
657 /* We have something to collect, make sure that the expr to
658 bytecode translator can handle it and that it's not too
660 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
661 make_cleanup_free_agent_expr (aexpr
);
663 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
664 error (_("Expression is too complicated."));
666 ax_reqs (aexpr
, &areqs
);
667 (void) make_cleanup (xfree
, areqs
.reg_mask
);
669 report_agent_reqs_errors (aexpr
, &areqs
);
671 do_cleanups (old_chain
);
674 while (p
&& *p
++ == ',');
677 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
680 { /* repeat over a comma-separated list */
681 QUIT
; /* allow user to bail out with ^C */
682 while (isspace ((int) *p
))
686 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
689 /* Only expressions are allowed for this action. */
690 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
691 old_chain
= make_cleanup (free_current_contents
, &exp
);
693 /* We have something to evaluate, make sure that the expr to
694 bytecode translator can handle it and that it's not too
696 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
697 make_cleanup_free_agent_expr (aexpr
);
699 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
700 error (_("Expression is too complicated."));
702 ax_reqs (aexpr
, &areqs
);
703 (void) make_cleanup (xfree
, areqs
.reg_mask
);
705 report_agent_reqs_errors (aexpr
, &areqs
);
707 do_cleanups (old_chain
);
710 while (p
&& *p
++ == ',');
713 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
715 char *steparg
; /* in case warning is necessary */
717 while (isspace ((int) *p
))
721 if (*p
== '\0' || (t
->step_count
= strtol (p
, &p
, 0)) == 0)
722 error (_("while-stepping step count `%s' is malformed."), *line
);
725 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
729 error (_("`%s' is not a supported tracepoint action."), *line
);
733 memrange_absolute
= -1
738 int type
; /* memrange_absolute for absolute memory range,
739 else basereg number */
740 bfd_signed_vma start
;
744 struct collection_list
746 unsigned char regs_mask
[32]; /* room for up to 256 regs */
749 struct memrange
*list
;
750 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
752 struct agent_expr
**aexpr_list
;
755 tracepoint_list
, stepping_list
;
757 /* MEMRANGE functions: */
759 static int memrange_cmp (const void *, const void *);
761 /* compare memranges for qsort */
763 memrange_cmp (const void *va
, const void *vb
)
765 const struct memrange
*a
= va
, *b
= vb
;
767 if (a
->type
< b
->type
)
769 if (a
->type
> b
->type
)
771 if (a
->type
== memrange_absolute
)
773 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
775 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
780 if (a
->start
< b
->start
)
782 if (a
->start
> b
->start
)
788 /* Sort the memrange list using qsort, and merge adjacent memranges. */
790 memrange_sortmerge (struct collection_list
*memranges
)
794 qsort (memranges
->list
, memranges
->next_memrange
,
795 sizeof (struct memrange
), memrange_cmp
);
796 if (memranges
->next_memrange
> 0)
798 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
800 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
801 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
804 /* memrange b starts before memrange a ends; merge them. */
805 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
806 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
807 continue; /* next b, same a */
811 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
812 sizeof (struct memrange
));
814 memranges
->next_memrange
= a
+ 1;
818 /* Add a register to a collection list. */
820 add_register (struct collection_list
*collection
, unsigned int regno
)
823 printf_filtered ("collect register %d\n", regno
);
824 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
825 error (_("Internal: register number %d too large for tracepoint"),
827 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
830 /* Add a memrange to a collection list */
832 add_memrange (struct collection_list
*memranges
,
833 int type
, bfd_signed_vma base
,
838 printf_filtered ("(%d,", type
);
840 printf_filtered (",%ld)\n", len
);
843 /* type: memrange_absolute == memory, other n == basereg */
844 memranges
->list
[memranges
->next_memrange
].type
= type
;
845 /* base: addr if memory, offset if reg relative. */
846 memranges
->list
[memranges
->next_memrange
].start
= base
;
847 /* len: we actually save end (base + len) for convenience */
848 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
849 memranges
->next_memrange
++;
850 if (memranges
->next_memrange
>= memranges
->listsize
)
852 memranges
->listsize
*= 2;
853 memranges
->list
= xrealloc (memranges
->list
,
854 memranges
->listsize
);
857 if (type
!= memrange_absolute
) /* Better collect the base register! */
858 add_register (memranges
, type
);
861 /* Add a symbol to a collection list. */
863 collect_symbol (struct collection_list
*collect
,
865 struct gdbarch
*gdbarch
,
866 long frame_regno
, long frame_offset
,
871 bfd_signed_vma offset
;
872 int treat_as_expr
= 0;
874 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
875 switch (SYMBOL_CLASS (sym
))
878 printf_filtered ("%s: don't know symbol class %d\n",
879 SYMBOL_PRINT_NAME (sym
),
883 printf_filtered ("constant %s (value %ld) will not be collected.\n",
884 SYMBOL_PRINT_NAME (sym
), SYMBOL_VALUE (sym
));
887 offset
= SYMBOL_VALUE_ADDRESS (sym
);
892 sprintf_vma (tmp
, offset
);
893 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
894 SYMBOL_PRINT_NAME (sym
), len
,
897 /* A struct may be a C++ class with static fields, go to general
898 expression handling. */
899 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
902 add_memrange (collect
, memrange_absolute
, offset
, len
);
905 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
907 printf_filtered ("LOC_REG[parm] %s: ",
908 SYMBOL_PRINT_NAME (sym
));
909 add_register (collect
, reg
);
910 /* Check for doubles stored in two registers. */
911 /* FIXME: how about larger types stored in 3 or more regs? */
912 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
913 len
> register_size (gdbarch
, reg
))
914 add_register (collect
, reg
+ 1);
917 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
918 printf_filtered (" (will not collect %s)\n",
919 SYMBOL_PRINT_NAME (sym
));
923 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
926 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
927 SYMBOL_PRINT_NAME (sym
), len
);
929 printf_filtered (" from frame ptr reg %d\n", reg
);
931 add_memrange (collect
, reg
, offset
, len
);
933 case LOC_REGPARM_ADDR
:
934 reg
= SYMBOL_VALUE (sym
);
938 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
939 SYMBOL_PRINT_NAME (sym
), len
);
941 printf_filtered (" from reg %d\n", reg
);
943 add_memrange (collect
, reg
, offset
, len
);
947 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
950 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
951 SYMBOL_PRINT_NAME (sym
), len
);
953 printf_filtered (" from frame ptr reg %d\n", reg
);
955 add_memrange (collect
, reg
, offset
, len
);
962 case LOC_OPTIMIZED_OUT
:
963 printf_filtered ("%s has been optimized out of existence.\n",
964 SYMBOL_PRINT_NAME (sym
));
972 /* Expressions are the most general case. */
975 struct agent_expr
*aexpr
;
976 struct cleanup
*old_chain1
= NULL
;
977 struct agent_reqs areqs
;
979 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
981 /* It can happen that the symbol is recorded as a computed
982 location, but it's been optimized away and doesn't actually
983 have a location expression. */
986 printf_filtered ("%s has been optimized out of existence.\n",
987 SYMBOL_PRINT_NAME (sym
));
991 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
993 ax_reqs (aexpr
, &areqs
);
995 report_agent_reqs_errors (aexpr
, &areqs
);
997 discard_cleanups (old_chain1
);
998 add_aexpr (collect
, aexpr
);
1000 /* take care of the registers */
1001 if (areqs
.reg_mask_len
> 0)
1005 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1007 QUIT
; /* allow user to bail out with ^C */
1008 if (areqs
.reg_mask
[ndx1
] != 0)
1010 /* assume chars have 8 bits */
1011 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1012 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1013 /* it's used -- record it */
1014 add_register (collect
, ndx1
* 8 + ndx2
);
1021 /* Data to be passed around in the calls to the locals and args
1024 struct add_local_symbols_data
1026 struct collection_list
*collect
;
1027 struct gdbarch
*gdbarch
;
1034 /* The callback for the locals and args iterators */
1037 do_collect_symbol (const char *print_name
,
1041 struct add_local_symbols_data
*p
= cb_data
;
1043 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1044 p
->frame_offset
, p
->pc
);
1048 /* Add all locals (or args) symbols to collection list */
1050 add_local_symbols (struct collection_list
*collect
,
1051 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1052 long frame_regno
, long frame_offset
, int type
)
1054 struct block
*block
;
1055 struct add_local_symbols_data cb_data
;
1057 cb_data
.collect
= collect
;
1058 cb_data
.gdbarch
= gdbarch
;
1060 cb_data
.frame_regno
= frame_regno
;
1061 cb_data
.frame_offset
= frame_offset
;
1066 block
= block_for_pc (pc
);
1069 warning (_("Can't collect locals; "
1070 "no symbol table info available.\n"));
1074 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1075 if (cb_data
.count
== 0)
1076 warning (_("No locals found in scope."));
1080 pc
= get_pc_function_start (pc
);
1081 block
= block_for_pc (pc
);
1084 warning (_("Can't collect args; no symbol table info available.\n"));
1088 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1089 if (cb_data
.count
== 0)
1090 warning (_("No args found in scope."));
1094 /* worker function */
1096 clear_collection_list (struct collection_list
*list
)
1100 list
->next_memrange
= 0;
1101 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1103 free_agent_expr (list
->aexpr_list
[ndx
]);
1104 list
->aexpr_list
[ndx
] = NULL
;
1106 list
->next_aexpr_elt
= 0;
1107 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1110 /* reduce a collection list to string form (for gdb protocol) */
1112 stringify_collection_list (struct collection_list
*list
, char *string
)
1114 char temp_buf
[2048];
1118 char *(*str_list
)[];
1122 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1123 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1125 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1126 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1128 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1131 printf_filtered ("\nCollecting registers (mask): 0x");
1136 QUIT
; /* allow user to bail out with ^C */
1138 printf_filtered ("%02X", list
->regs_mask
[i
]);
1139 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1142 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1146 printf_filtered ("\n");
1147 if (list
->next_memrange
> 0 && info_verbose
)
1148 printf_filtered ("Collecting memranges: \n");
1149 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1151 QUIT
; /* allow user to bail out with ^C */
1152 sprintf_vma (tmp2
, list
->list
[i
].start
);
1155 printf_filtered ("(%d, %s, %ld)\n",
1158 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1160 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1162 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1169 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1171 /* The "%X" conversion specifier expects an unsigned argument,
1172 so passing -1 (memrange_absolute) to it directly gives you
1173 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1175 if (list
->list
[i
].type
== memrange_absolute
)
1176 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1178 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1181 count
+= strlen (end
);
1182 end
= temp_buf
+ count
;
1185 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1187 QUIT
; /* allow user to bail out with ^C */
1188 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1190 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1195 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1196 end
+= 10; /* 'X' + 8 hex digits + ',' */
1199 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1200 end
, list
->aexpr_list
[i
]->len
);
1201 count
+= 2 * list
->aexpr_list
[i
]->len
;
1206 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1211 (*str_list
)[ndx
] = NULL
;
1224 encode_actions_1 (struct command_line
*action
,
1225 struct breakpoint
*t
,
1226 struct bp_location
*tloc
,
1228 LONGEST frame_offset
,
1229 struct collection_list
*collect
,
1230 struct collection_list
*stepping_list
)
1233 struct expression
*exp
= NULL
;
1234 struct command_line
*actions
;
1236 struct value
*tempval
;
1237 struct cmd_list_element
*cmd
;
1238 struct agent_expr
*aexpr
;
1240 for (; action
; action
= action
->next
)
1242 QUIT
; /* allow user to bail out with ^C */
1243 action_exp
= action
->line
;
1244 while (isspace ((int) *action_exp
))
1247 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1249 error (_("Bad action list item: %s"), action_exp
);
1251 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1254 { /* repeat over a comma-separated list */
1255 QUIT
; /* allow user to bail out with ^C */
1256 while (isspace ((int) *action_exp
))
1259 if (0 == strncasecmp ("$reg", action_exp
, 4))
1261 for (i
= 0; i
< gdbarch_num_regs (t
->gdbarch
); i
++)
1262 add_register (collect
, i
);
1263 action_exp
= strchr (action_exp
, ','); /* more? */
1265 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1267 add_local_symbols (collect
,
1273 action_exp
= strchr (action_exp
, ','); /* more? */
1275 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1277 add_local_symbols (collect
,
1283 action_exp
= strchr (action_exp
, ','); /* more? */
1287 unsigned long addr
, len
;
1288 struct cleanup
*old_chain
= NULL
;
1289 struct cleanup
*old_chain1
= NULL
;
1290 struct agent_reqs areqs
;
1292 exp
= parse_exp_1 (&action_exp
,
1293 block_for_pc (tloc
->address
), 1);
1294 old_chain
= make_cleanup (free_current_contents
, &exp
);
1296 switch (exp
->elts
[0].opcode
)
1300 const char *name
= &exp
->elts
[2].string
;
1302 i
= user_reg_map_name_to_regnum (t
->gdbarch
,
1303 name
, strlen (name
));
1305 internal_error (__FILE__
, __LINE__
,
1306 _("Register $%s not available"),
1309 printf_filtered ("OP_REGISTER: ");
1310 add_register (collect
, i
);
1315 /* safe because we know it's a simple expression */
1316 tempval
= evaluate_expression (exp
);
1317 addr
= value_address (tempval
);
1318 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1319 add_memrange (collect
, memrange_absolute
, addr
, len
);
1323 collect_symbol (collect
,
1324 exp
->elts
[2].symbol
,
1331 default: /* full-fledged expression */
1332 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1334 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1336 ax_reqs (aexpr
, &areqs
);
1338 report_agent_reqs_errors (aexpr
, &areqs
);
1340 discard_cleanups (old_chain1
);
1341 add_aexpr (collect
, aexpr
);
1343 /* take care of the registers */
1344 if (areqs
.reg_mask_len
> 0)
1349 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1351 QUIT
; /* allow user to bail out with ^C */
1352 if (areqs
.reg_mask
[ndx1
] != 0)
1354 /* assume chars have 8 bits */
1355 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1356 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1357 /* it's used -- record it */
1358 add_register (collect
,
1365 do_cleanups (old_chain
);
1368 while (action_exp
&& *action_exp
++ == ',');
1370 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1373 { /* repeat over a comma-separated list */
1374 QUIT
; /* allow user to bail out with ^C */
1375 while (isspace ((int) *action_exp
))
1379 unsigned long addr
, len
;
1380 struct cleanup
*old_chain
= NULL
;
1381 struct cleanup
*old_chain1
= NULL
;
1382 struct agent_reqs areqs
;
1384 exp
= parse_exp_1 (&action_exp
,
1385 block_for_pc (tloc
->address
), 1);
1386 old_chain
= make_cleanup (free_current_contents
, &exp
);
1388 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1389 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1391 ax_reqs (aexpr
, &areqs
);
1393 report_agent_reqs_errors (aexpr
, &areqs
);
1395 discard_cleanups (old_chain1
);
1396 /* Even though we're not officially collecting, add
1397 to the collect list anyway. */
1398 add_aexpr (collect
, aexpr
);
1400 do_cleanups (old_chain
);
1403 while (action_exp
&& *action_exp
++ == ',');
1405 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1407 /* We check against nested while-stepping when setting
1408 breakpoint action, so no way to run into nested
1410 gdb_assert (stepping_list
);
1412 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
, frame_offset
,
1413 stepping_list
, NULL
);
1416 error (_("Invalid tracepoint command '%s'"), action
->line
);
1420 /* Render all actions into gdb protocol. */
1422 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1423 char ***tdp_actions
, char ***stepping_actions
)
1425 static char tdp_buff
[2048], step_buff
[2048];
1426 char *default_collect_line
= NULL
;
1427 struct command_line
*actions
;
1428 struct command_line
*default_collect_action
= NULL
;
1430 LONGEST frame_offset
;
1431 struct cleanup
*back_to
;
1433 back_to
= make_cleanup (null_cleanup
, NULL
);
1435 clear_collection_list (&tracepoint_list
);
1436 clear_collection_list (&stepping_list
);
1438 *tdp_actions
= NULL
;
1439 *stepping_actions
= NULL
;
1441 gdbarch_virtual_frame_pointer (t
->gdbarch
,
1442 t
->loc
->address
, &frame_reg
, &frame_offset
);
1444 actions
= breakpoint_commands (t
);
1446 /* If there are default expressions to collect, make up a collect
1447 action and prepend to the action list to encode. Note that since
1448 validation is per-tracepoint (local var "xyz" might be valid for
1449 one tracepoint and not another, etc), we make up the action on
1450 the fly, and don't cache it. */
1451 if (*default_collect
)
1455 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1456 make_cleanup (xfree
, default_collect_line
);
1458 line
= default_collect_line
;
1459 validate_actionline (&line
, t
);
1461 default_collect_action
= xmalloc (sizeof (struct command_line
));
1462 make_cleanup (xfree
, default_collect_action
);
1463 default_collect_action
->next
= actions
;
1464 default_collect_action
->line
= line
;
1465 actions
= default_collect_action
;
1467 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1468 &tracepoint_list
, &stepping_list
);
1470 memrange_sortmerge (&tracepoint_list
);
1471 memrange_sortmerge (&stepping_list
);
1473 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1475 *stepping_actions
= stringify_collection_list (&stepping_list
,
1478 do_cleanups (back_to
);
1482 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1484 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1486 collect
->aexpr_list
=
1487 xrealloc (collect
->aexpr_list
,
1488 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1489 collect
->aexpr_listsize
*= 2;
1491 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1492 collect
->next_aexpr_elt
++;
1497 start_tracing (void)
1500 VEC(breakpoint_p
) *tp_vec
= NULL
;
1502 struct breakpoint
*t
;
1503 struct trace_state_variable
*tsv
;
1504 int any_enabled
= 0;
1506 tp_vec
= all_tracepoints ();
1508 /* No point in tracing without any tracepoints... */
1509 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1511 VEC_free (breakpoint_p
, tp_vec
);
1512 error (_("No tracepoints defined, not starting trace"));
1515 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1517 if (t
->enable_state
== bp_enabled
)
1524 /* No point in tracing with only disabled tracepoints. */
1527 VEC_free (breakpoint_p
, tp_vec
);
1528 error (_("No tracepoints enabled, not starting trace"));
1531 target_trace_init ();
1533 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1535 t
->number_on_target
= 0;
1536 target_download_tracepoint (t
);
1537 t
->number_on_target
= t
->number
;
1539 VEC_free (breakpoint_p
, tp_vec
);
1541 /* Send down all the trace state variables too. */
1542 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1544 target_download_trace_state_variable (tsv
);
1547 /* Tell target to treat text-like sections as transparent. */
1548 target_trace_set_readonly_regions ();
1549 /* Set some mode flags. */
1550 target_set_disconnected_tracing (disconnected_tracing
);
1551 target_set_circular_trace_buffer (circular_trace_buffer
);
1553 /* Now insert traps and begin collecting data. */
1554 target_trace_start ();
1556 /* Reset our local state. */
1557 set_traceframe_num (-1);
1558 set_tracepoint_num (-1);
1559 set_traceframe_context (NULL
);
1560 current_trace_status()->running
= 1;
1565 Tell target to clear any previous trace experiment.
1566 Walk the list of tracepoints, and send them (and their actions)
1567 to the target. If no errors,
1568 Tell target to start a new trace experiment. */
1571 trace_start_command (char *args
, int from_tty
)
1573 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1575 if (current_trace_status ()->running
)
1578 && !query (_("A trace is running already. Start a new run? ")))
1579 error (_("New trace run not started."));
1587 trace_stop_command (char *args
, int from_tty
)
1589 if (!current_trace_status ()->running
)
1590 error (_("Trace is not running."));
1598 target_trace_stop ();
1599 /* should change in response to reply? */
1600 current_trace_status ()->running
= 0;
1603 /* tstatus command */
1605 trace_status_command (char *args
, int from_tty
)
1607 struct trace_status
*ts
= current_trace_status ();
1610 status
= target_get_trace_status (ts
);
1615 printf_filtered (_("Using a trace file.\n"));
1618 printf_filtered (_("Trace can not be run on this target.\n"));
1623 if (!ts
->running_known
)
1625 printf_filtered (_("Run/stop status is unknown.\n"));
1627 else if (ts
->running
)
1629 printf_filtered (_("Trace is running on the target.\n"));
1633 switch (ts
->stop_reason
)
1635 case trace_never_run
:
1636 printf_filtered (_("No trace has been run on the target.\n"));
1639 printf_filtered (_("Trace stopped by a tstop command.\n"));
1641 case trace_buffer_full
:
1642 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1644 case trace_disconnected
:
1645 printf_filtered (_("Trace stopped because of disconnection.\n"));
1647 case tracepoint_passcount
:
1648 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1649 ts
->stopping_tracepoint
);
1651 case tracepoint_error
:
1652 if (ts
->stopping_tracepoint
)
1653 printf_filtered (_("Trace stopped by an error (%s, tracepoint %d).\n"),
1654 ts
->error_desc
, ts
->stopping_tracepoint
);
1656 printf_filtered (_("Trace stopped by an error (%s).\n"),
1659 case trace_stop_reason_unknown
:
1660 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1663 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1669 if (ts
->traceframes_created
>= 0
1670 && ts
->traceframe_count
!= ts
->traceframes_created
)
1672 printf_filtered (_("Buffer contains %d trace frames (of %d created total).\n"),
1673 ts
->traceframe_count
, ts
->traceframes_created
);
1675 else if (ts
->traceframe_count
>= 0)
1677 printf_filtered (_("Collected %d trace frames.\n"),
1678 ts
->traceframe_count
);
1681 if (ts
->buffer_free
>= 0)
1683 if (ts
->buffer_size
>= 0)
1685 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1686 ts
->buffer_free
, ts
->buffer_size
);
1687 if (ts
->buffer_size
> 0)
1688 printf_filtered (_(" (%d%% full)"),
1689 ((int) ((((long long) (ts
->buffer_size
1690 - ts
->buffer_free
)) * 100)
1691 / ts
->buffer_size
)));
1692 printf_filtered (_(".\n"));
1695 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1699 if (ts
->disconnected_tracing
)
1700 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1702 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1704 if (ts
->circular_buffer
)
1705 printf_filtered (_("Trace buffer is circular.\n"));
1707 /* Now report on what we're doing with tfind. */
1708 if (traceframe_number
>= 0)
1709 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1710 traceframe_number
, tracepoint_number
);
1712 printf_filtered (_("Not looking at any trace frame.\n"));
1715 /* Report the trace status to uiout, in a way suitable for MI, and not
1716 suitable for CLI. If ON_STOP is true, suppress a few fields that
1717 are not meaningful in the -trace-stop response.
1719 The implementation is essentially parallel to trace_status_command, but
1720 merging them will result in unreadable code. */
1722 trace_status_mi (int on_stop
)
1724 struct trace_status
*ts
= current_trace_status ();
1726 char *string_status
;
1728 status
= target_get_trace_status (ts
);
1730 if (status
== -1 && !ts
->from_file
)
1732 ui_out_field_string (uiout
, "supported", "0");
1737 ui_out_field_string (uiout
, "supported", "file");
1739 ui_out_field_string (uiout
, "supported", "1");
1741 gdb_assert (ts
->running_known
);
1745 ui_out_field_string (uiout
, "running", "1");
1747 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1748 Given that the frontend gets the status either on -trace-stop, or from
1749 -trace-status after re-connection, it does not seem like this
1750 information is necessary for anything. It is not necessary for either
1751 figuring the vital state of the target nor for navigation of trace
1752 frames. If the frontend wants to show the current state is some
1753 configure dialog, it can request the value when such dialog is
1754 invoked by the user. */
1758 char *stop_reason
= NULL
;
1759 int stopping_tracepoint
= -1;
1762 ui_out_field_string (uiout
, "running", "0");
1764 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
1766 switch (ts
->stop_reason
)
1769 stop_reason
= "request";
1771 case trace_buffer_full
:
1772 stop_reason
= "overflow";
1774 case trace_disconnected
:
1775 stop_reason
= "disconnection";
1777 case tracepoint_passcount
:
1778 stop_reason
= "passcount";
1779 stopping_tracepoint
= ts
->stopping_tracepoint
;
1781 case tracepoint_error
:
1782 stop_reason
= "error";
1783 stopping_tracepoint
= ts
->stopping_tracepoint
;
1789 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
1790 if (stopping_tracepoint
!= -1)
1791 ui_out_field_int (uiout
, "stopping-tracepoint",
1792 stopping_tracepoint
);
1793 if (ts
->stop_reason
== tracepoint_error
)
1794 ui_out_field_string (uiout
, "error-description",
1800 if (ts
->traceframe_count
!= -1)
1801 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
1802 if (ts
->traceframes_created
!= -1)
1803 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
1804 if (ts
->buffer_size
!= -1)
1805 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
1806 if (ts
->buffer_free
!= -1)
1807 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
1809 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
1810 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
1813 /* This function handles the details of what to do about an ongoing
1814 tracing run if the user has asked to detach or otherwise disconnect
1817 disconnect_tracing (int from_tty
)
1819 /* It can happen that the target that was tracing went away on its
1820 own, and we didn't notice. Get a status update, and if the
1821 current target doesn't even do tracing, then assume it's not
1823 if (target_get_trace_status (current_trace_status ()) < 0)
1824 current_trace_status ()->running
= 0;
1826 /* If running interactively, give the user the option to cancel and
1827 then decide what to do differently with the run. Scripts are
1828 just going to disconnect and let the target deal with it,
1829 according to how it's been instructed previously via
1830 disconnected-tracing. */
1831 if (current_trace_status ()->running
&& from_tty
)
1833 if (current_trace_status ()->disconnected_tracing
)
1835 if (!query (_("Trace is running and will continue after detach; detach anyway? ")))
1836 error (_("Not confirmed."));
1840 if (!query (_("Trace is running but will stop on detach; detach anyway? ")))
1841 error (_("Not confirmed."));
1845 /* Also we want to be out of tfind mode, otherwise things can get
1846 confusing upon reconnection. Just use these calls instead of
1847 full tfind_1 behavior because we're in the middle of detaching,
1848 and there's no point to updating current stack frame etc. */
1849 set_traceframe_number (-1);
1850 set_traceframe_context (NULL
);
1853 /* Worker function for the various flavors of the tfind command. */
1855 tfind_1 (enum trace_find_type type
, int num
,
1856 ULONGEST addr1
, ULONGEST addr2
,
1859 int target_frameno
= -1, target_tracept
= -1;
1860 struct frame_id old_frame_id
= null_frame_id
;
1862 struct breakpoint
*tp
;
1864 /* Only try to get the current stack frame if we have a chance of
1865 succeeding. In particular, if we're trying to get a first trace
1866 frame while all threads are running, it's not going to succeed,
1867 so leave it with a default value and let the frame comparison
1868 below (correctly) decide to print out the source location of the
1870 if (!(type
== tfind_number
&& num
== -1)
1871 && (has_stack_frames () || traceframe_number
>= 0))
1872 old_frame_id
= get_frame_id (get_current_frame ());
1874 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
1877 if (type
== tfind_number
1879 && target_frameno
== -1)
1881 /* We told the target to get out of tfind mode, and it did. */
1883 else if (target_frameno
== -1)
1885 /* A request for a non-existent trace frame has failed.
1886 Our response will be different, depending on FROM_TTY:
1888 If FROM_TTY is true, meaning that this command was
1889 typed interactively by the user, then give an error
1890 and DO NOT change the state of traceframe_number etc.
1892 However if FROM_TTY is false, meaning that we're either
1893 in a script, a loop, or a user-defined command, then
1894 DON'T give an error, but DO change the state of
1895 traceframe_number etc. to invalid.
1897 The rationalle is that if you typed the command, you
1898 might just have committed a typo or something, and you'd
1899 like to NOT lose your current debugging state. However
1900 if you're in a user-defined command or especially in a
1901 loop, then you need a way to detect that the command
1902 failed WITHOUT aborting. This allows you to write
1903 scripts that search thru the trace buffer until the end,
1904 and then continue on to do something else. */
1907 error (_("Target failed to find requested trace frame."));
1911 printf_filtered ("End of trace buffer.\n");
1912 #if 0 /* dubious now? */
1913 /* The following will not recurse, since it's
1915 trace_find_command ("-1", from_tty
);
1920 tp
= get_tracepoint_by_number_on_target (target_tracept
);
1922 reinit_frame_cache ();
1923 registers_changed ();
1924 target_dcache_invalidate ();
1925 set_traceframe_num (target_frameno
);
1926 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
1927 if (target_frameno
== -1)
1928 set_traceframe_context (NULL
);
1930 set_traceframe_context (get_current_frame ());
1932 if (traceframe_number
>= 0)
1934 /* Use different branches for MI and CLI to make CLI messages
1936 if (ui_out_is_mi_like_p (uiout
))
1938 ui_out_field_string (uiout
, "found", "1");
1939 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
1940 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
1944 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
1945 traceframe_number
, tracepoint_number
);
1950 if (ui_out_is_mi_like_p (uiout
))
1951 ui_out_field_string (uiout
, "found", "0");
1952 else if (type
== tfind_number
&& num
== -1)
1953 printf_unfiltered (_("No longer looking at any trace frame\n"));
1954 else /* this case may never occur, check */
1955 printf_unfiltered (_("No trace frame found\n"));
1958 /* If we're in nonstop mode and getting out of looking at trace
1959 frames, there won't be any current frame to go back to and
1962 && (has_stack_frames () || traceframe_number
>= 0))
1964 enum print_what print_what
;
1966 /* NOTE: in imitation of the step command, try to determine
1967 whether we have made a transition from one function to
1968 another. If so, we'll print the "stack frame" (ie. the new
1969 function and it's arguments) -- otherwise we'll just show the
1972 if (frame_id_eq (old_frame_id
,
1973 get_frame_id (get_current_frame ())))
1974 print_what
= SRC_LINE
;
1976 print_what
= SRC_AND_LOC
;
1978 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
1983 /* trace_find_command takes a trace frame number n,
1984 sends "QTFrame:<n>" to the target,
1985 and accepts a reply that may contain several optional pieces
1986 of information: a frame number, a tracepoint number, and an
1987 indication of whether this is a trap frame or a stepping frame.
1989 The minimal response is just "OK" (which indicates that the
1990 target does not give us a frame number or a tracepoint number).
1991 Instead of that, the target may send us a string containing
1993 F<hexnum> (gives the selected frame number)
1994 T<hexnum> (gives the selected tracepoint number)
1999 trace_find_command (char *args
, int from_tty
)
2000 { /* this should only be called with a numeric argument */
2003 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2004 error ("May not look at trace frames while trace is running.");
2006 if (args
== 0 || *args
== 0)
2007 { /* TFIND with no args means find NEXT trace frame. */
2008 if (traceframe_number
== -1)
2009 frameno
= 0; /* "next" is first one */
2011 frameno
= traceframe_number
+ 1;
2013 else if (0 == strcmp (args
, "-"))
2015 if (traceframe_number
== -1)
2016 error (_("not debugging trace buffer"));
2017 else if (from_tty
&& traceframe_number
== 0)
2018 error (_("already at start of trace buffer"));
2020 frameno
= traceframe_number
- 1;
2022 /* A hack to work around eval's need for fp to have been collected. */
2023 else if (0 == strcmp (args
, "-1"))
2026 frameno
= parse_and_eval_long (args
);
2029 error (_("invalid input (%d is less than zero)"), frameno
);
2031 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2036 trace_find_end_command (char *args
, int from_tty
)
2038 trace_find_command ("-1", from_tty
);
2043 trace_find_none_command (char *args
, int from_tty
)
2045 trace_find_command ("-1", from_tty
);
2050 trace_find_start_command (char *args
, int from_tty
)
2052 trace_find_command ("0", from_tty
);
2055 /* tfind pc command */
2057 trace_find_pc_command (char *args
, int from_tty
)
2062 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2063 error ("May not look at trace frames while trace is running.");
2065 if (args
== 0 || *args
== 0)
2066 pc
= regcache_read_pc (get_current_regcache ());
2068 pc
= parse_and_eval_address (args
);
2070 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2073 /* tfind tracepoint command */
2075 trace_find_tracepoint_command (char *args
, int from_tty
)
2078 struct breakpoint
*tp
;
2080 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2081 error ("May not look at trace frames while trace is running.");
2083 if (args
== 0 || *args
== 0)
2085 if (tracepoint_number
== -1)
2086 error (_("No current tracepoint -- please supply an argument."));
2088 tdp
= tracepoint_number
; /* default is current TDP */
2091 tdp
= parse_and_eval_long (args
);
2093 /* If we have the tracepoint on hand, use the number that the
2094 target knows about (which may be different if we disconnected
2095 and reconnected). */
2096 tp
= get_tracepoint (tdp
);
2098 tdp
= tp
->number_on_target
;
2100 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2103 /* TFIND LINE command:
2105 This command will take a sourceline for argument, just like BREAK
2106 or TRACE (ie. anything that "decode_line_1" can handle).
2108 With no argument, this command will find the next trace frame
2109 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2112 trace_find_line_command (char *args
, int from_tty
)
2114 static CORE_ADDR start_pc
, end_pc
;
2115 struct symtabs_and_lines sals
;
2116 struct symtab_and_line sal
;
2117 struct cleanup
*old_chain
;
2118 char startpc_str
[40], endpc_str
[40];
2120 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2121 error ("May not look at trace frames while trace is running.");
2123 if (args
== 0 || *args
== 0)
2125 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2127 sals
.sals
= (struct symtab_and_line
*)
2128 xmalloc (sizeof (struct symtab_and_line
));
2133 sals
= decode_line_spec (args
, 1);
2137 old_chain
= make_cleanup (xfree
, sals
.sals
);
2138 if (sal
.symtab
== 0)
2139 error (_("No line number information available."));
2141 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2143 if (start_pc
== end_pc
)
2145 printf_filtered ("Line %d of \"%s\"",
2146 sal
.line
, sal
.symtab
->filename
);
2148 printf_filtered (" is at address ");
2149 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2151 printf_filtered (" but contains no code.\n");
2152 sal
= find_pc_line (start_pc
, 0);
2154 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2155 && start_pc
!= end_pc
)
2156 printf_filtered ("Attempting to find line %d instead.\n",
2159 error (_("Cannot find a good line."));
2163 /* Is there any case in which we get here, and have an address
2164 which the user would want to see? If we have debugging
2165 symbols and no line numbers? */
2166 error (_("Line number %d is out of range for \"%s\"."),
2167 sal
.line
, sal
.symtab
->filename
);
2169 /* Find within range of stated line. */
2171 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2173 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2174 do_cleanups (old_chain
);
2177 /* tfind range command */
2179 trace_find_range_command (char *args
, int from_tty
)
2181 static CORE_ADDR start
, stop
;
2182 char start_str
[40], stop_str
[40];
2185 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2186 error ("May not look at trace frames while trace is running.");
2188 if (args
== 0 || *args
== 0)
2189 { /* XXX FIXME: what should default behavior be? */
2190 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2194 if (0 != (tmp
= strchr (args
, ',')))
2196 *tmp
++ = '\0'; /* terminate start address */
2197 while (isspace ((int) *tmp
))
2199 start
= parse_and_eval_address (args
);
2200 stop
= parse_and_eval_address (tmp
);
2203 { /* no explicit end address? */
2204 start
= parse_and_eval_address (args
);
2205 stop
= start
+ 1; /* ??? */
2208 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2211 /* tfind outside command */
2213 trace_find_outside_command (char *args
, int from_tty
)
2215 CORE_ADDR start
, stop
;
2216 char start_str
[40], stop_str
[40];
2219 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2220 error ("May not look at trace frames while trace is running.");
2222 if (args
== 0 || *args
== 0)
2223 { /* XXX FIXME: what should default behavior be? */
2224 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2228 if (0 != (tmp
= strchr (args
, ',')))
2230 *tmp
++ = '\0'; /* terminate start address */
2231 while (isspace ((int) *tmp
))
2233 start
= parse_and_eval_address (args
);
2234 stop
= parse_and_eval_address (tmp
);
2237 { /* no explicit end address? */
2238 start
= parse_and_eval_address (args
);
2239 stop
= start
+ 1; /* ??? */
2242 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2245 /* info scope command: list the locals for a scope. */
2247 scope_info (char *args
, int from_tty
)
2249 struct symtabs_and_lines sals
;
2251 struct minimal_symbol
*msym
;
2252 struct block
*block
;
2253 char **canonical
, *symname
, *save_args
= args
;
2254 struct dict_iterator iter
;
2256 struct gdbarch
*gdbarch
;
2259 if (args
== 0 || *args
== 0)
2260 error (_("requires an argument (function, line or *addr) to define a scope"));
2262 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2263 if (sals
.nelts
== 0)
2264 return; /* presumably decode_line_1 has already warned */
2266 /* Resolve line numbers to PC */
2267 resolve_sal_pc (&sals
.sals
[0]);
2268 block
= block_for_pc (sals
.sals
[0].pc
);
2272 QUIT
; /* allow user to bail out with ^C */
2273 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2275 QUIT
; /* allow user to bail out with ^C */
2277 printf_filtered ("Scope for %s:\n", save_args
);
2280 symname
= SYMBOL_PRINT_NAME (sym
);
2281 if (symname
== NULL
|| *symname
== '\0')
2282 continue; /* probably botched, certainly useless */
2284 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2286 printf_filtered ("Symbol %s is ", symname
);
2287 switch (SYMBOL_CLASS (sym
))
2290 case LOC_UNDEF
: /* messed up symbol? */
2291 printf_filtered ("a bogus symbol, class %d.\n",
2292 SYMBOL_CLASS (sym
));
2293 count
--; /* don't count this one */
2296 printf_filtered ("a constant with value %ld (0x%lx)",
2297 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2299 case LOC_CONST_BYTES
:
2300 printf_filtered ("constant bytes: ");
2301 if (SYMBOL_TYPE (sym
))
2302 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2303 fprintf_filtered (gdb_stdout
, " %02x",
2304 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2307 printf_filtered ("in static storage at address ");
2308 printf_filtered ("%s", paddress (gdbarch
,
2309 SYMBOL_VALUE_ADDRESS (sym
)));
2312 /* GDBARCH is the architecture associated with the objfile
2313 the symbol is defined in; the target architecture may be
2314 different, and may provide additional registers. However,
2315 we do not know the target architecture at this point.
2316 We assume the objfile architecture will contain all the
2317 standard registers that occur in debug info in that
2319 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2321 if (SYMBOL_IS_ARGUMENT (sym
))
2322 printf_filtered ("an argument in register $%s",
2323 gdbarch_register_name (gdbarch
, regno
));
2325 printf_filtered ("a local variable in register $%s",
2326 gdbarch_register_name (gdbarch
, regno
));
2329 printf_filtered ("an argument at stack/frame offset %ld",
2330 SYMBOL_VALUE (sym
));
2333 printf_filtered ("a local variable at frame offset %ld",
2334 SYMBOL_VALUE (sym
));
2337 printf_filtered ("a reference argument at offset %ld",
2338 SYMBOL_VALUE (sym
));
2340 case LOC_REGPARM_ADDR
:
2341 /* Note comment at LOC_REGISTER. */
2342 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2343 printf_filtered ("the address of an argument, in register $%s",
2344 gdbarch_register_name (gdbarch
, regno
));
2347 printf_filtered ("a typedef.\n");
2350 printf_filtered ("a label at address ");
2351 printf_filtered ("%s", paddress (gdbarch
,
2352 SYMBOL_VALUE_ADDRESS (sym
)));
2355 printf_filtered ("a function at address ");
2356 printf_filtered ("%s",
2357 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2359 case LOC_UNRESOLVED
:
2360 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2363 printf_filtered ("Unresolved Static");
2366 printf_filtered ("static storage at address ");
2367 printf_filtered ("%s",
2368 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2371 case LOC_OPTIMIZED_OUT
:
2372 printf_filtered ("optimized out.\n");
2375 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2376 BLOCK_START (block
),
2380 if (SYMBOL_TYPE (sym
))
2381 printf_filtered (", length %d.\n",
2382 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2384 if (BLOCK_FUNCTION (block
))
2387 block
= BLOCK_SUPERBLOCK (block
);
2390 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2394 /* worker function (cleanup) */
2396 replace_comma (void *data
)
2403 /* Helper for trace_dump_command. Dump the action list starting at
2404 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2405 actions of the body of a while-stepping action. STEPPING_FRAME is
2406 set if the current traceframe was determined to be a while-stepping
2410 trace_dump_actions (struct command_line
*action
,
2411 int stepping_actions
, int stepping_frame
,
2414 char *action_exp
, *next_comma
;
2416 for (; action
!= NULL
; action
= action
->next
)
2418 struct cmd_list_element
*cmd
;
2420 QUIT
; /* allow user to bail out with ^C */
2421 action_exp
= action
->line
;
2422 while (isspace ((int) *action_exp
))
2425 /* The collection actions to be done while stepping are
2426 bracketed by the commands "while-stepping" and "end". */
2428 if (*action_exp
== '#') /* comment line */
2431 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2433 error (_("Bad action list item: %s"), action_exp
);
2435 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2439 for (i
= 0; i
< action
->body_count
; ++i
)
2440 trace_dump_actions (action
->body_list
[i
],
2441 1, stepping_frame
, from_tty
);
2443 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2445 /* Display the collected data.
2446 For the trap frame, display only what was collected at
2447 the trap. Likewise for stepping frames, display only
2448 what was collected while stepping. This means that the
2449 two boolean variables, STEPPING_FRAME and
2450 STEPPING_ACTIONS should be equal. */
2451 if (stepping_frame
== stepping_actions
)
2454 { /* repeat over a comma-separated list */
2455 QUIT
; /* allow user to bail out with ^C */
2456 if (*action_exp
== ',')
2458 while (isspace ((int) *action_exp
))
2461 next_comma
= strchr (action_exp
, ',');
2463 if (0 == strncasecmp (action_exp
, "$reg", 4))
2464 registers_info (NULL
, from_tty
);
2465 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2466 locals_info (NULL
, from_tty
);
2467 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2468 args_info (NULL
, from_tty
);
2473 make_cleanup (replace_comma
, next_comma
);
2476 printf_filtered ("%s = ", action_exp
);
2477 output_command (action_exp
, from_tty
);
2478 printf_filtered ("\n");
2482 action_exp
= next_comma
;
2484 while (action_exp
&& *action_exp
== ',');
2490 /* The tdump command. */
2493 trace_dump_command (char *args
, int from_tty
)
2495 struct regcache
*regcache
;
2496 struct breakpoint
*t
;
2497 int stepping_frame
= 0;
2498 struct bp_location
*loc
;
2499 char *line
, *default_collect_line
= NULL
;
2500 struct command_line
*actions
, *default_collect_action
= NULL
;
2501 struct cleanup
*old_chain
= NULL
;
2503 if (tracepoint_number
== -1)
2505 warning (_("No current trace frame."));
2509 t
= get_tracepoint (tracepoint_number
);
2512 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2515 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2516 tracepoint_number
, traceframe_number
);
2518 /* The current frame is a trap frame if the frame PC is equal
2519 to the tracepoint PC. If not, then the current frame was
2520 collected during single-stepping. */
2522 regcache
= get_current_regcache ();
2524 /* If the traceframe's address matches any of the tracepoint's
2525 locations, assume it is a direct hit rather than a while-stepping
2526 frame. (FIXME this is not reliable, should record each frame's
2529 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2530 if (loc
->address
== regcache_read_pc (regcache
))
2533 actions
= breakpoint_commands (t
);
2535 /* If there is a default-collect list, make up a collect command,
2536 prepend to the tracepoint's commands, and pass the whole mess to
2537 the trace dump scanner. We need to validate because
2538 default-collect might have been junked since the trace run. */
2539 if (*default_collect
)
2541 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2542 old_chain
= make_cleanup (xfree
, default_collect_line
);
2543 line
= default_collect_line
;
2544 validate_actionline (&line
, t
);
2545 default_collect_action
= xmalloc (sizeof (struct command_line
));
2546 make_cleanup (xfree
, default_collect_action
);
2547 default_collect_action
->next
= actions
;
2548 default_collect_action
->line
= line
;
2549 actions
= default_collect_action
;
2552 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2554 if (*default_collect
)
2555 do_cleanups (old_chain
);
2558 /* Encode a piece of a tracepoint's source-level definition in a form
2559 that is suitable for both protocol and saving in files. */
2560 /* This version does not do multiple encodes for long strings; it should
2561 return an offset to the next piece to encode. FIXME */
2564 encode_source_string (int tpnum
, ULONGEST addr
,
2565 char *srctype
, char *src
, char *buf
, int buf_size
)
2567 if (80 + strlen (srctype
) > buf_size
)
2568 error (_("Buffer too small for source encoding"));
2569 sprintf (buf
, "%x:%s:%s:%x:%x:",
2570 tpnum
, phex_nz (addr
, sizeof (addr
)), srctype
, 0, (int) strlen (src
));
2571 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2572 error (_("Source string too long for buffer"));
2573 bin2hex (src
, buf
+ strlen (buf
), 0);
2577 extern int trace_regblock_size
;
2579 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2580 non-zero, the save is performed on the target, otherwise GDB obtains all
2581 trace data and saves it locally. */
2584 trace_save (const char *filename
, int target_does_save
)
2586 struct cleanup
*cleanup
;
2588 struct trace_status
*ts
= current_trace_status ();
2591 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2592 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2596 ULONGEST offset
= 0;
2597 #define MAX_TRACE_UPLOAD 2000
2598 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2601 /* If the target is to save the data to a file on its own, then just
2602 send the command and be done with it. */
2603 if (target_does_save
)
2605 err
= target_save_trace_data (filename
);
2607 error (_("Target failed to save trace data to '%s'."),
2612 /* Get the trace status first before opening the file, so if the
2613 target is losing, we can get out without touching files. */
2614 status
= target_get_trace_status (ts
);
2616 pathname
= tilde_expand (filename
);
2617 cleanup
= make_cleanup (xfree
, pathname
);
2619 fp
= fopen (pathname
, "wb");
2621 error (_("Unable to open file '%s' for saving trace data (%s)"),
2622 filename
, safe_strerror (errno
));
2623 make_cleanup_fclose (fp
);
2625 /* Write a file header, with a high-bit-set char to indicate a
2626 binary file, plus a hint as what this file is, and a version
2627 number in case of future needs. */
2628 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2630 perror_with_name (pathname
);
2632 /* Write descriptive info. */
2634 /* Write out the size of a register block. */
2635 fprintf (fp
, "R %x\n", trace_regblock_size
);
2637 /* Write out status of the tracing run (aka "tstatus" info). */
2638 fprintf (fp
, "status %c;%s",
2639 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
2640 if (ts
->stop_reason
== tracepoint_error
)
2642 char *buf
= (char *) alloca (strlen (ts
->error_desc
) * 2 + 1);
2643 bin2hex ((gdb_byte
*) ts
->error_desc
, buf
, 0);
2644 fprintf (fp
, ":%s", buf
);
2646 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
2647 if (ts
->traceframe_count
>= 0)
2648 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
2649 if (ts
->traceframes_created
>= 0)
2650 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
2651 if (ts
->buffer_free
>= 0)
2652 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
2653 if (ts
->buffer_size
>= 0)
2654 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
2655 if (ts
->disconnected_tracing
)
2656 fprintf (fp
, ";disconn:%x", ts
->disconnected_tracing
);
2657 if (ts
->circular_buffer
)
2658 fprintf (fp
, ";circular:%x", ts
->circular_buffer
);
2661 /* Note that we want to upload tracepoints and save those, rather
2662 than simply writing out the local ones, because the user may have
2663 changed tracepoints in GDB in preparation for a future tracing
2664 run, or maybe just mass-deleted all types of breakpoints as part
2665 of cleaning up. So as not to contaminate the session, leave the
2666 data in its uploaded form, don't make into real tracepoints. */
2668 /* Get trace state variables first, they may be checked when parsing
2669 uploaded commands. */
2671 target_upload_trace_state_variables (&uploaded_tsvs
);
2673 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2679 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
2680 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
2683 fprintf (fp
, "tsv %x:%s:%x:%s\n",
2684 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
2685 utsv
->builtin
, buf
);
2691 free_uploaded_tsvs (&uploaded_tsvs
);
2693 target_upload_tracepoints (&uploaded_tps
);
2695 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
2697 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
2698 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2699 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
2700 if (utp
->type
== bp_fast_tracepoint
)
2701 fprintf (fp
, ":F%x", utp
->orig_size
);
2703 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
2706 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
2707 fprintf (fp
, "tp A%x:%s:%s\n",
2708 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
2709 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
2710 fprintf (fp
, "tp S%x:%s:%s\n",
2711 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
2714 encode_source_string (utp
->number
, utp
->addr
,
2715 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
2716 fprintf (fp
, "tp Z%s\n", buf
);
2718 if (utp
->cond_string
)
2720 encode_source_string (utp
->number
, utp
->addr
,
2721 "cond", utp
->cond_string
, buf
, MAX_TRACE_UPLOAD
);
2722 fprintf (fp
, "tp Z%s\n", buf
);
2724 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
2726 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
2727 buf
, MAX_TRACE_UPLOAD
);
2728 fprintf (fp
, "tp Z%s\n", buf
);
2732 free_uploaded_tps (&uploaded_tps
);
2734 /* Mark the end of the definition section. */
2737 /* Get and write the trace data proper. We ask for big blocks, in
2738 the hopes of efficiency, but will take less if the target has
2739 packet size limitations or some such. */
2742 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
2744 error (_("Failure to get requested trace buffer data"));
2745 /* No more data is forthcoming, we're done. */
2748 written
= fwrite (buf
, gotten
, 1, fp
);
2750 perror_with_name (pathname
);
2754 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
2755 written
= fwrite (&gotten
, 4, 1, fp
);
2757 perror_with_name (pathname
);
2759 do_cleanups (cleanup
);
2763 trace_save_command (char *args
, int from_tty
)
2765 int target_does_save
= 0;
2767 char *filename
= NULL
;
2768 struct cleanup
*back_to
;
2771 error_no_arg (_("file in which to save trace data"));
2773 argv
= gdb_buildargv (args
);
2774 back_to
= make_cleanup_freeargv (argv
);
2776 for (; *argv
; ++argv
)
2778 if (strcmp (*argv
, "-r") == 0)
2779 target_does_save
= 1;
2780 else if (**argv
== '-')
2781 error (_("unknown option `%s'"), *argv
);
2787 error_no_arg (_("file in which to save trace data"));
2789 trace_save (filename
, target_does_save
);
2792 printf_filtered (_("Trace data saved to file '%s'.\n"), args
);
2794 do_cleanups (back_to
);
2797 /* Tell the target what to do with an ongoing tracing run if GDB
2798 disconnects for some reason. */
2801 send_disconnected_tracing_value (int value
)
2803 target_set_disconnected_tracing (value
);
2807 set_disconnected_tracing (char *args
, int from_tty
,
2808 struct cmd_list_element
*c
)
2810 send_disconnected_tracing_value (disconnected_tracing
);
2814 set_circular_trace_buffer (char *args
, int from_tty
,
2815 struct cmd_list_element
*c
)
2817 target_set_circular_trace_buffer (circular_trace_buffer
);
2820 /* Convert the memory pointed to by mem into hex, placing result in buf.
2821 * Return a pointer to the last char put in buf (null)
2822 * "stolen" from sparc-stub.c
2825 static const char hexchars
[] = "0123456789abcdef";
2828 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2836 *buf
++ = hexchars
[ch
>> 4];
2837 *buf
++ = hexchars
[ch
& 0xf];
2846 get_traceframe_number (void)
2848 return traceframe_number
;
2851 /* Make the traceframe NUM be the current trace frame. Does nothing
2852 if NUM is already current. */
2855 set_traceframe_number (int num
)
2859 if (traceframe_number
== num
)
2861 /* Nothing to do. */
2865 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
2868 warning (_("could not change traceframe"));
2870 traceframe_number
= newnum
;
2872 /* Changing the traceframe changes our view of registers and of the
2874 registers_changed ();
2877 /* A cleanup used when switching away and back from tfind mode. */
2879 struct current_traceframe_cleanup
2881 /* The traceframe we were inspecting. */
2882 int traceframe_number
;
2886 do_restore_current_traceframe_cleanup (void *arg
)
2888 struct current_traceframe_cleanup
*old
= arg
;
2890 set_traceframe_number (old
->traceframe_number
);
2894 restore_current_traceframe_cleanup_dtor (void *arg
)
2896 struct current_traceframe_cleanup
*old
= arg
;
2902 make_cleanup_restore_current_traceframe (void)
2904 struct current_traceframe_cleanup
*old
;
2906 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
2907 old
->traceframe_number
= traceframe_number
;
2909 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
2910 restore_current_traceframe_cleanup_dtor
);
2913 /* Given a number and address, return an uploaded tracepoint with that
2914 number, creating if necessary. */
2916 struct uploaded_tp
*
2917 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
2919 struct uploaded_tp
*utp
;
2921 for (utp
= *utpp
; utp
; utp
= utp
->next
)
2922 if (utp
->number
== num
&& utp
->addr
== addr
)
2924 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
2925 memset (utp
, 0, sizeof (struct uploaded_tp
));
2928 utp
->actions
= NULL
;
2929 utp
->step_actions
= NULL
;
2930 utp
->cmd_strings
= NULL
;
2937 free_uploaded_tps (struct uploaded_tp
**utpp
)
2939 struct uploaded_tp
*next_one
;
2943 next_one
= (*utpp
)->next
;
2949 /* Given a number and address, return an uploaded tracepoint with that
2950 number, creating if necessary. */
2952 struct uploaded_tsv
*
2953 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
2955 struct uploaded_tsv
*utsv
;
2957 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
2958 if (utsv
->number
== num
)
2960 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
2961 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
2963 utsv
->next
= *utsvp
;
2969 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
2971 struct uploaded_tsv
*next_one
;
2975 next_one
= (*utsvp
)->next
;
2981 /* Look for an existing tracepoint that seems similar enough to the
2982 uploaded one. Enablement isn't compared, because the user can
2983 toggle that freely, and may have done so in anticipation of the
2987 find_matching_tracepoint (struct uploaded_tp
*utp
)
2989 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
2991 struct breakpoint
*t
;
2992 struct bp_location
*loc
;
2994 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2996 if (t
->type
== utp
->type
2997 && t
->step_count
== utp
->step
2998 && t
->pass_count
== utp
->pass
2999 /* FIXME also test conditionals and actions */
3002 /* Scan the locations for an address match. */
3003 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
3005 if (loc
->address
== utp
->addr
)
3013 /* Given a list of tracepoints uploaded from a target, attempt to
3014 match them up with existing tracepoints, and create new ones if not
3018 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3020 struct uploaded_tp
*utp
;
3021 struct breakpoint
*t
;
3023 /* Look for GDB tracepoints that match up with our uploaded versions. */
3024 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3026 t
= find_matching_tracepoint (utp
);
3028 printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
3029 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
3032 t
= create_tracepoint_from_upload (utp
);
3034 printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
3035 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
3037 printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
3038 utp
->number
, paddress (get_current_arch (), utp
->addr
));
3040 /* Whether found or created, record the number used by the
3041 target, to help with mapping target tracepoints back to their
3042 counterparts here. */
3044 t
->number_on_target
= utp
->number
;
3047 free_uploaded_tps (uploaded_tps
);
3050 /* Trace state variables don't have much to identify them beyond their
3051 name, so just use that to detect matches. */
3053 struct trace_state_variable
*
3054 find_matching_tsv (struct uploaded_tsv
*utsv
)
3059 return find_trace_state_variable (utsv
->name
);
3062 struct trace_state_variable
*
3063 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3065 const char *namebase
;
3068 struct trace_state_variable
*tsv
;
3072 namebase
= utsv
->name
;
3073 sprintf (buf
, "%s", namebase
);
3078 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3081 /* Fish for a name that is not in use. */
3082 /* (should check against all internal vars?) */
3083 while (find_trace_state_variable (buf
))
3084 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3086 /* We have an available name, create the variable. */
3087 tsv
= create_trace_state_variable (xstrdup (buf
));
3088 tsv
->initial_value
= utsv
->initial_value
;
3089 tsv
->builtin
= utsv
->builtin
;
3094 /* Given a list of uploaded trace state variables, try to match them
3095 up with existing variables, or create additional ones. */
3098 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3101 struct uploaded_tsv
*utsv
;
3102 struct trace_state_variable
*tsv
;
3105 /* Most likely some numbers will have to be reassigned as part of
3106 the merge, so clear them all in anticipation. */
3107 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3110 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3112 tsv
= find_matching_tsv (utsv
);
3114 printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
3115 tsv
->name
, utsv
->number
);
3118 tsv
= create_tsv_from_upload (utsv
);
3119 printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
3120 tsv
->name
, utsv
->number
);
3122 /* Give precedence to numberings that come from the target. */
3124 tsv
->number
= utsv
->number
;
3127 /* Renumber everything that didn't get a target-assigned number. */
3129 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3130 if (tsv
->number
> highest
)
3131 highest
= tsv
->number
;
3134 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3135 if (tsv
->number
== 0)
3136 tsv
->number
= highest
++;
3138 free_uploaded_tsvs (uploaded_tsvs
);
3141 /* target tfile command */
3143 struct target_ops tfile_ops
;
3145 /* Fill in tfile_ops with its defined operations and properties. */
3147 #define TRACE_HEADER_SIZE 8
3149 char *trace_filename
;
3151 off_t trace_frames_offset
;
3154 int trace_regblock_size
;
3156 static void tfile_interp_line (char *line
,
3157 struct uploaded_tp
**utpp
,
3158 struct uploaded_tsv
**utsvp
);
3161 tfile_open (char *filename
, int from_tty
)
3164 struct cleanup
*old_chain
;
3167 char header
[TRACE_HEADER_SIZE
];
3168 char linebuf
[1000]; /* should be max remote packet size or so */
3170 int bytes
, i
, gotten
;
3171 struct trace_status
*ts
;
3172 struct uploaded_tp
*uploaded_tps
= NULL
;
3173 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3175 target_preopen (from_tty
);
3177 error (_("No trace file specified."));
3179 filename
= tilde_expand (filename
);
3180 if (!IS_ABSOLUTE_PATH(filename
))
3182 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
3187 old_chain
= make_cleanup (xfree
, filename
);
3189 flags
= O_BINARY
| O_LARGEFILE
;
3191 scratch_chan
= open (filename
, flags
, 0);
3192 if (scratch_chan
< 0)
3193 perror_with_name (filename
);
3195 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3197 discard_cleanups (old_chain
); /* Don't free filename any more */
3198 unpush_target (&tfile_ops
);
3200 push_target (&tfile_ops
);
3202 trace_filename
= xstrdup (filename
);
3203 trace_fd
= scratch_chan
;
3206 /* Read the file header and test for validity. */
3207 gotten
= read (trace_fd
, &header
, TRACE_HEADER_SIZE
);
3209 perror_with_name (trace_filename
);
3210 else if (gotten
< TRACE_HEADER_SIZE
)
3211 error (_("Premature end of file while reading trace file"));
3213 bytes
+= TRACE_HEADER_SIZE
;
3214 if (!(header
[0] == 0x7f
3215 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3216 error (_("File is not a valid trace file."));
3218 trace_regblock_size
= 0;
3219 ts
= current_trace_status ();
3220 /* We know we're working with a file. */
3222 /* Set defaults in case there is no status line. */
3223 ts
->running_known
= 0;
3224 ts
->stop_reason
= trace_stop_reason_unknown
;
3225 ts
->traceframe_count
= -1;
3226 ts
->buffer_free
= 0;
3227 ts
->disconnected_tracing
= 0;
3228 ts
->circular_buffer
= 0;
3230 /* Read through a section of newline-terminated lines that
3231 define things like tracepoints. */
3235 gotten
= read (trace_fd
, &byte
, 1);
3237 perror_with_name (trace_filename
);
3238 else if (gotten
< 1)
3239 error (_("Premature end of file while reading trace file"));
3244 /* Empty line marks end of the definition section. */
3249 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3252 linebuf
[i
++] = byte
;
3254 error (_("Excessively long lines in trace file"));
3257 /* Add the file's tracepoints and variables into the current mix. */
3259 /* Get trace state variables first, they may be checked when parsing
3260 uploaded commands. */
3261 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3263 merge_uploaded_tracepoints (&uploaded_tps
);
3265 /* Record the starting offset of the binary trace data. */
3266 trace_frames_offset
= bytes
;
3268 /* If we don't have a blocksize, we can't interpret the
3270 if (trace_regblock_size
== 0)
3271 error (_("No register block size recorded in trace file"));
3272 if (ts
->traceframe_count
<= 0)
3274 warning ("No traceframes present in this file.");
3278 #define TFILE_PID (1)
3279 inferior_appeared (current_inferior (), TFILE_PID
);
3280 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3281 add_thread_silent (inferior_ptid
);
3283 post_create_inferior (&tfile_ops
, from_tty
);
3286 /* FIXME this will get defined in MI patch submission */
3287 tfind_1 (tfind_number
, 0, 0, 0, 0);
3291 /* Interpret the given line from the definitions part of the trace
3295 tfile_interp_line (char *line
,
3296 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3300 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3303 trace_regblock_size
= strtol (p
, &p
, 16);
3305 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3307 p
+= strlen ("status ");
3308 parse_trace_status (p
, current_trace_status ());
3310 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3312 p
+= strlen ("tp ");
3313 parse_tracepoint_definition (p
, utpp
);
3315 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3317 p
+= strlen ("tsv ");
3318 parse_tsv_definition (p
, utsvp
);
3321 warning ("Ignoring trace file definition \"%s\"", line
);
3324 /* Parse the part of trace status syntax that is shared between
3325 the remote protocol and the trace file reader. */
3327 extern char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
3330 parse_trace_status (char *line
, struct trace_status
*ts
)
3332 char *p
= line
, *p1
, *p2
, *p_temp
;
3335 ts
->running_known
= 1;
3336 ts
->running
= (*p
++ == '1');
3337 ts
->stop_reason
= trace_stop_reason_unknown
;
3338 xfree (ts
->error_desc
);
3339 ts
->error_desc
= NULL
;
3340 ts
->traceframe_count
= -1;
3341 ts
->traceframes_created
= -1;
3342 ts
->buffer_free
= -1;
3343 ts
->buffer_size
= -1;
3344 ts
->disconnected_tracing
= 0;
3345 ts
->circular_buffer
= 0;
3349 p1
= strchr (p
, ':');
3351 error (_("Malformed trace status, at %s\n\
3352 Status line: '%s'\n"), p
, line
);
3353 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3355 p
= unpack_varlen_hex (++p1
, &val
);
3356 ts
->stop_reason
= trace_buffer_full
;
3358 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3360 p
= unpack_varlen_hex (++p1
, &val
);
3361 ts
->stop_reason
= trace_never_run
;
3363 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
], p1
- p
) == 0)
3365 p
= unpack_varlen_hex (++p1
, &val
);
3366 ts
->stop_reason
= tracepoint_passcount
;
3367 ts
->stopping_tracepoint
= val
;
3369 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3371 p
= unpack_varlen_hex (++p1
, &val
);
3372 ts
->stop_reason
= tstop_command
;
3374 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3376 p
= unpack_varlen_hex (++p1
, &val
);
3377 ts
->stop_reason
= trace_disconnected
;
3379 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3381 p2
= strchr (++p1
, ':');
3386 ts
->error_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3387 end
= hex2bin (p1
, ts
->error_desc
, (p2
- p1
) / 2);
3388 ts
->error_desc
[end
] = '\0';
3391 ts
->error_desc
= xstrdup ("");
3393 p
= unpack_varlen_hex (++p2
, &val
);
3394 ts
->stopping_tracepoint
= val
;
3395 ts
->stop_reason
= tracepoint_error
;
3397 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3399 p
= unpack_varlen_hex (++p1
, &val
);
3400 ts
->traceframe_count
= val
;
3402 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3404 p
= unpack_varlen_hex (++p1
, &val
);
3405 ts
->traceframes_created
= val
;
3407 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3409 p
= unpack_varlen_hex (++p1
, &val
);
3410 ts
->buffer_free
= val
;
3412 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3414 p
= unpack_varlen_hex (++p1
, &val
);
3415 ts
->buffer_size
= val
;
3417 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3419 p
= unpack_varlen_hex (++p1
, &val
);
3420 ts
->disconnected_tracing
= val
;
3422 else if (strncmp (p
, "circular", p1
- p
) == 0)
3424 p
= unpack_varlen_hex (++p1
, &val
);
3425 ts
->circular_buffer
= val
;
3429 /* Silently skip unknown optional info. */
3430 p_temp
= strchr (p1
+ 1, ';');
3434 /* Must be at the end. */
3440 /* Given a line of text defining a part of a tracepoint, parse it into
3441 an "uploaded tracepoint". */
3444 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3448 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3449 int enabled
, i
, end
;
3451 char *cond
, *srctype
, *src
, *buf
;
3452 struct uploaded_tp
*utp
= NULL
;
3455 /* Both tracepoint and action definitions start with the same number
3456 and address sequence. */
3458 p
= unpack_varlen_hex (p
, &num
);
3459 p
++; /* skip a colon */
3460 p
= unpack_varlen_hex (p
, &addr
);
3461 p
++; /* skip a colon */
3464 enabled
= (*p
++ == 'E');
3465 p
++; /* skip a colon */
3466 p
= unpack_varlen_hex (p
, &step
);
3467 p
++; /* skip a colon */
3468 p
= unpack_varlen_hex (p
, &pass
);
3469 type
= bp_tracepoint
;
3471 /* Thumb through optional fields. */
3474 p
++; /* skip a colon */
3477 type
= bp_fast_tracepoint
;
3479 p
= unpack_varlen_hex (p
, &orig_size
);
3484 p
= unpack_varlen_hex (p
, &xlen
);
3485 p
++; /* skip a comma */
3486 cond
= (char *) xmalloc (2 * xlen
+ 1);
3487 strncpy (cond
, p
, 2 * xlen
);
3488 cond
[2 * xlen
] = '\0';
3492 warning (_("Unrecognized char '%c' in tracepoint definition, skipping rest"), *p
);
3494 utp
= get_uploaded_tp (num
, addr
, utpp
);
3496 utp
->enabled
= enabled
;
3501 else if (piece
== 'A')
3503 utp
= get_uploaded_tp (num
, addr
, utpp
);
3504 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
3506 else if (piece
== 'S')
3508 utp
= get_uploaded_tp (num
, addr
, utpp
);
3509 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
3511 else if (piece
== 'Z')
3513 /* Parse a chunk of source form definition. */
3514 utp
= get_uploaded_tp (num
, addr
, utpp
);
3516 p
= strchr (p
, ':');
3517 p
++; /* skip a colon */
3518 p
= unpack_varlen_hex (p
, &start
);
3519 p
++; /* skip a colon */
3520 p
= unpack_varlen_hex (p
, &xlen
);
3521 p
++; /* skip a colon */
3523 buf
= alloca (strlen (line
));
3525 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3528 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
3529 utp
->at_string
= xstrdup (buf
);
3530 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
3531 utp
->cond_string
= xstrdup (buf
);
3532 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
3533 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
3537 /* Don't error out, the target might be sending us optional
3538 info that we don't care about. */
3539 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3543 /* Convert a textual description of a trace state variable into an
3547 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3550 ULONGEST num
, initval
, builtin
;
3552 struct uploaded_tsv
*utsv
= NULL
;
3554 buf
= alloca (strlen (line
));
3557 p
= unpack_varlen_hex (p
, &num
);
3558 p
++; /* skip a colon */
3559 p
= unpack_varlen_hex (p
, &initval
);
3560 p
++; /* skip a colon */
3561 p
= unpack_varlen_hex (p
, &builtin
);
3562 p
++; /* skip a colon */
3563 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3566 utsv
= get_uploaded_tsv (num
, utsvp
);
3567 utsv
->initial_value
= initval
;
3568 utsv
->builtin
= builtin
;
3569 utsv
->name
= xstrdup (buf
);
3572 /* Close the trace file and generally clean up. */
3575 tfile_close (int quitting
)
3582 pid
= ptid_get_pid (inferior_ptid
);
3583 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
3584 exit_inferior_silent (pid
);
3589 xfree (trace_filename
);
3593 tfile_files_info (struct target_ops
*t
)
3595 /* (it would be useful to mention the name of the file) */
3596 printf_filtered ("Looking at a trace file.\n");
3599 /* The trace status for a file is that tracing can never be run. */
3602 tfile_get_trace_status (struct trace_status
*ts
)
3604 /* Other bits of trace status were collected as part of opening the
3605 trace files, so nothing to do here. */
3610 /* Given the position of a traceframe in the file, figure out what
3611 address the frame was collected at. This would normally be the
3612 value of a collected PC register, but if not available, we
3616 tfile_get_traceframe_address (off_t tframe_offset
)
3620 struct breakpoint
*tp
;
3621 off_t saved_offset
= cur_offset
;
3624 /* FIXME dig pc out of collected registers */
3626 /* Fall back to using tracepoint address. */
3627 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
3628 gotten
= read (trace_fd
, &tpnum
, 2);
3630 perror_with_name (trace_filename
);
3631 else if (gotten
< 2)
3632 error (_("Premature end of file while reading trace file"));
3634 tp
= get_tracepoint_by_number_on_target (tpnum
);
3635 /* FIXME this is a poor heuristic if multiple locations */
3637 addr
= tp
->loc
->address
;
3639 /* Restore our seek position. */
3640 cur_offset
= saved_offset
;
3641 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3645 /* Given a type of search and some parameters, scan the collection of
3646 traceframes in the file looking for a match. When found, return
3647 both the traceframe and tracepoint number, otherwise -1 for
3651 tfile_trace_find (enum trace_find_type type
, int num
,
3652 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
3655 int tfnum
= 0, found
= 0, gotten
;
3657 struct breakpoint
*tp
;
3658 off_t offset
, tframe_offset
;
3661 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
3662 offset
= trace_frames_offset
;
3665 tframe_offset
= offset
;
3666 gotten
= read (trace_fd
, &tpnum
, 2);
3668 perror_with_name (trace_filename
);
3669 else if (gotten
< 2)
3670 error (_("Premature end of file while reading trace file"));
3674 gotten
= read (trace_fd
, &data_size
, 4);
3676 perror_with_name (trace_filename
);
3677 else if (gotten
< 4)
3678 error (_("Premature end of file while reading trace file"));
3687 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3688 if (tfaddr
== addr1
)
3692 tp
= get_tracepoint (num
);
3693 if (tp
&& tpnum
== tp
->number_on_target
)
3697 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3698 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
3702 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3703 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
3707 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
3713 cur_offset
= offset
;
3714 cur_data_size
= data_size
;
3717 /* Skip past the traceframe's data. */
3718 lseek (trace_fd
, data_size
, SEEK_CUR
);
3719 offset
+= data_size
;
3720 /* Update our own count of traceframes. */
3723 /* Did not find what we were looking for. */
3729 /* Look for a block of saved registers in the traceframe, and get the
3730 requested register from it. */
3733 tfile_fetch_registers (struct target_ops
*ops
,
3734 struct regcache
*regcache
, int regno
)
3736 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3738 int i
, pos
, offset
, regn
, regsize
, gotten
, pc_regno
;
3739 unsigned short mlen
;
3742 /* An uninitialized reg size says we're not going to be
3743 successful at getting register blocks. */
3744 if (!trace_regblock_size
)
3747 regs
= alloca (trace_regblock_size
);
3749 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3751 while (pos
< cur_data_size
)
3753 gotten
= read (trace_fd
, &block_type
, 1);
3755 perror_with_name (trace_filename
);
3756 else if (gotten
< 1)
3757 error (_("Premature end of file while reading trace file"));
3763 gotten
= read (trace_fd
, regs
, trace_regblock_size
);
3765 perror_with_name (trace_filename
);
3766 else if (gotten
< trace_regblock_size
)
3767 error (_("Premature end of file while reading trace file"));
3769 /* Assume the block is laid out in GDB register number order,
3770 each register with the size that it has in GDB. */
3772 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3774 regsize
= register_size (gdbarch
, regn
);
3775 /* Make sure we stay within block bounds. */
3776 if (offset
+ regsize
>= trace_regblock_size
)
3778 if (!regcache_valid_p (regcache
, regn
))
3782 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
3785 else if (regno
== -1)
3787 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
3794 lseek (trace_fd
, 8, SEEK_CUR
);
3795 gotten
= read (trace_fd
, &mlen
, 2);
3797 perror_with_name (trace_filename
);
3798 else if (gotten
< 2)
3799 error (_("Premature end of file while reading trace file"));
3800 lseek (trace_fd
, mlen
, SEEK_CUR
);
3801 pos
+= (8 + 2 + mlen
);
3804 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3808 error ("Unknown block type '%c' (0x%x) in trace frame",
3809 block_type
, block_type
);
3814 /* We get here if no register data has been found. Although we
3815 don't like making up numbers, GDB has all manner of troubles when
3816 the target says some register is not available. Filling in with
3817 zeroes is a reasonable fallback. */
3818 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3819 regcache_raw_supply (regcache
, regn
, NULL
);
3821 /* We can often usefully guess that the PC is going to be the same
3822 as the address of the tracepoint. */
3823 pc_regno
= gdbarch_pc_regnum (gdbarch
);
3824 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
3826 struct breakpoint
*tp
= get_tracepoint (tracepoint_number
);
3830 /* But don't try to guess if tracepoint is multi-location... */
3833 warning ("Tracepoint %d has multiple locations, cannot infer $pc",
3837 /* ... or does while-stepping. */
3838 if (tp
->step_count
> 0)
3840 warning ("Tracepoint %d does while-stepping, cannot infer $pc",
3845 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
3846 gdbarch_byte_order (gdbarch
),
3848 regcache_raw_supply (regcache
, pc_regno
, regs
);
3854 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3855 const char *annex
, gdb_byte
*readbuf
,
3856 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3860 ULONGEST maddr
, amt
;
3861 unsigned short mlen
;
3863 /* We're only doing regular memory for now. */
3864 if (object
!= TARGET_OBJECT_MEMORY
)
3867 if (readbuf
== NULL
)
3868 error ("tfile_xfer_partial: trace file is read-only");
3870 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3872 while (pos
< cur_data_size
)
3874 gotten
= read (trace_fd
, &block_type
, 1);
3876 perror_with_name (trace_filename
);
3877 else if (gotten
< 1)
3878 error (_("Premature end of file while reading trace file"));
3883 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3884 pos
+= trace_regblock_size
;
3887 gotten
= read (trace_fd
, &maddr
, 8);
3889 perror_with_name (trace_filename
);
3890 else if (gotten
< 8)
3891 error (_("Premature end of file while reading trace file"));
3893 gotten
= read (trace_fd
, &mlen
, 2);
3895 perror_with_name (trace_filename
);
3896 else if (gotten
< 2)
3897 error (_("Premature end of file while reading trace file"));
3898 /* If the block includes the first part of the desired
3899 range, return as much it has; GDB will re-request the
3900 remainder, which might be in a different block of this
3902 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
3904 amt
= (maddr
+ mlen
) - offset
;
3908 gotten
= read (trace_fd
, readbuf
, amt
);
3910 perror_with_name (trace_filename
);
3911 /* While it's acceptable to return less than was
3912 originally asked for, it's not acceptable to return
3913 less than what this block claims to contain. */
3914 else if (gotten
< amt
)
3915 error (_("Premature end of file while reading trace file"));
3918 lseek (trace_fd
, mlen
, SEEK_CUR
);
3919 pos
+= (8 + 2 + mlen
);
3922 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3926 error ("Unknown block type '%c' (0x%x) in traceframe",
3927 block_type
, block_type
);
3932 /* It's unduly pedantic to refuse to look at the executable for
3933 read-only pieces; so do the equivalent of readonly regions aka
3935 /* FIXME account for relocation at some point */
3942 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
3944 if ((s
->flags
& SEC_LOAD
) == 0 ||
3945 (s
->flags
& SEC_READONLY
) == 0)
3949 size
= bfd_get_section_size (s
);
3950 if (lma
<= offset
&& offset
< (lma
+ size
))
3952 amt
= (lma
+ size
) - offset
;
3956 amt
= bfd_get_section_contents (exec_bfd
, s
,
3957 readbuf
, offset
- lma
, amt
);
3963 /* Indicate failure to find the requested memory block. */
3967 /* Iterate through the blocks of a trace frame, looking for a 'V'
3968 block with a matching tsv number. */
3971 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
3974 int pos
, vnum
, gotten
;
3975 unsigned short mlen
;
3977 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3979 while (pos
< cur_data_size
)
3981 gotten
= read (trace_fd
, &block_type
, 1);
3983 perror_with_name (trace_filename
);
3984 else if (gotten
< 1)
3985 error (_("Premature end of file while reading trace file"));
3990 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3991 pos
+= trace_regblock_size
;
3994 lseek (trace_fd
, 8, SEEK_CUR
);
3995 gotten
= read (trace_fd
, &mlen
, 2);
3997 perror_with_name (trace_filename
);
3998 else if (gotten
< 2)
3999 error (_("Premature end of file while reading trace file"));
4000 lseek (trace_fd
, mlen
, SEEK_CUR
);
4001 pos
+= (8 + 2 + mlen
);
4004 gotten
= read (trace_fd
, &vnum
, 4);
4006 perror_with_name (trace_filename
);
4007 else if (gotten
< 4)
4008 error (_("Premature end of file while reading trace file"));
4011 gotten
= read (trace_fd
, val
, 8);
4013 perror_with_name (trace_filename
);
4014 else if (gotten
< 8)
4015 error (_("Premature end of file while reading trace file"));
4018 lseek (trace_fd
, 8, SEEK_CUR
);
4022 error ("Unknown block type '%c' (0x%x) in traceframe",
4023 block_type
, block_type
);
4027 /* Didn't find anything. */
4032 tfile_has_all_memory (struct target_ops
*ops
)
4038 tfile_has_memory (struct target_ops
*ops
)
4044 tfile_has_stack (struct target_ops
*ops
)
4050 tfile_has_registers (struct target_ops
*ops
)
4056 init_tfile_ops (void)
4058 tfile_ops
.to_shortname
= "tfile";
4059 tfile_ops
.to_longname
= "Local trace dump file";
4061 "Use a trace file as a target. Specify the filename of the trace file.";
4062 tfile_ops
.to_open
= tfile_open
;
4063 tfile_ops
.to_close
= tfile_close
;
4064 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
4065 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
4066 tfile_ops
.to_files_info
= tfile_files_info
;
4067 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
4068 tfile_ops
.to_trace_find
= tfile_trace_find
;
4069 tfile_ops
.to_get_trace_state_variable_value
= tfile_get_trace_state_variable_value
;
4070 /* core_stratum might seem more logical, but GDB doesn't like having
4071 more than one core_stratum vector. */
4072 tfile_ops
.to_stratum
= process_stratum
;
4073 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
4074 tfile_ops
.to_has_memory
= tfile_has_memory
;
4075 tfile_ops
.to_has_stack
= tfile_has_stack
;
4076 tfile_ops
.to_has_registers
= tfile_has_registers
;
4077 tfile_ops
.to_magic
= OPS_MAGIC
;
4080 /* module initialization */
4082 _initialize_tracepoint (void)
4084 struct cmd_list_element
*c
;
4086 traceframe_number
= -1;
4087 tracepoint_number
= -1;
4089 if (tracepoint_list
.list
== NULL
)
4091 tracepoint_list
.listsize
= 128;
4092 tracepoint_list
.list
= xmalloc
4093 (tracepoint_list
.listsize
* sizeof (struct memrange
));
4095 if (tracepoint_list
.aexpr_list
== NULL
)
4097 tracepoint_list
.aexpr_listsize
= 128;
4098 tracepoint_list
.aexpr_list
= xmalloc
4099 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
4102 if (stepping_list
.list
== NULL
)
4104 stepping_list
.listsize
= 128;
4105 stepping_list
.list
= xmalloc
4106 (stepping_list
.listsize
* sizeof (struct memrange
));
4109 if (stepping_list
.aexpr_list
== NULL
)
4111 stepping_list
.aexpr_listsize
= 128;
4112 stepping_list
.aexpr_list
= xmalloc
4113 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
4116 add_info ("scope", scope_info
,
4117 _("List the variables local to a scope"));
4119 add_cmd ("tracepoints", class_trace
, NULL
,
4120 _("Tracing of program execution without stopping the program."),
4123 add_com ("tdump", class_trace
, trace_dump_command
,
4124 _("Print everything collected at the current tracepoint."));
4126 add_com ("tsave", class_trace
, trace_save_command
, _("\
4127 Save the trace data to a file.\n\
4128 Use the '-r' option to direct the target to save directly to the file,\n\
4129 using its own filesystem."));
4131 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
4132 Define a trace state variable.\n\
4133 Argument is a $-prefixed name, optionally followed\n\
4134 by '=' and an expression that sets the initial value\n\
4135 at the start of tracing."));
4136 set_cmd_completer (c
, expression_completer
);
4138 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
4139 Delete one or more trace state variables.\n\
4140 Arguments are the names of the variables to delete.\n\
4141 If no arguments are supplied, delete all variables."), &deletelist
);
4142 /* FIXME add a trace variable completer */
4144 add_info ("tvariables", tvariables_info
, _("\
4145 Status of trace state variables and their values.\n\
4148 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
4149 Select a trace frame;\n\
4150 No argument means forward by one frame; '-' means backward by one frame."),
4151 &tfindlist
, "tfind ", 1, &cmdlist
);
4153 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
4154 Select a trace frame whose PC is outside the given range (exclusive).\n\
4155 Usage: tfind outside addr1, addr2"),
4158 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
4159 Select a trace frame whose PC is in the given range (inclusive).\n\
4160 Usage: tfind range addr1,addr2"),
4163 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
4164 Select a trace frame by source line.\n\
4165 Argument can be a line number (with optional source file), \n\
4166 a function name, or '*' followed by an address.\n\
4167 Default argument is 'the next source line that was traced'."),
4170 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
4171 Select a trace frame by tracepoint number.\n\
4172 Default is the tracepoint for the current trace frame."),
4175 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
4176 Select a trace frame by PC.\n\
4177 Default is the current PC, or the PC of the current trace frame."),
4180 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
4181 Synonym for 'none'.\n\
4182 De-select any trace frame and resume 'live' debugging."),
4185 add_cmd ("none", class_trace
, trace_find_none_command
,
4186 _("De-select any trace frame and resume 'live' debugging."),
4189 add_cmd ("start", class_trace
, trace_find_start_command
,
4190 _("Select the first trace frame in the trace buffer."),
4193 add_com ("tstatus", class_trace
, trace_status_command
,
4194 _("Display the status of the current trace data collection."));
4196 add_com ("tstop", class_trace
, trace_stop_command
,
4197 _("Stop trace data collection."));
4199 add_com ("tstart", class_trace
, trace_start_command
,
4200 _("Start trace data collection."));
4202 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
4203 Ends a list of commands or actions.\n\
4204 Several GDB commands allow you to enter a list of commands or actions.\n\
4205 Entering \"end\" on a line by itself is the normal way to terminate\n\
4207 Note: the \"end\" command cannot be used at the gdb prompt."));
4209 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
4210 Specify single-stepping behavior at a tracepoint.\n\
4211 Argument is number of instructions to trace in single-step mode\n\
4212 following the tracepoint. This command is normally followed by\n\
4213 one or more \"collect\" commands, to specify what to collect\n\
4214 while single-stepping.\n\n\
4215 Note: this command can only be used in a tracepoint \"actions\" list."));
4217 add_com_alias ("ws", "while-stepping", class_alias
, 0);
4218 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
4220 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
4221 Specify one or more data items to be collected at a tracepoint.\n\
4222 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4223 collect all data (variables, registers) referenced by that expression.\n\
4224 Also accepts the following special arguments:\n\
4225 $regs -- all registers.\n\
4226 $args -- all function arguments.\n\
4227 $locals -- all variables local to the block/function scope.\n\
4228 Note: this command can only be used in a tracepoint \"actions\" list."));
4230 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4231 Specify one or more expressions to be evaluated at a tracepoint.\n\
4232 Accepts a comma-separated list of (one or more) expressions.\n\
4233 The result of each evaluation will be discarded.\n\
4234 Note: this command can only be used in a tracepoint \"actions\" list."));
4236 add_com ("actions", class_trace
, trace_actions_command
, _("\
4237 Specify the actions to be taken at a tracepoint.\n\
4238 Tracepoint actions may include collecting of specified data, \n\
4239 single-stepping, or enabling/disabling other tracepoints, \n\
4240 depending on target's capabilities."));
4242 default_collect
= xstrdup ("");
4243 add_setshow_string_cmd ("default-collect", class_trace
,
4244 &default_collect
, _("\
4245 Set the list of expressions to collect by default"), _("\
4246 Show the list of expressions to collect by default"), NULL
,
4248 &setlist
, &showlist
);
4250 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4251 &disconnected_tracing
, _("\
4252 Set whether tracing continues after GDB disconnects."), _("\
4253 Show whether tracing continues after GDB disconnects."), _("\
4254 Use this to continue a tracing run even if GDB disconnects\n\
4255 or detaches from the target. You can reconnect later and look at\n\
4256 trace data collected in the meantime."),
4257 set_disconnected_tracing
,
4262 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4263 &circular_trace_buffer
, _("\
4264 Set target's use of circular trace buffer."), _("\
4265 Show target's use of circular trace buffer."), _("\
4266 Use this to make the trace buffer into a circular buffer,\n\
4267 which will discard traceframes (oldest first) instead of filling\n\
4268 up and stopping the trace run."),
4269 set_circular_trace_buffer
,
4276 add_target (&tfile_ops
);