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, 2011 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"
55 /* readline include files */
56 #include "readline/readline.h"
57 #include "readline/history.h"
59 /* readline defines this. */
70 extern int hex2bin (const char *hex
, gdb_byte
*bin
, int count
);
71 extern int bin2hex (const gdb_byte
*bin
, char *hex
, int count
);
73 /* Maximum length of an agent aexpression.
74 This accounts for the fact that packets are limited to 400 bytes
75 (which includes everything -- including the checksum), and assumes
76 the worst case of maximum length for each of the pieces of a
79 NOTE: expressions get mem2hex'ed otherwise this would be twice as
80 large. (400 - 31)/2 == 184 */
81 #define MAX_AGENT_EXPR_LEN 184
83 /* A hook used to notify the UI of tracepoint operations. */
85 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
86 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
88 extern void (*deprecated_readline_begin_hook
) (char *, ...);
89 extern char *(*deprecated_readline_hook
) (char *);
90 extern void (*deprecated_readline_end_hook
) (void);
92 /* GDB commands implemented in other modules:
95 extern void output_command (char *, int);
100 This module defines the following debugger commands:
101 trace : set a tracepoint on a function, line, or address.
102 info trace : list all debugger-defined tracepoints.
103 delete trace : delete one or more tracepoints.
104 enable trace : enable one or more tracepoints.
105 disable trace : disable one or more tracepoints.
106 actions : specify actions to be taken at a tracepoint.
107 passcount : specify a pass count for a tracepoint.
108 tstart : start a trace experiment.
109 tstop : stop a trace experiment.
110 tstatus : query the status of a trace experiment.
111 tfind : find a trace frame in the trace buffer.
112 tdump : print everything collected at the current tracepoint.
113 save-tracepoints : write tracepoint setup into a file.
115 This module defines the following user-visible debugger variables:
116 $trace_frame : sequence number of trace frame currently being debugged.
117 $trace_line : source line of trace frame currently being debugged.
118 $trace_file : source file of trace frame currently being debugged.
119 $tracepoint : tracepoint number of trace frame currently being debugged.
123 /* ======= Important global variables: ======= */
125 /* The list of all trace state variables. We don't retain pointers to
126 any of these for any reason - API is by name or number only - so it
127 works to have a vector of objects. */
129 typedef struct trace_state_variable tsv_s
;
132 /* An object describing the contents of a traceframe. */
134 struct traceframe_info
136 /* Collected memory. */
137 VEC(mem_range_s
) *memory
;
140 static VEC(tsv_s
) *tvariables
;
142 /* The next integer to assign to a variable. */
144 static int next_tsv_number
= 1;
146 /* Number of last traceframe collected. */
147 static int traceframe_number
;
149 /* Tracepoint for last traceframe collected. */
150 static int tracepoint_number
;
152 /* Symbol for function for last traceframe collected. */
153 static struct symbol
*traceframe_fun
;
155 /* Symtab and line for last traceframe collected. */
156 static struct symtab_and_line traceframe_sal
;
158 /* The traceframe info of the current traceframe. NULL if we haven't
159 yet attempted to fetch it, or if the target does not support
160 fetching this object, or if we're not inspecting a traceframe
162 static struct traceframe_info
*traceframe_info
;
164 /* Tracing command lists. */
165 static struct cmd_list_element
*tfindlist
;
167 /* List of expressions to collect by default at each tracepoint hit. */
168 char *default_collect
= "";
170 static int disconnected_tracing
;
172 /* This variable controls whether we ask the target for a linear or
173 circular trace buffer. */
175 static int circular_trace_buffer
;
177 /* ======= Important command functions: ======= */
178 static void trace_actions_command (char *, int);
179 static void trace_start_command (char *, int);
180 static void trace_stop_command (char *, int);
181 static void trace_status_command (char *, int);
182 static void trace_find_command (char *, int);
183 static void trace_find_pc_command (char *, int);
184 static void trace_find_tracepoint_command (char *, int);
185 static void trace_find_line_command (char *, int);
186 static void trace_find_range_command (char *, int);
187 static void trace_find_outside_command (char *, int);
188 static void trace_dump_command (char *, int);
190 /* support routines */
192 struct collection_list
;
193 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
194 static char *mem2hex (gdb_byte
*, char *, int);
195 static void add_register (struct collection_list
*collection
,
198 extern void send_disconnected_tracing_value (int value
);
200 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
201 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
204 extern void _initialize_tracepoint (void);
206 static struct trace_status trace_status
;
208 char *stop_reason_names
[] = {
218 struct trace_status
*
219 current_trace_status (void)
221 return &trace_status
;
227 free_traceframe_info (struct traceframe_info
*info
)
231 VEC_free (mem_range_s
, info
->memory
);
237 /* Free and clear the traceframe info cache of the current
241 clear_traceframe_info (void)
243 free_traceframe_info (traceframe_info
);
244 traceframe_info
= NULL
;
247 /* Set traceframe number to NUM. */
249 set_traceframe_num (int num
)
251 traceframe_number
= num
;
252 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
255 /* Set tracepoint number to NUM. */
257 set_tracepoint_num (int num
)
259 tracepoint_number
= num
;
260 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
263 /* Set externally visible debug variables for querying/printing
264 the traceframe context (line, function, file). */
267 set_traceframe_context (struct frame_info
*trace_frame
)
271 /* Save as globals for internal use. */
272 if (trace_frame
!= NULL
273 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
275 traceframe_sal
= find_pc_line (trace_pc
, 0);
276 traceframe_fun
= find_pc_function (trace_pc
);
278 /* Save linenumber as "$trace_line", a debugger variable visible to
280 set_internalvar_integer (lookup_internalvar ("trace_line"),
281 traceframe_sal
.line
);
285 init_sal (&traceframe_sal
);
286 traceframe_fun
= NULL
;
287 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
290 /* Save func name as "$trace_func", a debugger variable visible to
292 if (traceframe_fun
== NULL
293 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
294 clear_internalvar (lookup_internalvar ("trace_func"));
296 set_internalvar_string (lookup_internalvar ("trace_func"),
297 SYMBOL_LINKAGE_NAME (traceframe_fun
));
299 /* Save file name as "$trace_file", a debugger variable visible to
301 if (traceframe_sal
.symtab
== NULL
302 || traceframe_sal
.symtab
->filename
== NULL
)
303 clear_internalvar (lookup_internalvar ("trace_file"));
305 set_internalvar_string (lookup_internalvar ("trace_file"),
306 traceframe_sal
.symtab
->filename
);
309 /* Create a new trace state variable with the given name. */
311 struct trace_state_variable
*
312 create_trace_state_variable (const char *name
)
314 struct trace_state_variable tsv
;
316 memset (&tsv
, 0, sizeof (tsv
));
317 tsv
.name
= xstrdup (name
);
318 tsv
.number
= next_tsv_number
++;
319 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
322 /* Look for a trace state variable of the given name. */
324 struct trace_state_variable
*
325 find_trace_state_variable (const char *name
)
327 struct trace_state_variable
*tsv
;
330 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
331 if (strcmp (name
, tsv
->name
) == 0)
338 delete_trace_state_variable (const char *name
)
340 struct trace_state_variable
*tsv
;
343 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
344 if (strcmp (name
, tsv
->name
) == 0)
346 xfree ((void *)tsv
->name
);
347 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
351 warning (_("No trace variable named \"$%s\", not deleting"), name
);
354 /* The 'tvariable' command collects a name and optional expression to
355 evaluate into an initial value. */
358 trace_variable_command (char *args
, int from_tty
)
360 struct expression
*expr
;
361 struct cleanup
*old_chain
;
362 struct internalvar
*intvar
= NULL
;
364 struct trace_state_variable
*tsv
;
367 error_no_arg (_("trace state variable name"));
369 /* All the possible valid arguments are expressions. */
370 expr
= parse_expression (args
);
371 old_chain
= make_cleanup (free_current_contents
, &expr
);
373 if (expr
->nelts
== 0)
374 error (_("No expression?"));
376 /* Only allow two syntaxes; "$name" and "$name=value". */
377 if (expr
->elts
[0].opcode
== OP_INTERNALVAR
)
379 intvar
= expr
->elts
[1].internalvar
;
381 else if (expr
->elts
[0].opcode
== BINOP_ASSIGN
382 && expr
->elts
[1].opcode
== OP_INTERNALVAR
)
384 intvar
= expr
->elts
[2].internalvar
;
385 initval
= value_as_long (evaluate_subexpression_type (expr
, 4));
388 error (_("Syntax must be $NAME [ = EXPR ]"));
391 error (_("No name given"));
393 if (strlen (internalvar_name (intvar
)) <= 0)
394 error (_("Must supply a non-empty variable name"));
396 /* If the variable already exists, just change its initial value. */
397 tsv
= find_trace_state_variable (internalvar_name (intvar
));
400 tsv
->initial_value
= initval
;
401 printf_filtered (_("Trace state variable $%s "
402 "now has initial value %s.\n"),
403 tsv
->name
, plongest (tsv
->initial_value
));
404 do_cleanups (old_chain
);
408 /* Create a new variable. */
409 tsv
= create_trace_state_variable (internalvar_name (intvar
));
410 tsv
->initial_value
= initval
;
412 printf_filtered (_("Trace state variable $%s "
413 "created, with initial value %s.\n"),
414 tsv
->name
, plongest (tsv
->initial_value
));
416 do_cleanups (old_chain
);
420 delete_trace_variable_command (char *args
, int from_tty
)
424 struct cleanup
*back_to
;
428 if (query (_("Delete all trace state variables? ")))
429 VEC_free (tsv_s
, tvariables
);
434 argv
= gdb_buildargv (args
);
435 back_to
= make_cleanup_freeargv (argv
);
437 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
439 if (*argv
[ix
] == '$')
440 delete_trace_state_variable (argv
[ix
] + 1);
442 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
445 do_cleanups (back_to
);
451 tvariables_info_1 (void)
453 struct trace_state_variable
*tsv
;
456 struct cleanup
*back_to
;
458 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
460 printf_filtered (_("No trace state variables.\n"));
464 /* Try to acquire values from the target. */
465 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
466 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
469 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
470 count
, "trace-variables");
471 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
472 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
473 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
475 ui_out_table_body (uiout
);
477 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
479 struct cleanup
*back_to2
;
483 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
485 name
= concat ("$", tsv
->name
, (char *) NULL
);
486 make_cleanup (xfree
, name
);
487 ui_out_field_string (uiout
, "name", name
);
488 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
490 if (tsv
->value_known
)
491 c
= plongest (tsv
->value
);
492 else if (ui_out_is_mi_like_p (uiout
))
493 /* For MI, we prefer not to use magic string constants, but rather
494 omit the field completely. The difference between unknown and
495 undefined does not seem important enough to represent. */
497 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
498 /* The value is/was defined, but we don't have it. */
501 /* It is not meaningful to ask about the value. */
504 ui_out_field_string (uiout
, "current", c
);
505 ui_out_text (uiout
, "\n");
507 do_cleanups (back_to2
);
510 do_cleanups (back_to
);
513 /* List all the trace state variables. */
516 tvariables_info (char *args
, int from_tty
)
518 tvariables_info_1 ();
521 /* Stash definitions of tsvs into the given file. */
524 save_trace_state_variables (struct ui_file
*fp
)
526 struct trace_state_variable
*tsv
;
529 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
531 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
532 if (tsv
->initial_value
)
533 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
534 fprintf_unfiltered (fp
, "\n");
538 /* ACTIONS functions: */
540 /* The three functions:
541 collect_pseudocommand,
542 while_stepping_pseudocommand, and
543 end_actions_pseudocommand
544 are placeholders for "commands" that are actually ONLY to be used
545 within a tracepoint action list. If the actual function is ever called,
546 it means that somebody issued the "command" at the top level,
547 which is always an error. */
550 end_actions_pseudocommand (char *args
, int from_tty
)
552 error (_("This command cannot be used at the top level."));
556 while_stepping_pseudocommand (char *args
, int from_tty
)
558 error (_("This command can only be used in a tracepoint actions list."));
562 collect_pseudocommand (char *args
, int from_tty
)
564 error (_("This command can only be used in a tracepoint actions list."));
568 teval_pseudocommand (char *args
, int from_tty
)
570 error (_("This command can only be used in a tracepoint actions list."));
573 /* Enter a list of actions for a tracepoint. */
575 trace_actions_command (char *args
, int from_tty
)
577 struct breakpoint
*t
;
578 struct command_line
*l
;
580 t
= get_tracepoint_by_number (&args
, NULL
, 1);
584 xstrprintf ("Enter actions for tracepoint %d, one per line.",
586 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
588 l
= read_command_lines (tmpbuf
, from_tty
, 1,
589 check_tracepoint_command
, t
);
590 do_cleanups (cleanups
);
591 breakpoint_set_commands (t
, l
);
593 /* else just return */
596 /* Report the results of checking the agent expression, as errors or
600 report_agent_reqs_errors (struct agent_expr
*aexpr
)
602 /* All of the "flaws" are serious bytecode generation issues that
603 should never occur. */
604 if (aexpr
->flaw
!= agent_flaw_none
)
605 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
607 /* If analysis shows a stack underflow, GDB must have done something
608 badly wrong in its bytecode generation. */
609 if (aexpr
->min_height
< 0)
610 internal_error (__FILE__
, __LINE__
,
611 _("expression has min height < 0"));
613 /* Issue this error if the stack is predicted to get too deep. The
614 limit is rather arbitrary; a better scheme might be for the
615 target to report how much stack it will have available. The
616 depth roughly corresponds to parenthesization, so a limit of 20
617 amounts to 20 levels of expression nesting, which is actually
618 a pretty big hairy expression. */
619 if (aexpr
->max_height
> 20)
620 error (_("Expression is too complicated."));
623 /* worker function */
625 validate_actionline (char **line
, struct breakpoint
*t
)
627 struct cmd_list_element
*c
;
628 struct expression
*exp
= NULL
;
629 struct cleanup
*old_chain
= NULL
;
631 struct bp_location
*loc
;
632 struct agent_expr
*aexpr
;
634 /* If EOF is typed, *line is NULL. */
638 for (p
= *line
; isspace ((int) *p
);)
641 /* Symbol lookup etc. */
642 if (*p
== '\0') /* empty line: just prompt for another line. */
645 if (*p
== '#') /* comment line */
648 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
650 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
652 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
655 { /* Repeat over a comma-separated list. */
656 QUIT
; /* Allow user to bail out with ^C. */
657 while (isspace ((int) *p
))
660 if (*p
== '$') /* Look for special pseudo-symbols. */
662 if (0 == strncasecmp ("reg", p
+ 1, 3)
663 || 0 == strncasecmp ("arg", p
+ 1, 3)
664 || 0 == strncasecmp ("loc", p
+ 1, 3)
665 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
670 /* else fall thru, treat p as an expression and parse it! */
673 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
676 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
677 old_chain
= make_cleanup (free_current_contents
, &exp
);
679 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
681 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
683 error (_("constant `%s' (value %ld) "
684 "will not be collected."),
685 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
686 SYMBOL_VALUE (exp
->elts
[2].symbol
));
688 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
689 == LOC_OPTIMIZED_OUT
)
691 error (_("`%s' is optimized away "
692 "and cannot be collected."),
693 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
697 /* We have something to collect, make sure that the expr to
698 bytecode translator can handle it and that it's not too
700 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
701 make_cleanup_free_agent_expr (aexpr
);
703 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
704 error (_("Expression is too complicated."));
708 report_agent_reqs_errors (aexpr
);
710 do_cleanups (old_chain
);
713 while (p
&& *p
++ == ',');
716 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
719 { /* Repeat over a comma-separated list. */
720 QUIT
; /* Allow user to bail out with ^C. */
721 while (isspace ((int) *p
))
725 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
728 /* Only expressions are allowed for this action. */
729 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
730 old_chain
= make_cleanup (free_current_contents
, &exp
);
732 /* We have something to evaluate, make sure that the expr to
733 bytecode translator can handle it and that it's not too
735 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
736 make_cleanup_free_agent_expr (aexpr
);
738 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
739 error (_("Expression is too complicated."));
742 report_agent_reqs_errors (aexpr
);
744 do_cleanups (old_chain
);
747 while (p
&& *p
++ == ',');
750 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
752 char *steparg
; /* In case warning is necessary. */
754 while (isspace ((int) *p
))
758 if (*p
== '\0' || (t
->step_count
= strtol (p
, &p
, 0)) == 0)
759 error (_("while-stepping step count `%s' is malformed."), *line
);
762 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
766 error (_("`%s' is not a supported tracepoint action."), *line
);
770 memrange_absolute
= -1
775 int type
; /* memrange_absolute for absolute memory range,
776 else basereg number. */
777 bfd_signed_vma start
;
781 struct collection_list
783 unsigned char regs_mask
[32]; /* room for up to 256 regs */
786 struct memrange
*list
;
787 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
789 struct agent_expr
**aexpr_list
;
791 /* True is the user requested a collection of "$_sdata", "static
795 tracepoint_list
, stepping_list
;
797 /* MEMRANGE functions: */
799 static int memrange_cmp (const void *, const void *);
801 /* Compare memranges for qsort. */
803 memrange_cmp (const void *va
, const void *vb
)
805 const struct memrange
*a
= va
, *b
= vb
;
807 if (a
->type
< b
->type
)
809 if (a
->type
> b
->type
)
811 if (a
->type
== memrange_absolute
)
813 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
815 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
820 if (a
->start
< b
->start
)
822 if (a
->start
> b
->start
)
828 /* Sort the memrange list using qsort, and merge adjacent memranges. */
830 memrange_sortmerge (struct collection_list
*memranges
)
834 qsort (memranges
->list
, memranges
->next_memrange
,
835 sizeof (struct memrange
), memrange_cmp
);
836 if (memranges
->next_memrange
> 0)
838 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
840 /* If memrange b overlaps or is adjacent to memrange a,
842 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
843 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
845 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
846 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
847 continue; /* next b, same a */
851 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
852 sizeof (struct memrange
));
854 memranges
->next_memrange
= a
+ 1;
858 /* Add a register to a collection list. */
860 add_register (struct collection_list
*collection
, unsigned int regno
)
863 printf_filtered ("collect register %d\n", regno
);
864 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
865 error (_("Internal: register number %d too large for tracepoint"),
867 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
870 /* Add a memrange to a collection list. */
872 add_memrange (struct collection_list
*memranges
,
873 int type
, bfd_signed_vma base
,
878 printf_filtered ("(%d,", type
);
880 printf_filtered (",%ld)\n", len
);
883 /* type: memrange_absolute == memory, other n == basereg */
884 memranges
->list
[memranges
->next_memrange
].type
= type
;
885 /* base: addr if memory, offset if reg relative. */
886 memranges
->list
[memranges
->next_memrange
].start
= base
;
887 /* len: we actually save end (base + len) for convenience */
888 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
889 memranges
->next_memrange
++;
890 if (memranges
->next_memrange
>= memranges
->listsize
)
892 memranges
->listsize
*= 2;
893 memranges
->list
= xrealloc (memranges
->list
,
894 memranges
->listsize
);
897 if (type
!= memrange_absolute
) /* Better collect the base register! */
898 add_register (memranges
, type
);
901 /* Add a symbol to a collection list. */
903 collect_symbol (struct collection_list
*collect
,
905 struct gdbarch
*gdbarch
,
906 long frame_regno
, long frame_offset
,
911 bfd_signed_vma offset
;
912 int treat_as_expr
= 0;
914 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
915 switch (SYMBOL_CLASS (sym
))
918 printf_filtered ("%s: don't know symbol class %d\n",
919 SYMBOL_PRINT_NAME (sym
),
923 printf_filtered ("constant %s (value %ld) will not be collected.\n",
924 SYMBOL_PRINT_NAME (sym
), SYMBOL_VALUE (sym
));
927 offset
= SYMBOL_VALUE_ADDRESS (sym
);
932 sprintf_vma (tmp
, offset
);
933 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
934 SYMBOL_PRINT_NAME (sym
), len
,
937 /* A struct may be a C++ class with static fields, go to general
938 expression handling. */
939 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
942 add_memrange (collect
, memrange_absolute
, offset
, len
);
945 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
947 printf_filtered ("LOC_REG[parm] %s: ",
948 SYMBOL_PRINT_NAME (sym
));
949 add_register (collect
, reg
);
950 /* Check for doubles stored in two registers. */
951 /* FIXME: how about larger types stored in 3 or more regs? */
952 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
953 len
> register_size (gdbarch
, reg
))
954 add_register (collect
, reg
+ 1);
957 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
958 printf_filtered (" (will not collect %s)\n",
959 SYMBOL_PRINT_NAME (sym
));
963 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
966 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
967 SYMBOL_PRINT_NAME (sym
), len
);
969 printf_filtered (" from frame ptr reg %d\n", reg
);
971 add_memrange (collect
, reg
, offset
, len
);
973 case LOC_REGPARM_ADDR
:
974 reg
= SYMBOL_VALUE (sym
);
978 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
979 SYMBOL_PRINT_NAME (sym
), len
);
981 printf_filtered (" from reg %d\n", reg
);
983 add_memrange (collect
, reg
, offset
, len
);
987 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
990 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
991 SYMBOL_PRINT_NAME (sym
), len
);
993 printf_filtered (" from frame ptr reg %d\n", reg
);
995 add_memrange (collect
, reg
, offset
, len
);
1002 case LOC_OPTIMIZED_OUT
:
1003 printf_filtered ("%s has been optimized out of existence.\n",
1004 SYMBOL_PRINT_NAME (sym
));
1012 /* Expressions are the most general case. */
1015 struct agent_expr
*aexpr
;
1016 struct cleanup
*old_chain1
= NULL
;
1018 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
1020 /* It can happen that the symbol is recorded as a computed
1021 location, but it's been optimized away and doesn't actually
1022 have a location expression. */
1025 printf_filtered ("%s has been optimized out of existence.\n",
1026 SYMBOL_PRINT_NAME (sym
));
1030 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1034 report_agent_reqs_errors (aexpr
);
1036 discard_cleanups (old_chain1
);
1037 add_aexpr (collect
, aexpr
);
1039 /* Take care of the registers. */
1040 if (aexpr
->reg_mask_len
> 0)
1044 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1046 QUIT
; /* Allow user to bail out with ^C. */
1047 if (aexpr
->reg_mask
[ndx1
] != 0)
1049 /* Assume chars have 8 bits. */
1050 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1051 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1052 /* It's used -- record it. */
1053 add_register (collect
, ndx1
* 8 + ndx2
);
1060 /* Data to be passed around in the calls to the locals and args
1063 struct add_local_symbols_data
1065 struct collection_list
*collect
;
1066 struct gdbarch
*gdbarch
;
1073 /* The callback for the locals and args iterators. */
1076 do_collect_symbol (const char *print_name
,
1080 struct add_local_symbols_data
*p
= cb_data
;
1082 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1083 p
->frame_offset
, p
->pc
);
1087 /* Add all locals (or args) symbols to collection list. */
1089 add_local_symbols (struct collection_list
*collect
,
1090 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1091 long frame_regno
, long frame_offset
, int type
)
1093 struct block
*block
;
1094 struct add_local_symbols_data cb_data
;
1096 cb_data
.collect
= collect
;
1097 cb_data
.gdbarch
= gdbarch
;
1099 cb_data
.frame_regno
= frame_regno
;
1100 cb_data
.frame_offset
= frame_offset
;
1105 block
= block_for_pc (pc
);
1108 warning (_("Can't collect locals; "
1109 "no symbol table info available.\n"));
1113 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1114 if (cb_data
.count
== 0)
1115 warning (_("No locals found in scope."));
1119 pc
= get_pc_function_start (pc
);
1120 block
= block_for_pc (pc
);
1123 warning (_("Can't collect args; no symbol table info available."));
1127 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1128 if (cb_data
.count
== 0)
1129 warning (_("No args found in scope."));
1134 add_static_trace_data (struct collection_list
*collection
)
1137 printf_filtered ("collect static trace data\n");
1138 collection
->strace_data
= 1;
1141 /* worker function */
1143 clear_collection_list (struct collection_list
*list
)
1147 list
->next_memrange
= 0;
1148 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1150 free_agent_expr (list
->aexpr_list
[ndx
]);
1151 list
->aexpr_list
[ndx
] = NULL
;
1153 list
->next_aexpr_elt
= 0;
1154 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1155 list
->strace_data
= 0;
1158 /* Reduce a collection list to string form (for gdb protocol). */
1160 stringify_collection_list (struct collection_list
*list
, char *string
)
1162 char temp_buf
[2048];
1166 char *(*str_list
)[];
1170 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1171 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1173 if (list
->strace_data
)
1176 printf_filtered ("\nCollecting static trace data\n");
1179 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1183 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1184 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1186 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1189 printf_filtered ("\nCollecting registers (mask): 0x");
1194 QUIT
; /* Allow user to bail out with ^C. */
1196 printf_filtered ("%02X", list
->regs_mask
[i
]);
1197 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1200 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1204 printf_filtered ("\n");
1205 if (list
->next_memrange
> 0 && info_verbose
)
1206 printf_filtered ("Collecting memranges: \n");
1207 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1209 QUIT
; /* Allow user to bail out with ^C. */
1210 sprintf_vma (tmp2
, list
->list
[i
].start
);
1213 printf_filtered ("(%d, %s, %ld)\n",
1216 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1218 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1220 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1227 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1229 /* The "%X" conversion specifier expects an unsigned argument,
1230 so passing -1 (memrange_absolute) to it directly gives you
1231 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1233 if (list
->list
[i
].type
== memrange_absolute
)
1234 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1236 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1239 count
+= strlen (end
);
1240 end
= temp_buf
+ count
;
1243 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1245 QUIT
; /* Allow user to bail out with ^C. */
1246 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1248 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1253 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1254 end
+= 10; /* 'X' + 8 hex digits + ',' */
1257 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1258 end
, list
->aexpr_list
[i
]->len
);
1259 count
+= 2 * list
->aexpr_list
[i
]->len
;
1264 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1269 (*str_list
)[ndx
] = NULL
;
1282 encode_actions_1 (struct command_line
*action
,
1283 struct breakpoint
*t
,
1284 struct bp_location
*tloc
,
1286 LONGEST frame_offset
,
1287 struct collection_list
*collect
,
1288 struct collection_list
*stepping_list
)
1291 struct expression
*exp
= NULL
;
1293 struct value
*tempval
;
1294 struct cmd_list_element
*cmd
;
1295 struct agent_expr
*aexpr
;
1297 for (; action
; action
= action
->next
)
1299 QUIT
; /* Allow user to bail out with ^C. */
1300 action_exp
= action
->line
;
1301 while (isspace ((int) *action_exp
))
1304 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1306 error (_("Bad action list item: %s"), action_exp
);
1308 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1311 { /* Repeat over a comma-separated list. */
1312 QUIT
; /* Allow user to bail out with ^C. */
1313 while (isspace ((int) *action_exp
))
1316 if (0 == strncasecmp ("$reg", action_exp
, 4))
1318 for (i
= 0; i
< gdbarch_num_regs (t
->gdbarch
); i
++)
1319 add_register (collect
, i
);
1320 action_exp
= strchr (action_exp
, ','); /* more? */
1322 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1324 add_local_symbols (collect
,
1330 action_exp
= strchr (action_exp
, ','); /* more? */
1332 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1334 add_local_symbols (collect
,
1340 action_exp
= strchr (action_exp
, ','); /* more? */
1342 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1344 add_static_trace_data (collect
);
1345 action_exp
= strchr (action_exp
, ','); /* more? */
1349 unsigned long addr
, len
;
1350 struct cleanup
*old_chain
= NULL
;
1351 struct cleanup
*old_chain1
= NULL
;
1353 exp
= parse_exp_1 (&action_exp
,
1354 block_for_pc (tloc
->address
), 1);
1355 old_chain
= make_cleanup (free_current_contents
, &exp
);
1357 switch (exp
->elts
[0].opcode
)
1361 const char *name
= &exp
->elts
[2].string
;
1363 i
= user_reg_map_name_to_regnum (t
->gdbarch
,
1364 name
, strlen (name
));
1366 internal_error (__FILE__
, __LINE__
,
1367 _("Register $%s not available"),
1370 printf_filtered ("OP_REGISTER: ");
1371 add_register (collect
, i
);
1376 /* Safe because we know it's a simple expression. */
1377 tempval
= evaluate_expression (exp
);
1378 addr
= value_address (tempval
);
1379 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1380 add_memrange (collect
, memrange_absolute
, addr
, len
);
1384 collect_symbol (collect
,
1385 exp
->elts
[2].symbol
,
1392 default: /* Full-fledged expression. */
1393 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1395 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1399 report_agent_reqs_errors (aexpr
);
1401 discard_cleanups (old_chain1
);
1402 add_aexpr (collect
, aexpr
);
1404 /* Take care of the registers. */
1405 if (aexpr
->reg_mask_len
> 0)
1410 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1412 QUIT
; /* Allow user to bail out with ^C. */
1413 if (aexpr
->reg_mask
[ndx1
] != 0)
1415 /* Assume chars have 8 bits. */
1416 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1417 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1418 /* It's used -- record it. */
1419 add_register (collect
,
1426 do_cleanups (old_chain
);
1429 while (action_exp
&& *action_exp
++ == ',');
1431 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1434 { /* Repeat over a comma-separated list. */
1435 QUIT
; /* Allow user to bail out with ^C. */
1436 while (isspace ((int) *action_exp
))
1440 struct cleanup
*old_chain
= NULL
;
1441 struct cleanup
*old_chain1
= NULL
;
1443 exp
= parse_exp_1 (&action_exp
,
1444 block_for_pc (tloc
->address
), 1);
1445 old_chain
= make_cleanup (free_current_contents
, &exp
);
1447 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1448 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1451 report_agent_reqs_errors (aexpr
);
1453 discard_cleanups (old_chain1
);
1454 /* Even though we're not officially collecting, add
1455 to the collect list anyway. */
1456 add_aexpr (collect
, aexpr
);
1458 do_cleanups (old_chain
);
1461 while (action_exp
&& *action_exp
++ == ',');
1463 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1465 /* We check against nested while-stepping when setting
1466 breakpoint action, so no way to run into nested
1468 gdb_assert (stepping_list
);
1470 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
,
1471 frame_offset
, stepping_list
, NULL
);
1474 error (_("Invalid tracepoint command '%s'"), action
->line
);
1478 /* Render all actions into gdb protocol. */
1480 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1481 char ***tdp_actions
, char ***stepping_actions
)
1483 static char tdp_buff
[2048], step_buff
[2048];
1484 char *default_collect_line
= NULL
;
1485 struct command_line
*actions
;
1486 struct command_line
*default_collect_action
= NULL
;
1488 LONGEST frame_offset
;
1489 struct cleanup
*back_to
;
1491 back_to
= make_cleanup (null_cleanup
, NULL
);
1493 clear_collection_list (&tracepoint_list
);
1494 clear_collection_list (&stepping_list
);
1496 *tdp_actions
= NULL
;
1497 *stepping_actions
= NULL
;
1499 gdbarch_virtual_frame_pointer (t
->gdbarch
,
1500 t
->loc
->address
, &frame_reg
, &frame_offset
);
1502 actions
= breakpoint_commands (t
);
1504 /* If there are default expressions to collect, make up a collect
1505 action and prepend to the action list to encode. Note that since
1506 validation is per-tracepoint (local var "xyz" might be valid for
1507 one tracepoint and not another, etc), we make up the action on
1508 the fly, and don't cache it. */
1509 if (*default_collect
)
1513 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1514 make_cleanup (xfree
, default_collect_line
);
1516 line
= default_collect_line
;
1517 validate_actionline (&line
, t
);
1519 default_collect_action
= xmalloc (sizeof (struct command_line
));
1520 make_cleanup (xfree
, default_collect_action
);
1521 default_collect_action
->next
= actions
;
1522 default_collect_action
->line
= line
;
1523 actions
= default_collect_action
;
1525 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1526 &tracepoint_list
, &stepping_list
);
1528 memrange_sortmerge (&tracepoint_list
);
1529 memrange_sortmerge (&stepping_list
);
1531 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1533 *stepping_actions
= stringify_collection_list (&stepping_list
,
1536 do_cleanups (back_to
);
1540 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1542 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1544 collect
->aexpr_list
=
1545 xrealloc (collect
->aexpr_list
,
1546 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1547 collect
->aexpr_listsize
*= 2;
1549 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1550 collect
->next_aexpr_elt
++;
1555 start_tracing (void)
1557 VEC(breakpoint_p
) *tp_vec
= NULL
;
1559 struct breakpoint
*t
;
1560 struct trace_state_variable
*tsv
;
1561 int any_enabled
= 0, num_to_download
= 0;
1563 tp_vec
= all_tracepoints ();
1565 /* No point in tracing without any tracepoints... */
1566 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1568 VEC_free (breakpoint_p
, tp_vec
);
1569 error (_("No tracepoints defined, not starting trace"));
1572 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1574 if (t
->enable_state
== bp_enabled
)
1577 if ((t
->type
== bp_fast_tracepoint
1578 ? may_insert_fast_tracepoints
1579 : may_insert_tracepoints
))
1582 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1583 (t
->type
== bp_fast_tracepoint
? "fast " : ""), t
->number
);
1588 if (target_supports_enable_disable_tracepoint ())
1589 warning (_("No tracepoints enabled"));
1592 /* No point in tracing with only disabled tracepoints that
1593 cannot be re-enabled. */
1594 VEC_free (breakpoint_p
, tp_vec
);
1595 error (_("No tracepoints enabled, not starting trace"));
1599 if (num_to_download
<= 0)
1601 VEC_free (breakpoint_p
, tp_vec
);
1602 error (_("No tracepoints that may be downloaded, not starting trace"));
1605 target_trace_init ();
1607 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1609 if ((t
->type
== bp_fast_tracepoint
1610 ? !may_insert_fast_tracepoints
1611 : !may_insert_tracepoints
))
1614 t
->number_on_target
= 0;
1615 target_download_tracepoint (t
);
1616 t
->number_on_target
= t
->number
;
1618 VEC_free (breakpoint_p
, tp_vec
);
1620 /* Send down all the trace state variables too. */
1621 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1623 target_download_trace_state_variable (tsv
);
1626 /* Tell target to treat text-like sections as transparent. */
1627 target_trace_set_readonly_regions ();
1628 /* Set some mode flags. */
1629 target_set_disconnected_tracing (disconnected_tracing
);
1630 target_set_circular_trace_buffer (circular_trace_buffer
);
1632 /* Now insert traps and begin collecting data. */
1633 target_trace_start ();
1635 /* Reset our local state. */
1636 set_traceframe_num (-1);
1637 set_tracepoint_num (-1);
1638 set_traceframe_context (NULL
);
1639 current_trace_status()->running
= 1;
1640 clear_traceframe_info ();
1645 Tell target to clear any previous trace experiment.
1646 Walk the list of tracepoints, and send them (and their actions)
1647 to the target. If no errors,
1648 Tell target to start a new trace experiment. */
1651 trace_start_command (char *args
, int from_tty
)
1653 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1655 if (current_trace_status ()->running
)
1658 && !query (_("A trace is running already. Start a new run? ")))
1659 error (_("New trace run not started."));
1667 trace_stop_command (char *args
, int from_tty
)
1669 if (!current_trace_status ()->running
)
1670 error (_("Trace is not running."));
1678 target_trace_stop ();
1679 /* Should change in response to reply? */
1680 current_trace_status ()->running
= 0;
1683 /* tstatus command */
1685 trace_status_command (char *args
, int from_tty
)
1687 struct trace_status
*ts
= current_trace_status ();
1690 status
= target_get_trace_status (ts
);
1695 printf_filtered (_("Using a trace file.\n"));
1698 printf_filtered (_("Trace can not be run on this target.\n"));
1703 if (!ts
->running_known
)
1705 printf_filtered (_("Run/stop status is unknown.\n"));
1707 else if (ts
->running
)
1709 printf_filtered (_("Trace is running on the target.\n"));
1713 switch (ts
->stop_reason
)
1715 case trace_never_run
:
1716 printf_filtered (_("No trace has been run on the target.\n"));
1719 printf_filtered (_("Trace stopped by a tstop command.\n"));
1721 case trace_buffer_full
:
1722 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1724 case trace_disconnected
:
1725 printf_filtered (_("Trace stopped because of disconnection.\n"));
1727 case tracepoint_passcount
:
1728 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1729 ts
->stopping_tracepoint
);
1731 case tracepoint_error
:
1732 if (ts
->stopping_tracepoint
)
1733 printf_filtered (_("Trace stopped by an "
1734 "error (%s, tracepoint %d).\n"),
1735 ts
->error_desc
, ts
->stopping_tracepoint
);
1737 printf_filtered (_("Trace stopped by an error (%s).\n"),
1740 case trace_stop_reason_unknown
:
1741 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1744 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1750 if (ts
->traceframes_created
>= 0
1751 && ts
->traceframe_count
!= ts
->traceframes_created
)
1753 printf_filtered (_("Buffer contains %d trace "
1754 "frames (of %d created total).\n"),
1755 ts
->traceframe_count
, ts
->traceframes_created
);
1757 else if (ts
->traceframe_count
>= 0)
1759 printf_filtered (_("Collected %d trace frames.\n"),
1760 ts
->traceframe_count
);
1763 if (ts
->buffer_free
>= 0)
1765 if (ts
->buffer_size
>= 0)
1767 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1768 ts
->buffer_free
, ts
->buffer_size
);
1769 if (ts
->buffer_size
> 0)
1770 printf_filtered (_(" (%d%% full)"),
1771 ((int) ((((long long) (ts
->buffer_size
1772 - ts
->buffer_free
)) * 100)
1773 / ts
->buffer_size
)));
1774 printf_filtered (_(".\n"));
1777 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1781 if (ts
->disconnected_tracing
)
1782 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1784 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1786 if (ts
->circular_buffer
)
1787 printf_filtered (_("Trace buffer is circular.\n"));
1789 /* Now report on what we're doing with tfind. */
1790 if (traceframe_number
>= 0)
1791 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1792 traceframe_number
, tracepoint_number
);
1794 printf_filtered (_("Not looking at any trace frame.\n"));
1797 /* Report the trace status to uiout, in a way suitable for MI, and not
1798 suitable for CLI. If ON_STOP is true, suppress a few fields that
1799 are not meaningful in the -trace-stop response.
1801 The implementation is essentially parallel to trace_status_command, but
1802 merging them will result in unreadable code. */
1804 trace_status_mi (int on_stop
)
1806 struct trace_status
*ts
= current_trace_status ();
1809 status
= target_get_trace_status (ts
);
1811 if (status
== -1 && !ts
->from_file
)
1813 ui_out_field_string (uiout
, "supported", "0");
1818 ui_out_field_string (uiout
, "supported", "file");
1820 ui_out_field_string (uiout
, "supported", "1");
1822 gdb_assert (ts
->running_known
);
1826 ui_out_field_string (uiout
, "running", "1");
1828 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1829 Given that the frontend gets the status either on -trace-stop, or from
1830 -trace-status after re-connection, it does not seem like this
1831 information is necessary for anything. It is not necessary for either
1832 figuring the vital state of the target nor for navigation of trace
1833 frames. If the frontend wants to show the current state is some
1834 configure dialog, it can request the value when such dialog is
1835 invoked by the user. */
1839 char *stop_reason
= NULL
;
1840 int stopping_tracepoint
= -1;
1843 ui_out_field_string (uiout
, "running", "0");
1845 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
1847 switch (ts
->stop_reason
)
1850 stop_reason
= "request";
1852 case trace_buffer_full
:
1853 stop_reason
= "overflow";
1855 case trace_disconnected
:
1856 stop_reason
= "disconnection";
1858 case tracepoint_passcount
:
1859 stop_reason
= "passcount";
1860 stopping_tracepoint
= ts
->stopping_tracepoint
;
1862 case tracepoint_error
:
1863 stop_reason
= "error";
1864 stopping_tracepoint
= ts
->stopping_tracepoint
;
1870 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
1871 if (stopping_tracepoint
!= -1)
1872 ui_out_field_int (uiout
, "stopping-tracepoint",
1873 stopping_tracepoint
);
1874 if (ts
->stop_reason
== tracepoint_error
)
1875 ui_out_field_string (uiout
, "error-description",
1881 if (ts
->traceframe_count
!= -1)
1882 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
1883 if (ts
->traceframes_created
!= -1)
1884 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
1885 if (ts
->buffer_size
!= -1)
1886 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
1887 if (ts
->buffer_free
!= -1)
1888 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
1890 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
1891 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
1894 /* This function handles the details of what to do about an ongoing
1895 tracing run if the user has asked to detach or otherwise disconnect
1898 disconnect_tracing (int from_tty
)
1900 /* It can happen that the target that was tracing went away on its
1901 own, and we didn't notice. Get a status update, and if the
1902 current target doesn't even do tracing, then assume it's not
1904 if (target_get_trace_status (current_trace_status ()) < 0)
1905 current_trace_status ()->running
= 0;
1907 /* If running interactively, give the user the option to cancel and
1908 then decide what to do differently with the run. Scripts are
1909 just going to disconnect and let the target deal with it,
1910 according to how it's been instructed previously via
1911 disconnected-tracing. */
1912 if (current_trace_status ()->running
&& from_tty
)
1914 if (current_trace_status ()->disconnected_tracing
)
1916 if (!query (_("Trace is running and will "
1917 "continue after detach; detach anyway? ")))
1918 error (_("Not confirmed."));
1922 if (!query (_("Trace is running but will "
1923 "stop on detach; detach anyway? ")))
1924 error (_("Not confirmed."));
1928 /* Also we want to be out of tfind mode, otherwise things can get
1929 confusing upon reconnection. Just use these calls instead of
1930 full tfind_1 behavior because we're in the middle of detaching,
1931 and there's no point to updating current stack frame etc. */
1932 set_current_traceframe (-1);
1933 set_traceframe_context (NULL
);
1936 /* Worker function for the various flavors of the tfind command. */
1938 tfind_1 (enum trace_find_type type
, int num
,
1939 ULONGEST addr1
, ULONGEST addr2
,
1942 int target_frameno
= -1, target_tracept
= -1;
1943 struct frame_id old_frame_id
= null_frame_id
;
1944 struct breakpoint
*tp
;
1946 /* Only try to get the current stack frame if we have a chance of
1947 succeeding. In particular, if we're trying to get a first trace
1948 frame while all threads are running, it's not going to succeed,
1949 so leave it with a default value and let the frame comparison
1950 below (correctly) decide to print out the source location of the
1952 if (!(type
== tfind_number
&& num
== -1)
1953 && (has_stack_frames () || traceframe_number
>= 0))
1954 old_frame_id
= get_frame_id (get_current_frame ());
1956 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
1959 if (type
== tfind_number
1961 && target_frameno
== -1)
1963 /* We told the target to get out of tfind mode, and it did. */
1965 else if (target_frameno
== -1)
1967 /* A request for a non-existent trace frame has failed.
1968 Our response will be different, depending on FROM_TTY:
1970 If FROM_TTY is true, meaning that this command was
1971 typed interactively by the user, then give an error
1972 and DO NOT change the state of traceframe_number etc.
1974 However if FROM_TTY is false, meaning that we're either
1975 in a script, a loop, or a user-defined command, then
1976 DON'T give an error, but DO change the state of
1977 traceframe_number etc. to invalid.
1979 The rationalle is that if you typed the command, you
1980 might just have committed a typo or something, and you'd
1981 like to NOT lose your current debugging state. However
1982 if you're in a user-defined command or especially in a
1983 loop, then you need a way to detect that the command
1984 failed WITHOUT aborting. This allows you to write
1985 scripts that search thru the trace buffer until the end,
1986 and then continue on to do something else. */
1989 error (_("Target failed to find requested trace frame."));
1993 printf_filtered ("End of trace buffer.\n");
1994 #if 0 /* dubious now? */
1995 /* The following will not recurse, since it's
1997 trace_find_command ("-1", from_tty
);
2002 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2004 reinit_frame_cache ();
2005 registers_changed ();
2006 target_dcache_invalidate ();
2007 set_traceframe_num (target_frameno
);
2008 clear_traceframe_info ();
2009 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
2010 if (target_frameno
== -1)
2011 set_traceframe_context (NULL
);
2013 set_traceframe_context (get_current_frame ());
2015 if (traceframe_number
>= 0)
2017 /* Use different branches for MI and CLI to make CLI messages
2019 if (ui_out_is_mi_like_p (uiout
))
2021 ui_out_field_string (uiout
, "found", "1");
2022 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2023 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2027 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2028 traceframe_number
, tracepoint_number
);
2033 if (ui_out_is_mi_like_p (uiout
))
2034 ui_out_field_string (uiout
, "found", "0");
2035 else if (type
== tfind_number
&& num
== -1)
2036 printf_unfiltered (_("No longer looking at any trace frame\n"));
2037 else /* This case may never occur, check. */
2038 printf_unfiltered (_("No trace frame found\n"));
2041 /* If we're in nonstop mode and getting out of looking at trace
2042 frames, there won't be any current frame to go back to and
2045 && (has_stack_frames () || traceframe_number
>= 0))
2047 enum print_what print_what
;
2049 /* NOTE: in imitation of the step command, try to determine
2050 whether we have made a transition from one function to
2051 another. If so, we'll print the "stack frame" (ie. the new
2052 function and it's arguments) -- otherwise we'll just show the
2055 if (frame_id_eq (old_frame_id
,
2056 get_frame_id (get_current_frame ())))
2057 print_what
= SRC_LINE
;
2059 print_what
= SRC_AND_LOC
;
2061 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2066 /* trace_find_command takes a trace frame number n,
2067 sends "QTFrame:<n>" to the target,
2068 and accepts a reply that may contain several optional pieces
2069 of information: a frame number, a tracepoint number, and an
2070 indication of whether this is a trap frame or a stepping frame.
2072 The minimal response is just "OK" (which indicates that the
2073 target does not give us a frame number or a tracepoint number).
2074 Instead of that, the target may send us a string containing
2076 F<hexnum> (gives the selected frame number)
2077 T<hexnum> (gives the selected tracepoint number)
2082 trace_find_command (char *args
, int from_tty
)
2083 { /* This should only be called with a numeric argument. */
2086 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2087 error (_("May not look at trace frames while trace is running."));
2089 if (args
== 0 || *args
== 0)
2090 { /* TFIND with no args means find NEXT trace frame. */
2091 if (traceframe_number
== -1)
2092 frameno
= 0; /* "next" is first one. */
2094 frameno
= traceframe_number
+ 1;
2096 else if (0 == strcmp (args
, "-"))
2098 if (traceframe_number
== -1)
2099 error (_("not debugging trace buffer"));
2100 else if (from_tty
&& traceframe_number
== 0)
2101 error (_("already at start of trace buffer"));
2103 frameno
= traceframe_number
- 1;
2105 /* A hack to work around eval's need for fp to have been collected. */
2106 else if (0 == strcmp (args
, "-1"))
2109 frameno
= parse_and_eval_long (args
);
2112 error (_("invalid input (%d is less than zero)"), frameno
);
2114 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2119 trace_find_end_command (char *args
, int from_tty
)
2121 trace_find_command ("-1", from_tty
);
2126 trace_find_none_command (char *args
, int from_tty
)
2128 trace_find_command ("-1", from_tty
);
2133 trace_find_start_command (char *args
, int from_tty
)
2135 trace_find_command ("0", from_tty
);
2138 /* tfind pc command */
2140 trace_find_pc_command (char *args
, int from_tty
)
2144 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2145 error (_("May not look at trace frames while trace is running."));
2147 if (args
== 0 || *args
== 0)
2148 pc
= regcache_read_pc (get_current_regcache ());
2150 pc
= parse_and_eval_address (args
);
2152 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2155 /* tfind tracepoint command */
2157 trace_find_tracepoint_command (char *args
, int from_tty
)
2160 struct breakpoint
*tp
;
2162 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2163 error (_("May not look at trace frames while trace is running."));
2165 if (args
== 0 || *args
== 0)
2167 if (tracepoint_number
== -1)
2168 error (_("No current tracepoint -- please supply an argument."));
2170 tdp
= tracepoint_number
; /* Default is current TDP. */
2173 tdp
= parse_and_eval_long (args
);
2175 /* If we have the tracepoint on hand, use the number that the
2176 target knows about (which may be different if we disconnected
2177 and reconnected). */
2178 tp
= get_tracepoint (tdp
);
2180 tdp
= tp
->number_on_target
;
2182 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2185 /* TFIND LINE command:
2187 This command will take a sourceline for argument, just like BREAK
2188 or TRACE (ie. anything that "decode_line_1" can handle).
2190 With no argument, this command will find the next trace frame
2191 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2194 trace_find_line_command (char *args
, int from_tty
)
2196 static CORE_ADDR start_pc
, end_pc
;
2197 struct symtabs_and_lines sals
;
2198 struct symtab_and_line sal
;
2199 struct cleanup
*old_chain
;
2201 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2202 error (_("May not look at trace frames while trace is running."));
2204 if (args
== 0 || *args
== 0)
2206 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2208 sals
.sals
= (struct symtab_and_line
*)
2209 xmalloc (sizeof (struct symtab_and_line
));
2214 sals
= decode_line_spec (args
, 1);
2218 old_chain
= make_cleanup (xfree
, sals
.sals
);
2219 if (sal
.symtab
== 0)
2220 error (_("No line number information available."));
2222 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2224 if (start_pc
== end_pc
)
2226 printf_filtered ("Line %d of \"%s\"",
2227 sal
.line
, sal
.symtab
->filename
);
2229 printf_filtered (" is at address ");
2230 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2232 printf_filtered (" but contains no code.\n");
2233 sal
= find_pc_line (start_pc
, 0);
2235 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2236 && start_pc
!= end_pc
)
2237 printf_filtered ("Attempting to find line %d instead.\n",
2240 error (_("Cannot find a good line."));
2244 /* Is there any case in which we get here, and have an address
2245 which the user would want to see? If we have debugging
2246 symbols and no line numbers? */
2247 error (_("Line number %d is out of range for \"%s\"."),
2248 sal
.line
, sal
.symtab
->filename
);
2250 /* Find within range of stated line. */
2252 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2254 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2255 do_cleanups (old_chain
);
2258 /* tfind range command */
2260 trace_find_range_command (char *args
, int from_tty
)
2262 static CORE_ADDR start
, stop
;
2265 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2266 error (_("May not look at trace frames while trace is running."));
2268 if (args
== 0 || *args
== 0)
2269 { /* XXX FIXME: what should default behavior be? */
2270 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2274 if (0 != (tmp
= strchr (args
, ',')))
2276 *tmp
++ = '\0'; /* Terminate start address. */
2277 while (isspace ((int) *tmp
))
2279 start
= parse_and_eval_address (args
);
2280 stop
= parse_and_eval_address (tmp
);
2283 { /* No explicit end address? */
2284 start
= parse_and_eval_address (args
);
2285 stop
= start
+ 1; /* ??? */
2288 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2291 /* tfind outside command */
2293 trace_find_outside_command (char *args
, int from_tty
)
2295 CORE_ADDR start
, stop
;
2298 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2299 error (_("May not look at trace frames while trace is running."));
2301 if (args
== 0 || *args
== 0)
2302 { /* XXX FIXME: what should default behavior be? */
2303 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2307 if (0 != (tmp
= strchr (args
, ',')))
2309 *tmp
++ = '\0'; /* Terminate start address. */
2310 while (isspace ((int) *tmp
))
2312 start
= parse_and_eval_address (args
);
2313 stop
= parse_and_eval_address (tmp
);
2316 { /* No explicit end address? */
2317 start
= parse_and_eval_address (args
);
2318 stop
= start
+ 1; /* ??? */
2321 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2324 /* info scope command: list the locals for a scope. */
2326 scope_info (char *args
, int from_tty
)
2328 struct symtabs_and_lines sals
;
2330 struct minimal_symbol
*msym
;
2331 struct block
*block
;
2332 char *symname
, *save_args
= args
;
2333 struct dict_iterator iter
;
2335 struct gdbarch
*gdbarch
;
2338 if (args
== 0 || *args
== 0)
2339 error (_("requires an argument (function, "
2340 "line or *addr) to define a scope"));
2342 sals
= decode_line_1 (&args
, 1, NULL
, 0, NULL
);
2343 if (sals
.nelts
== 0)
2344 return; /* Presumably decode_line_1 has already warned. */
2346 /* Resolve line numbers to PC. */
2347 resolve_sal_pc (&sals
.sals
[0]);
2348 block
= block_for_pc (sals
.sals
[0].pc
);
2352 QUIT
; /* Allow user to bail out with ^C. */
2353 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2355 QUIT
; /* Allow user to bail out with ^C. */
2357 printf_filtered ("Scope for %s:\n", save_args
);
2360 symname
= SYMBOL_PRINT_NAME (sym
);
2361 if (symname
== NULL
|| *symname
== '\0')
2362 continue; /* Probably botched, certainly useless. */
2364 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2366 printf_filtered ("Symbol %s is ", symname
);
2367 switch (SYMBOL_CLASS (sym
))
2370 case LOC_UNDEF
: /* Messed up symbol? */
2371 printf_filtered ("a bogus symbol, class %d.\n",
2372 SYMBOL_CLASS (sym
));
2373 count
--; /* Don't count this one. */
2376 printf_filtered ("a constant with value %ld (0x%lx)",
2377 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2379 case LOC_CONST_BYTES
:
2380 printf_filtered ("constant bytes: ");
2381 if (SYMBOL_TYPE (sym
))
2382 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2383 fprintf_filtered (gdb_stdout
, " %02x",
2384 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2387 printf_filtered ("in static storage at address ");
2388 printf_filtered ("%s", paddress (gdbarch
,
2389 SYMBOL_VALUE_ADDRESS (sym
)));
2392 /* GDBARCH is the architecture associated with the objfile
2393 the symbol is defined in; the target architecture may be
2394 different, and may provide additional registers. However,
2395 we do not know the target architecture at this point.
2396 We assume the objfile architecture will contain all the
2397 standard registers that occur in debug info in that
2399 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2402 if (SYMBOL_IS_ARGUMENT (sym
))
2403 printf_filtered ("an argument in register $%s",
2404 gdbarch_register_name (gdbarch
, regno
));
2406 printf_filtered ("a local variable in register $%s",
2407 gdbarch_register_name (gdbarch
, regno
));
2410 printf_filtered ("an argument at stack/frame offset %ld",
2411 SYMBOL_VALUE (sym
));
2414 printf_filtered ("a local variable at frame offset %ld",
2415 SYMBOL_VALUE (sym
));
2418 printf_filtered ("a reference argument at offset %ld",
2419 SYMBOL_VALUE (sym
));
2421 case LOC_REGPARM_ADDR
:
2422 /* Note comment at LOC_REGISTER. */
2423 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2425 printf_filtered ("the address of an argument, in register $%s",
2426 gdbarch_register_name (gdbarch
, regno
));
2429 printf_filtered ("a typedef.\n");
2432 printf_filtered ("a label at address ");
2433 printf_filtered ("%s", paddress (gdbarch
,
2434 SYMBOL_VALUE_ADDRESS (sym
)));
2437 printf_filtered ("a function at address ");
2438 printf_filtered ("%s",
2439 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2441 case LOC_UNRESOLVED
:
2442 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2445 printf_filtered ("Unresolved Static");
2448 printf_filtered ("static storage at address ");
2449 printf_filtered ("%s",
2450 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2453 case LOC_OPTIMIZED_OUT
:
2454 printf_filtered ("optimized out.\n");
2457 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2458 BLOCK_START (block
),
2462 if (SYMBOL_TYPE (sym
))
2463 printf_filtered (", length %d.\n",
2464 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2466 if (BLOCK_FUNCTION (block
))
2469 block
= BLOCK_SUPERBLOCK (block
);
2472 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2476 /* worker function (cleanup) */
2478 replace_comma (void *data
)
2485 /* Helper for trace_dump_command. Dump the action list starting at
2486 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2487 actions of the body of a while-stepping action. STEPPING_FRAME is
2488 set if the current traceframe was determined to be a while-stepping
2492 trace_dump_actions (struct command_line
*action
,
2493 int stepping_actions
, int stepping_frame
,
2496 char *action_exp
, *next_comma
;
2498 for (; action
!= NULL
; action
= action
->next
)
2500 struct cmd_list_element
*cmd
;
2502 QUIT
; /* Allow user to bail out with ^C. */
2503 action_exp
= action
->line
;
2504 while (isspace ((int) *action_exp
))
2507 /* The collection actions to be done while stepping are
2508 bracketed by the commands "while-stepping" and "end". */
2510 if (*action_exp
== '#') /* comment line */
2513 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2515 error (_("Bad action list item: %s"), action_exp
);
2517 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2521 for (i
= 0; i
< action
->body_count
; ++i
)
2522 trace_dump_actions (action
->body_list
[i
],
2523 1, stepping_frame
, from_tty
);
2525 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2527 /* Display the collected data.
2528 For the trap frame, display only what was collected at
2529 the trap. Likewise for stepping frames, display only
2530 what was collected while stepping. This means that the
2531 two boolean variables, STEPPING_FRAME and
2532 STEPPING_ACTIONS should be equal. */
2533 if (stepping_frame
== stepping_actions
)
2536 { /* Repeat over a comma-separated list. */
2537 QUIT
; /* Allow user to bail out with ^C. */
2538 if (*action_exp
== ',')
2540 while (isspace ((int) *action_exp
))
2543 next_comma
= strchr (action_exp
, ',');
2545 if (0 == strncasecmp (action_exp
, "$reg", 4))
2546 registers_info (NULL
, from_tty
);
2547 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2548 locals_info (NULL
, from_tty
);
2549 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2550 args_info (NULL
, from_tty
);
2555 make_cleanup (replace_comma
, next_comma
);
2558 printf_filtered ("%s = ", action_exp
);
2559 output_command (action_exp
, from_tty
);
2560 printf_filtered ("\n");
2564 action_exp
= next_comma
;
2566 while (action_exp
&& *action_exp
== ',');
2572 /* The tdump command. */
2575 trace_dump_command (char *args
, int from_tty
)
2577 struct regcache
*regcache
;
2578 struct breakpoint
*t
;
2579 int stepping_frame
= 0;
2580 struct bp_location
*loc
;
2581 char *line
, *default_collect_line
= NULL
;
2582 struct command_line
*actions
, *default_collect_action
= NULL
;
2583 struct cleanup
*old_chain
= NULL
;
2585 if (tracepoint_number
== -1)
2587 warning (_("No current trace frame."));
2591 t
= get_tracepoint (tracepoint_number
);
2594 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2597 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2598 tracepoint_number
, traceframe_number
);
2600 /* The current frame is a trap frame if the frame PC is equal
2601 to the tracepoint PC. If not, then the current frame was
2602 collected during single-stepping. */
2604 regcache
= get_current_regcache ();
2606 /* If the traceframe's address matches any of the tracepoint's
2607 locations, assume it is a direct hit rather than a while-stepping
2608 frame. (FIXME this is not reliable, should record each frame's
2611 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2612 if (loc
->address
== regcache_read_pc (regcache
))
2615 actions
= breakpoint_commands (t
);
2617 /* If there is a default-collect list, make up a collect command,
2618 prepend to the tracepoint's commands, and pass the whole mess to
2619 the trace dump scanner. We need to validate because
2620 default-collect might have been junked since the trace run. */
2621 if (*default_collect
)
2623 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2624 old_chain
= make_cleanup (xfree
, default_collect_line
);
2625 line
= default_collect_line
;
2626 validate_actionline (&line
, t
);
2627 default_collect_action
= xmalloc (sizeof (struct command_line
));
2628 make_cleanup (xfree
, default_collect_action
);
2629 default_collect_action
->next
= actions
;
2630 default_collect_action
->line
= line
;
2631 actions
= default_collect_action
;
2634 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2636 if (*default_collect
)
2637 do_cleanups (old_chain
);
2640 /* Encode a piece of a tracepoint's source-level definition in a form
2641 that is suitable for both protocol and saving in files. */
2642 /* This version does not do multiple encodes for long strings; it should
2643 return an offset to the next piece to encode. FIXME */
2646 encode_source_string (int tpnum
, ULONGEST addr
,
2647 char *srctype
, char *src
, char *buf
, int buf_size
)
2649 if (80 + strlen (srctype
) > buf_size
)
2650 error (_("Buffer too small for source encoding"));
2651 sprintf (buf
, "%x:%s:%s:%x:%x:",
2652 tpnum
, phex_nz (addr
, sizeof (addr
)),
2653 srctype
, 0, (int) strlen (src
));
2654 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2655 error (_("Source string too long for buffer"));
2656 bin2hex (src
, buf
+ strlen (buf
), 0);
2660 extern int trace_regblock_size
;
2662 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2663 non-zero, the save is performed on the target, otherwise GDB obtains all
2664 trace data and saves it locally. */
2667 trace_save (const char *filename
, int target_does_save
)
2669 struct cleanup
*cleanup
;
2671 struct trace_status
*ts
= current_trace_status ();
2674 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2675 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2679 ULONGEST offset
= 0;
2680 #define MAX_TRACE_UPLOAD 2000
2681 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2684 /* If the target is to save the data to a file on its own, then just
2685 send the command and be done with it. */
2686 if (target_does_save
)
2688 err
= target_save_trace_data (filename
);
2690 error (_("Target failed to save trace data to '%s'."),
2695 /* Get the trace status first before opening the file, so if the
2696 target is losing, we can get out without touching files. */
2697 status
= target_get_trace_status (ts
);
2699 pathname
= tilde_expand (filename
);
2700 cleanup
= make_cleanup (xfree
, pathname
);
2702 fp
= fopen (pathname
, "wb");
2704 error (_("Unable to open file '%s' for saving trace data (%s)"),
2705 filename
, safe_strerror (errno
));
2706 make_cleanup_fclose (fp
);
2708 /* Write a file header, with a high-bit-set char to indicate a
2709 binary file, plus a hint as what this file is, and a version
2710 number in case of future needs. */
2711 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2713 perror_with_name (pathname
);
2715 /* Write descriptive info. */
2717 /* Write out the size of a register block. */
2718 fprintf (fp
, "R %x\n", trace_regblock_size
);
2720 /* Write out status of the tracing run (aka "tstatus" info). */
2721 fprintf (fp
, "status %c;%s",
2722 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
2723 if (ts
->stop_reason
== tracepoint_error
)
2725 char *buf
= (char *) alloca (strlen (ts
->error_desc
) * 2 + 1);
2727 bin2hex ((gdb_byte
*) ts
->error_desc
, buf
, 0);
2728 fprintf (fp
, ":%s", buf
);
2730 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
2731 if (ts
->traceframe_count
>= 0)
2732 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
2733 if (ts
->traceframes_created
>= 0)
2734 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
2735 if (ts
->buffer_free
>= 0)
2736 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
2737 if (ts
->buffer_size
>= 0)
2738 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
2739 if (ts
->disconnected_tracing
)
2740 fprintf (fp
, ";disconn:%x", ts
->disconnected_tracing
);
2741 if (ts
->circular_buffer
)
2742 fprintf (fp
, ";circular:%x", ts
->circular_buffer
);
2745 /* Note that we want to upload tracepoints and save those, rather
2746 than simply writing out the local ones, because the user may have
2747 changed tracepoints in GDB in preparation for a future tracing
2748 run, or maybe just mass-deleted all types of breakpoints as part
2749 of cleaning up. So as not to contaminate the session, leave the
2750 data in its uploaded form, don't make into real tracepoints. */
2752 /* Get trace state variables first, they may be checked when parsing
2753 uploaded commands. */
2755 target_upload_trace_state_variables (&uploaded_tsvs
);
2757 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2763 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
2764 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
2767 fprintf (fp
, "tsv %x:%s:%x:%s\n",
2768 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
2769 utsv
->builtin
, buf
);
2775 free_uploaded_tsvs (&uploaded_tsvs
);
2777 target_upload_tracepoints (&uploaded_tps
);
2779 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
2781 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
2782 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2783 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
2784 if (utp
->type
== bp_fast_tracepoint
)
2785 fprintf (fp
, ":F%x", utp
->orig_size
);
2787 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
2790 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
2791 fprintf (fp
, "tp A%x:%s:%s\n",
2792 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
2793 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
2794 fprintf (fp
, "tp S%x:%s:%s\n",
2795 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
2798 encode_source_string (utp
->number
, utp
->addr
,
2799 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
2800 fprintf (fp
, "tp Z%s\n", buf
);
2802 if (utp
->cond_string
)
2804 encode_source_string (utp
->number
, utp
->addr
,
2805 "cond", utp
->cond_string
,
2806 buf
, MAX_TRACE_UPLOAD
);
2807 fprintf (fp
, "tp Z%s\n", buf
);
2809 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
2811 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
2812 buf
, MAX_TRACE_UPLOAD
);
2813 fprintf (fp
, "tp Z%s\n", buf
);
2817 free_uploaded_tps (&uploaded_tps
);
2819 /* Mark the end of the definition section. */
2822 /* Get and write the trace data proper. We ask for big blocks, in
2823 the hopes of efficiency, but will take less if the target has
2824 packet size limitations or some such. */
2827 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
2829 error (_("Failure to get requested trace buffer data"));
2830 /* No more data is forthcoming, we're done. */
2833 written
= fwrite (buf
, gotten
, 1, fp
);
2835 perror_with_name (pathname
);
2839 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
2840 written
= fwrite (&gotten
, 4, 1, fp
);
2842 perror_with_name (pathname
);
2844 do_cleanups (cleanup
);
2848 trace_save_command (char *args
, int from_tty
)
2850 int target_does_save
= 0;
2852 char *filename
= NULL
;
2853 struct cleanup
*back_to
;
2856 error_no_arg (_("file in which to save trace data"));
2858 argv
= gdb_buildargv (args
);
2859 back_to
= make_cleanup_freeargv (argv
);
2861 for (; *argv
; ++argv
)
2863 if (strcmp (*argv
, "-r") == 0)
2864 target_does_save
= 1;
2865 else if (**argv
== '-')
2866 error (_("unknown option `%s'"), *argv
);
2872 error_no_arg (_("file in which to save trace data"));
2874 trace_save (filename
, target_does_save
);
2877 printf_filtered (_("Trace data saved to file '%s'.\n"), args
);
2879 do_cleanups (back_to
);
2882 /* Tell the target what to do with an ongoing tracing run if GDB
2883 disconnects for some reason. */
2886 send_disconnected_tracing_value (int value
)
2888 target_set_disconnected_tracing (value
);
2892 set_disconnected_tracing (char *args
, int from_tty
,
2893 struct cmd_list_element
*c
)
2895 send_disconnected_tracing_value (disconnected_tracing
);
2899 set_circular_trace_buffer (char *args
, int from_tty
,
2900 struct cmd_list_element
*c
)
2902 target_set_circular_trace_buffer (circular_trace_buffer
);
2905 /* Convert the memory pointed to by mem into hex, placing result in buf.
2906 * Return a pointer to the last char put in buf (null)
2907 * "stolen" from sparc-stub.c
2910 static const char hexchars
[] = "0123456789abcdef";
2913 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2921 *buf
++ = hexchars
[ch
>> 4];
2922 *buf
++ = hexchars
[ch
& 0xf];
2931 get_traceframe_number (void)
2933 return traceframe_number
;
2936 /* Make the traceframe NUM be the current trace frame. Does nothing
2937 if NUM is already current. */
2940 set_current_traceframe (int num
)
2944 if (traceframe_number
== num
)
2946 /* Nothing to do. */
2950 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
2953 warning (_("could not change traceframe"));
2955 traceframe_number
= newnum
;
2957 /* Changing the traceframe changes our view of registers and of the
2959 registers_changed ();
2961 clear_traceframe_info ();
2964 /* Make the traceframe NUM be the current trace frame, and do nothing
2968 set_traceframe_number (int num
)
2970 traceframe_number
= num
;
2973 /* A cleanup used when switching away and back from tfind mode. */
2975 struct current_traceframe_cleanup
2977 /* The traceframe we were inspecting. */
2978 int traceframe_number
;
2982 do_restore_current_traceframe_cleanup (void *arg
)
2984 struct current_traceframe_cleanup
*old
= arg
;
2986 set_current_traceframe (old
->traceframe_number
);
2990 restore_current_traceframe_cleanup_dtor (void *arg
)
2992 struct current_traceframe_cleanup
*old
= arg
;
2998 make_cleanup_restore_current_traceframe (void)
3000 struct current_traceframe_cleanup
*old
;
3002 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3003 old
->traceframe_number
= traceframe_number
;
3005 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3006 restore_current_traceframe_cleanup_dtor
);
3010 make_cleanup_restore_traceframe_number (void)
3012 return make_cleanup_restore_integer (&traceframe_number
);
3015 /* Given a number and address, return an uploaded tracepoint with that
3016 number, creating if necessary. */
3018 struct uploaded_tp
*
3019 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3021 struct uploaded_tp
*utp
;
3023 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3024 if (utp
->number
== num
&& utp
->addr
== addr
)
3026 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3027 memset (utp
, 0, sizeof (struct uploaded_tp
));
3030 utp
->actions
= NULL
;
3031 utp
->step_actions
= NULL
;
3032 utp
->cmd_strings
= NULL
;
3039 free_uploaded_tps (struct uploaded_tp
**utpp
)
3041 struct uploaded_tp
*next_one
;
3045 next_one
= (*utpp
)->next
;
3051 /* Given a number and address, return an uploaded tracepoint with that
3052 number, creating if necessary. */
3054 struct uploaded_tsv
*
3055 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3057 struct uploaded_tsv
*utsv
;
3059 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3060 if (utsv
->number
== num
)
3062 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3063 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3065 utsv
->next
= *utsvp
;
3071 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3073 struct uploaded_tsv
*next_one
;
3077 next_one
= (*utsvp
)->next
;
3083 /* Look for an existing tracepoint that seems similar enough to the
3084 uploaded one. Enablement isn't compared, because the user can
3085 toggle that freely, and may have done so in anticipation of the
3089 find_matching_tracepoint (struct uploaded_tp
*utp
)
3091 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3093 struct breakpoint
*t
;
3094 struct bp_location
*loc
;
3096 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
3098 if (t
->type
== utp
->type
3099 && t
->step_count
== utp
->step
3100 && t
->pass_count
== utp
->pass
3101 /* FIXME also test conditionals and actions. */
3104 /* Scan the locations for an address match. */
3105 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
3107 if (loc
->address
== utp
->addr
)
3115 /* Given a list of tracepoints uploaded from a target, attempt to
3116 match them up with existing tracepoints, and create new ones if not
3120 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3122 struct uploaded_tp
*utp
;
3123 struct breakpoint
*t
;
3125 /* Look for GDB tracepoints that match up with our uploaded versions. */
3126 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3128 t
= find_matching_tracepoint (utp
);
3130 printf_filtered (_("Assuming tracepoint %d is same "
3131 "as target's tracepoint %d at %s.\n"),
3132 t
->number
, utp
->number
,
3133 paddress (get_current_arch (), utp
->addr
));
3136 t
= create_tracepoint_from_upload (utp
);
3138 printf_filtered (_("Created tracepoint %d for "
3139 "target's tracepoint %d at %s.\n"),
3140 t
->number
, utp
->number
,
3141 paddress (get_current_arch (), utp
->addr
));
3143 printf_filtered (_("Failed to create tracepoint for target's "
3144 "tracepoint %d at %s, skipping it.\n"),
3146 paddress (get_current_arch (), utp
->addr
));
3148 /* Whether found or created, record the number used by the
3149 target, to help with mapping target tracepoints back to their
3150 counterparts here. */
3152 t
->number_on_target
= utp
->number
;
3155 free_uploaded_tps (uploaded_tps
);
3158 /* Trace state variables don't have much to identify them beyond their
3159 name, so just use that to detect matches. */
3161 struct trace_state_variable
*
3162 find_matching_tsv (struct uploaded_tsv
*utsv
)
3167 return find_trace_state_variable (utsv
->name
);
3170 struct trace_state_variable
*
3171 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3173 const char *namebase
;
3176 struct trace_state_variable
*tsv
;
3180 namebase
= utsv
->name
;
3181 sprintf (buf
, "%s", namebase
);
3186 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3189 /* Fish for a name that is not in use. */
3190 /* (should check against all internal vars?) */
3191 while (find_trace_state_variable (buf
))
3192 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3194 /* We have an available name, create the variable. */
3195 tsv
= create_trace_state_variable (buf
);
3196 tsv
->initial_value
= utsv
->initial_value
;
3197 tsv
->builtin
= utsv
->builtin
;
3202 /* Given a list of uploaded trace state variables, try to match them
3203 up with existing variables, or create additional ones. */
3206 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3209 struct uploaded_tsv
*utsv
;
3210 struct trace_state_variable
*tsv
;
3213 /* Most likely some numbers will have to be reassigned as part of
3214 the merge, so clear them all in anticipation. */
3215 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3218 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3220 tsv
= find_matching_tsv (utsv
);
3224 printf_filtered (_("Assuming trace state variable $%s "
3225 "is same as target's variable %d.\n"),
3226 tsv
->name
, utsv
->number
);
3230 tsv
= create_tsv_from_upload (utsv
);
3232 printf_filtered (_("Created trace state variable "
3233 "$%s for target's variable %d.\n"),
3234 tsv
->name
, utsv
->number
);
3236 /* Give precedence to numberings that come from the target. */
3238 tsv
->number
= utsv
->number
;
3241 /* Renumber everything that didn't get a target-assigned number. */
3243 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3244 if (tsv
->number
> highest
)
3245 highest
= tsv
->number
;
3248 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3249 if (tsv
->number
== 0)
3250 tsv
->number
= highest
++;
3252 free_uploaded_tsvs (uploaded_tsvs
);
3255 /* target tfile command */
3257 struct target_ops tfile_ops
;
3259 /* Fill in tfile_ops with its defined operations and properties. */
3261 #define TRACE_HEADER_SIZE 8
3263 char *trace_filename
;
3265 off_t trace_frames_offset
;
3267 int cur_traceframe_number
;
3269 int trace_regblock_size
;
3271 static void tfile_interp_line (char *line
,
3272 struct uploaded_tp
**utpp
,
3273 struct uploaded_tsv
**utsvp
);
3275 /* Read SIZE bytes into READBUF from the trace frame, starting at
3276 TRACE_FD's current position. Note that this call `read'
3277 underneath, hence it advances the file's seek position. Throws an
3278 error if the `read' syscall fails, or less than SIZE bytes are
3282 tfile_read (gdb_byte
*readbuf
, int size
)
3286 gotten
= read (trace_fd
, readbuf
, size
);
3288 perror_with_name (trace_filename
);
3289 else if (gotten
< size
)
3290 error (_("Premature end of file while reading trace file"));
3294 tfile_open (char *filename
, int from_tty
)
3297 struct cleanup
*old_chain
;
3300 char header
[TRACE_HEADER_SIZE
];
3301 char linebuf
[1000]; /* Should be max remote packet size or so. */
3304 struct trace_status
*ts
;
3305 struct uploaded_tp
*uploaded_tps
= NULL
;
3306 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3308 target_preopen (from_tty
);
3310 error (_("No trace file specified."));
3312 filename
= tilde_expand (filename
);
3313 if (!IS_ABSOLUTE_PATH(filename
))
3315 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
3320 old_chain
= make_cleanup (xfree
, filename
);
3322 flags
= O_BINARY
| O_LARGEFILE
;
3324 scratch_chan
= open (filename
, flags
, 0);
3325 if (scratch_chan
< 0)
3326 perror_with_name (filename
);
3328 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3330 discard_cleanups (old_chain
); /* Don't free filename any more. */
3331 unpush_target (&tfile_ops
);
3333 push_target (&tfile_ops
);
3335 trace_filename
= xstrdup (filename
);
3336 trace_fd
= scratch_chan
;
3339 /* Read the file header and test for validity. */
3340 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
3342 bytes
+= TRACE_HEADER_SIZE
;
3343 if (!(header
[0] == 0x7f
3344 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3345 error (_("File is not a valid trace file."));
3347 trace_regblock_size
= 0;
3348 ts
= current_trace_status ();
3349 /* We know we're working with a file. */
3351 /* Set defaults in case there is no status line. */
3352 ts
->running_known
= 0;
3353 ts
->stop_reason
= trace_stop_reason_unknown
;
3354 ts
->traceframe_count
= -1;
3355 ts
->buffer_free
= 0;
3356 ts
->disconnected_tracing
= 0;
3357 ts
->circular_buffer
= 0;
3359 cur_traceframe_number
= -1;
3361 /* Read through a section of newline-terminated lines that
3362 define things like tracepoints. */
3366 tfile_read (&byte
, 1);
3371 /* Empty line marks end of the definition section. */
3376 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3379 linebuf
[i
++] = byte
;
3381 error (_("Excessively long lines in trace file"));
3384 /* Add the file's tracepoints and variables into the current mix. */
3386 /* Get trace state variables first, they may be checked when parsing
3387 uploaded commands. */
3388 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3390 merge_uploaded_tracepoints (&uploaded_tps
);
3392 /* Record the starting offset of the binary trace data. */
3393 trace_frames_offset
= bytes
;
3395 /* If we don't have a blocksize, we can't interpret the
3397 if (trace_regblock_size
== 0)
3398 error (_("No register block size recorded in trace file"));
3399 if (ts
->traceframe_count
<= 0)
3401 warning (_("No traceframes present in this file."));
3405 #define TFILE_PID (1)
3406 inferior_appeared (current_inferior (), TFILE_PID
);
3407 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3408 add_thread_silent (inferior_ptid
);
3410 post_create_inferior (&tfile_ops
, from_tty
);
3413 /* FIXME this will get defined in MI patch submission. */
3414 tfind_1 (tfind_number
, 0, 0, 0, 0);
3418 /* Interpret the given line from the definitions part of the trace
3422 tfile_interp_line (char *line
,
3423 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3427 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3430 trace_regblock_size
= strtol (p
, &p
, 16);
3432 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3434 p
+= strlen ("status ");
3435 parse_trace_status (p
, current_trace_status ());
3437 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3439 p
+= strlen ("tp ");
3440 parse_tracepoint_definition (p
, utpp
);
3442 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3444 p
+= strlen ("tsv ");
3445 parse_tsv_definition (p
, utsvp
);
3448 warning (_("Ignoring trace file definition \"%s\""), line
);
3451 /* Parse the part of trace status syntax that is shared between
3452 the remote protocol and the trace file reader. */
3455 parse_trace_status (char *line
, struct trace_status
*ts
)
3457 char *p
= line
, *p1
, *p2
, *p_temp
;
3460 ts
->running_known
= 1;
3461 ts
->running
= (*p
++ == '1');
3462 ts
->stop_reason
= trace_stop_reason_unknown
;
3463 xfree (ts
->error_desc
);
3464 ts
->error_desc
= NULL
;
3465 ts
->traceframe_count
= -1;
3466 ts
->traceframes_created
= -1;
3467 ts
->buffer_free
= -1;
3468 ts
->buffer_size
= -1;
3469 ts
->disconnected_tracing
= 0;
3470 ts
->circular_buffer
= 0;
3474 p1
= strchr (p
, ':');
3476 error (_("Malformed trace status, at %s\n\
3477 Status line: '%s'\n"), p
, line
);
3478 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3480 p
= unpack_varlen_hex (++p1
, &val
);
3481 ts
->stop_reason
= trace_buffer_full
;
3483 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3485 p
= unpack_varlen_hex (++p1
, &val
);
3486 ts
->stop_reason
= trace_never_run
;
3488 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3491 p
= unpack_varlen_hex (++p1
, &val
);
3492 ts
->stop_reason
= tracepoint_passcount
;
3493 ts
->stopping_tracepoint
= val
;
3495 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3497 p
= unpack_varlen_hex (++p1
, &val
);
3498 ts
->stop_reason
= tstop_command
;
3500 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3502 p
= unpack_varlen_hex (++p1
, &val
);
3503 ts
->stop_reason
= trace_disconnected
;
3505 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3507 p2
= strchr (++p1
, ':');
3512 ts
->error_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3513 end
= hex2bin (p1
, ts
->error_desc
, (p2
- p1
) / 2);
3514 ts
->error_desc
[end
] = '\0';
3517 ts
->error_desc
= xstrdup ("");
3519 p
= unpack_varlen_hex (++p2
, &val
);
3520 ts
->stopping_tracepoint
= val
;
3521 ts
->stop_reason
= tracepoint_error
;
3523 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3525 p
= unpack_varlen_hex (++p1
, &val
);
3526 ts
->traceframe_count
= val
;
3528 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3530 p
= unpack_varlen_hex (++p1
, &val
);
3531 ts
->traceframes_created
= val
;
3533 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3535 p
= unpack_varlen_hex (++p1
, &val
);
3536 ts
->buffer_free
= val
;
3538 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3540 p
= unpack_varlen_hex (++p1
, &val
);
3541 ts
->buffer_size
= val
;
3543 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3545 p
= unpack_varlen_hex (++p1
, &val
);
3546 ts
->disconnected_tracing
= val
;
3548 else if (strncmp (p
, "circular", p1
- p
) == 0)
3550 p
= unpack_varlen_hex (++p1
, &val
);
3551 ts
->circular_buffer
= val
;
3555 /* Silently skip unknown optional info. */
3556 p_temp
= strchr (p1
+ 1, ';');
3560 /* Must be at the end. */
3566 /* Given a line of text defining a part of a tracepoint, parse it into
3567 an "uploaded tracepoint". */
3570 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3574 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3577 char *cond
, *srctype
, *buf
;
3578 struct uploaded_tp
*utp
= NULL
;
3581 /* Both tracepoint and action definitions start with the same number
3582 and address sequence. */
3584 p
= unpack_varlen_hex (p
, &num
);
3585 p
++; /* skip a colon */
3586 p
= unpack_varlen_hex (p
, &addr
);
3587 p
++; /* skip a colon */
3590 enabled
= (*p
++ == 'E');
3591 p
++; /* skip a colon */
3592 p
= unpack_varlen_hex (p
, &step
);
3593 p
++; /* skip a colon */
3594 p
= unpack_varlen_hex (p
, &pass
);
3595 type
= bp_tracepoint
;
3597 /* Thumb through optional fields. */
3600 p
++; /* skip a colon */
3603 type
= bp_fast_tracepoint
;
3605 p
= unpack_varlen_hex (p
, &orig_size
);
3609 type
= bp_static_tracepoint
;
3615 p
= unpack_varlen_hex (p
, &xlen
);
3616 p
++; /* skip a comma */
3617 cond
= (char *) xmalloc (2 * xlen
+ 1);
3618 strncpy (cond
, p
, 2 * xlen
);
3619 cond
[2 * xlen
] = '\0';
3623 warning (_("Unrecognized char '%c' in tracepoint "
3624 "definition, skipping rest"), *p
);
3626 utp
= get_uploaded_tp (num
, addr
, utpp
);
3628 utp
->enabled
= enabled
;
3633 else if (piece
== 'A')
3635 utp
= get_uploaded_tp (num
, addr
, utpp
);
3636 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
3638 else if (piece
== 'S')
3640 utp
= get_uploaded_tp (num
, addr
, utpp
);
3641 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
3643 else if (piece
== 'Z')
3645 /* Parse a chunk of source form definition. */
3646 utp
= get_uploaded_tp (num
, addr
, utpp
);
3648 p
= strchr (p
, ':');
3649 p
++; /* skip a colon */
3650 p
= unpack_varlen_hex (p
, &start
);
3651 p
++; /* skip a colon */
3652 p
= unpack_varlen_hex (p
, &xlen
);
3653 p
++; /* skip a colon */
3655 buf
= alloca (strlen (line
));
3657 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3660 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
3661 utp
->at_string
= xstrdup (buf
);
3662 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
3663 utp
->cond_string
= xstrdup (buf
);
3664 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
3665 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
3669 /* Don't error out, the target might be sending us optional
3670 info that we don't care about. */
3671 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3675 /* Convert a textual description of a trace state variable into an
3679 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3682 ULONGEST num
, initval
, builtin
;
3684 struct uploaded_tsv
*utsv
= NULL
;
3686 buf
= alloca (strlen (line
));
3689 p
= unpack_varlen_hex (p
, &num
);
3690 p
++; /* skip a colon */
3691 p
= unpack_varlen_hex (p
, &initval
);
3692 p
++; /* skip a colon */
3693 p
= unpack_varlen_hex (p
, &builtin
);
3694 p
++; /* skip a colon */
3695 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3698 utsv
= get_uploaded_tsv (num
, utsvp
);
3699 utsv
->initial_value
= initval
;
3700 utsv
->builtin
= builtin
;
3701 utsv
->name
= xstrdup (buf
);
3704 /* Close the trace file and generally clean up. */
3707 tfile_close (int quitting
)
3714 pid
= ptid_get_pid (inferior_ptid
);
3715 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff. */
3716 exit_inferior_silent (pid
);
3721 xfree (trace_filename
);
3725 tfile_files_info (struct target_ops
*t
)
3727 /* (it would be useful to mention the name of the file). */
3728 printf_filtered ("Looking at a trace file.\n");
3731 /* The trace status for a file is that tracing can never be run. */
3734 tfile_get_trace_status (struct trace_status
*ts
)
3736 /* Other bits of trace status were collected as part of opening the
3737 trace files, so nothing to do here. */
3742 /* Given the position of a traceframe in the file, figure out what
3743 address the frame was collected at. This would normally be the
3744 value of a collected PC register, but if not available, we
3748 tfile_get_traceframe_address (off_t tframe_offset
)
3752 struct breakpoint
*tp
;
3753 off_t saved_offset
= cur_offset
;
3755 /* FIXME dig pc out of collected registers. */
3757 /* Fall back to using tracepoint address. */
3758 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
3759 tfile_read ((gdb_byte
*) &tpnum
, 2);
3760 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
3764 tp
= get_tracepoint_by_number_on_target (tpnum
);
3765 /* FIXME this is a poor heuristic if multiple locations. */
3767 addr
= tp
->loc
->address
;
3769 /* Restore our seek position. */
3770 cur_offset
= saved_offset
;
3771 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3775 /* Make tfile's selected traceframe match GDB's selected
3779 set_tfile_traceframe (void)
3783 if (cur_traceframe_number
== get_traceframe_number ())
3786 /* Avoid recursion, tfile_trace_find calls us again. */
3787 cur_traceframe_number
= get_traceframe_number ();
3789 newnum
= target_trace_find (tfind_number
,
3790 get_traceframe_number (), 0, 0, NULL
);
3792 /* Should not happen. If it does, all bets are off. */
3793 if (newnum
!= get_traceframe_number ())
3794 warning (_("could not set tfile's traceframe"));
3797 /* Given a type of search and some parameters, scan the collection of
3798 traceframes in the file looking for a match. When found, return
3799 both the traceframe and tracepoint number, otherwise -1 for
3803 tfile_trace_find (enum trace_find_type type
, int num
,
3804 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
3807 int tfnum
= 0, found
= 0;
3808 unsigned int data_size
;
3809 struct breakpoint
*tp
;
3810 off_t offset
, tframe_offset
;
3813 /* Lookups other than by absolute frame number depend on the current
3814 trace selected, so make sure it is correct on the tfile end
3816 if (type
!= tfind_number
)
3817 set_tfile_traceframe ();
3819 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
3820 offset
= trace_frames_offset
;
3823 tframe_offset
= offset
;
3824 tfile_read ((gdb_byte
*) &tpnum
, 2);
3825 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
3831 tfile_read ((gdb_byte
*) &data_size
, 4);
3832 data_size
= (unsigned int) extract_unsigned_integer
3833 ((gdb_byte
*) &data_size
, 4,
3834 gdbarch_byte_order (target_gdbarch
));
3843 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3844 if (tfaddr
== addr1
)
3848 tp
= get_tracepoint (num
);
3849 if (tp
&& tpnum
== tp
->number_on_target
)
3853 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3854 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
3858 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3859 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
3863 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
3869 cur_offset
= offset
;
3870 cur_data_size
= data_size
;
3871 cur_traceframe_number
= tfnum
;
3874 /* Skip past the traceframe's data. */
3875 lseek (trace_fd
, data_size
, SEEK_CUR
);
3876 offset
+= data_size
;
3877 /* Update our own count of traceframes. */
3880 /* Did not find what we were looking for. */
3886 /* Prototype of the callback passed to tframe_walk_blocks. */
3887 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
3889 /* Callback for traceframe_walk_blocks, used to find a given block
3890 type in a traceframe. */
3893 match_blocktype (char blocktype
, void *data
)
3895 char *wantedp
= data
;
3897 if (*wantedp
== blocktype
)
3903 /* Walk over all traceframe block starting at POS offset from
3904 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
3905 unmodified. If CALLBACK returns true, this returns the position in
3906 the traceframe where the block is found, relative to the start of
3907 the traceframe (cur_offset). Returns -1 if no callback call
3908 returned true, indicating that all blocks have been walked. */
3911 traceframe_walk_blocks (walk_blocks_callback_func callback
,
3912 int pos
, void *data
)
3914 /* Iterate through a traceframe's blocks, looking for a block of the
3917 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
3918 while (pos
< cur_data_size
)
3920 unsigned short mlen
;
3923 tfile_read (&block_type
, 1);
3927 if ((*callback
) (block_type
, data
))
3933 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
3934 pos
+= trace_regblock_size
;
3937 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
3938 tfile_read ((gdb_byte
*) &mlen
, 2);
3939 mlen
= (unsigned short)
3940 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
3943 lseek (trace_fd
, mlen
, SEEK_CUR
);
3944 pos
+= (8 + 2 + mlen
);
3947 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
3951 error (_("Unknown block type '%c' (0x%x) in trace frame"),
3952 block_type
, block_type
);
3960 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
3961 position offset of a block of type TYPE_WANTED in the current trace
3962 frame, starting at POS. Returns -1 if no such block was found. */
3965 traceframe_find_block_type (char type_wanted
, int pos
)
3967 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
3970 /* Look for a block of saved registers in the traceframe, and get the
3971 requested register from it. */
3974 tfile_fetch_registers (struct target_ops
*ops
,
3975 struct regcache
*regcache
, int regno
)
3977 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3979 int pos
, offset
, regn
, regsize
, pc_regno
;
3980 unsigned short mlen
;
3983 /* An uninitialized reg size says we're not going to be
3984 successful at getting register blocks. */
3985 if (!trace_regblock_size
)
3988 set_tfile_traceframe ();
3990 regs
= alloca (trace_regblock_size
);
3992 if (traceframe_find_block_type ('R', 0) >= 0)
3994 tfile_read (regs
, trace_regblock_size
);
3996 /* Assume the block is laid out in GDB register number order,
3997 each register with the size that it has in GDB. */
3999 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4001 regsize
= register_size (gdbarch
, regn
);
4002 /* Make sure we stay within block bounds. */
4003 if (offset
+ regsize
>= trace_regblock_size
)
4005 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
4009 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
4012 else if (regno
== -1)
4014 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
4022 /* We get here if no register data has been found. Mark registers
4024 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4025 regcache_raw_supply (regcache
, regn
, NULL
);
4027 /* We can often usefully guess that the PC is going to be the same
4028 as the address of the tracepoint. */
4029 pc_regno
= gdbarch_pc_regnum (gdbarch
);
4030 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
4032 struct breakpoint
*tp
= get_tracepoint (tracepoint_number
);
4036 /* But don't try to guess if tracepoint is multi-location... */
4039 warning (_("Tracepoint %d has multiple "
4040 "locations, cannot infer $pc"),
4044 /* ... or does while-stepping. */
4045 if (tp
->step_count
> 0)
4047 warning (_("Tracepoint %d does while-stepping, "
4048 "cannot infer $pc"),
4053 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
4054 gdbarch_byte_order (gdbarch
),
4056 regcache_raw_supply (regcache
, pc_regno
, regs
);
4062 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4063 const char *annex
, gdb_byte
*readbuf
,
4064 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
4066 /* We're only doing regular memory for now. */
4067 if (object
!= TARGET_OBJECT_MEMORY
)
4070 if (readbuf
== NULL
)
4071 error (_("tfile_xfer_partial: trace file is read-only"));
4073 set_tfile_traceframe ();
4075 if (traceframe_number
!= -1)
4079 /* Iterate through the traceframe's blocks, looking for
4081 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
4083 ULONGEST maddr
, amt
;
4084 unsigned short mlen
;
4085 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
4087 tfile_read ((gdb_byte
*) &maddr
, 8);
4088 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
4090 tfile_read ((gdb_byte
*) &mlen
, 2);
4091 mlen
= (unsigned short)
4092 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
4094 /* If the block includes the first part of the desired
4095 range, return as much it has; GDB will re-request the
4096 remainder, which might be in a different block of this
4098 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
4100 amt
= (maddr
+ mlen
) - offset
;
4104 tfile_read (readbuf
, amt
);
4108 /* Skip over this block. */
4109 pos
+= (8 + 2 + mlen
);
4113 /* It's unduly pedantic to refuse to look at the executable for
4114 read-only pieces; so do the equivalent of readonly regions aka
4116 /* FIXME account for relocation at some point. */
4123 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
4125 if ((s
->flags
& SEC_LOAD
) == 0
4126 || (s
->flags
& SEC_READONLY
) == 0)
4130 size
= bfd_get_section_size (s
);
4131 if (vma
<= offset
&& offset
< (vma
+ size
))
4135 amt
= (vma
+ size
) - offset
;
4139 amt
= bfd_get_section_contents (exec_bfd
, s
,
4140 readbuf
, offset
- vma
, amt
);
4146 /* Indicate failure to find the requested memory block. */
4150 /* Iterate through the blocks of a trace frame, looking for a 'V'
4151 block with a matching tsv number. */
4154 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
4158 set_tfile_traceframe ();
4161 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
4165 tfile_read ((gdb_byte
*) &vnum
, 4);
4166 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
4171 tfile_read ((gdb_byte
*) val
, 8);
4172 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
4180 /* Didn't find anything. */
4185 tfile_has_all_memory (struct target_ops
*ops
)
4191 tfile_has_memory (struct target_ops
*ops
)
4197 tfile_has_stack (struct target_ops
*ops
)
4199 return traceframe_number
!= -1;
4203 tfile_has_registers (struct target_ops
*ops
)
4205 return traceframe_number
!= -1;
4208 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
4209 object for the tfile target's current traceframe. */
4212 build_traceframe_info (char blocktype
, void *data
)
4214 struct traceframe_info
*info
= data
;
4220 struct mem_range
*r
;
4222 unsigned short mlen
;
4224 tfile_read ((gdb_byte
*) &maddr
, 8);
4225 tfile_read ((gdb_byte
*) &mlen
, 2);
4227 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4240 warning (_("Unhandled trace block type (%d) '%c ' "
4241 "while building trace frame info."),
4242 blocktype
, blocktype
);
4249 static struct traceframe_info
*
4250 tfile_traceframe_info (void)
4252 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
4254 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
4259 init_tfile_ops (void)
4261 tfile_ops
.to_shortname
= "tfile";
4262 tfile_ops
.to_longname
= "Local trace dump file";
4264 = "Use a trace file as a target. Specify the filename of the trace file.";
4265 tfile_ops
.to_open
= tfile_open
;
4266 tfile_ops
.to_close
= tfile_close
;
4267 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
4268 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
4269 tfile_ops
.to_files_info
= tfile_files_info
;
4270 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
4271 tfile_ops
.to_trace_find
= tfile_trace_find
;
4272 tfile_ops
.to_get_trace_state_variable_value
4273 = tfile_get_trace_state_variable_value
;
4274 tfile_ops
.to_stratum
= process_stratum
;
4275 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
4276 tfile_ops
.to_has_memory
= tfile_has_memory
;
4277 tfile_ops
.to_has_stack
= tfile_has_stack
;
4278 tfile_ops
.to_has_registers
= tfile_has_registers
;
4279 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
4280 tfile_ops
.to_magic
= OPS_MAGIC
;
4283 /* Given a line of text defining a static tracepoint marker, parse it
4284 into a "static tracepoint marker" object. Throws an error is
4285 parsing fails. If PP is non-null, it points to one past the end of
4286 the parsed marker definition. */
4289 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
4290 struct static_tracepoint_marker
*marker
)
4297 p
= unpack_varlen_hex (p
, &addr
);
4298 p
++; /* skip a colon */
4300 marker
->gdbarch
= target_gdbarch
;
4301 marker
->address
= (CORE_ADDR
) addr
;
4303 endp
= strchr (p
, ':');
4305 error (_("bad marker definition: %s"), line
);
4307 marker
->str_id
= xmalloc (endp
- p
+ 1);
4308 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
4309 marker
->str_id
[end
] = '\0';
4312 p
++; /* skip a colon */
4314 marker
->extra
= xmalloc (strlen (p
) + 1);
4315 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
4316 marker
->extra
[end
] = '\0';
4322 /* Release a static tracepoint marker's contents. Note that the
4323 object itself isn't released here. There objects are usually on
4327 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
4329 xfree (marker
->str_id
);
4330 marker
->str_id
= NULL
;
4333 /* Print MARKER to gdb_stdout. */
4336 print_one_static_tracepoint_marker (int count
,
4337 struct static_tracepoint_marker
*marker
)
4339 struct command_line
*l
;
4342 char wrap_indent
[80];
4343 char extra_field_indent
[80];
4344 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
4345 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4346 struct cleanup
*bkpt_chain
;
4347 VEC(breakpoint_p
) *tracepoints
;
4349 struct symtab_and_line sal
;
4353 sal
.pc
= marker
->address
;
4355 tracepoints
= static_tracepoints_here (marker
->address
);
4357 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
4359 /* A counter field to help readability. This is not a stable
4361 ui_out_field_int (uiout
, "count", count
);
4363 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
4365 ui_out_field_fmt (uiout
, "enabled", "%c",
4366 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
4367 ui_out_spaces (uiout
, 2);
4369 strcpy (wrap_indent
, " ");
4371 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
4372 strcat (wrap_indent
, " ");
4374 strcat (wrap_indent
, " ");
4376 strcpy (extra_field_indent
, " ");
4378 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
4380 sal
= find_pc_line (marker
->address
, 0);
4381 sym
= find_pc_sect_function (marker
->address
, NULL
);
4384 ui_out_text (uiout
, "in ");
4385 ui_out_field_string (uiout
, "func",
4386 SYMBOL_PRINT_NAME (sym
));
4387 ui_out_wrap_hint (uiout
, wrap_indent
);
4388 ui_out_text (uiout
, " at ");
4391 ui_out_field_skip (uiout
, "func");
4393 if (sal
.symtab
!= NULL
)
4395 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
4396 ui_out_text (uiout
, ":");
4398 if (ui_out_is_mi_like_p (uiout
))
4400 char *fullname
= symtab_to_fullname (sal
.symtab
);
4403 ui_out_field_string (uiout
, "fullname", fullname
);
4406 ui_out_field_skip (uiout
, "fullname");
4408 ui_out_field_int (uiout
, "line", sal
.line
);
4412 ui_out_field_skip (uiout
, "fullname");
4413 ui_out_field_skip (uiout
, "line");
4416 ui_out_text (uiout
, "\n");
4417 ui_out_text (uiout
, extra_field_indent
);
4418 ui_out_text (uiout
, _("Data: \""));
4419 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
4420 ui_out_text (uiout
, "\"\n");
4422 if (!VEC_empty (breakpoint_p
, tracepoints
))
4424 struct cleanup
*cleanup_chain
;
4426 struct breakpoint
*b
;
4428 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
4431 ui_out_text (uiout
, extra_field_indent
);
4432 ui_out_text (uiout
, _("Probed by static tracepoints: "));
4433 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
4436 ui_out_text (uiout
, ", ");
4437 ui_out_text (uiout
, "#");
4438 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
4441 do_cleanups (cleanup_chain
);
4443 if (ui_out_is_mi_like_p (uiout
))
4444 ui_out_field_int (uiout
, "number-of-tracepoints",
4445 VEC_length(breakpoint_p
, tracepoints
));
4447 ui_out_text (uiout
, "\n");
4449 VEC_free (breakpoint_p
, tracepoints
);
4451 do_cleanups (bkpt_chain
);
4452 do_cleanups (old_chain
);
4456 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
4458 VEC(static_tracepoint_marker_p
) *markers
;
4459 struct cleanup
*old_chain
;
4460 struct static_tracepoint_marker
*marker
;
4464 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
4465 "StaticTracepointMarkersTable");
4467 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
4469 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
4471 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
4472 if (gdbarch_addr_bit (target_gdbarch
) <= 32)
4473 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
4475 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
4476 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
4478 ui_out_table_body (uiout
);
4480 markers
= target_static_tracepoint_markers_by_strid (NULL
);
4481 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
4484 VEC_iterate (static_tracepoint_marker_p
,
4485 markers
, i
, marker
);
4488 print_one_static_tracepoint_marker (i
+ 1, marker
);
4489 release_static_tracepoint_marker (marker
);
4492 do_cleanups (old_chain
);
4495 /* The $_sdata convenience variable is a bit special. We don't know
4496 for sure type of the value until we actually have a chance to fetch
4497 the data --- the size of the object depends on what has been
4498 collected. We solve this by making $_sdata be an internalvar that
4499 creates a new value on access. */
4501 /* Return a new value with the correct type for the sdata object of
4502 the current trace frame. Return a void value if there's no object
4505 static struct value
*
4506 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
)
4511 /* We need to read the whole object before we know its size. */
4512 size
= target_read_alloc (¤t_target
,
4513 TARGET_OBJECT_STATIC_TRACE_DATA
,
4520 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
4522 v
= allocate_value (type
);
4523 memcpy (value_contents_raw (v
), buf
, size
);
4528 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
4531 #if !defined(HAVE_LIBEXPAT)
4533 struct traceframe_info
*
4534 parse_traceframe_info (const char *tframe_info
)
4536 static int have_warned
;
4541 warning (_("Can not parse XML trace frame info; XML support "
4542 "was disabled at compile time"));
4548 #else /* HAVE_LIBEXPAT */
4550 #include "xml-support.h"
4552 /* Handle the start of a <memory> element. */
4555 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
4556 const struct gdb_xml_element
*element
,
4557 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
4559 struct traceframe_info
*info
= user_data
;
4560 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4561 ULONGEST
*start_p
, *length_p
;
4563 start_p
= xml_find_attribute (attributes
, "start")->value
;
4564 length_p
= xml_find_attribute (attributes
, "length")->value
;
4566 r
->start
= *start_p
;
4567 r
->length
= *length_p
;
4570 /* Discard the constructed trace frame info (if an error occurs). */
4573 free_result (void *p
)
4575 struct traceframe_info
*result
= p
;
4577 free_traceframe_info (result
);
4580 /* The allowed elements and attributes for an XML memory map. */
4582 static const struct gdb_xml_attribute memory_attributes
[] = {
4583 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
4584 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
4585 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
4588 static const struct gdb_xml_element traceframe_info_children
[] = {
4589 { "memory", memory_attributes
, NULL
,
4590 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
4591 traceframe_info_start_memory
, NULL
},
4592 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
4595 static const struct gdb_xml_element traceframe_info_elements
[] = {
4596 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
4598 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
4601 /* Parse a traceframe-info XML document. */
4603 struct traceframe_info
*
4604 parse_traceframe_info (const char *tframe_info
)
4606 struct traceframe_info
*result
;
4607 struct cleanup
*back_to
;
4609 result
= XCNEW (struct traceframe_info
);
4610 back_to
= make_cleanup (free_result
, result
);
4612 if (gdb_xml_parse_quick (_("trace frame info"),
4613 "traceframe-info.dtd", traceframe_info_elements
,
4614 tframe_info
, result
) == 0)
4616 /* Parsed successfully, keep the result. */
4617 discard_cleanups (back_to
);
4622 do_cleanups (back_to
);
4626 #endif /* HAVE_LIBEXPAT */
4628 /* Returns the traceframe_info object for the current traceframe.
4629 This is where we avoid re-fetching the object from the target if we
4630 already have it cached. */
4632 struct traceframe_info
*
4633 get_traceframe_info (void)
4635 if (traceframe_info
== NULL
)
4636 traceframe_info
= target_traceframe_info ();
4638 return traceframe_info
;
4641 /* If the target supports the query, return in RESULT the set of
4642 collected memory in the current traceframe, found within the LEN
4643 bytes range starting at MEMADDR. Returns true if the target
4644 supports the query, otherwise returns false, and RESULT is left
4648 traceframe_available_memory (VEC(mem_range_s
) **result
,
4649 CORE_ADDR memaddr
, ULONGEST len
)
4651 struct traceframe_info
*info
= get_traceframe_info ();
4655 struct mem_range
*r
;
4660 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
4661 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
4663 ULONGEST lo1
, hi1
, lo2
, hi2
;
4664 struct mem_range
*nr
;
4667 hi1
= memaddr
+ len
;
4670 hi2
= r
->start
+ r
->length
;
4672 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
4674 nr
->start
= max (lo1
, lo2
);
4675 nr
->length
= min (hi1
, hi2
) - nr
->start
;
4678 normalize_mem_ranges (*result
);
4685 /* module initialization */
4687 _initialize_tracepoint (void)
4689 struct cmd_list_element
*c
;
4691 /* Explicitly create without lookup, since that tries to create a
4692 value with a void typed value, and when we get here, gdbarch
4693 isn't initialized yet. At this point, we're quite sure there
4694 isn't another convenience variable of the same name. */
4695 create_internalvar_type_lazy ("_sdata", sdata_make_value
);
4697 traceframe_number
= -1;
4698 tracepoint_number
= -1;
4700 if (tracepoint_list
.list
== NULL
)
4702 tracepoint_list
.listsize
= 128;
4703 tracepoint_list
.list
= xmalloc
4704 (tracepoint_list
.listsize
* sizeof (struct memrange
));
4706 if (tracepoint_list
.aexpr_list
== NULL
)
4708 tracepoint_list
.aexpr_listsize
= 128;
4709 tracepoint_list
.aexpr_list
= xmalloc
4710 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
4713 if (stepping_list
.list
== NULL
)
4715 stepping_list
.listsize
= 128;
4716 stepping_list
.list
= xmalloc
4717 (stepping_list
.listsize
* sizeof (struct memrange
));
4720 if (stepping_list
.aexpr_list
== NULL
)
4722 stepping_list
.aexpr_listsize
= 128;
4723 stepping_list
.aexpr_list
= xmalloc
4724 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
4727 add_info ("scope", scope_info
,
4728 _("List the variables local to a scope"));
4730 add_cmd ("tracepoints", class_trace
, NULL
,
4731 _("Tracing of program execution without stopping the program."),
4734 add_com ("tdump", class_trace
, trace_dump_command
,
4735 _("Print everything collected at the current tracepoint."));
4737 add_com ("tsave", class_trace
, trace_save_command
, _("\
4738 Save the trace data to a file.\n\
4739 Use the '-r' option to direct the target to save directly to the file,\n\
4740 using its own filesystem."));
4742 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
4743 Define a trace state variable.\n\
4744 Argument is a $-prefixed name, optionally followed\n\
4745 by '=' and an expression that sets the initial value\n\
4746 at the start of tracing."));
4747 set_cmd_completer (c
, expression_completer
);
4749 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
4750 Delete one or more trace state variables.\n\
4751 Arguments are the names of the variables to delete.\n\
4752 If no arguments are supplied, delete all variables."), &deletelist
);
4753 /* FIXME add a trace variable completer. */
4755 add_info ("tvariables", tvariables_info
, _("\
4756 Status of trace state variables and their values.\n\
4759 add_info ("static-tracepoint-markers",
4760 info_static_tracepoint_markers_command
, _("\
4761 List target static tracepoints markers.\n\
4764 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
4765 Select a trace frame;\n\
4766 No argument means forward by one frame; '-' means backward by one frame."),
4767 &tfindlist
, "tfind ", 1, &cmdlist
);
4769 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
4770 Select a trace frame whose PC is outside the given range (exclusive).\n\
4771 Usage: tfind outside addr1, addr2"),
4774 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
4775 Select a trace frame whose PC is in the given range (inclusive).\n\
4776 Usage: tfind range addr1,addr2"),
4779 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
4780 Select a trace frame by source line.\n\
4781 Argument can be a line number (with optional source file),\n\
4782 a function name, or '*' followed by an address.\n\
4783 Default argument is 'the next source line that was traced'."),
4786 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
4787 Select a trace frame by tracepoint number.\n\
4788 Default is the tracepoint for the current trace frame."),
4791 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
4792 Select a trace frame by PC.\n\
4793 Default is the current PC, or the PC of the current trace frame."),
4796 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
4797 Synonym for 'none'.\n\
4798 De-select any trace frame and resume 'live' debugging."),
4801 add_cmd ("none", class_trace
, trace_find_none_command
,
4802 _("De-select any trace frame and resume 'live' debugging."),
4805 add_cmd ("start", class_trace
, trace_find_start_command
,
4806 _("Select the first trace frame in the trace buffer."),
4809 add_com ("tstatus", class_trace
, trace_status_command
,
4810 _("Display the status of the current trace data collection."));
4812 add_com ("tstop", class_trace
, trace_stop_command
,
4813 _("Stop trace data collection."));
4815 add_com ("tstart", class_trace
, trace_start_command
,
4816 _("Start trace data collection."));
4818 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
4819 Ends a list of commands or actions.\n\
4820 Several GDB commands allow you to enter a list of commands or actions.\n\
4821 Entering \"end\" on a line by itself is the normal way to terminate\n\
4823 Note: the \"end\" command cannot be used at the gdb prompt."));
4825 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
4826 Specify single-stepping behavior at a tracepoint.\n\
4827 Argument is number of instructions to trace in single-step mode\n\
4828 following the tracepoint. This command is normally followed by\n\
4829 one or more \"collect\" commands, to specify what to collect\n\
4830 while single-stepping.\n\n\
4831 Note: this command can only be used in a tracepoint \"actions\" list."));
4833 add_com_alias ("ws", "while-stepping", class_alias
, 0);
4834 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
4836 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
4837 Specify one or more data items to be collected at a tracepoint.\n\
4838 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4839 collect all data (variables, registers) referenced by that expression.\n\
4840 Also accepts the following special arguments:\n\
4841 $regs -- all registers.\n\
4842 $args -- all function arguments.\n\
4843 $locals -- all variables local to the block/function scope.\n\
4844 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4845 Note: this command can only be used in a tracepoint \"actions\" list."));
4847 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4848 Specify one or more expressions to be evaluated at a tracepoint.\n\
4849 Accepts a comma-separated list of (one or more) expressions.\n\
4850 The result of each evaluation will be discarded.\n\
4851 Note: this command can only be used in a tracepoint \"actions\" list."));
4853 add_com ("actions", class_trace
, trace_actions_command
, _("\
4854 Specify the actions to be taken at a tracepoint.\n\
4855 Tracepoint actions may include collecting of specified data,\n\
4856 single-stepping, or enabling/disabling other tracepoints,\n\
4857 depending on target's capabilities."));
4859 default_collect
= xstrdup ("");
4860 add_setshow_string_cmd ("default-collect", class_trace
,
4861 &default_collect
, _("\
4862 Set the list of expressions to collect by default"), _("\
4863 Show the list of expressions to collect by default"), NULL
,
4865 &setlist
, &showlist
);
4867 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4868 &disconnected_tracing
, _("\
4869 Set whether tracing continues after GDB disconnects."), _("\
4870 Show whether tracing continues after GDB disconnects."), _("\
4871 Use this to continue a tracing run even if GDB disconnects\n\
4872 or detaches from the target. You can reconnect later and look at\n\
4873 trace data collected in the meantime."),
4874 set_disconnected_tracing
,
4879 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4880 &circular_trace_buffer
, _("\
4881 Set target's use of circular trace buffer."), _("\
4882 Show target's use of circular trace buffer."), _("\
4883 Use this to make the trace buffer into a circular buffer,\n\
4884 which will discard traceframes (oldest first) instead of filling\n\
4885 up and stopping the trace run."),
4886 set_circular_trace_buffer
,
4893 add_target (&tfile_ops
);