1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
4 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "arch-utils.h"
26 #include "expression.h"
31 #include "gdb_string.h"
33 #include "breakpoint.h"
34 #include "tracepoint.h"
37 #include "completer.h"
39 #include "dictionary.h"
41 #include "user-regs.h"
45 #include "filenames.h"
46 #include "gdbthread.h"
52 /* readline include files */
53 #include "readline/readline.h"
54 #include "readline/history.h"
56 /* readline defines this. */
67 extern int hex2bin (const char *hex
, gdb_byte
*bin
, int count
);
68 extern int bin2hex (const gdb_byte
*bin
, char *hex
, int count
);
70 extern void stop_tracing ();
72 /* Maximum length of an agent aexpression.
73 This accounts for the fact that packets are limited to 400 bytes
74 (which includes everything -- including the checksum), and assumes
75 the worst case of maximum length for each of the pieces of a
78 NOTE: expressions get mem2hex'ed otherwise this would be twice as
79 large. (400 - 31)/2 == 184 */
80 #define MAX_AGENT_EXPR_LEN 184
82 /* A hook used to notify the UI of tracepoint operations. */
84 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
85 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
87 extern void (*deprecated_readline_begin_hook
) (char *, ...);
88 extern char *(*deprecated_readline_hook
) (char *);
89 extern void (*deprecated_readline_end_hook
) (void);
91 /* GDB commands implemented in other modules:
94 extern void output_command (char *, int);
99 This module defines the following debugger commands:
100 trace : set a tracepoint on a function, line, or address.
101 info trace : list all debugger-defined tracepoints.
102 delete trace : delete one or more tracepoints.
103 enable trace : enable one or more tracepoints.
104 disable trace : disable one or more tracepoints.
105 actions : specify actions to be taken at a tracepoint.
106 passcount : specify a pass count for a tracepoint.
107 tstart : start a trace experiment.
108 tstop : stop a trace experiment.
109 tstatus : query the status of a trace experiment.
110 tfind : find a trace frame in the trace buffer.
111 tdump : print everything collected at the current tracepoint.
112 save-tracepoints : write tracepoint setup into a file.
114 This module defines the following user-visible debugger variables:
115 $trace_frame : sequence number of trace frame currently being debugged.
116 $trace_line : source line of trace frame currently being debugged.
117 $trace_file : source file of trace frame currently being debugged.
118 $tracepoint : tracepoint number of trace frame currently being debugged.
122 /* ======= Important global variables: ======= */
124 /* The list of all trace state variables. We don't retain pointers to
125 any of these for any reason - API is by name or number only - so it
126 works to have a vector of objects. */
128 typedef struct trace_state_variable tsv_s
;
131 static VEC(tsv_s
) *tvariables
;
133 /* The next integer to assign to a variable. */
135 static int next_tsv_number
= 1;
137 /* Number of last traceframe collected. */
138 static int traceframe_number
;
140 /* Tracepoint for last traceframe collected. */
141 static int tracepoint_number
;
143 /* Symbol for function for last traceframe collected */
144 static struct symbol
*traceframe_fun
;
146 /* Symtab and line for last traceframe collected */
147 static struct symtab_and_line traceframe_sal
;
149 /* Tracing command lists */
150 static struct cmd_list_element
*tfindlist
;
152 /* List of expressions to collect by default at each tracepoint hit. */
153 char *default_collect
= "";
155 static int disconnected_tracing
;
157 /* This variable controls whether we ask the target for a linear or
158 circular trace buffer. */
160 static int circular_trace_buffer
;
162 /* ======= Important command functions: ======= */
163 static void trace_actions_command (char *, int);
164 static void trace_start_command (char *, int);
165 static void trace_stop_command (char *, int);
166 static void trace_status_command (char *, int);
167 static void trace_find_command (char *, int);
168 static void trace_find_pc_command (char *, int);
169 static void trace_find_tracepoint_command (char *, int);
170 static void trace_find_line_command (char *, int);
171 static void trace_find_range_command (char *, int);
172 static void trace_find_outside_command (char *, int);
173 static void trace_dump_command (char *, int);
175 /* support routines */
177 struct collection_list
;
178 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
179 static char *mem2hex (gdb_byte
*, char *, int);
180 static void add_register (struct collection_list
*collection
,
183 extern void send_disconnected_tracing_value (int value
);
185 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
186 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
189 extern void _initialize_tracepoint (void);
191 static struct trace_status trace_status
;
193 char *stop_reason_names
[] = {
203 struct trace_status
*
204 current_trace_status ()
206 return &trace_status
;
209 /* Set traceframe number to NUM. */
211 set_traceframe_num (int num
)
213 traceframe_number
= num
;
214 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
217 /* Set tracepoint number to NUM. */
219 set_tracepoint_num (int num
)
221 tracepoint_number
= num
;
222 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
225 /* Set externally visible debug variables for querying/printing
226 the traceframe context (line, function, file) */
229 set_traceframe_context (struct frame_info
*trace_frame
)
233 if (trace_frame
== NULL
) /* Cease debugging any trace buffers. */
236 traceframe_sal
.pc
= traceframe_sal
.line
= 0;
237 traceframe_sal
.symtab
= NULL
;
238 clear_internalvar (lookup_internalvar ("trace_func"));
239 clear_internalvar (lookup_internalvar ("trace_file"));
240 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
244 /* Save as globals for internal use. */
245 trace_pc
= get_frame_pc (trace_frame
);
246 traceframe_sal
= find_pc_line (trace_pc
, 0);
247 traceframe_fun
= find_pc_function (trace_pc
);
249 /* Save linenumber as "$trace_line", a debugger variable visible to
251 set_internalvar_integer (lookup_internalvar ("trace_line"),
252 traceframe_sal
.line
);
254 /* Save func name as "$trace_func", a debugger variable visible to
256 if (traceframe_fun
== NULL
257 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
258 clear_internalvar (lookup_internalvar ("trace_func"));
260 set_internalvar_string (lookup_internalvar ("trace_func"),
261 SYMBOL_LINKAGE_NAME (traceframe_fun
));
263 /* Save file name as "$trace_file", a debugger variable visible to
265 if (traceframe_sal
.symtab
== NULL
266 || traceframe_sal
.symtab
->filename
== NULL
)
267 clear_internalvar (lookup_internalvar ("trace_file"));
269 set_internalvar_string (lookup_internalvar ("trace_file"),
270 traceframe_sal
.symtab
->filename
);
273 /* Create a new trace state variable with the given name. */
275 struct trace_state_variable
*
276 create_trace_state_variable (const char *name
)
278 struct trace_state_variable tsv
;
280 memset (&tsv
, 0, sizeof (tsv
));
281 tsv
.name
= xstrdup (name
);
282 tsv
.number
= next_tsv_number
++;
283 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
286 /* Look for a trace state variable of the given name. */
288 struct trace_state_variable
*
289 find_trace_state_variable (const char *name
)
291 struct trace_state_variable
*tsv
;
294 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
295 if (strcmp (name
, tsv
->name
) == 0)
302 delete_trace_state_variable (const char *name
)
304 struct trace_state_variable
*tsv
;
307 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
308 if (strcmp (name
, tsv
->name
) == 0)
310 xfree ((void *)tsv
->name
);
311 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
315 warning (_("No trace variable named \"$%s\", not deleting"), name
);
318 /* The 'tvariable' command collects a name and optional expression to
319 evaluate into an initial value. */
322 trace_variable_command (char *args
, int from_tty
)
324 struct expression
*expr
;
325 struct cleanup
*old_chain
;
326 struct internalvar
*intvar
= NULL
;
328 struct trace_state_variable
*tsv
;
331 error_no_arg (_("trace state variable name"));
333 /* All the possible valid arguments are expressions. */
334 expr
= parse_expression (args
);
335 old_chain
= make_cleanup (free_current_contents
, &expr
);
337 if (expr
->nelts
== 0)
338 error (_("No expression?"));
340 /* Only allow two syntaxes; "$name" and "$name=value". */
341 if (expr
->elts
[0].opcode
== OP_INTERNALVAR
)
343 intvar
= expr
->elts
[1].internalvar
;
345 else if (expr
->elts
[0].opcode
== BINOP_ASSIGN
346 && expr
->elts
[1].opcode
== OP_INTERNALVAR
)
348 intvar
= expr
->elts
[2].internalvar
;
349 initval
= value_as_long (evaluate_subexpression_type (expr
, 4));
352 error (_("Syntax must be $NAME [ = EXPR ]"));
355 error (_("No name given"));
357 if (strlen (internalvar_name (intvar
)) <= 0)
358 error (_("Must supply a non-empty variable name"));
360 /* If the variable already exists, just change its initial value. */
361 tsv
= find_trace_state_variable (internalvar_name (intvar
));
364 tsv
->initial_value
= initval
;
365 printf_filtered (_("Trace state variable $%s now has initial value %s.\n"),
366 tsv
->name
, plongest (tsv
->initial_value
));
370 /* Create a new variable. */
371 tsv
= create_trace_state_variable (internalvar_name (intvar
));
372 tsv
->initial_value
= initval
;
374 printf_filtered (_("Trace state variable $%s created, with initial value %s.\n"),
375 tsv
->name
, plongest (tsv
->initial_value
));
377 do_cleanups (old_chain
);
381 delete_trace_variable_command (char *args
, int from_tty
)
385 struct cleanup
*back_to
;
386 struct trace_state_variable
*tsv
;
390 if (query (_("Delete all trace state variables? ")))
391 VEC_free (tsv_s
, tvariables
);
396 argv
= gdb_buildargv (args
);
397 back_to
= make_cleanup_freeargv (argv
);
399 for (i
= 0; argv
[i
] != NULL
; i
++)
402 delete_trace_state_variable (argv
[i
] + 1);
404 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[i
]);
407 do_cleanups (back_to
);
413 tvariables_info_1 (void)
415 struct trace_state_variable
*tsv
;
418 struct cleanup
*back_to
;
420 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
422 printf_filtered (_("No trace state variables.\n"));
426 /* Try to acquire values from the target. */
427 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
428 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
431 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
432 count
, "trace-variables");
433 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
434 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
435 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
437 ui_out_table_body (uiout
);
439 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
441 struct cleanup
*back_to2
;
445 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
447 name
= concat ("$", tsv
->name
, NULL
);
448 make_cleanup (xfree
, name
);
449 ui_out_field_string (uiout
, "name", name
);
450 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
452 if (tsv
->value_known
)
453 c
= plongest (tsv
->value
);
454 else if (ui_out_is_mi_like_p (uiout
))
455 /* For MI, we prefer not to use magic string constants, but rather
456 omit the field completely. The difference between unknown and
457 undefined does not seem important enough to represent. */
459 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
460 /* The value is/was defined, but we don't have it. */
463 /* It is not meaningful to ask about the value. */
466 ui_out_field_string (uiout
, "current", c
);
467 ui_out_text (uiout
, "\n");
469 do_cleanups (back_to2
);
472 do_cleanups (back_to
);
475 /* List all the trace state variables. */
478 tvariables_info (char *args
, int from_tty
)
480 tvariables_info_1 ();
483 /* Stash definitions of tsvs into the given file. */
486 save_trace_state_variables (struct ui_file
*fp
)
488 struct trace_state_variable
*tsv
;
491 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
493 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
494 if (tsv
->initial_value
)
495 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
496 fprintf_unfiltered (fp
, "\n");
500 /* ACTIONS functions: */
502 /* The three functions:
503 collect_pseudocommand,
504 while_stepping_pseudocommand, and
505 end_actions_pseudocommand
506 are placeholders for "commands" that are actually ONLY to be used
507 within a tracepoint action list. If the actual function is ever called,
508 it means that somebody issued the "command" at the top level,
509 which is always an error. */
512 end_actions_pseudocommand (char *args
, int from_tty
)
514 error (_("This command cannot be used at the top level."));
518 while_stepping_pseudocommand (char *args
, int from_tty
)
520 error (_("This command can only be used in a tracepoint actions list."));
524 collect_pseudocommand (char *args
, int from_tty
)
526 error (_("This command can only be used in a tracepoint actions list."));
530 teval_pseudocommand (char *args
, int from_tty
)
532 error (_("This command can only be used in a tracepoint actions list."));
535 /* Enter a list of actions for a tracepoint. */
537 trace_actions_command (char *args
, int from_tty
)
539 struct breakpoint
*t
;
540 struct command_line
*l
;
542 t
= get_tracepoint_by_number (&args
, 0, 1);
546 xstrprintf ("Enter actions for tracepoint %d, one per line.",
548 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
550 l
= read_command_lines (tmpbuf
, from_tty
, 1, check_tracepoint_command
, t
);
551 do_cleanups (cleanups
);
552 breakpoint_set_commands (t
, l
);
554 /* else just return */
557 /* Report the results of checking the agent expression, as errors or
561 report_agent_reqs_errors (struct agent_expr
*aexpr
, struct agent_reqs
*areqs
)
563 /* All of the "flaws" are serious bytecode generation issues that
564 should never occur. */
565 if (areqs
->flaw
!= agent_flaw_none
)
566 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
568 /* If analysis shows a stack underflow, GDB must have done something
569 badly wrong in its bytecode generation. */
570 if (areqs
->min_height
< 0)
571 internal_error (__FILE__
, __LINE__
,
572 _("expression has min height < 0"));
574 /* Issue this error if the stack is predicted to get too deep. The
575 limit is rather arbitrary; a better scheme might be for the
576 target to report how much stack it will have available. The
577 depth roughly corresponds to parenthesization, so a limit of 20
578 amounts to 20 levels of expression nesting, which is actually
579 a pretty big hairy expression. */
580 if (areqs
->max_height
> 20)
581 error (_("Expression is too complicated."));
584 /* worker function */
586 validate_actionline (char **line
, struct breakpoint
*t
)
588 struct cmd_list_element
*c
;
589 struct expression
*exp
= NULL
;
590 struct cleanup
*old_chain
= NULL
;
592 struct bp_location
*loc
;
593 struct agent_expr
*aexpr
;
594 struct agent_reqs areqs
;
596 /* if EOF is typed, *line is NULL */
600 for (p
= *line
; isspace ((int) *p
);)
603 /* Symbol lookup etc. */
604 if (*p
== '\0') /* empty line: just prompt for another line. */
607 if (*p
== '#') /* comment line */
610 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
612 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
614 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
617 { /* repeat over a comma-separated list */
618 QUIT
; /* allow user to bail out with ^C */
619 while (isspace ((int) *p
))
622 if (*p
== '$') /* look for special pseudo-symbols */
624 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
625 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
626 (0 == strncasecmp ("loc", p
+ 1, 3)))
631 /* else fall thru, treat p as an expression and parse it! */
634 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
637 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
638 old_chain
= make_cleanup (free_current_contents
, &exp
);
640 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
642 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
644 error (_("constant `%s' (value %ld) will not be collected."),
645 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
646 SYMBOL_VALUE (exp
->elts
[2].symbol
));
648 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
650 error (_("`%s' is optimized away and cannot be collected."),
651 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
655 /* We have something to collect, make sure that the expr to
656 bytecode translator can handle it and that it's not too
658 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
659 make_cleanup_free_agent_expr (aexpr
);
661 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
662 error (_("Expression is too complicated."));
664 ax_reqs (aexpr
, &areqs
);
665 (void) make_cleanup (xfree
, areqs
.reg_mask
);
667 report_agent_reqs_errors (aexpr
, &areqs
);
669 do_cleanups (old_chain
);
672 while (p
&& *p
++ == ',');
675 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
678 { /* repeat over a comma-separated list */
679 QUIT
; /* allow user to bail out with ^C */
680 while (isspace ((int) *p
))
684 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
687 /* Only expressions are allowed for this action. */
688 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
689 old_chain
= make_cleanup (free_current_contents
, &exp
);
691 /* We have something to evaluate, make sure that the expr to
692 bytecode translator can handle it and that it's not too
694 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
695 make_cleanup_free_agent_expr (aexpr
);
697 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
698 error (_("Expression is too complicated."));
700 ax_reqs (aexpr
, &areqs
);
701 (void) make_cleanup (xfree
, areqs
.reg_mask
);
703 report_agent_reqs_errors (aexpr
, &areqs
);
705 do_cleanups (old_chain
);
708 while (p
&& *p
++ == ',');
711 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
713 char *steparg
; /* in case warning is necessary */
715 while (isspace ((int) *p
))
719 if (*p
== '\0' || (t
->step_count
= strtol (p
, &p
, 0)) == 0)
720 error (_("while-stepping step count `%s' is malformed."), *line
);
723 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
727 error (_("`%s' is not a supported tracepoint action."), *line
);
731 memrange_absolute
= -1
736 int type
; /* memrange_absolute for absolute memory range,
737 else basereg number */
738 bfd_signed_vma start
;
742 struct collection_list
744 unsigned char regs_mask
[32]; /* room for up to 256 regs */
747 struct memrange
*list
;
748 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
750 struct agent_expr
**aexpr_list
;
753 tracepoint_list
, stepping_list
;
755 /* MEMRANGE functions: */
757 static int memrange_cmp (const void *, const void *);
759 /* compare memranges for qsort */
761 memrange_cmp (const void *va
, const void *vb
)
763 const struct memrange
*a
= va
, *b
= vb
;
765 if (a
->type
< b
->type
)
767 if (a
->type
> b
->type
)
769 if (a
->type
== memrange_absolute
)
771 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
773 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
778 if (a
->start
< b
->start
)
780 if (a
->start
> b
->start
)
786 /* Sort the memrange list using qsort, and merge adjacent memranges. */
788 memrange_sortmerge (struct collection_list
*memranges
)
792 qsort (memranges
->list
, memranges
->next_memrange
,
793 sizeof (struct memrange
), memrange_cmp
);
794 if (memranges
->next_memrange
> 0)
796 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
798 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
799 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
802 /* memrange b starts before memrange a ends; merge them. */
803 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
804 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
805 continue; /* next b, same a */
809 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
810 sizeof (struct memrange
));
812 memranges
->next_memrange
= a
+ 1;
816 /* Add a register to a collection list. */
818 add_register (struct collection_list
*collection
, unsigned int regno
)
821 printf_filtered ("collect register %d\n", regno
);
822 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
823 error (_("Internal: register number %d too large for tracepoint"),
825 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
828 /* Add a memrange to a collection list */
830 add_memrange (struct collection_list
*memranges
,
831 int type
, bfd_signed_vma base
,
836 printf_filtered ("(%d,", type
);
838 printf_filtered (",%ld)\n", len
);
841 /* type: memrange_absolute == memory, other n == basereg */
842 memranges
->list
[memranges
->next_memrange
].type
= type
;
843 /* base: addr if memory, offset if reg relative. */
844 memranges
->list
[memranges
->next_memrange
].start
= base
;
845 /* len: we actually save end (base + len) for convenience */
846 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
847 memranges
->next_memrange
++;
848 if (memranges
->next_memrange
>= memranges
->listsize
)
850 memranges
->listsize
*= 2;
851 memranges
->list
= xrealloc (memranges
->list
,
852 memranges
->listsize
);
855 if (type
!= memrange_absolute
) /* Better collect the base register! */
856 add_register (memranges
, type
);
859 /* Add a symbol to a collection list. */
861 collect_symbol (struct collection_list
*collect
,
863 struct gdbarch
*gdbarch
,
864 long frame_regno
, long frame_offset
,
869 bfd_signed_vma offset
;
870 int treat_as_expr
= 0;
872 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
873 switch (SYMBOL_CLASS (sym
))
876 printf_filtered ("%s: don't know symbol class %d\n",
877 SYMBOL_PRINT_NAME (sym
),
881 printf_filtered ("constant %s (value %ld) will not be collected.\n",
882 SYMBOL_PRINT_NAME (sym
), SYMBOL_VALUE (sym
));
885 offset
= SYMBOL_VALUE_ADDRESS (sym
);
890 sprintf_vma (tmp
, offset
);
891 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
892 SYMBOL_PRINT_NAME (sym
), len
,
895 /* A struct may be a C++ class with static fields, go to general
896 expression handling. */
897 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
900 add_memrange (collect
, memrange_absolute
, offset
, len
);
903 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
905 printf_filtered ("LOC_REG[parm] %s: ",
906 SYMBOL_PRINT_NAME (sym
));
907 add_register (collect
, reg
);
908 /* Check for doubles stored in two registers. */
909 /* FIXME: how about larger types stored in 3 or more regs? */
910 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
911 len
> register_size (gdbarch
, reg
))
912 add_register (collect
, reg
+ 1);
915 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
916 printf_filtered (" (will not collect %s)\n",
917 SYMBOL_PRINT_NAME (sym
));
921 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
924 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
925 SYMBOL_PRINT_NAME (sym
), len
);
927 printf_filtered (" from frame ptr reg %d\n", reg
);
929 add_memrange (collect
, reg
, offset
, len
);
931 case LOC_REGPARM_ADDR
:
932 reg
= SYMBOL_VALUE (sym
);
936 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
937 SYMBOL_PRINT_NAME (sym
), len
);
939 printf_filtered (" from reg %d\n", reg
);
941 add_memrange (collect
, reg
, offset
, len
);
945 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
948 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
949 SYMBOL_PRINT_NAME (sym
), len
);
951 printf_filtered (" from frame ptr reg %d\n", reg
);
953 add_memrange (collect
, reg
, offset
, len
);
960 case LOC_OPTIMIZED_OUT
:
961 printf_filtered ("%s has been optimized out of existence.\n",
962 SYMBOL_PRINT_NAME (sym
));
970 /* Expressions are the most general case. */
973 struct agent_expr
*aexpr
;
974 struct cleanup
*old_chain1
= NULL
;
975 struct agent_reqs areqs
;
977 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
979 /* It can happen that the symbol is recorded as a computed
980 location, but it's been optimized away and doesn't actually
981 have a location expression. */
984 printf_filtered ("%s has been optimized out of existence.\n",
985 SYMBOL_PRINT_NAME (sym
));
989 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
991 ax_reqs (aexpr
, &areqs
);
993 report_agent_reqs_errors (aexpr
, &areqs
);
995 discard_cleanups (old_chain1
);
996 add_aexpr (collect
, aexpr
);
998 /* take care of the registers */
999 if (areqs
.reg_mask_len
> 0)
1003 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1005 QUIT
; /* allow user to bail out with ^C */
1006 if (areqs
.reg_mask
[ndx1
] != 0)
1008 /* assume chars have 8 bits */
1009 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1010 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1011 /* it's used -- record it */
1012 add_register (collect
, ndx1
* 8 + ndx2
);
1019 /* Data to be passed around in the calls to the locals and args
1022 struct add_local_symbols_data
1024 struct collection_list
*collect
;
1025 struct gdbarch
*gdbarch
;
1032 /* The callback for the locals and args iterators */
1035 do_collect_symbol (const char *print_name
,
1039 struct add_local_symbols_data
*p
= cb_data
;
1041 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1042 p
->frame_offset
, p
->pc
);
1046 /* Add all locals (or args) symbols to collection list */
1048 add_local_symbols (struct collection_list
*collect
,
1049 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1050 long frame_regno
, long frame_offset
, int type
)
1052 struct block
*block
;
1053 struct add_local_symbols_data cb_data
;
1055 cb_data
.collect
= collect
;
1056 cb_data
.gdbarch
= gdbarch
;
1058 cb_data
.frame_regno
= frame_regno
;
1059 cb_data
.frame_offset
= frame_offset
;
1064 block
= block_for_pc (pc
);
1067 warning (_("Can't collect locals; "
1068 "no symbol table info available.\n"));
1072 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1073 if (cb_data
.count
== 0)
1074 warning (_("No locals found in scope."));
1078 pc
= get_pc_function_start (pc
);
1079 block
= block_for_pc (pc
);
1082 warning (_("Can't collect args; no symbol table info available.\n"));
1086 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1087 if (cb_data
.count
== 0)
1088 warning (_("No args found in scope."));
1092 /* worker function */
1094 clear_collection_list (struct collection_list
*list
)
1098 list
->next_memrange
= 0;
1099 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1101 free_agent_expr (list
->aexpr_list
[ndx
]);
1102 list
->aexpr_list
[ndx
] = NULL
;
1104 list
->next_aexpr_elt
= 0;
1105 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1108 /* reduce a collection list to string form (for gdb protocol) */
1110 stringify_collection_list (struct collection_list
*list
, char *string
)
1112 char temp_buf
[2048];
1116 char *(*str_list
)[];
1120 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1121 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1123 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1124 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1126 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1129 printf_filtered ("\nCollecting registers (mask): 0x");
1134 QUIT
; /* allow user to bail out with ^C */
1136 printf_filtered ("%02X", list
->regs_mask
[i
]);
1137 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1140 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1144 printf_filtered ("\n");
1145 if (list
->next_memrange
> 0 && info_verbose
)
1146 printf_filtered ("Collecting memranges: \n");
1147 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1149 QUIT
; /* allow user to bail out with ^C */
1150 sprintf_vma (tmp2
, list
->list
[i
].start
);
1153 printf_filtered ("(%d, %s, %ld)\n",
1156 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1158 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1160 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1167 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1169 /* The "%X" conversion specifier expects an unsigned argument,
1170 so passing -1 (memrange_absolute) to it directly gives you
1171 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1173 if (list
->list
[i
].type
== memrange_absolute
)
1174 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1176 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1179 count
+= strlen (end
);
1180 end
= temp_buf
+ count
;
1183 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1185 QUIT
; /* allow user to bail out with ^C */
1186 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1188 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1193 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1194 end
+= 10; /* 'X' + 8 hex digits + ',' */
1197 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1198 end
, list
->aexpr_list
[i
]->len
);
1199 count
+= 2 * list
->aexpr_list
[i
]->len
;
1204 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1209 (*str_list
)[ndx
] = NULL
;
1222 encode_actions_1 (struct command_line
*action
,
1223 struct breakpoint
*t
,
1224 struct bp_location
*tloc
,
1226 LONGEST frame_offset
,
1227 struct collection_list
*collect
,
1228 struct collection_list
*stepping_list
)
1231 struct expression
*exp
= NULL
;
1232 struct command_line
*actions
;
1234 struct value
*tempval
;
1235 struct cmd_list_element
*cmd
;
1236 struct agent_expr
*aexpr
;
1238 for (; action
; action
= action
->next
)
1240 QUIT
; /* allow user to bail out with ^C */
1241 action_exp
= action
->line
;
1242 while (isspace ((int) *action_exp
))
1245 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1247 error (_("Bad action list item: %s"), action_exp
);
1249 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1252 { /* repeat over a comma-separated list */
1253 QUIT
; /* allow user to bail out with ^C */
1254 while (isspace ((int) *action_exp
))
1257 if (0 == strncasecmp ("$reg", action_exp
, 4))
1259 for (i
= 0; i
< gdbarch_num_regs (t
->gdbarch
); i
++)
1260 add_register (collect
, i
);
1261 action_exp
= strchr (action_exp
, ','); /* more? */
1263 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1265 add_local_symbols (collect
,
1271 action_exp
= strchr (action_exp
, ','); /* more? */
1273 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1275 add_local_symbols (collect
,
1281 action_exp
= strchr (action_exp
, ','); /* more? */
1285 unsigned long addr
, len
;
1286 struct cleanup
*old_chain
= NULL
;
1287 struct cleanup
*old_chain1
= NULL
;
1288 struct agent_reqs areqs
;
1290 exp
= parse_exp_1 (&action_exp
,
1291 block_for_pc (tloc
->address
), 1);
1292 old_chain
= make_cleanup (free_current_contents
, &exp
);
1294 switch (exp
->elts
[0].opcode
)
1298 const char *name
= &exp
->elts
[2].string
;
1300 i
= user_reg_map_name_to_regnum (t
->gdbarch
,
1301 name
, strlen (name
));
1303 internal_error (__FILE__
, __LINE__
,
1304 _("Register $%s not available"),
1307 printf_filtered ("OP_REGISTER: ");
1308 add_register (collect
, i
);
1313 /* safe because we know it's a simple expression */
1314 tempval
= evaluate_expression (exp
);
1315 addr
= value_address (tempval
);
1316 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1317 add_memrange (collect
, memrange_absolute
, addr
, len
);
1321 collect_symbol (collect
,
1322 exp
->elts
[2].symbol
,
1329 default: /* full-fledged expression */
1330 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1332 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1334 ax_reqs (aexpr
, &areqs
);
1336 report_agent_reqs_errors (aexpr
, &areqs
);
1338 discard_cleanups (old_chain1
);
1339 add_aexpr (collect
, aexpr
);
1341 /* take care of the registers */
1342 if (areqs
.reg_mask_len
> 0)
1347 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1349 QUIT
; /* allow user to bail out with ^C */
1350 if (areqs
.reg_mask
[ndx1
] != 0)
1352 /* assume chars have 8 bits */
1353 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1354 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1355 /* it's used -- record it */
1356 add_register (collect
,
1363 do_cleanups (old_chain
);
1366 while (action_exp
&& *action_exp
++ == ',');
1368 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1371 { /* repeat over a comma-separated list */
1372 QUIT
; /* allow user to bail out with ^C */
1373 while (isspace ((int) *action_exp
))
1377 unsigned long addr
, len
;
1378 struct cleanup
*old_chain
= NULL
;
1379 struct cleanup
*old_chain1
= NULL
;
1380 struct agent_reqs areqs
;
1382 exp
= parse_exp_1 (&action_exp
,
1383 block_for_pc (tloc
->address
), 1);
1384 old_chain
= make_cleanup (free_current_contents
, &exp
);
1386 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1387 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1389 ax_reqs (aexpr
, &areqs
);
1391 report_agent_reqs_errors (aexpr
, &areqs
);
1393 discard_cleanups (old_chain1
);
1394 /* Even though we're not officially collecting, add
1395 to the collect list anyway. */
1396 add_aexpr (collect
, aexpr
);
1398 do_cleanups (old_chain
);
1401 while (action_exp
&& *action_exp
++ == ',');
1403 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1405 /* We check against nested while-stepping when setting
1406 breakpoint action, so no way to run into nested
1408 gdb_assert (stepping_list
);
1410 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
, frame_offset
,
1411 stepping_list
, NULL
);
1414 error (_("Invalid tracepoint command '%s'"), action
->line
);
1418 /* Render all actions into gdb protocol. */
1420 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1421 char ***tdp_actions
, char ***stepping_actions
)
1423 static char tdp_buff
[2048], step_buff
[2048];
1424 char *default_collect_line
= NULL
;
1425 struct command_line
*actions
;
1426 struct command_line
*default_collect_action
= NULL
;
1428 LONGEST frame_offset
;
1429 struct cleanup
*back_to
;
1431 back_to
= make_cleanup (null_cleanup
, NULL
);
1433 clear_collection_list (&tracepoint_list
);
1434 clear_collection_list (&stepping_list
);
1436 *tdp_actions
= NULL
;
1437 *stepping_actions
= NULL
;
1439 gdbarch_virtual_frame_pointer (t
->gdbarch
,
1440 t
->loc
->address
, &frame_reg
, &frame_offset
);
1442 actions
= t
->commands
->commands
;
1444 /* If there are default expressions to collect, make up a collect
1445 action and prepend to the action list to encode. Note that since
1446 validation is per-tracepoint (local var "xyz" might be valid for
1447 one tracepoint and not another, etc), we make up the action on
1448 the fly, and don't cache it. */
1449 if (*default_collect
)
1453 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1454 make_cleanup (xfree
, default_collect_line
);
1456 line
= default_collect_line
;
1457 validate_actionline (&line
, t
);
1459 default_collect_action
= xmalloc (sizeof (struct command_line
));
1460 make_cleanup (xfree
, default_collect_action
);
1461 default_collect_action
->next
= t
->commands
->commands
;
1462 default_collect_action
->line
= line
;
1463 actions
= default_collect_action
;
1465 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1466 &tracepoint_list
, &stepping_list
);
1468 memrange_sortmerge (&tracepoint_list
);
1469 memrange_sortmerge (&stepping_list
);
1471 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1473 *stepping_actions
= stringify_collection_list (&stepping_list
,
1476 do_cleanups (back_to
);
1480 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1482 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1484 collect
->aexpr_list
=
1485 xrealloc (collect
->aexpr_list
,
1486 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1487 collect
->aexpr_listsize
*= 2;
1489 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1490 collect
->next_aexpr_elt
++;
1495 start_tracing (void)
1498 VEC(breakpoint_p
) *tp_vec
= NULL
;
1500 struct breakpoint
*t
;
1501 struct trace_state_variable
*tsv
;
1502 int any_enabled
= 0;
1504 tp_vec
= all_tracepoints ();
1506 /* No point in tracing without any tracepoints... */
1507 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1509 VEC_free (breakpoint_p
, tp_vec
);
1510 error (_("No tracepoints defined, not starting trace"));
1513 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1515 if (t
->enable_state
== bp_enabled
)
1522 /* No point in tracing with only disabled tracepoints. */
1525 VEC_free (breakpoint_p
, tp_vec
);
1526 error (_("No tracepoints enabled, not starting trace"));
1529 target_trace_init ();
1531 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1533 t
->number_on_target
= 0;
1534 target_download_tracepoint (t
);
1535 t
->number_on_target
= t
->number
;
1537 VEC_free (breakpoint_p
, tp_vec
);
1539 /* Send down all the trace state variables too. */
1540 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1542 target_download_trace_state_variable (tsv
);
1545 /* Tell target to treat text-like sections as transparent. */
1546 target_trace_set_readonly_regions ();
1547 /* Set some mode flags. */
1548 target_set_disconnected_tracing (disconnected_tracing
);
1549 target_set_circular_trace_buffer (circular_trace_buffer
);
1551 /* Now insert traps and begin collecting data. */
1552 target_trace_start ();
1554 /* Reset our local state. */
1555 set_traceframe_num (-1);
1556 set_tracepoint_num (-1);
1557 set_traceframe_context (NULL
);
1558 current_trace_status()->running
= 1;
1563 Tell target to clear any previous trace experiment.
1564 Walk the list of tracepoints, and send them (and their actions)
1565 to the target. If no errors,
1566 Tell target to start a new trace experiment. */
1569 trace_start_command (char *args
, int from_tty
)
1571 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1573 if (current_trace_status ()->running
)
1576 && !query (_("A trace is running already. Start a new run? ")))
1577 error (_("New trace run not started."));
1585 trace_stop_command (char *args
, int from_tty
)
1587 if (!current_trace_status ()->running
)
1588 error (_("Trace is not running."));
1596 target_trace_stop ();
1597 /* should change in response to reply? */
1598 current_trace_status ()->running
= 0;
1601 /* tstatus command */
1603 trace_status_command (char *args
, int from_tty
)
1605 struct trace_status
*ts
= current_trace_status ();
1608 status
= target_get_trace_status (ts
);
1613 printf_filtered (_("Using a trace file.\n"));
1616 printf_filtered (_("Trace can not be run on this target.\n"));
1621 if (!ts
->running_known
)
1623 printf_filtered (_("Run/stop status is unknown.\n"));
1625 else if (ts
->running
)
1627 printf_filtered (_("Trace is running on the target.\n"));
1628 if (disconnected_tracing
)
1629 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1631 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1635 switch (ts
->stop_reason
)
1637 case trace_never_run
:
1638 printf_filtered (_("No trace has been run on the target.\n"));
1641 printf_filtered (_("Trace stopped by a tstop command.\n"));
1643 case trace_buffer_full
:
1644 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1646 case trace_disconnected
:
1647 printf_filtered (_("Trace stopped because of disconnection.\n"));
1649 case tracepoint_passcount
:
1650 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1651 ts
->stopping_tracepoint
);
1653 case tracepoint_error
:
1654 if (ts
->stopping_tracepoint
)
1655 printf_filtered (_("Trace stopped by an error (%s, tracepoint %d).\n"),
1656 ts
->error_desc
, ts
->stopping_tracepoint
);
1658 printf_filtered (_("Trace stopped by an error (%s).\n"),
1661 case trace_stop_reason_unknown
:
1662 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1665 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1671 if (ts
->traceframes_created
>= 0
1672 && ts
->traceframe_count
!= ts
->traceframes_created
)
1674 printf_filtered (_("Buffer contains %d trace frames (of %d created total).\n"),
1675 ts
->traceframe_count
, ts
->traceframes_created
);
1677 else if (ts
->traceframe_count
>= 0)
1679 printf_filtered (_("Collected %d trace frames.\n"),
1680 ts
->traceframe_count
);
1683 if (ts
->buffer_free
>= 0)
1685 if (ts
->buffer_size
>= 0)
1687 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1688 ts
->buffer_free
, ts
->buffer_size
);
1689 if (ts
->buffer_size
> 0)
1690 printf_filtered (_(" (%d%% full)"),
1691 ((int) ((((long long) (ts
->buffer_size
1692 - ts
->buffer_free
)) * 100)
1693 / ts
->buffer_size
)));
1694 printf_filtered (_(".\n"));
1697 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1701 /* Now report on what we're doing with tfind. */
1702 if (traceframe_number
>= 0)
1703 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1704 traceframe_number
, tracepoint_number
);
1706 printf_filtered (_("Not looking at any trace frame.\n"));
1709 /* Report the trace status to uiout, in a way suitable for MI, and not
1710 suitable for CLI. If ON_STOP is true, suppress a few fields that
1711 are not meaningful in the -trace-stop response.
1713 The implementation is essentially parallel to trace_status_command, but
1714 merging them will result in unreadable code. */
1716 trace_status_mi (int on_stop
)
1718 struct trace_status
*ts
= current_trace_status ();
1720 char *string_status
;
1722 status
= target_get_trace_status (ts
);
1724 if (status
== -1 && !ts
->from_file
)
1726 ui_out_field_string (uiout
, "supported", "0");
1731 ui_out_field_string (uiout
, "supported", "file");
1733 ui_out_field_string (uiout
, "supported", "1");
1735 gdb_assert (ts
->running_known
);
1739 ui_out_field_string (uiout
, "running", "1");
1741 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1742 Given that the frontend gets the status either on -trace-stop, or from
1743 -trace-status after re-connection, it does not seem like this
1744 information is necessary for anything. It is not necessary for either
1745 figuring the vital state of the target nor for navigation of trace
1746 frames. If the frontend wants to show the current state is some
1747 configure dialog, it can request the value when such dialog is
1748 invoked by the user. */
1752 char *stop_reason
= NULL
;
1753 int stopping_tracepoint
= -1;
1756 ui_out_field_string (uiout
, "running", "0");
1758 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
1760 switch (ts
->stop_reason
)
1763 stop_reason
= "request";
1765 case trace_buffer_full
:
1766 stop_reason
= "overflow";
1768 case trace_disconnected
:
1769 stop_reason
= "disconnection";
1771 case tracepoint_passcount
:
1772 stop_reason
= "passcount";
1773 stopping_tracepoint
= ts
->stopping_tracepoint
;
1775 case tracepoint_error
:
1776 stop_reason
= "error";
1777 stopping_tracepoint
= ts
->stopping_tracepoint
;
1783 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
1784 if (stopping_tracepoint
!= -1)
1785 ui_out_field_int (uiout
, "stopping-tracepoint",
1786 stopping_tracepoint
);
1787 if (ts
->stop_reason
== tracepoint_error
)
1788 ui_out_field_string (uiout
, "error-description",
1795 if ((int) ts
->traceframe_count
!= -1)
1796 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
1797 if ((int) ts
->buffer_size
!= -1)
1798 ui_out_field_int (uiout
, "buffer-size", (int) ts
->buffer_size
);
1799 if ((int) ts
->buffer_free
!= -1)
1800 ui_out_field_int (uiout
, "buffer-free", (int) ts
->buffer_free
);
1805 disconnect_or_stop_tracing (int from_tty
)
1807 /* It can happen that the target that was tracing went away on its
1808 own, and we didn't notice. Get a status update, and if the
1809 current target doesn't even do tracing, then assume it's not
1811 if (target_get_trace_status (current_trace_status ()) < 0)
1812 current_trace_status ()->running
= 0;
1814 if (current_trace_status ()->running
&& from_tty
)
1816 int cont
= query (_("Trace is running. Continue tracing after detach? "));
1817 /* Note that we send the query result without affecting the
1818 user's setting of disconnected_tracing, so that the answer is
1820 send_disconnected_tracing_value (cont
);
1822 /* Also ensure that we do the equivalent of a tstop command if
1823 tracing is not to continue after the detach. */
1828 /* Also we want to be out of tfind mode, otherwise things can get
1829 confusing upon reconnection. Just use these calls instead of
1830 full tfind_1 behavior because we're in the middle of detaching,
1831 and there's no point to updating current stack frame etc. */
1832 set_traceframe_number (-1);
1833 set_traceframe_context (NULL
);
1836 /* Worker function for the various flavors of the tfind command. */
1838 tfind_1 (enum trace_find_type type
, int num
,
1839 ULONGEST addr1
, ULONGEST addr2
,
1842 int target_frameno
= -1, target_tracept
= -1;
1843 struct frame_id old_frame_id
;
1845 struct breakpoint
*tp
;
1847 old_frame_id
= get_frame_id (get_current_frame ());
1849 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
1852 if (type
== tfind_number
1854 && target_frameno
== -1)
1856 /* We told the target to get out of tfind mode, and it did. */
1858 else if (target_frameno
== -1)
1860 /* A request for a non-existant trace frame has failed.
1861 Our response will be different, depending on FROM_TTY:
1863 If FROM_TTY is true, meaning that this command was
1864 typed interactively by the user, then give an error
1865 and DO NOT change the state of traceframe_number etc.
1867 However if FROM_TTY is false, meaning that we're either
1868 in a script, a loop, or a user-defined command, then
1869 DON'T give an error, but DO change the state of
1870 traceframe_number etc. to invalid.
1872 The rationalle is that if you typed the command, you
1873 might just have committed a typo or something, and you'd
1874 like to NOT lose your current debugging state. However
1875 if you're in a user-defined command or especially in a
1876 loop, then you need a way to detect that the command
1877 failed WITHOUT aborting. This allows you to write
1878 scripts that search thru the trace buffer until the end,
1879 and then continue on to do something else. */
1882 error (_("Target failed to find requested trace frame."));
1886 printf_filtered ("End of trace buffer.\n");
1887 #if 0 /* dubious now? */
1888 /* The following will not recurse, since it's
1890 trace_find_command ("-1", from_tty
);
1895 tp
= get_tracepoint_by_number_on_target (target_tracept
);
1897 reinit_frame_cache ();
1898 registers_changed ();
1899 target_dcache_invalidate ();
1900 set_traceframe_num (target_frameno
);
1901 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
1902 if (target_frameno
== -1)
1903 set_traceframe_context (NULL
);
1905 set_traceframe_context (get_current_frame ());
1907 if (traceframe_number
>= 0)
1909 /* Use different branches for MI and CLI to make CLI messages
1911 if (ui_out_is_mi_like_p (uiout
))
1913 ui_out_field_string (uiout
, "found", "1");
1914 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
1915 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
1919 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
1920 traceframe_number
, tracepoint_number
);
1925 if (ui_out_is_mi_like_p (uiout
))
1926 ui_out_field_string (uiout
, "found", "0");
1928 printf_unfiltered (_("No trace frame found"));
1931 /* If we're in nonstop mode and getting out of looking at trace
1932 frames, there won't be any current frame to go back to and
1935 && (has_stack_frames () || traceframe_number
>= 0))
1937 enum print_what print_what
;
1939 /* NOTE: in immitation of the step command, try to determine
1940 whether we have made a transition from one function to
1941 another. If so, we'll print the "stack frame" (ie. the new
1942 function and it's arguments) -- otherwise we'll just show the
1945 if (frame_id_eq (old_frame_id
,
1946 get_frame_id (get_current_frame ())))
1947 print_what
= SRC_LINE
;
1949 print_what
= SRC_AND_LOC
;
1951 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
1956 /* trace_find_command takes a trace frame number n,
1957 sends "QTFrame:<n>" to the target,
1958 and accepts a reply that may contain several optional pieces
1959 of information: a frame number, a tracepoint number, and an
1960 indication of whether this is a trap frame or a stepping frame.
1962 The minimal response is just "OK" (which indicates that the
1963 target does not give us a frame number or a tracepoint number).
1964 Instead of that, the target may send us a string containing
1966 F<hexnum> (gives the selected frame number)
1967 T<hexnum> (gives the selected tracepoint number)
1972 trace_find_command (char *args
, int from_tty
)
1973 { /* this should only be called with a numeric argument */
1976 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1977 error ("May not look at trace frames while trace is running.");
1979 if (args
== 0 || *args
== 0)
1980 { /* TFIND with no args means find NEXT trace frame. */
1981 if (traceframe_number
== -1)
1982 frameno
= 0; /* "next" is first one */
1984 frameno
= traceframe_number
+ 1;
1986 else if (0 == strcmp (args
, "-"))
1988 if (traceframe_number
== -1)
1989 error (_("not debugging trace buffer"));
1990 else if (from_tty
&& traceframe_number
== 0)
1991 error (_("already at start of trace buffer"));
1993 frameno
= traceframe_number
- 1;
1995 /* A hack to work around eval's need for fp to have been collected. */
1996 else if (0 == strcmp (args
, "-1"))
1999 frameno
= parse_and_eval_long (args
);
2002 error (_("invalid input (%d is less than zero)"), frameno
);
2004 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2009 trace_find_end_command (char *args
, int from_tty
)
2011 trace_find_command ("-1", from_tty
);
2016 trace_find_none_command (char *args
, int from_tty
)
2018 trace_find_command ("-1", from_tty
);
2023 trace_find_start_command (char *args
, int from_tty
)
2025 trace_find_command ("0", from_tty
);
2028 /* tfind pc command */
2030 trace_find_pc_command (char *args
, int from_tty
)
2035 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2036 error ("May not look at trace frames while trace is running.");
2038 if (args
== 0 || *args
== 0)
2039 pc
= regcache_read_pc (get_current_regcache ());
2041 pc
= parse_and_eval_address (args
);
2043 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2046 /* tfind tracepoint command */
2048 trace_find_tracepoint_command (char *args
, int from_tty
)
2051 struct breakpoint
*tp
;
2053 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2054 error ("May not look at trace frames while trace is running.");
2056 if (args
== 0 || *args
== 0)
2058 if (tracepoint_number
== -1)
2059 error (_("No current tracepoint -- please supply an argument."));
2061 tdp
= tracepoint_number
; /* default is current TDP */
2064 tdp
= parse_and_eval_long (args
);
2066 /* If we have the tracepoint on hand, use the number that the
2067 target knows about (which may be different if we disconnected
2068 and reconnected). */
2069 tp
= get_tracepoint (tdp
);
2071 tdp
= tp
->number_on_target
;
2073 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2076 /* TFIND LINE command:
2078 This command will take a sourceline for argument, just like BREAK
2079 or TRACE (ie. anything that "decode_line_1" can handle).
2081 With no argument, this command will find the next trace frame
2082 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2085 trace_find_line_command (char *args
, int from_tty
)
2087 static CORE_ADDR start_pc
, end_pc
;
2088 struct symtabs_and_lines sals
;
2089 struct symtab_and_line sal
;
2090 struct cleanup
*old_chain
;
2091 char startpc_str
[40], endpc_str
[40];
2093 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2094 error ("May not look at trace frames while trace is running.");
2096 if (args
== 0 || *args
== 0)
2098 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2100 sals
.sals
= (struct symtab_and_line
*)
2101 xmalloc (sizeof (struct symtab_and_line
));
2106 sals
= decode_line_spec (args
, 1);
2110 old_chain
= make_cleanup (xfree
, sals
.sals
);
2111 if (sal
.symtab
== 0)
2112 error (_("No line number information available."));
2114 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2116 if (start_pc
== end_pc
)
2118 printf_filtered ("Line %d of \"%s\"",
2119 sal
.line
, sal
.symtab
->filename
);
2121 printf_filtered (" is at address ");
2122 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2124 printf_filtered (" but contains no code.\n");
2125 sal
= find_pc_line (start_pc
, 0);
2127 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2128 && start_pc
!= end_pc
)
2129 printf_filtered ("Attempting to find line %d instead.\n",
2132 error (_("Cannot find a good line."));
2136 /* Is there any case in which we get here, and have an address
2137 which the user would want to see? If we have debugging
2138 symbols and no line numbers? */
2139 error (_("Line number %d is out of range for \"%s\"."),
2140 sal
.line
, sal
.symtab
->filename
);
2142 /* Find within range of stated line. */
2144 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2146 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2147 do_cleanups (old_chain
);
2150 /* tfind range command */
2152 trace_find_range_command (char *args
, int from_tty
)
2154 static CORE_ADDR start
, stop
;
2155 char start_str
[40], stop_str
[40];
2158 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2159 error ("May not look at trace frames while trace is running.");
2161 if (args
== 0 || *args
== 0)
2162 { /* XXX FIXME: what should default behavior be? */
2163 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2167 if (0 != (tmp
= strchr (args
, ',')))
2169 *tmp
++ = '\0'; /* terminate start address */
2170 while (isspace ((int) *tmp
))
2172 start
= parse_and_eval_address (args
);
2173 stop
= parse_and_eval_address (tmp
);
2176 { /* no explicit end address? */
2177 start
= parse_and_eval_address (args
);
2178 stop
= start
+ 1; /* ??? */
2181 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2184 /* tfind outside command */
2186 trace_find_outside_command (char *args
, int from_tty
)
2188 CORE_ADDR start
, stop
;
2189 char start_str
[40], stop_str
[40];
2192 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2193 error ("May not look at trace frames while trace is running.");
2195 if (args
== 0 || *args
== 0)
2196 { /* XXX FIXME: what should default behavior be? */
2197 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2201 if (0 != (tmp
= strchr (args
, ',')))
2203 *tmp
++ = '\0'; /* terminate start address */
2204 while (isspace ((int) *tmp
))
2206 start
= parse_and_eval_address (args
);
2207 stop
= parse_and_eval_address (tmp
);
2210 { /* no explicit end address? */
2211 start
= parse_and_eval_address (args
);
2212 stop
= start
+ 1; /* ??? */
2215 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2218 /* info scope command: list the locals for a scope. */
2220 scope_info (char *args
, int from_tty
)
2222 struct symtabs_and_lines sals
;
2224 struct minimal_symbol
*msym
;
2225 struct block
*block
;
2226 char **canonical
, *symname
, *save_args
= args
;
2227 struct dict_iterator iter
;
2229 struct gdbarch
*gdbarch
;
2232 if (args
== 0 || *args
== 0)
2233 error (_("requires an argument (function, line or *addr) to define a scope"));
2235 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2236 if (sals
.nelts
== 0)
2237 return; /* presumably decode_line_1 has already warned */
2239 /* Resolve line numbers to PC */
2240 resolve_sal_pc (&sals
.sals
[0]);
2241 block
= block_for_pc (sals
.sals
[0].pc
);
2245 QUIT
; /* allow user to bail out with ^C */
2246 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2248 QUIT
; /* allow user to bail out with ^C */
2250 printf_filtered ("Scope for %s:\n", save_args
);
2253 symname
= SYMBOL_PRINT_NAME (sym
);
2254 if (symname
== NULL
|| *symname
== '\0')
2255 continue; /* probably botched, certainly useless */
2257 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2259 printf_filtered ("Symbol %s is ", symname
);
2260 switch (SYMBOL_CLASS (sym
))
2263 case LOC_UNDEF
: /* messed up symbol? */
2264 printf_filtered ("a bogus symbol, class %d.\n",
2265 SYMBOL_CLASS (sym
));
2266 count
--; /* don't count this one */
2269 printf_filtered ("a constant with value %ld (0x%lx)",
2270 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2272 case LOC_CONST_BYTES
:
2273 printf_filtered ("constant bytes: ");
2274 if (SYMBOL_TYPE (sym
))
2275 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2276 fprintf_filtered (gdb_stdout
, " %02x",
2277 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2280 printf_filtered ("in static storage at address ");
2281 printf_filtered ("%s", paddress (gdbarch
,
2282 SYMBOL_VALUE_ADDRESS (sym
)));
2285 /* GDBARCH is the architecture associated with the objfile
2286 the symbol is defined in; the target architecture may be
2287 different, and may provide additional registers. However,
2288 we do not know the target architecture at this point.
2289 We assume the objfile architecture will contain all the
2290 standard registers that occur in debug info in that
2292 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2294 if (SYMBOL_IS_ARGUMENT (sym
))
2295 printf_filtered ("an argument in register $%s",
2296 gdbarch_register_name (gdbarch
, regno
));
2298 printf_filtered ("a local variable in register $%s",
2299 gdbarch_register_name (gdbarch
, regno
));
2302 printf_filtered ("an argument at stack/frame offset %ld",
2303 SYMBOL_VALUE (sym
));
2306 printf_filtered ("a local variable at frame offset %ld",
2307 SYMBOL_VALUE (sym
));
2310 printf_filtered ("a reference argument at offset %ld",
2311 SYMBOL_VALUE (sym
));
2313 case LOC_REGPARM_ADDR
:
2314 /* Note comment at LOC_REGISTER. */
2315 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2316 printf_filtered ("the address of an argument, in register $%s",
2317 gdbarch_register_name (gdbarch
, regno
));
2320 printf_filtered ("a typedef.\n");
2323 printf_filtered ("a label at address ");
2324 printf_filtered ("%s", paddress (gdbarch
,
2325 SYMBOL_VALUE_ADDRESS (sym
)));
2328 printf_filtered ("a function at address ");
2329 printf_filtered ("%s",
2330 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2332 case LOC_UNRESOLVED
:
2333 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2336 printf_filtered ("Unresolved Static");
2339 printf_filtered ("static storage at address ");
2340 printf_filtered ("%s",
2341 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2344 case LOC_OPTIMIZED_OUT
:
2345 printf_filtered ("optimized out.\n");
2348 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, gdb_stdout
);
2351 if (SYMBOL_TYPE (sym
))
2352 printf_filtered (", length %d.\n",
2353 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2355 if (BLOCK_FUNCTION (block
))
2358 block
= BLOCK_SUPERBLOCK (block
);
2361 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2365 /* worker function (cleanup) */
2367 replace_comma (void *data
)
2375 trace_dump_command (char *args
, int from_tty
)
2377 struct regcache
*regcache
;
2378 struct gdbarch
*gdbarch
;
2379 struct breakpoint
*t
;
2380 struct command_line
*action
;
2381 char *action_exp
, *next_comma
;
2382 struct cleanup
*old_cleanups
;
2383 int stepping_actions
= 0;
2384 int stepping_frame
= 0;
2385 struct bp_location
*loc
;
2387 if (tracepoint_number
== -1)
2389 warning (_("No current trace frame."));
2393 t
= get_tracepoint (tracepoint_number
);
2396 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2399 old_cleanups
= make_cleanup (null_cleanup
, NULL
);
2401 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2402 tracepoint_number
, traceframe_number
);
2404 /* The current frame is a trap frame if the frame PC is equal
2405 to the tracepoint PC. If not, then the current frame was
2406 collected during single-stepping. */
2408 regcache
= get_current_regcache ();
2409 gdbarch
= get_regcache_arch (regcache
);
2411 /* If the traceframe's address matches any of the tracepoint's
2412 locations, assume it is a direct hit rather than a while-stepping
2413 frame. (FIXME this is not reliable, should record each frame's
2416 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2417 if (loc
->address
== regcache_read_pc (regcache
))
2420 for (action
= t
->commands
->commands
; action
; action
= action
->next
)
2422 struct cmd_list_element
*cmd
;
2424 QUIT
; /* allow user to bail out with ^C */
2425 action_exp
= action
->line
;
2426 while (isspace ((int) *action_exp
))
2429 /* The collection actions to be done while stepping are
2430 bracketed by the commands "while-stepping" and "end". */
2432 if (*action_exp
== '#') /* comment line */
2435 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2437 error (_("Bad action list item: %s"), action_exp
);
2439 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2440 stepping_actions
= 1;
2441 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2442 stepping_actions
= 0;
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
== ',');
2488 discard_cleanups (old_cleanups
);
2491 /* Encode a piece of a tracepoint's source-level definition in a form
2492 that is suitable for both protocol and saving in files. */
2493 /* This version does not do multiple encodes for long strings; it should
2494 return an offset to the next piece to encode. FIXME */
2497 encode_source_string (int tpnum
, ULONGEST addr
,
2498 char *srctype
, char *src
, char *buf
, int buf_size
)
2500 if (80 + strlen (srctype
) > buf_size
)
2501 error (_("Buffer too small for source encoding"));
2502 sprintf (buf
, "%x:%s:%s:%x:%x:",
2503 tpnum
, phex_nz (addr
, sizeof (addr
)), srctype
, 0, (int) strlen (src
));
2504 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2505 error (_("Source string too long for buffer"));
2506 bin2hex (src
, buf
+ strlen (buf
), 0);
2510 extern int trace_regblock_size
;
2512 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2513 non-zero, the save is performed on the target, otherwise GDB obtains all
2514 trace data and saves it locally. */
2517 trace_save (const char *filename
, int target_does_save
)
2519 struct cleanup
*cleanup
;
2521 struct trace_status
*ts
= current_trace_status ();
2524 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2525 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2527 struct uploaded_string
*cmd
;
2529 ULONGEST offset
= 0;
2530 #define MAX_TRACE_UPLOAD 2000
2531 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2534 /* If the target is to save the data to a file on its own, then just
2535 send the command and be done with it. */
2536 if (target_does_save
)
2538 err
= target_save_trace_data (filename
);
2540 error (_("Target failed to save trace data to '%s'."),
2545 /* Get the trace status first before opening the file, so if the
2546 target is losing, we can get out without touching files. */
2547 status
= target_get_trace_status (ts
);
2549 pathname
= tilde_expand (filename
);
2550 cleanup
= make_cleanup (xfree
, pathname
);
2552 fp
= fopen (pathname
, "w");
2554 error (_("Unable to open file '%s' for saving trace data (%s)"),
2555 filename
, safe_strerror (errno
));
2556 make_cleanup_fclose (fp
);
2558 /* Write a file header, with a high-bit-set char to indicate a
2559 binary file, plus a hint as what this file is, and a version
2560 number in case of future needs. */
2561 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2563 perror_with_name (pathname
);
2565 /* Write descriptive info. */
2567 /* Write out the size of a register block. */
2568 fprintf (fp
, "R %x\n", trace_regblock_size
);
2570 /* Write out status of the tracing run (aka "tstatus" info). */
2571 fprintf (fp
, "status %c;%s",
2572 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
2573 if (ts
->stop_reason
== tracepoint_error
)
2575 char *buf
= (char *) alloca (strlen (ts
->error_desc
) * 2 + 1);
2576 bin2hex ((gdb_byte
*) ts
->error_desc
, buf
, 0);
2577 fprintf (fp
, ":%s", buf
);
2579 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
2580 if (ts
->traceframe_count
>= 0)
2581 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
2582 if (ts
->traceframes_created
>= 0)
2583 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
2584 if (ts
->buffer_free
>= 0)
2585 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
2586 if (ts
->buffer_size
>= 0)
2587 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
2590 /* Note that we want to upload tracepoints and save those, rather
2591 than simply writing out the local ones, because the user may have
2592 changed tracepoints in GDB in preparation for a future tracing
2593 run, or maybe just mass-deleted all types of breakpoints as part
2594 of cleaning up. So as not to contaminate the session, leave the
2595 data in its uploaded form, don't make into real tracepoints. */
2597 /* Get trace state variables first, they may be checked when parsing
2598 uploaded commands. */
2600 target_upload_trace_state_variables (&uploaded_tsvs
);
2602 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2608 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
2609 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
2612 fprintf (fp
, "tsv %x:%s:%x:%s\n",
2613 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
2614 utsv
->builtin
, buf
);
2620 free_uploaded_tsvs (&uploaded_tsvs
);
2622 target_upload_tracepoints (&uploaded_tps
);
2624 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
2626 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
2627 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2628 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
2629 if (utp
->type
== bp_fast_tracepoint
)
2630 fprintf (fp
, ":F%x", utp
->orig_size
);
2632 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
2635 for (a
= 0; a
< utp
->numactions
; ++a
)
2636 fprintf (fp
, "tp A%x:%s:%s\n",
2637 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2639 for (a
= 0; a
< utp
->num_step_actions
; ++a
)
2640 fprintf (fp
, "tp S%x:%s:%s\n",
2641 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2642 utp
->step_actions
[a
]);
2645 encode_source_string (utp
->number
, utp
->addr
,
2646 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
2647 fprintf (fp
, "tp Z%s\n", buf
);
2649 if (utp
->cond_string
)
2651 encode_source_string (utp
->number
, utp
->addr
,
2652 "cond", utp
->cond_string
, buf
, MAX_TRACE_UPLOAD
);
2653 fprintf (fp
, "tp Z%s\n", buf
);
2655 for (cmd
= utp
->cmd_strings
; cmd
; cmd
= cmd
->next
)
2657 encode_source_string (utp
->number
, utp
->addr
, "cmd", cmd
->str
,
2658 buf
, MAX_TRACE_UPLOAD
);
2659 fprintf (fp
, "tp Z%s\n", buf
);
2663 free_uploaded_tps (&uploaded_tps
);
2665 /* Mark the end of the definition section. */
2668 /* Get and write the trace data proper. We ask for big blocks, in
2669 the hopes of efficiency, but will take less if the target has
2670 packet size limitations or some such. */
2673 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
2675 error (_("Failure to get requested trace buffer data"));
2676 /* No more data is forthcoming, we're done. */
2679 written
= fwrite (buf
, gotten
, 1, fp
);
2681 perror_with_name (pathname
);
2685 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
2686 written
= fwrite (&gotten
, 4, 1, fp
);
2688 perror_with_name (pathname
);
2690 do_cleanups (cleanup
);
2694 trace_save_command (char *args
, int from_tty
)
2696 int target_does_save
= 0;
2698 char *filename
= NULL
;
2699 struct cleanup
*back_to
;
2702 error_no_arg (_("file in which to save trace data"));
2704 argv
= gdb_buildargv (args
);
2705 back_to
= make_cleanup_freeargv (argv
);
2707 for (; *argv
; ++argv
)
2709 if (strcmp (*argv
, "-r") == 0)
2710 target_does_save
= 1;
2711 else if (**argv
== '-')
2712 error (_("unknown option `%s'"), *argv
);
2718 error_no_arg (_("file in which to save trace data"));
2720 trace_save (filename
, target_does_save
);
2723 printf_filtered (_("Trace data saved to file '%s'.\n"), args
);
2725 do_cleanups (back_to
);
2728 /* Tell the target what to do with an ongoing tracing run if GDB
2729 disconnects for some reason. */
2732 send_disconnected_tracing_value (int value
)
2734 target_set_disconnected_tracing (value
);
2738 set_disconnected_tracing (char *args
, int from_tty
,
2739 struct cmd_list_element
*c
)
2741 send_disconnected_tracing_value (disconnected_tracing
);
2745 set_circular_trace_buffer (char *args
, int from_tty
,
2746 struct cmd_list_element
*c
)
2748 target_set_circular_trace_buffer (circular_trace_buffer
);
2751 /* Convert the memory pointed to by mem into hex, placing result in buf.
2752 * Return a pointer to the last char put in buf (null)
2753 * "stolen" from sparc-stub.c
2756 static const char hexchars
[] = "0123456789abcdef";
2759 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2767 *buf
++ = hexchars
[ch
>> 4];
2768 *buf
++ = hexchars
[ch
& 0xf];
2777 get_traceframe_number (void)
2779 return traceframe_number
;
2782 /* Make the traceframe NUM be the current trace frame. Does nothing
2783 if NUM is already current. */
2786 set_traceframe_number (int num
)
2790 if (traceframe_number
== num
)
2792 /* Nothing to do. */
2796 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
2799 warning (_("could not change traceframe"));
2801 traceframe_number
= newnum
;
2803 /* Changing the traceframe changes our view of registers and of the
2805 registers_changed ();
2808 /* A cleanup used when switching away and back from tfind mode. */
2810 struct current_traceframe_cleanup
2812 /* The traceframe we were inspecting. */
2813 int traceframe_number
;
2817 do_restore_current_traceframe_cleanup (void *arg
)
2819 struct current_traceframe_cleanup
*old
= arg
;
2821 set_traceframe_number (old
->traceframe_number
);
2825 restore_current_traceframe_cleanup_dtor (void *arg
)
2827 struct current_traceframe_cleanup
*old
= arg
;
2833 make_cleanup_restore_current_traceframe (void)
2835 struct current_traceframe_cleanup
*old
;
2837 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
2838 old
->traceframe_number
= traceframe_number
;
2840 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
2841 restore_current_traceframe_cleanup_dtor
);
2844 /* Given a number and address, return an uploaded tracepoint with that
2845 number, creating if necessary. */
2847 struct uploaded_tp
*
2848 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
2850 struct uploaded_tp
*utp
;
2852 for (utp
= *utpp
; utp
; utp
= utp
->next
)
2853 if (utp
->number
== num
&& utp
->addr
== addr
)
2855 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
2856 memset (utp
, 0, sizeof (struct uploaded_tp
));
2865 free_uploaded_tps (struct uploaded_tp
**utpp
)
2867 struct uploaded_tp
*next_one
;
2871 next_one
= (*utpp
)->next
;
2877 /* Given a number and address, return an uploaded tracepoint with that
2878 number, creating if necessary. */
2880 struct uploaded_tsv
*
2881 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
2883 struct uploaded_tsv
*utsv
;
2885 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
2886 if (utsv
->number
== num
)
2888 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
2889 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
2891 utsv
->next
= *utsvp
;
2897 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
2899 struct uploaded_tsv
*next_one
;
2903 next_one
= (*utsvp
)->next
;
2909 /* Look for an existing tracepoint that seems similar enough to the
2910 uploaded one. Enablement isn't compared, because the user can
2911 toggle that freely, and may have done so in anticipation of the
2915 find_matching_tracepoint (struct uploaded_tp
*utp
)
2917 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
2919 struct breakpoint
*t
;
2920 struct bp_location
*loc
;
2922 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2924 if (t
->type
== utp
->type
2925 && t
->step_count
== utp
->step
2926 && t
->pass_count
== utp
->pass
2927 /* FIXME also test conditionals and actions */
2930 /* Scan the locations for an address match. */
2931 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2933 if (loc
->address
== utp
->addr
)
2941 /* Given a list of tracepoints uploaded from a target, attempt to
2942 match them up with existing tracepoints, and create new ones if not
2946 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
2948 struct uploaded_tp
*utp
;
2949 struct breakpoint
*t
;
2951 /* Look for GDB tracepoints that match up with our uploaded versions. */
2952 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
2954 t
= find_matching_tracepoint (utp
);
2956 printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
2957 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2960 t
= create_tracepoint_from_upload (utp
);
2962 printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
2963 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2965 printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
2966 utp
->number
, paddress (get_current_arch (), utp
->addr
));
2968 /* Whether found or created, record the number used by the
2969 target, to help with mapping target tracepoints back to their
2970 counterparts here. */
2972 t
->number_on_target
= utp
->number
;
2975 free_uploaded_tps (uploaded_tps
);
2978 /* Trace state variables don't have much to identify them beyond their
2979 name, so just use that to detect matches. */
2981 struct trace_state_variable
*
2982 find_matching_tsv (struct uploaded_tsv
*utsv
)
2987 return find_trace_state_variable (utsv
->name
);
2990 struct trace_state_variable
*
2991 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
2993 const char *namebase
;
2996 struct trace_state_variable
*tsv
;
3000 namebase
= utsv
->name
;
3001 sprintf (buf
, "%s", namebase
);
3006 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3009 /* Fish for a name that is not in use. */
3010 /* (should check against all internal vars?) */
3011 while (find_trace_state_variable (buf
))
3012 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3014 /* We have an available name, create the variable. */
3015 tsv
= create_trace_state_variable (xstrdup (buf
));
3016 tsv
->initial_value
= utsv
->initial_value
;
3017 tsv
->builtin
= utsv
->builtin
;
3022 /* Given a list of uploaded trace state variables, try to match them
3023 up with existing variables, or create additional ones. */
3026 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3029 struct uploaded_tsv
*utsv
;
3030 struct trace_state_variable
*tsv
;
3033 /* Most likely some numbers will have to be reassigned as part of
3034 the merge, so clear them all in anticipation. */
3035 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3038 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3040 tsv
= find_matching_tsv (utsv
);
3042 printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
3043 tsv
->name
, utsv
->number
);
3046 tsv
= create_tsv_from_upload (utsv
);
3047 printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
3048 tsv
->name
, utsv
->number
);
3050 /* Give precedence to numberings that come from the target. */
3052 tsv
->number
= utsv
->number
;
3055 /* Renumber everything that didn't get a target-assigned number. */
3057 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3058 if (tsv
->number
> highest
)
3059 highest
= tsv
->number
;
3062 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3063 if (tsv
->number
== 0)
3064 tsv
->number
= highest
++;
3066 free_uploaded_tsvs (uploaded_tsvs
);
3069 /* target tfile command */
3071 struct target_ops tfile_ops
;
3073 /* Fill in tfile_ops with its defined operations and properties. */
3075 #define TRACE_HEADER_SIZE 8
3077 char *trace_filename
;
3079 off_t trace_frames_offset
;
3082 int trace_regblock_size
;
3084 static void tfile_interp_line (char *line
,
3085 struct uploaded_tp
**utpp
,
3086 struct uploaded_tsv
**utsvp
);
3089 tfile_open (char *filename
, int from_tty
)
3092 struct cleanup
*old_chain
;
3095 char header
[TRACE_HEADER_SIZE
];
3096 char linebuf
[1000]; /* should be max remote packet size or so */
3098 int bytes
, i
, gotten
;
3099 struct trace_status
*ts
;
3100 struct uploaded_tp
*uploaded_tps
= NULL
;
3101 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3103 target_preopen (from_tty
);
3105 error (_("No trace file specified."));
3107 filename
= tilde_expand (filename
);
3108 if (!IS_ABSOLUTE_PATH(filename
))
3110 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
3115 old_chain
= make_cleanup (xfree
, filename
);
3117 flags
= O_BINARY
| O_LARGEFILE
;
3119 scratch_chan
= open (filename
, flags
, 0);
3120 if (scratch_chan
< 0)
3121 perror_with_name (filename
);
3123 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3125 discard_cleanups (old_chain
); /* Don't free filename any more */
3126 unpush_target (&tfile_ops
);
3128 push_target (&tfile_ops
);
3130 trace_filename
= xstrdup (filename
);
3131 trace_fd
= scratch_chan
;
3134 /* Read the file header and test for validity. */
3135 gotten
= read (trace_fd
, &header
, TRACE_HEADER_SIZE
);
3137 perror_with_name (trace_filename
);
3138 else if (gotten
< TRACE_HEADER_SIZE
)
3139 error (_("Premature end of file while reading trace file"));
3141 bytes
+= TRACE_HEADER_SIZE
;
3142 if (!(header
[0] == 0x7f
3143 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3144 error (_("File is not a valid trace file."));
3146 trace_regblock_size
= 0;
3147 ts
= current_trace_status ();
3148 /* We know we're working with a file. */
3150 /* Set defaults in case there is no status line. */
3151 ts
->running_known
= 0;
3152 ts
->stop_reason
= trace_stop_reason_unknown
;
3153 ts
->traceframe_count
= -1;
3154 ts
->buffer_free
= 0;
3156 /* Read through a section of newline-terminated lines that
3157 define things like tracepoints. */
3161 gotten
= read (trace_fd
, &byte
, 1);
3163 perror_with_name (trace_filename
);
3164 else if (gotten
< 1)
3165 error (_("Premature end of file while reading trace file"));
3170 /* Empty line marks end of the definition section. */
3175 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3178 linebuf
[i
++] = byte
;
3180 error (_("Excessively long lines in trace file"));
3183 /* Add the file's tracepoints and variables into the current mix. */
3185 /* Get trace state variables first, they may be checked when parsing
3186 uploaded commands. */
3187 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3189 merge_uploaded_tracepoints (&uploaded_tps
);
3191 /* Record the starting offset of the binary trace data. */
3192 trace_frames_offset
= bytes
;
3194 /* If we don't have a blocksize, we can't interpret the
3196 if (trace_regblock_size
== 0)
3197 error (_("No register block size recorded in trace file"));
3198 if (ts
->traceframe_count
<= 0)
3200 warning ("No traceframes present in this file.");
3204 #define TFILE_PID (1)
3205 inferior_appeared (current_inferior (), TFILE_PID
);
3206 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3207 add_thread_silent (inferior_ptid
);
3209 post_create_inferior (&tfile_ops
, from_tty
);
3212 /* FIXME this will get defined in MI patch submission */
3213 tfind_1 (tfind_number
, 0, 0, 0, 0);
3217 /* Interpret the given line from the definitions part of the trace
3221 tfile_interp_line (char *line
,
3222 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3226 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3229 trace_regblock_size
= strtol (p
, &p
, 16);
3231 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3233 p
+= strlen ("status ");
3234 parse_trace_status (p
, current_trace_status ());
3236 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3238 p
+= strlen ("tp ");
3239 parse_tracepoint_definition (p
, utpp
);
3241 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3243 p
+= strlen ("tsv ");
3244 parse_tsv_definition (p
, utsvp
);
3247 warning ("Ignoring trace file definition \"%s\"", line
);
3250 /* Parse the part of trace status syntax that is shared between
3251 the remote protocol and the trace file reader. */
3253 extern char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
3256 parse_trace_status (char *line
, struct trace_status
*ts
)
3258 char *p
= line
, *p1
, *p2
, *p_temp
;
3261 ts
->running_known
= 1;
3262 ts
->running
= (*p
++ == '1');
3263 ts
->stop_reason
= trace_stop_reason_unknown
;
3264 xfree (ts
->error_desc
);
3265 ts
->error_desc
= NULL
;
3266 ts
->traceframe_count
= -1;
3267 ts
->traceframes_created
= -1;
3268 ts
->buffer_free
= -1;
3269 ts
->buffer_size
= -1;
3273 p1
= strchr (p
, ':');
3275 error (_("Malformed trace status, at %s\n\
3276 Status line: '%s'\n"), p
, line
);
3277 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3279 p
= unpack_varlen_hex (++p1
, &val
);
3280 ts
->stop_reason
= trace_buffer_full
;
3282 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3284 p
= unpack_varlen_hex (++p1
, &val
);
3285 ts
->stop_reason
= trace_never_run
;
3287 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
], p1
- p
) == 0)
3289 p
= unpack_varlen_hex (++p1
, &val
);
3290 ts
->stop_reason
= tracepoint_passcount
;
3291 ts
->stopping_tracepoint
= val
;
3293 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3295 p
= unpack_varlen_hex (++p1
, &val
);
3296 ts
->stop_reason
= tstop_command
;
3298 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3300 p2
= strchr (++p1
, ':');
3305 ts
->error_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3306 end
= hex2bin (p1
, ts
->error_desc
, (p2
- p1
) / 2);
3307 ts
->error_desc
[end
] = '\0';
3310 ts
->error_desc
= xstrdup ("");
3312 p
= unpack_varlen_hex (++p2
, &val
);
3313 ts
->stopping_tracepoint
= val
;
3314 ts
->stop_reason
= tracepoint_error
;
3316 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3318 p
= unpack_varlen_hex (++p1
, &val
);
3319 ts
->traceframe_count
= val
;
3321 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3323 p
= unpack_varlen_hex (++p1
, &val
);
3324 ts
->traceframes_created
= val
;
3326 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3328 p
= unpack_varlen_hex (++p1
, &val
);
3329 ts
->buffer_free
= val
;
3331 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3333 p
= unpack_varlen_hex (++p1
, &val
);
3334 ts
->buffer_size
= val
;
3338 /* Silently skip unknown optional info. */
3339 p_temp
= strchr (p1
+ 1, ';');
3343 /* Must be at the end. */
3349 /* Given a line of text defining a part of a tracepoint, parse it into
3350 an "uploaded tracepoint". */
3353 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3357 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3358 int enabled
, i
, end
;
3360 char *cond
, *srctype
, *src
, *buf
;
3361 struct uploaded_tp
*utp
= NULL
;
3364 /* Both tracepoint and action definitions start with the same number
3365 and address sequence. */
3367 p
= unpack_varlen_hex (p
, &num
);
3368 p
++; /* skip a colon */
3369 p
= unpack_varlen_hex (p
, &addr
);
3370 p
++; /* skip a colon */
3373 enabled
= (*p
++ == 'E');
3374 p
++; /* skip a colon */
3375 p
= unpack_varlen_hex (p
, &step
);
3376 p
++; /* skip a colon */
3377 p
= unpack_varlen_hex (p
, &pass
);
3378 type
= bp_tracepoint
;
3380 /* Thumb through optional fields. */
3383 p
++; /* skip a colon */
3386 type
= bp_fast_tracepoint
;
3388 p
= unpack_varlen_hex (p
, &orig_size
);
3393 p
= unpack_varlen_hex (p
, &xlen
);
3394 p
++; /* skip a comma */
3395 cond
= (char *) xmalloc (2 * xlen
+ 1);
3396 strncpy (cond
, p
, 2 * xlen
);
3397 cond
[2 * xlen
] = '\0';
3401 warning (_("Unrecognized char '%c' in tracepoint definition, skipping rest"), *p
);
3403 utp
= get_uploaded_tp (num
, addr
, utpp
);
3405 utp
->enabled
= enabled
;
3410 else if (piece
== 'A')
3412 utp
= get_uploaded_tp (num
, addr
, utpp
);
3413 utp
->actions
[utp
->numactions
++] = xstrdup (p
);
3415 else if (piece
== 'S')
3417 utp
= get_uploaded_tp (num
, addr
, utpp
);
3418 utp
->step_actions
[utp
->num_step_actions
++] = xstrdup (p
);
3420 else if (piece
== 'Z')
3422 /* Parse a chunk of source form definition. */
3423 utp
= get_uploaded_tp (num
, addr
, utpp
);
3425 p
= strchr (p
, ':');
3426 p
++; /* skip a colon */
3427 p
= unpack_varlen_hex (p
, &start
);
3428 p
++; /* skip a colon */
3429 p
= unpack_varlen_hex (p
, &xlen
);
3430 p
++; /* skip a colon */
3432 buf
= alloca (strlen (line
));
3434 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3437 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
3438 utp
->at_string
= xstrdup (buf
);
3439 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
3440 utp
->cond_string
= xstrdup (buf
);
3441 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
3443 /* FIXME consider using a vector? */
3444 struct uploaded_string
*last
, *newlast
;
3445 newlast
= (struct uploaded_string
*) xmalloc (sizeof (struct uploaded_string
));
3446 newlast
->str
= xstrdup (buf
);
3447 newlast
->next
= NULL
;
3448 if (utp
->cmd_strings
)
3450 for (last
= utp
->cmd_strings
; last
->next
; last
= last
->next
)
3452 last
->next
= newlast
;
3455 utp
->cmd_strings
= newlast
;
3460 /* Don't error out, the target might be sending us optional
3461 info that we don't care about. */
3462 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3466 /* Convert a textual description of a trace state variable into an
3470 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3473 ULONGEST num
, initval
, builtin
;
3475 struct uploaded_tsv
*utsv
= NULL
;
3477 buf
= alloca (strlen (line
));
3480 p
= unpack_varlen_hex (p
, &num
);
3481 p
++; /* skip a colon */
3482 p
= unpack_varlen_hex (p
, &initval
);
3483 p
++; /* skip a colon */
3484 p
= unpack_varlen_hex (p
, &builtin
);
3485 p
++; /* skip a colon */
3486 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3489 utsv
= get_uploaded_tsv (num
, utsvp
);
3490 utsv
->initial_value
= initval
;
3491 utsv
->builtin
= builtin
;
3492 utsv
->name
= xstrdup (buf
);
3495 /* Close the trace file and generally clean up. */
3498 tfile_close (int quitting
)
3505 pid
= ptid_get_pid (inferior_ptid
);
3506 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
3507 exit_inferior_silent (pid
);
3512 xfree (trace_filename
);
3516 tfile_files_info (struct target_ops
*t
)
3518 /* (it would be useful to mention the name of the file) */
3519 printf_filtered ("Looking at a trace file.\n");
3522 /* The trace status for a file is that tracing can never be run. */
3525 tfile_get_trace_status (struct trace_status
*ts
)
3527 /* Other bits of trace status were collected as part of opening the
3528 trace files, so nothing to do here. */
3533 /* Given the position of a traceframe in the file, figure out what
3534 address the frame was collected at. This would normally be the
3535 value of a collected PC register, but if not available, we
3539 tfile_get_traceframe_address (off_t tframe_offset
)
3543 struct breakpoint
*tp
;
3544 off_t saved_offset
= cur_offset
;
3547 /* FIXME dig pc out of collected registers */
3549 /* Fall back to using tracepoint address. */
3550 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
3551 gotten
= read (trace_fd
, &tpnum
, 2);
3553 perror_with_name (trace_filename
);
3554 else if (gotten
< 2)
3555 error (_("Premature end of file while reading trace file"));
3557 tp
= get_tracepoint_by_number_on_target (tpnum
);
3558 /* FIXME this is a poor heuristic if multiple locations */
3560 addr
= tp
->loc
->address
;
3562 /* Restore our seek position. */
3563 cur_offset
= saved_offset
;
3564 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3568 /* Given a type of search and some parameters, scan the collection of
3569 traceframes in the file looking for a match. When found, return
3570 both the traceframe and tracepoint number, otherwise -1 for
3574 tfile_trace_find (enum trace_find_type type
, int num
,
3575 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
3578 int tfnum
= 0, found
= 0, gotten
;
3580 struct breakpoint
*tp
;
3581 off_t offset
, tframe_offset
;
3584 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
3585 offset
= trace_frames_offset
;
3588 tframe_offset
= offset
;
3589 gotten
= read (trace_fd
, &tpnum
, 2);
3591 perror_with_name (trace_filename
);
3592 else if (gotten
< 2)
3593 error (_("Premature end of file while reading trace file"));
3597 gotten
= read (trace_fd
, &data_size
, 4);
3599 perror_with_name (trace_filename
);
3600 else if (gotten
< 4)
3601 error (_("Premature end of file while reading trace file"));
3610 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3611 if (tfaddr
== addr1
)
3615 tp
= get_tracepoint (num
);
3616 if (tp
&& tpnum
== tp
->number_on_target
)
3620 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3621 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
3625 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3626 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
3630 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
3636 cur_offset
= offset
;
3637 cur_data_size
= data_size
;
3640 /* Skip past the traceframe's data. */
3641 lseek (trace_fd
, data_size
, SEEK_CUR
);
3642 offset
+= data_size
;
3643 /* Update our own count of traceframes. */
3646 /* Did not find what we were looking for. */
3652 /* Look for a block of saved registers in the traceframe, and get the
3653 requested register from it. */
3656 tfile_fetch_registers (struct target_ops
*ops
,
3657 struct regcache
*regcache
, int regno
)
3659 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3661 int i
, pos
, offset
, regn
, regsize
, gotten
;
3662 unsigned short mlen
;
3665 /* An uninitialized reg size says we're not going to be
3666 successful at getting register blocks. */
3667 if (!trace_regblock_size
)
3670 regs
= alloca (trace_regblock_size
);
3672 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3674 while (pos
< cur_data_size
)
3676 gotten
= read (trace_fd
, &block_type
, 1);
3678 perror_with_name (trace_filename
);
3679 else if (gotten
< 1)
3680 error (_("Premature end of file while reading trace file"));
3686 gotten
= read (trace_fd
, regs
, trace_regblock_size
);
3688 perror_with_name (trace_filename
);
3689 else if (gotten
< trace_regblock_size
)
3690 error (_("Premature end of file while reading trace file"));
3692 /* Assume the block is laid out in GDB register number order,
3693 each register with the size that it has in GDB. */
3695 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3697 regsize
= register_size (gdbarch
, regn
);
3698 /* Make sure we stay within block bounds. */
3699 if (offset
+ regsize
>= trace_regblock_size
)
3701 if (!regcache_valid_p (regcache
, regn
))
3705 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
3708 else if (regno
== -1)
3710 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
3717 lseek (trace_fd
, 8, SEEK_CUR
);
3718 gotten
= read (trace_fd
, &mlen
, 2);
3720 perror_with_name (trace_filename
);
3721 else if (gotten
< 2)
3722 error (_("Premature end of file while reading trace file"));
3723 lseek (trace_fd
, mlen
, SEEK_CUR
);
3724 pos
+= (8 + 2 + mlen
);
3727 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3731 error ("Unknown block type '%c' (0x%x) in trace frame",
3732 block_type
, block_type
);
3739 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3740 const char *annex
, gdb_byte
*readbuf
,
3741 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3746 unsigned short mlen
;
3748 /* We're only doing regular memory for now. */
3749 if (object
!= TARGET_OBJECT_MEMORY
)
3752 if (readbuf
== NULL
)
3753 error ("tfile_xfer_partial: trace file is read-only");
3755 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3757 while (pos
< cur_data_size
)
3759 gotten
= read (trace_fd
, &block_type
, 1);
3761 perror_with_name (trace_filename
);
3762 else if (gotten
< 1)
3763 error (_("Premature end of file while reading trace file"));
3768 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3769 pos
+= trace_regblock_size
;
3772 gotten
= read (trace_fd
, &maddr
, 8);
3774 perror_with_name (trace_filename
);
3775 else if (gotten
< 8)
3776 error (_("Premature end of file while reading trace file"));
3778 gotten
= read (trace_fd
, &mlen
, 2);
3780 perror_with_name (trace_filename
);
3781 else if (gotten
< 2)
3782 error (_("Premature end of file while reading trace file"));
3783 if (maddr
<= offset
&& (offset
+ len
) <= (maddr
+ mlen
))
3785 gotten
= read (trace_fd
, readbuf
, mlen
);
3787 perror_with_name (trace_filename
);
3788 else if (gotten
< mlen
)
3789 error (_("Premature end of file qwhile reading trace file"));
3793 lseek (trace_fd
, mlen
, SEEK_CUR
);
3794 pos
+= (8 + 2 + mlen
);
3797 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3801 error ("Unknown block type '%c' (0x%x) in traceframe",
3802 block_type
, block_type
);
3806 /* Indicate failure to find the requested memory block. */
3810 /* Iterate through the blocks of a trace frame, looking for a 'V'
3811 block with a matching tsv number. */
3814 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
3817 int pos
, vnum
, gotten
;
3818 unsigned short mlen
;
3820 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3822 while (pos
< cur_data_size
)
3824 gotten
= read (trace_fd
, &block_type
, 1);
3826 perror_with_name (trace_filename
);
3827 else if (gotten
< 1)
3828 error (_("Premature end of file while reading trace file"));
3833 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3834 pos
+= trace_regblock_size
;
3837 lseek (trace_fd
, 8, SEEK_CUR
);
3838 gotten
= read (trace_fd
, &mlen
, 2);
3840 perror_with_name (trace_filename
);
3841 else if (gotten
< 2)
3842 error (_("Premature end of file while reading trace file"));
3843 lseek (trace_fd
, mlen
, SEEK_CUR
);
3844 pos
+= (8 + 2 + mlen
);
3847 gotten
= read (trace_fd
, &vnum
, 4);
3849 perror_with_name (trace_filename
);
3850 else if (gotten
< 4)
3851 error (_("Premature end of file while reading trace file"));
3854 gotten
= read (trace_fd
, val
, 8);
3856 perror_with_name (trace_filename
);
3857 else if (gotten
< 8)
3858 error (_("Premature end of file while reading trace file"));
3861 lseek (trace_fd
, 8, SEEK_CUR
);
3865 error ("Unknown block type '%c' (0x%x) in traceframe",
3866 block_type
, block_type
);
3870 /* Didn't find anything. */
3875 tfile_has_memory (struct target_ops
*ops
)
3881 tfile_has_stack (struct target_ops
*ops
)
3887 tfile_has_registers (struct target_ops
*ops
)
3893 init_tfile_ops (void)
3895 tfile_ops
.to_shortname
= "tfile";
3896 tfile_ops
.to_longname
= "Local trace dump file";
3898 "Use a trace file as a target. Specify the filename of the trace file.";
3899 tfile_ops
.to_open
= tfile_open
;
3900 tfile_ops
.to_close
= tfile_close
;
3901 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
3902 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
3903 tfile_ops
.to_files_info
= tfile_files_info
;
3904 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
3905 tfile_ops
.to_trace_find
= tfile_trace_find
;
3906 tfile_ops
.to_get_trace_state_variable_value
= tfile_get_trace_state_variable_value
;
3907 /* core_stratum might seem more logical, but GDB doesn't like having
3908 more than one core_stratum vector. */
3909 tfile_ops
.to_stratum
= process_stratum
;
3910 tfile_ops
.to_has_memory
= tfile_has_memory
;
3911 tfile_ops
.to_has_stack
= tfile_has_stack
;
3912 tfile_ops
.to_has_registers
= tfile_has_registers
;
3913 tfile_ops
.to_magic
= OPS_MAGIC
;
3916 /* module initialization */
3918 _initialize_tracepoint (void)
3920 struct cmd_list_element
*c
;
3922 traceframe_number
= -1;
3923 tracepoint_number
= -1;
3925 if (tracepoint_list
.list
== NULL
)
3927 tracepoint_list
.listsize
= 128;
3928 tracepoint_list
.list
= xmalloc
3929 (tracepoint_list
.listsize
* sizeof (struct memrange
));
3931 if (tracepoint_list
.aexpr_list
== NULL
)
3933 tracepoint_list
.aexpr_listsize
= 128;
3934 tracepoint_list
.aexpr_list
= xmalloc
3935 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3938 if (stepping_list
.list
== NULL
)
3940 stepping_list
.listsize
= 128;
3941 stepping_list
.list
= xmalloc
3942 (stepping_list
.listsize
* sizeof (struct memrange
));
3945 if (stepping_list
.aexpr_list
== NULL
)
3947 stepping_list
.aexpr_listsize
= 128;
3948 stepping_list
.aexpr_list
= xmalloc
3949 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3952 add_info ("scope", scope_info
,
3953 _("List the variables local to a scope"));
3955 add_cmd ("tracepoints", class_trace
, NULL
,
3956 _("Tracing of program execution without stopping the program."),
3959 add_com ("tdump", class_trace
, trace_dump_command
,
3960 _("Print everything collected at the current tracepoint."));
3962 add_com ("tsave", class_trace
, trace_save_command
, _("\
3963 Save the trace data to a file.\n\
3964 Use the '-r' option to direct the target to save directly to the file,\n\
3965 using its own filesystem."));
3967 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
3968 Define a trace state variable.\n\
3969 Argument is a $-prefixed name, optionally followed\n\
3970 by '=' and an expression that sets the initial value\n\
3971 at the start of tracing."));
3972 set_cmd_completer (c
, expression_completer
);
3974 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
3975 Delete one or more trace state variables.\n\
3976 Arguments are the names of the variables to delete.\n\
3977 If no arguments are supplied, delete all variables."), &deletelist
);
3978 /* FIXME add a trace variable completer */
3980 add_info ("tvariables", tvariables_info
, _("\
3981 Status of trace state variables and their values.\n\
3984 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
3985 Select a trace frame;\n\
3986 No argument means forward by one frame; '-' means backward by one frame."),
3987 &tfindlist
, "tfind ", 1, &cmdlist
);
3989 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
3990 Select a trace frame whose PC is outside the given range (exclusive).\n\
3991 Usage: tfind outside addr1, addr2"),
3994 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
3995 Select a trace frame whose PC is in the given range (inclusive).\n\
3996 Usage: tfind range addr1,addr2"),
3999 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
4000 Select a trace frame by source line.\n\
4001 Argument can be a line number (with optional source file), \n\
4002 a function name, or '*' followed by an address.\n\
4003 Default argument is 'the next source line that was traced'."),
4006 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
4007 Select a trace frame by tracepoint number.\n\
4008 Default is the tracepoint for the current trace frame."),
4011 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
4012 Select a trace frame by PC.\n\
4013 Default is the current PC, or the PC of the current trace frame."),
4016 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
4017 Synonym for 'none'.\n\
4018 De-select any trace frame and resume 'live' debugging."),
4021 add_cmd ("none", class_trace
, trace_find_none_command
,
4022 _("De-select any trace frame and resume 'live' debugging."),
4025 add_cmd ("start", class_trace
, trace_find_start_command
,
4026 _("Select the first trace frame in the trace buffer."),
4029 add_com ("tstatus", class_trace
, trace_status_command
,
4030 _("Display the status of the current trace data collection."));
4032 add_com ("tstop", class_trace
, trace_stop_command
,
4033 _("Stop trace data collection."));
4035 add_com ("tstart", class_trace
, trace_start_command
,
4036 _("Start trace data collection."));
4038 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
4039 Ends a list of commands or actions.\n\
4040 Several GDB commands allow you to enter a list of commands or actions.\n\
4041 Entering \"end\" on a line by itself is the normal way to terminate\n\
4043 Note: the \"end\" command cannot be used at the gdb prompt."));
4045 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
4046 Specify single-stepping behavior at a tracepoint.\n\
4047 Argument is number of instructions to trace in single-step mode\n\
4048 following the tracepoint. This command is normally followed by\n\
4049 one or more \"collect\" commands, to specify what to collect\n\
4050 while single-stepping.\n\n\
4051 Note: this command can only be used in a tracepoint \"actions\" list."));
4053 add_com_alias ("ws", "while-stepping", class_alias
, 0);
4054 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
4056 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
4057 Specify one or more data items to be collected at a tracepoint.\n\
4058 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4059 collect all data (variables, registers) referenced by that expression.\n\
4060 Also accepts the following special arguments:\n\
4061 $regs -- all registers.\n\
4062 $args -- all function arguments.\n\
4063 $locals -- all variables local to the block/function scope.\n\
4064 Note: this command can only be used in a tracepoint \"actions\" list."));
4066 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4067 Specify one or more expressions to be evaluated at a tracepoint.\n\
4068 Accepts a comma-separated list of (one or more) expressions.\n\
4069 The result of each evaluation will be discarded.\n\
4070 Note: this command can only be used in a tracepoint \"actions\" list."));
4072 add_com ("actions", class_trace
, trace_actions_command
, _("\
4073 Specify the actions to be taken at a tracepoint.\n\
4074 Tracepoint actions may include collecting of specified data, \n\
4075 single-stepping, or enabling/disabling other tracepoints, \n\
4076 depending on target's capabilities."));
4078 default_collect
= xstrdup ("");
4079 add_setshow_string_cmd ("default-collect", class_trace
,
4080 &default_collect
, _("\
4081 Set the list of expressions to collect by default"), _("\
4082 Show the list of expressions to collect by default"), NULL
,
4084 &setlist
, &showlist
);
4086 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4087 &disconnected_tracing
, _("\
4088 Set whether tracing continues after GDB disconnects."), _("\
4089 Show whether tracing continues after GDB disconnects."), _("\
4090 Use this to continue a tracing run even if GDB disconnects\n\
4091 or detaches from the target. You can reconnect later and look at\n\
4092 trace data collected in the meantime."),
4093 set_disconnected_tracing
,
4098 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4099 &circular_trace_buffer
, _("\
4100 Set target's use of circular trace buffer."), _("\
4101 Show target's use of circular trace buffer."), _("\
4102 Use this to make the trace buffer into a circular buffer,\n\
4103 which will discard traceframes (oldest first) instead of filling\n\
4104 up and stopping the trace run."),
4105 set_circular_trace_buffer
,
4112 add_target (&tfile_ops
);