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"
54 #include "exceptions.h"
56 /* readline include files */
57 #include "readline/readline.h"
58 #include "readline/history.h"
60 /* readline defines this. */
71 extern int hex2bin (const char *hex
, gdb_byte
*bin
, int count
);
72 extern int bin2hex (const gdb_byte
*bin
, char *hex
, int count
);
74 /* Maximum length of an agent aexpression.
75 This accounts for the fact that packets are limited to 400 bytes
76 (which includes everything -- including the checksum), and assumes
77 the worst case of maximum length for each of the pieces of a
80 NOTE: expressions get mem2hex'ed otherwise this would be twice as
81 large. (400 - 31)/2 == 184 */
82 #define MAX_AGENT_EXPR_LEN 184
86 /* A hook used to notify the UI of tracepoint operations. */
88 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
89 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
91 extern void (*deprecated_readline_begin_hook
) (char *, ...);
92 extern char *(*deprecated_readline_hook
) (char *);
93 extern void (*deprecated_readline_end_hook
) (void);
95 /* GDB commands implemented in other modules:
98 extern void output_command (char *, int);
103 This module defines the following debugger commands:
104 trace : set a tracepoint on a function, line, or address.
105 info trace : list all debugger-defined tracepoints.
106 delete trace : delete one or more tracepoints.
107 enable trace : enable one or more tracepoints.
108 disable trace : disable one or more tracepoints.
109 actions : specify actions to be taken at a tracepoint.
110 passcount : specify a pass count for a tracepoint.
111 tstart : start a trace experiment.
112 tstop : stop a trace experiment.
113 tstatus : query the status of a trace experiment.
114 tfind : find a trace frame in the trace buffer.
115 tdump : print everything collected at the current tracepoint.
116 save-tracepoints : write tracepoint setup into a file.
118 This module defines the following user-visible debugger variables:
119 $trace_frame : sequence number of trace frame currently being debugged.
120 $trace_line : source line of trace frame currently being debugged.
121 $trace_file : source file of trace frame currently being debugged.
122 $tracepoint : tracepoint number of trace frame currently being debugged.
126 /* ======= Important global variables: ======= */
128 /* The list of all trace state variables. We don't retain pointers to
129 any of these for any reason - API is by name or number only - so it
130 works to have a vector of objects. */
132 typedef struct trace_state_variable tsv_s
;
135 /* An object describing the contents of a traceframe. */
137 struct traceframe_info
139 /* Collected memory. */
140 VEC(mem_range_s
) *memory
;
143 static VEC(tsv_s
) *tvariables
;
145 /* The next integer to assign to a variable. */
147 static int next_tsv_number
= 1;
149 /* Number of last traceframe collected. */
150 static int traceframe_number
;
152 /* Tracepoint for last traceframe collected. */
153 static int tracepoint_number
;
155 /* Symbol for function for last traceframe collected. */
156 static struct symbol
*traceframe_fun
;
158 /* Symtab and line for last traceframe collected. */
159 static struct symtab_and_line traceframe_sal
;
161 /* The traceframe info of the current traceframe. NULL if we haven't
162 yet attempted to fetch it, or if the target does not support
163 fetching this object, or if we're not inspecting a traceframe
165 static struct traceframe_info
*traceframe_info
;
167 /* Tracing command lists. */
168 static struct cmd_list_element
*tfindlist
;
170 /* List of expressions to collect by default at each tracepoint hit. */
171 char *default_collect
= "";
173 static int disconnected_tracing
;
175 /* This variable controls whether we ask the target for a linear or
176 circular trace buffer. */
178 static int circular_trace_buffer
;
180 /* ======= Important command functions: ======= */
181 static void trace_actions_command (char *, int);
182 static void trace_start_command (char *, int);
183 static void trace_stop_command (char *, int);
184 static void trace_status_command (char *, int);
185 static void trace_find_command (char *, int);
186 static void trace_find_pc_command (char *, int);
187 static void trace_find_tracepoint_command (char *, int);
188 static void trace_find_line_command (char *, int);
189 static void trace_find_range_command (char *, int);
190 static void trace_find_outside_command (char *, int);
191 static void trace_dump_command (char *, int);
193 /* support routines */
195 struct collection_list
;
196 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
197 static char *mem2hex (gdb_byte
*, char *, int);
198 static void add_register (struct collection_list
*collection
,
201 extern void send_disconnected_tracing_value (int value
);
203 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
204 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
207 extern void _initialize_tracepoint (void);
209 static struct trace_status trace_status
;
211 char *stop_reason_names
[] = {
221 struct trace_status
*
222 current_trace_status (void)
224 return &trace_status
;
230 free_traceframe_info (struct traceframe_info
*info
)
234 VEC_free (mem_range_s
, info
->memory
);
240 /* Free and clear the traceframe info cache of the current
244 clear_traceframe_info (void)
246 free_traceframe_info (traceframe_info
);
247 traceframe_info
= NULL
;
250 /* Set traceframe number to NUM. */
252 set_traceframe_num (int num
)
254 traceframe_number
= num
;
255 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
258 /* Set tracepoint number to NUM. */
260 set_tracepoint_num (int num
)
262 tracepoint_number
= num
;
263 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
266 /* Set externally visible debug variables for querying/printing
267 the traceframe context (line, function, file). */
270 set_traceframe_context (struct frame_info
*trace_frame
)
274 /* Save as globals for internal use. */
275 if (trace_frame
!= NULL
276 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
278 traceframe_sal
= find_pc_line (trace_pc
, 0);
279 traceframe_fun
= find_pc_function (trace_pc
);
281 /* Save linenumber as "$trace_line", a debugger variable visible to
283 set_internalvar_integer (lookup_internalvar ("trace_line"),
284 traceframe_sal
.line
);
288 init_sal (&traceframe_sal
);
289 traceframe_fun
= NULL
;
290 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
293 /* Save func name as "$trace_func", a debugger variable visible to
295 if (traceframe_fun
== NULL
296 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
297 clear_internalvar (lookup_internalvar ("trace_func"));
299 set_internalvar_string (lookup_internalvar ("trace_func"),
300 SYMBOL_LINKAGE_NAME (traceframe_fun
));
302 /* Save file name as "$trace_file", a debugger variable visible to
304 if (traceframe_sal
.symtab
== NULL
305 || traceframe_sal
.symtab
->filename
== NULL
)
306 clear_internalvar (lookup_internalvar ("trace_file"));
308 set_internalvar_string (lookup_internalvar ("trace_file"),
309 traceframe_sal
.symtab
->filename
);
312 /* Create a new trace state variable with the given name. */
314 struct trace_state_variable
*
315 create_trace_state_variable (const char *name
)
317 struct trace_state_variable tsv
;
319 memset (&tsv
, 0, sizeof (tsv
));
320 tsv
.name
= xstrdup (name
);
321 tsv
.number
= next_tsv_number
++;
322 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
325 /* Look for a trace state variable of the given name. */
327 struct trace_state_variable
*
328 find_trace_state_variable (const char *name
)
330 struct trace_state_variable
*tsv
;
333 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
334 if (strcmp (name
, tsv
->name
) == 0)
341 delete_trace_state_variable (const char *name
)
343 struct trace_state_variable
*tsv
;
346 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
347 if (strcmp (name
, tsv
->name
) == 0)
349 xfree ((void *)tsv
->name
);
350 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
354 warning (_("No trace variable named \"$%s\", not deleting"), name
);
357 /* The 'tvariable' command collects a name and optional expression to
358 evaluate into an initial value. */
361 trace_variable_command (char *args
, int from_tty
)
363 struct expression
*expr
;
364 struct cleanup
*old_chain
;
365 struct internalvar
*intvar
= NULL
;
367 struct trace_state_variable
*tsv
;
370 error_no_arg (_("trace state variable name"));
372 /* All the possible valid arguments are expressions. */
373 expr
= parse_expression (args
);
374 old_chain
= make_cleanup (free_current_contents
, &expr
);
376 if (expr
->nelts
== 0)
377 error (_("No expression?"));
379 /* Only allow two syntaxes; "$name" and "$name=value". */
380 if (expr
->elts
[0].opcode
== OP_INTERNALVAR
)
382 intvar
= expr
->elts
[1].internalvar
;
384 else if (expr
->elts
[0].opcode
== BINOP_ASSIGN
385 && expr
->elts
[1].opcode
== OP_INTERNALVAR
)
387 intvar
= expr
->elts
[2].internalvar
;
388 initval
= value_as_long (evaluate_subexpression_type (expr
, 4));
391 error (_("Syntax must be $NAME [ = EXPR ]"));
394 error (_("No name given"));
396 if (strlen (internalvar_name (intvar
)) <= 0)
397 error (_("Must supply a non-empty variable name"));
399 /* If the variable already exists, just change its initial value. */
400 tsv
= find_trace_state_variable (internalvar_name (intvar
));
403 tsv
->initial_value
= initval
;
404 printf_filtered (_("Trace state variable $%s "
405 "now has initial value %s.\n"),
406 tsv
->name
, plongest (tsv
->initial_value
));
407 do_cleanups (old_chain
);
411 /* Create a new variable. */
412 tsv
= create_trace_state_variable (internalvar_name (intvar
));
413 tsv
->initial_value
= initval
;
415 printf_filtered (_("Trace state variable $%s "
416 "created, with initial value %s.\n"),
417 tsv
->name
, plongest (tsv
->initial_value
));
419 do_cleanups (old_chain
);
423 delete_trace_variable_command (char *args
, int from_tty
)
427 struct cleanup
*back_to
;
431 if (query (_("Delete all trace state variables? ")))
432 VEC_free (tsv_s
, tvariables
);
437 argv
= gdb_buildargv (args
);
438 back_to
= make_cleanup_freeargv (argv
);
440 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
442 if (*argv
[ix
] == '$')
443 delete_trace_state_variable (argv
[ix
] + 1);
445 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
448 do_cleanups (back_to
);
454 tvariables_info_1 (void)
456 struct trace_state_variable
*tsv
;
459 struct cleanup
*back_to
;
461 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
463 printf_filtered (_("No trace state variables.\n"));
467 /* Try to acquire values from the target. */
468 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
469 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
472 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
473 count
, "trace-variables");
474 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
475 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
476 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
478 ui_out_table_body (uiout
);
480 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
482 struct cleanup
*back_to2
;
486 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
488 name
= concat ("$", tsv
->name
, (char *) NULL
);
489 make_cleanup (xfree
, name
);
490 ui_out_field_string (uiout
, "name", name
);
491 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
493 if (tsv
->value_known
)
494 c
= plongest (tsv
->value
);
495 else if (ui_out_is_mi_like_p (uiout
))
496 /* For MI, we prefer not to use magic string constants, but rather
497 omit the field completely. The difference between unknown and
498 undefined does not seem important enough to represent. */
500 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
501 /* The value is/was defined, but we don't have it. */
504 /* It is not meaningful to ask about the value. */
507 ui_out_field_string (uiout
, "current", c
);
508 ui_out_text (uiout
, "\n");
510 do_cleanups (back_to2
);
513 do_cleanups (back_to
);
516 /* List all the trace state variables. */
519 tvariables_info (char *args
, int from_tty
)
521 tvariables_info_1 ();
524 /* Stash definitions of tsvs into the given file. */
527 save_trace_state_variables (struct ui_file
*fp
)
529 struct trace_state_variable
*tsv
;
532 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
534 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
535 if (tsv
->initial_value
)
536 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
537 fprintf_unfiltered (fp
, "\n");
541 /* ACTIONS functions: */
543 /* The three functions:
544 collect_pseudocommand,
545 while_stepping_pseudocommand, and
546 end_actions_pseudocommand
547 are placeholders for "commands" that are actually ONLY to be used
548 within a tracepoint action list. If the actual function is ever called,
549 it means that somebody issued the "command" at the top level,
550 which is always an error. */
553 end_actions_pseudocommand (char *args
, int from_tty
)
555 error (_("This command cannot be used at the top level."));
559 while_stepping_pseudocommand (char *args
, int from_tty
)
561 error (_("This command can only be used in a tracepoint actions list."));
565 collect_pseudocommand (char *args
, int from_tty
)
567 error (_("This command can only be used in a tracepoint actions list."));
571 teval_pseudocommand (char *args
, int from_tty
)
573 error (_("This command can only be used in a tracepoint actions list."));
576 /* Enter a list of actions for a tracepoint. */
578 trace_actions_command (char *args
, int from_tty
)
580 struct breakpoint
*t
;
581 struct command_line
*l
;
583 t
= get_tracepoint_by_number (&args
, NULL
, 1);
587 xstrprintf ("Enter actions for tracepoint %d, one per line.",
589 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
591 l
= read_command_lines (tmpbuf
, from_tty
, 1,
592 check_tracepoint_command
, t
);
593 do_cleanups (cleanups
);
594 breakpoint_set_commands (t
, l
);
596 /* else just return */
599 /* Report the results of checking the agent expression, as errors or
603 report_agent_reqs_errors (struct agent_expr
*aexpr
)
605 /* All of the "flaws" are serious bytecode generation issues that
606 should never occur. */
607 if (aexpr
->flaw
!= agent_flaw_none
)
608 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
610 /* If analysis shows a stack underflow, GDB must have done something
611 badly wrong in its bytecode generation. */
612 if (aexpr
->min_height
< 0)
613 internal_error (__FILE__
, __LINE__
,
614 _("expression has min height < 0"));
616 /* Issue this error if the stack is predicted to get too deep. The
617 limit is rather arbitrary; a better scheme might be for the
618 target to report how much stack it will have available. The
619 depth roughly corresponds to parenthesization, so a limit of 20
620 amounts to 20 levels of expression nesting, which is actually
621 a pretty big hairy expression. */
622 if (aexpr
->max_height
> 20)
623 error (_("Expression is too complicated."));
626 /* worker function */
628 validate_actionline (char **line
, struct breakpoint
*t
)
630 struct cmd_list_element
*c
;
631 struct expression
*exp
= NULL
;
632 struct cleanup
*old_chain
= NULL
;
634 struct bp_location
*loc
;
635 struct agent_expr
*aexpr
;
637 /* If EOF is typed, *line is NULL. */
641 for (p
= *line
; isspace ((int) *p
);)
644 /* Symbol lookup etc. */
645 if (*p
== '\0') /* empty line: just prompt for another line. */
648 if (*p
== '#') /* comment line */
651 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
653 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
655 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
658 { /* Repeat over a comma-separated list. */
659 QUIT
; /* Allow user to bail out with ^C. */
660 while (isspace ((int) *p
))
663 if (*p
== '$') /* Look for special pseudo-symbols. */
665 if (0 == strncasecmp ("reg", p
+ 1, 3)
666 || 0 == strncasecmp ("arg", p
+ 1, 3)
667 || 0 == strncasecmp ("loc", p
+ 1, 3)
668 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
673 /* else fall thru, treat p as an expression and parse it! */
676 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
679 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
680 old_chain
= make_cleanup (free_current_contents
, &exp
);
682 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
684 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
686 error (_("constant `%s' (value %ld) "
687 "will not be collected."),
688 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
689 SYMBOL_VALUE (exp
->elts
[2].symbol
));
691 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
692 == LOC_OPTIMIZED_OUT
)
694 error (_("`%s' is optimized away "
695 "and cannot be collected."),
696 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
700 /* We have something to collect, make sure that the expr to
701 bytecode translator can handle it and that it's not too
703 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
704 make_cleanup_free_agent_expr (aexpr
);
706 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
707 error (_("Expression is too complicated."));
711 report_agent_reqs_errors (aexpr
);
713 do_cleanups (old_chain
);
716 while (p
&& *p
++ == ',');
719 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
722 { /* Repeat over a comma-separated list. */
723 QUIT
; /* Allow user to bail out with ^C. */
724 while (isspace ((int) *p
))
728 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
731 /* Only expressions are allowed for this action. */
732 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
733 old_chain
= make_cleanup (free_current_contents
, &exp
);
735 /* We have something to evaluate, make sure that the expr to
736 bytecode translator can handle it and that it's not too
738 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
739 make_cleanup_free_agent_expr (aexpr
);
741 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
742 error (_("Expression is too complicated."));
745 report_agent_reqs_errors (aexpr
);
747 do_cleanups (old_chain
);
750 while (p
&& *p
++ == ',');
753 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
755 char *steparg
; /* In case warning is necessary. */
757 while (isspace ((int) *p
))
761 if (*p
== '\0' || (t
->step_count
= strtol (p
, &p
, 0)) == 0)
762 error (_("while-stepping step count `%s' is malformed."), *line
);
765 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
769 error (_("`%s' is not a supported tracepoint action."), *line
);
773 memrange_absolute
= -1
778 int type
; /* memrange_absolute for absolute memory range,
779 else basereg number. */
780 bfd_signed_vma start
;
784 struct collection_list
786 unsigned char regs_mask
[32]; /* room for up to 256 regs */
789 struct memrange
*list
;
790 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
792 struct agent_expr
**aexpr_list
;
794 /* True is the user requested a collection of "$_sdata", "static
798 tracepoint_list
, stepping_list
;
800 /* MEMRANGE functions: */
802 static int memrange_cmp (const void *, const void *);
804 /* Compare memranges for qsort. */
806 memrange_cmp (const void *va
, const void *vb
)
808 const struct memrange
*a
= va
, *b
= vb
;
810 if (a
->type
< b
->type
)
812 if (a
->type
> b
->type
)
814 if (a
->type
== memrange_absolute
)
816 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
818 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
823 if (a
->start
< b
->start
)
825 if (a
->start
> b
->start
)
831 /* Sort the memrange list using qsort, and merge adjacent memranges. */
833 memrange_sortmerge (struct collection_list
*memranges
)
837 qsort (memranges
->list
, memranges
->next_memrange
,
838 sizeof (struct memrange
), memrange_cmp
);
839 if (memranges
->next_memrange
> 0)
841 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
843 /* If memrange b overlaps or is adjacent to memrange a,
845 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
846 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
848 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
849 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
850 continue; /* next b, same a */
854 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
855 sizeof (struct memrange
));
857 memranges
->next_memrange
= a
+ 1;
861 /* Add a register to a collection list. */
863 add_register (struct collection_list
*collection
, unsigned int regno
)
866 printf_filtered ("collect register %d\n", regno
);
867 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
868 error (_("Internal: register number %d too large for tracepoint"),
870 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
873 /* Add a memrange to a collection list. */
875 add_memrange (struct collection_list
*memranges
,
876 int type
, bfd_signed_vma base
,
881 printf_filtered ("(%d,", type
);
883 printf_filtered (",%ld)\n", len
);
886 /* type: memrange_absolute == memory, other n == basereg */
887 memranges
->list
[memranges
->next_memrange
].type
= type
;
888 /* base: addr if memory, offset if reg relative. */
889 memranges
->list
[memranges
->next_memrange
].start
= base
;
890 /* len: we actually save end (base + len) for convenience */
891 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
892 memranges
->next_memrange
++;
893 if (memranges
->next_memrange
>= memranges
->listsize
)
895 memranges
->listsize
*= 2;
896 memranges
->list
= xrealloc (memranges
->list
,
897 memranges
->listsize
);
900 if (type
!= memrange_absolute
) /* Better collect the base register! */
901 add_register (memranges
, type
);
904 /* Add a symbol to a collection list. */
906 collect_symbol (struct collection_list
*collect
,
908 struct gdbarch
*gdbarch
,
909 long frame_regno
, long frame_offset
,
914 bfd_signed_vma offset
;
915 int treat_as_expr
= 0;
917 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
918 switch (SYMBOL_CLASS (sym
))
921 printf_filtered ("%s: don't know symbol class %d\n",
922 SYMBOL_PRINT_NAME (sym
),
926 printf_filtered ("constant %s (value %ld) will not be collected.\n",
927 SYMBOL_PRINT_NAME (sym
), SYMBOL_VALUE (sym
));
930 offset
= SYMBOL_VALUE_ADDRESS (sym
);
935 sprintf_vma (tmp
, offset
);
936 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
937 SYMBOL_PRINT_NAME (sym
), len
,
940 /* A struct may be a C++ class with static fields, go to general
941 expression handling. */
942 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
945 add_memrange (collect
, memrange_absolute
, offset
, len
);
948 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
950 printf_filtered ("LOC_REG[parm] %s: ",
951 SYMBOL_PRINT_NAME (sym
));
952 add_register (collect
, reg
);
953 /* Check for doubles stored in two registers. */
954 /* FIXME: how about larger types stored in 3 or more regs? */
955 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
956 len
> register_size (gdbarch
, reg
))
957 add_register (collect
, reg
+ 1);
960 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
961 printf_filtered (" (will not collect %s)\n",
962 SYMBOL_PRINT_NAME (sym
));
966 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
969 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
970 SYMBOL_PRINT_NAME (sym
), len
);
972 printf_filtered (" from frame ptr reg %d\n", reg
);
974 add_memrange (collect
, reg
, offset
, len
);
976 case LOC_REGPARM_ADDR
:
977 reg
= SYMBOL_VALUE (sym
);
981 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
982 SYMBOL_PRINT_NAME (sym
), len
);
984 printf_filtered (" from reg %d\n", reg
);
986 add_memrange (collect
, reg
, offset
, len
);
990 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
993 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
994 SYMBOL_PRINT_NAME (sym
), len
);
996 printf_filtered (" from frame ptr reg %d\n", reg
);
998 add_memrange (collect
, reg
, offset
, len
);
1001 case LOC_UNRESOLVED
:
1005 case LOC_OPTIMIZED_OUT
:
1006 printf_filtered ("%s has been optimized out of existence.\n",
1007 SYMBOL_PRINT_NAME (sym
));
1015 /* Expressions are the most general case. */
1018 struct agent_expr
*aexpr
;
1019 struct cleanup
*old_chain1
= NULL
;
1021 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
1023 /* It can happen that the symbol is recorded as a computed
1024 location, but it's been optimized away and doesn't actually
1025 have a location expression. */
1028 printf_filtered ("%s has been optimized out of existence.\n",
1029 SYMBOL_PRINT_NAME (sym
));
1033 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1037 report_agent_reqs_errors (aexpr
);
1039 discard_cleanups (old_chain1
);
1040 add_aexpr (collect
, aexpr
);
1042 /* Take care of the registers. */
1043 if (aexpr
->reg_mask_len
> 0)
1047 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1049 QUIT
; /* Allow user to bail out with ^C. */
1050 if (aexpr
->reg_mask
[ndx1
] != 0)
1052 /* Assume chars have 8 bits. */
1053 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1054 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1055 /* It's used -- record it. */
1056 add_register (collect
, ndx1
* 8 + ndx2
);
1063 /* Data to be passed around in the calls to the locals and args
1066 struct add_local_symbols_data
1068 struct collection_list
*collect
;
1069 struct gdbarch
*gdbarch
;
1076 /* The callback for the locals and args iterators. */
1079 do_collect_symbol (const char *print_name
,
1083 struct add_local_symbols_data
*p
= cb_data
;
1085 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1086 p
->frame_offset
, p
->pc
);
1090 /* Add all locals (or args) symbols to collection list. */
1092 add_local_symbols (struct collection_list
*collect
,
1093 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1094 long frame_regno
, long frame_offset
, int type
)
1096 struct block
*block
;
1097 struct add_local_symbols_data cb_data
;
1099 cb_data
.collect
= collect
;
1100 cb_data
.gdbarch
= gdbarch
;
1102 cb_data
.frame_regno
= frame_regno
;
1103 cb_data
.frame_offset
= frame_offset
;
1108 block
= block_for_pc (pc
);
1111 warning (_("Can't collect locals; "
1112 "no symbol table info available.\n"));
1116 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1117 if (cb_data
.count
== 0)
1118 warning (_("No locals found in scope."));
1122 pc
= get_pc_function_start (pc
);
1123 block
= block_for_pc (pc
);
1126 warning (_("Can't collect args; no symbol table info available."));
1130 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1131 if (cb_data
.count
== 0)
1132 warning (_("No args found in scope."));
1137 add_static_trace_data (struct collection_list
*collection
)
1140 printf_filtered ("collect static trace data\n");
1141 collection
->strace_data
= 1;
1144 /* worker function */
1146 clear_collection_list (struct collection_list
*list
)
1150 list
->next_memrange
= 0;
1151 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1153 free_agent_expr (list
->aexpr_list
[ndx
]);
1154 list
->aexpr_list
[ndx
] = NULL
;
1156 list
->next_aexpr_elt
= 0;
1157 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1158 list
->strace_data
= 0;
1161 /* Reduce a collection list to string form (for gdb protocol). */
1163 stringify_collection_list (struct collection_list
*list
, char *string
)
1165 char temp_buf
[2048];
1169 char *(*str_list
)[];
1173 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1174 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1176 if (list
->strace_data
)
1179 printf_filtered ("\nCollecting static trace data\n");
1182 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1186 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1187 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1189 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1192 printf_filtered ("\nCollecting registers (mask): 0x");
1197 QUIT
; /* Allow user to bail out with ^C. */
1199 printf_filtered ("%02X", list
->regs_mask
[i
]);
1200 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1203 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1207 printf_filtered ("\n");
1208 if (list
->next_memrange
> 0 && info_verbose
)
1209 printf_filtered ("Collecting memranges: \n");
1210 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1212 QUIT
; /* Allow user to bail out with ^C. */
1213 sprintf_vma (tmp2
, list
->list
[i
].start
);
1216 printf_filtered ("(%d, %s, %ld)\n",
1219 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1221 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1223 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1230 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1232 /* The "%X" conversion specifier expects an unsigned argument,
1233 so passing -1 (memrange_absolute) to it directly gives you
1234 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1236 if (list
->list
[i
].type
== memrange_absolute
)
1237 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1239 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1242 count
+= strlen (end
);
1243 end
= temp_buf
+ count
;
1246 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1248 QUIT
; /* Allow user to bail out with ^C. */
1249 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1251 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1256 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1257 end
+= 10; /* 'X' + 8 hex digits + ',' */
1260 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1261 end
, list
->aexpr_list
[i
]->len
);
1262 count
+= 2 * list
->aexpr_list
[i
]->len
;
1267 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1272 (*str_list
)[ndx
] = NULL
;
1285 encode_actions_1 (struct command_line
*action
,
1286 struct breakpoint
*t
,
1287 struct bp_location
*tloc
,
1289 LONGEST frame_offset
,
1290 struct collection_list
*collect
,
1291 struct collection_list
*stepping_list
)
1294 struct expression
*exp
= NULL
;
1296 struct value
*tempval
;
1297 struct cmd_list_element
*cmd
;
1298 struct agent_expr
*aexpr
;
1300 for (; action
; action
= action
->next
)
1302 QUIT
; /* Allow user to bail out with ^C. */
1303 action_exp
= action
->line
;
1304 while (isspace ((int) *action_exp
))
1307 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1309 error (_("Bad action list item: %s"), action_exp
);
1311 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1314 { /* Repeat over a comma-separated list. */
1315 QUIT
; /* Allow user to bail out with ^C. */
1316 while (isspace ((int) *action_exp
))
1319 if (0 == strncasecmp ("$reg", action_exp
, 4))
1321 for (i
= 0; i
< gdbarch_num_regs (t
->gdbarch
); i
++)
1322 add_register (collect
, i
);
1323 action_exp
= strchr (action_exp
, ','); /* more? */
1325 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1327 add_local_symbols (collect
,
1333 action_exp
= strchr (action_exp
, ','); /* more? */
1335 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1337 add_local_symbols (collect
,
1343 action_exp
= strchr (action_exp
, ','); /* more? */
1345 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1347 add_static_trace_data (collect
);
1348 action_exp
= strchr (action_exp
, ','); /* more? */
1352 unsigned long addr
, len
;
1353 struct cleanup
*old_chain
= NULL
;
1354 struct cleanup
*old_chain1
= NULL
;
1356 exp
= parse_exp_1 (&action_exp
,
1357 block_for_pc (tloc
->address
), 1);
1358 old_chain
= make_cleanup (free_current_contents
, &exp
);
1360 switch (exp
->elts
[0].opcode
)
1364 const char *name
= &exp
->elts
[2].string
;
1366 i
= user_reg_map_name_to_regnum (t
->gdbarch
,
1367 name
, strlen (name
));
1369 internal_error (__FILE__
, __LINE__
,
1370 _("Register $%s not available"),
1373 printf_filtered ("OP_REGISTER: ");
1374 add_register (collect
, i
);
1379 /* Safe because we know it's a simple expression. */
1380 tempval
= evaluate_expression (exp
);
1381 addr
= value_address (tempval
);
1382 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1383 add_memrange (collect
, memrange_absolute
, addr
, len
);
1387 collect_symbol (collect
,
1388 exp
->elts
[2].symbol
,
1395 default: /* Full-fledged expression. */
1396 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1398 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1402 report_agent_reqs_errors (aexpr
);
1404 discard_cleanups (old_chain1
);
1405 add_aexpr (collect
, aexpr
);
1407 /* Take care of the registers. */
1408 if (aexpr
->reg_mask_len
> 0)
1413 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1415 QUIT
; /* Allow user to bail out with ^C. */
1416 if (aexpr
->reg_mask
[ndx1
] != 0)
1418 /* Assume chars have 8 bits. */
1419 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1420 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1421 /* It's used -- record it. */
1422 add_register (collect
,
1429 do_cleanups (old_chain
);
1432 while (action_exp
&& *action_exp
++ == ',');
1434 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1437 { /* Repeat over a comma-separated list. */
1438 QUIT
; /* Allow user to bail out with ^C. */
1439 while (isspace ((int) *action_exp
))
1443 struct cleanup
*old_chain
= NULL
;
1444 struct cleanup
*old_chain1
= NULL
;
1446 exp
= parse_exp_1 (&action_exp
,
1447 block_for_pc (tloc
->address
), 1);
1448 old_chain
= make_cleanup (free_current_contents
, &exp
);
1450 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1451 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1454 report_agent_reqs_errors (aexpr
);
1456 discard_cleanups (old_chain1
);
1457 /* Even though we're not officially collecting, add
1458 to the collect list anyway. */
1459 add_aexpr (collect
, aexpr
);
1461 do_cleanups (old_chain
);
1464 while (action_exp
&& *action_exp
++ == ',');
1466 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1468 /* We check against nested while-stepping when setting
1469 breakpoint action, so no way to run into nested
1471 gdb_assert (stepping_list
);
1473 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
,
1474 frame_offset
, stepping_list
, NULL
);
1477 error (_("Invalid tracepoint command '%s'"), action
->line
);
1481 /* Render all actions into gdb protocol. */
1483 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1484 char ***tdp_actions
, char ***stepping_actions
)
1486 static char tdp_buff
[2048], step_buff
[2048];
1487 char *default_collect_line
= NULL
;
1488 struct command_line
*actions
;
1489 struct command_line
*default_collect_action
= NULL
;
1491 LONGEST frame_offset
;
1492 struct cleanup
*back_to
;
1494 back_to
= make_cleanup (null_cleanup
, NULL
);
1496 clear_collection_list (&tracepoint_list
);
1497 clear_collection_list (&stepping_list
);
1499 *tdp_actions
= NULL
;
1500 *stepping_actions
= NULL
;
1502 gdbarch_virtual_frame_pointer (t
->gdbarch
,
1503 t
->loc
->address
, &frame_reg
, &frame_offset
);
1505 actions
= breakpoint_commands (t
);
1507 /* If there are default expressions to collect, make up a collect
1508 action and prepend to the action list to encode. Note that since
1509 validation is per-tracepoint (local var "xyz" might be valid for
1510 one tracepoint and not another, etc), we make up the action on
1511 the fly, and don't cache it. */
1512 if (*default_collect
)
1516 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1517 make_cleanup (xfree
, default_collect_line
);
1519 line
= default_collect_line
;
1520 validate_actionline (&line
, t
);
1522 default_collect_action
= xmalloc (sizeof (struct command_line
));
1523 make_cleanup (xfree
, default_collect_action
);
1524 default_collect_action
->next
= actions
;
1525 default_collect_action
->line
= line
;
1526 actions
= default_collect_action
;
1528 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1529 &tracepoint_list
, &stepping_list
);
1531 memrange_sortmerge (&tracepoint_list
);
1532 memrange_sortmerge (&stepping_list
);
1534 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1536 *stepping_actions
= stringify_collection_list (&stepping_list
,
1539 do_cleanups (back_to
);
1543 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1545 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1547 collect
->aexpr_list
=
1548 xrealloc (collect
->aexpr_list
,
1549 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1550 collect
->aexpr_listsize
*= 2;
1552 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1553 collect
->next_aexpr_elt
++;
1558 start_tracing (void)
1560 VEC(breakpoint_p
) *tp_vec
= NULL
;
1562 struct breakpoint
*t
;
1563 struct trace_state_variable
*tsv
;
1564 int any_enabled
= 0, num_to_download
= 0;
1566 tp_vec
= all_tracepoints ();
1568 /* No point in tracing without any tracepoints... */
1569 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1571 VEC_free (breakpoint_p
, tp_vec
);
1572 error (_("No tracepoints defined, not starting trace"));
1575 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1577 if (t
->enable_state
== bp_enabled
)
1580 if ((t
->type
== bp_fast_tracepoint
1581 ? may_insert_fast_tracepoints
1582 : may_insert_tracepoints
))
1585 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1586 (t
->type
== bp_fast_tracepoint
? "fast " : ""), t
->number
);
1591 if (target_supports_enable_disable_tracepoint ())
1592 warning (_("No tracepoints enabled"));
1595 /* No point in tracing with only disabled tracepoints that
1596 cannot be re-enabled. */
1597 VEC_free (breakpoint_p
, tp_vec
);
1598 error (_("No tracepoints enabled, not starting trace"));
1602 if (num_to_download
<= 0)
1604 VEC_free (breakpoint_p
, tp_vec
);
1605 error (_("No tracepoints that may be downloaded, not starting trace"));
1608 target_trace_init ();
1610 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1612 if ((t
->type
== bp_fast_tracepoint
1613 ? !may_insert_fast_tracepoints
1614 : !may_insert_tracepoints
))
1617 t
->number_on_target
= 0;
1618 target_download_tracepoint (t
);
1619 t
->number_on_target
= t
->number
;
1621 VEC_free (breakpoint_p
, tp_vec
);
1623 /* Send down all the trace state variables too. */
1624 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1626 target_download_trace_state_variable (tsv
);
1629 /* Tell target to treat text-like sections as transparent. */
1630 target_trace_set_readonly_regions ();
1631 /* Set some mode flags. */
1632 target_set_disconnected_tracing (disconnected_tracing
);
1633 target_set_circular_trace_buffer (circular_trace_buffer
);
1635 /* Now insert traps and begin collecting data. */
1636 target_trace_start ();
1638 /* Reset our local state. */
1639 set_traceframe_num (-1);
1640 set_tracepoint_num (-1);
1641 set_traceframe_context (NULL
);
1642 current_trace_status()->running
= 1;
1643 clear_traceframe_info ();
1648 Tell target to clear any previous trace experiment.
1649 Walk the list of tracepoints, and send them (and their actions)
1650 to the target. If no errors,
1651 Tell target to start a new trace experiment. */
1654 trace_start_command (char *args
, int from_tty
)
1656 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1658 if (current_trace_status ()->running
)
1661 && !query (_("A trace is running already. Start a new run? ")))
1662 error (_("New trace run not started."));
1670 trace_stop_command (char *args
, int from_tty
)
1672 if (!current_trace_status ()->running
)
1673 error (_("Trace is not running."));
1681 target_trace_stop ();
1682 /* Should change in response to reply? */
1683 current_trace_status ()->running
= 0;
1686 /* tstatus command */
1688 trace_status_command (char *args
, int from_tty
)
1690 struct trace_status
*ts
= current_trace_status ();
1693 status
= target_get_trace_status (ts
);
1698 printf_filtered (_("Using a trace file.\n"));
1701 printf_filtered (_("Trace can not be run on this target.\n"));
1706 if (!ts
->running_known
)
1708 printf_filtered (_("Run/stop status is unknown.\n"));
1710 else if (ts
->running
)
1712 printf_filtered (_("Trace is running on the target.\n"));
1716 switch (ts
->stop_reason
)
1718 case trace_never_run
:
1719 printf_filtered (_("No trace has been run on the target.\n"));
1722 printf_filtered (_("Trace stopped by a tstop command.\n"));
1724 case trace_buffer_full
:
1725 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1727 case trace_disconnected
:
1728 printf_filtered (_("Trace stopped because of disconnection.\n"));
1730 case tracepoint_passcount
:
1731 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1732 ts
->stopping_tracepoint
);
1734 case tracepoint_error
:
1735 if (ts
->stopping_tracepoint
)
1736 printf_filtered (_("Trace stopped by an "
1737 "error (%s, tracepoint %d).\n"),
1738 ts
->error_desc
, ts
->stopping_tracepoint
);
1740 printf_filtered (_("Trace stopped by an error (%s).\n"),
1743 case trace_stop_reason_unknown
:
1744 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1747 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1753 if (ts
->traceframes_created
>= 0
1754 && ts
->traceframe_count
!= ts
->traceframes_created
)
1756 printf_filtered (_("Buffer contains %d trace "
1757 "frames (of %d created total).\n"),
1758 ts
->traceframe_count
, ts
->traceframes_created
);
1760 else if (ts
->traceframe_count
>= 0)
1762 printf_filtered (_("Collected %d trace frames.\n"),
1763 ts
->traceframe_count
);
1766 if (ts
->buffer_free
>= 0)
1768 if (ts
->buffer_size
>= 0)
1770 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1771 ts
->buffer_free
, ts
->buffer_size
);
1772 if (ts
->buffer_size
> 0)
1773 printf_filtered (_(" (%d%% full)"),
1774 ((int) ((((long long) (ts
->buffer_size
1775 - ts
->buffer_free
)) * 100)
1776 / ts
->buffer_size
)));
1777 printf_filtered (_(".\n"));
1780 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1784 if (ts
->disconnected_tracing
)
1785 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1787 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1789 if (ts
->circular_buffer
)
1790 printf_filtered (_("Trace buffer is circular.\n"));
1792 /* Now report on what we're doing with tfind. */
1793 if (traceframe_number
>= 0)
1794 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1795 traceframe_number
, tracepoint_number
);
1797 printf_filtered (_("Not looking at any trace frame.\n"));
1800 /* Report the trace status to uiout, in a way suitable for MI, and not
1801 suitable for CLI. If ON_STOP is true, suppress a few fields that
1802 are not meaningful in the -trace-stop response.
1804 The implementation is essentially parallel to trace_status_command, but
1805 merging them will result in unreadable code. */
1807 trace_status_mi (int on_stop
)
1809 struct trace_status
*ts
= current_trace_status ();
1812 status
= target_get_trace_status (ts
);
1814 if (status
== -1 && !ts
->from_file
)
1816 ui_out_field_string (uiout
, "supported", "0");
1821 ui_out_field_string (uiout
, "supported", "file");
1823 ui_out_field_string (uiout
, "supported", "1");
1825 gdb_assert (ts
->running_known
);
1829 ui_out_field_string (uiout
, "running", "1");
1831 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1832 Given that the frontend gets the status either on -trace-stop, or from
1833 -trace-status after re-connection, it does not seem like this
1834 information is necessary for anything. It is not necessary for either
1835 figuring the vital state of the target nor for navigation of trace
1836 frames. If the frontend wants to show the current state is some
1837 configure dialog, it can request the value when such dialog is
1838 invoked by the user. */
1842 char *stop_reason
= NULL
;
1843 int stopping_tracepoint
= -1;
1846 ui_out_field_string (uiout
, "running", "0");
1848 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
1850 switch (ts
->stop_reason
)
1853 stop_reason
= "request";
1855 case trace_buffer_full
:
1856 stop_reason
= "overflow";
1858 case trace_disconnected
:
1859 stop_reason
= "disconnection";
1861 case tracepoint_passcount
:
1862 stop_reason
= "passcount";
1863 stopping_tracepoint
= ts
->stopping_tracepoint
;
1865 case tracepoint_error
:
1866 stop_reason
= "error";
1867 stopping_tracepoint
= ts
->stopping_tracepoint
;
1873 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
1874 if (stopping_tracepoint
!= -1)
1875 ui_out_field_int (uiout
, "stopping-tracepoint",
1876 stopping_tracepoint
);
1877 if (ts
->stop_reason
== tracepoint_error
)
1878 ui_out_field_string (uiout
, "error-description",
1884 if (ts
->traceframe_count
!= -1)
1885 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
1886 if (ts
->traceframes_created
!= -1)
1887 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
1888 if (ts
->buffer_size
!= -1)
1889 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
1890 if (ts
->buffer_free
!= -1)
1891 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
1893 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
1894 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
1897 /* This function handles the details of what to do about an ongoing
1898 tracing run if the user has asked to detach or otherwise disconnect
1901 disconnect_tracing (int from_tty
)
1903 /* It can happen that the target that was tracing went away on its
1904 own, and we didn't notice. Get a status update, and if the
1905 current target doesn't even do tracing, then assume it's not
1907 if (target_get_trace_status (current_trace_status ()) < 0)
1908 current_trace_status ()->running
= 0;
1910 /* If running interactively, give the user the option to cancel and
1911 then decide what to do differently with the run. Scripts are
1912 just going to disconnect and let the target deal with it,
1913 according to how it's been instructed previously via
1914 disconnected-tracing. */
1915 if (current_trace_status ()->running
&& from_tty
)
1917 if (current_trace_status ()->disconnected_tracing
)
1919 if (!query (_("Trace is running and will "
1920 "continue after detach; detach anyway? ")))
1921 error (_("Not confirmed."));
1925 if (!query (_("Trace is running but will "
1926 "stop on detach; detach anyway? ")))
1927 error (_("Not confirmed."));
1931 /* Also we want to be out of tfind mode, otherwise things can get
1932 confusing upon reconnection. Just use these calls instead of
1933 full tfind_1 behavior because we're in the middle of detaching,
1934 and there's no point to updating current stack frame etc. */
1935 set_current_traceframe (-1);
1936 set_traceframe_context (NULL
);
1939 /* Worker function for the various flavors of the tfind command. */
1941 tfind_1 (enum trace_find_type type
, int num
,
1942 ULONGEST addr1
, ULONGEST addr2
,
1945 int target_frameno
= -1, target_tracept
= -1;
1946 struct frame_id old_frame_id
= null_frame_id
;
1947 struct breakpoint
*tp
;
1949 /* Only try to get the current stack frame if we have a chance of
1950 succeeding. In particular, if we're trying to get a first trace
1951 frame while all threads are running, it's not going to succeed,
1952 so leave it with a default value and let the frame comparison
1953 below (correctly) decide to print out the source location of the
1955 if (!(type
== tfind_number
&& num
== -1)
1956 && (has_stack_frames () || traceframe_number
>= 0))
1957 old_frame_id
= get_frame_id (get_current_frame ());
1959 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
1962 if (type
== tfind_number
1964 && target_frameno
== -1)
1966 /* We told the target to get out of tfind mode, and it did. */
1968 else if (target_frameno
== -1)
1970 /* A request for a non-existent trace frame has failed.
1971 Our response will be different, depending on FROM_TTY:
1973 If FROM_TTY is true, meaning that this command was
1974 typed interactively by the user, then give an error
1975 and DO NOT change the state of traceframe_number etc.
1977 However if FROM_TTY is false, meaning that we're either
1978 in a script, a loop, or a user-defined command, then
1979 DON'T give an error, but DO change the state of
1980 traceframe_number etc. to invalid.
1982 The rationalle is that if you typed the command, you
1983 might just have committed a typo or something, and you'd
1984 like to NOT lose your current debugging state. However
1985 if you're in a user-defined command or especially in a
1986 loop, then you need a way to detect that the command
1987 failed WITHOUT aborting. This allows you to write
1988 scripts that search thru the trace buffer until the end,
1989 and then continue on to do something else. */
1992 error (_("Target failed to find requested trace frame."));
1996 printf_filtered ("End of trace buffer.\n");
1997 #if 0 /* dubious now? */
1998 /* The following will not recurse, since it's
2000 trace_find_command ("-1", from_tty
);
2005 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2007 reinit_frame_cache ();
2008 registers_changed ();
2009 target_dcache_invalidate ();
2010 set_traceframe_num (target_frameno
);
2011 clear_traceframe_info ();
2012 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
2013 if (target_frameno
== -1)
2014 set_traceframe_context (NULL
);
2016 set_traceframe_context (get_current_frame ());
2018 if (traceframe_number
>= 0)
2020 /* Use different branches for MI and CLI to make CLI messages
2022 if (ui_out_is_mi_like_p (uiout
))
2024 ui_out_field_string (uiout
, "found", "1");
2025 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2026 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2030 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2031 traceframe_number
, tracepoint_number
);
2036 if (ui_out_is_mi_like_p (uiout
))
2037 ui_out_field_string (uiout
, "found", "0");
2038 else if (type
== tfind_number
&& num
== -1)
2039 printf_unfiltered (_("No longer looking at any trace frame\n"));
2040 else /* This case may never occur, check. */
2041 printf_unfiltered (_("No trace frame found\n"));
2044 /* If we're in nonstop mode and getting out of looking at trace
2045 frames, there won't be any current frame to go back to and
2048 && (has_stack_frames () || traceframe_number
>= 0))
2050 enum print_what print_what
;
2052 /* NOTE: in imitation of the step command, try to determine
2053 whether we have made a transition from one function to
2054 another. If so, we'll print the "stack frame" (ie. the new
2055 function and it's arguments) -- otherwise we'll just show the
2058 if (frame_id_eq (old_frame_id
,
2059 get_frame_id (get_current_frame ())))
2060 print_what
= SRC_LINE
;
2062 print_what
= SRC_AND_LOC
;
2064 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2069 /* trace_find_command takes a trace frame number n,
2070 sends "QTFrame:<n>" to the target,
2071 and accepts a reply that may contain several optional pieces
2072 of information: a frame number, a tracepoint number, and an
2073 indication of whether this is a trap frame or a stepping frame.
2075 The minimal response is just "OK" (which indicates that the
2076 target does not give us a frame number or a tracepoint number).
2077 Instead of that, the target may send us a string containing
2079 F<hexnum> (gives the selected frame number)
2080 T<hexnum> (gives the selected tracepoint number)
2085 trace_find_command (char *args
, int from_tty
)
2086 { /* This should only be called with a numeric argument. */
2089 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2090 error (_("May not look at trace frames while trace is running."));
2092 if (args
== 0 || *args
== 0)
2093 { /* TFIND with no args means find NEXT trace frame. */
2094 if (traceframe_number
== -1)
2095 frameno
= 0; /* "next" is first one. */
2097 frameno
= traceframe_number
+ 1;
2099 else if (0 == strcmp (args
, "-"))
2101 if (traceframe_number
== -1)
2102 error (_("not debugging trace buffer"));
2103 else if (from_tty
&& traceframe_number
== 0)
2104 error (_("already at start of trace buffer"));
2106 frameno
= traceframe_number
- 1;
2108 /* A hack to work around eval's need for fp to have been collected. */
2109 else if (0 == strcmp (args
, "-1"))
2112 frameno
= parse_and_eval_long (args
);
2115 error (_("invalid input (%d is less than zero)"), frameno
);
2117 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2122 trace_find_end_command (char *args
, int from_tty
)
2124 trace_find_command ("-1", from_tty
);
2129 trace_find_none_command (char *args
, int from_tty
)
2131 trace_find_command ("-1", from_tty
);
2136 trace_find_start_command (char *args
, int from_tty
)
2138 trace_find_command ("0", from_tty
);
2141 /* tfind pc command */
2143 trace_find_pc_command (char *args
, int from_tty
)
2147 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2148 error (_("May not look at trace frames while trace is running."));
2150 if (args
== 0 || *args
== 0)
2151 pc
= regcache_read_pc (get_current_regcache ());
2153 pc
= parse_and_eval_address (args
);
2155 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2158 /* tfind tracepoint command */
2160 trace_find_tracepoint_command (char *args
, int from_tty
)
2163 struct breakpoint
*tp
;
2165 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2166 error (_("May not look at trace frames while trace is running."));
2168 if (args
== 0 || *args
== 0)
2170 if (tracepoint_number
== -1)
2171 error (_("No current tracepoint -- please supply an argument."));
2173 tdp
= tracepoint_number
; /* Default is current TDP. */
2176 tdp
= parse_and_eval_long (args
);
2178 /* If we have the tracepoint on hand, use the number that the
2179 target knows about (which may be different if we disconnected
2180 and reconnected). */
2181 tp
= get_tracepoint (tdp
);
2183 tdp
= tp
->number_on_target
;
2185 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2188 /* TFIND LINE command:
2190 This command will take a sourceline for argument, just like BREAK
2191 or TRACE (ie. anything that "decode_line_1" can handle).
2193 With no argument, this command will find the next trace frame
2194 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2197 trace_find_line_command (char *args
, int from_tty
)
2199 static CORE_ADDR start_pc
, end_pc
;
2200 struct symtabs_and_lines sals
;
2201 struct symtab_and_line sal
;
2202 struct cleanup
*old_chain
;
2204 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2205 error (_("May not look at trace frames while trace is running."));
2207 if (args
== 0 || *args
== 0)
2209 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2211 sals
.sals
= (struct symtab_and_line
*)
2212 xmalloc (sizeof (struct symtab_and_line
));
2217 sals
= decode_line_spec (args
, 1);
2221 old_chain
= make_cleanup (xfree
, sals
.sals
);
2222 if (sal
.symtab
== 0)
2223 error (_("No line number information available."));
2225 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2227 if (start_pc
== end_pc
)
2229 printf_filtered ("Line %d of \"%s\"",
2230 sal
.line
, sal
.symtab
->filename
);
2232 printf_filtered (" is at address ");
2233 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2235 printf_filtered (" but contains no code.\n");
2236 sal
= find_pc_line (start_pc
, 0);
2238 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2239 && start_pc
!= end_pc
)
2240 printf_filtered ("Attempting to find line %d instead.\n",
2243 error (_("Cannot find a good line."));
2247 /* Is there any case in which we get here, and have an address
2248 which the user would want to see? If we have debugging
2249 symbols and no line numbers? */
2250 error (_("Line number %d is out of range for \"%s\"."),
2251 sal
.line
, sal
.symtab
->filename
);
2253 /* Find within range of stated line. */
2255 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2257 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2258 do_cleanups (old_chain
);
2261 /* tfind range command */
2263 trace_find_range_command (char *args
, int from_tty
)
2265 static CORE_ADDR start
, stop
;
2268 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2269 error (_("May not look at trace frames while trace is running."));
2271 if (args
== 0 || *args
== 0)
2272 { /* XXX FIXME: what should default behavior be? */
2273 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2277 if (0 != (tmp
= strchr (args
, ',')))
2279 *tmp
++ = '\0'; /* Terminate start address. */
2280 while (isspace ((int) *tmp
))
2282 start
= parse_and_eval_address (args
);
2283 stop
= parse_and_eval_address (tmp
);
2286 { /* No explicit end address? */
2287 start
= parse_and_eval_address (args
);
2288 stop
= start
+ 1; /* ??? */
2291 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2294 /* tfind outside command */
2296 trace_find_outside_command (char *args
, int from_tty
)
2298 CORE_ADDR start
, stop
;
2301 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2302 error (_("May not look at trace frames while trace is running."));
2304 if (args
== 0 || *args
== 0)
2305 { /* XXX FIXME: what should default behavior be? */
2306 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2310 if (0 != (tmp
= strchr (args
, ',')))
2312 *tmp
++ = '\0'; /* Terminate start address. */
2313 while (isspace ((int) *tmp
))
2315 start
= parse_and_eval_address (args
);
2316 stop
= parse_and_eval_address (tmp
);
2319 { /* No explicit end address? */
2320 start
= parse_and_eval_address (args
);
2321 stop
= start
+ 1; /* ??? */
2324 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2327 /* info scope command: list the locals for a scope. */
2329 scope_info (char *args
, int from_tty
)
2331 struct symtabs_and_lines sals
;
2333 struct minimal_symbol
*msym
;
2334 struct block
*block
;
2335 char *symname
, *save_args
= args
;
2336 struct dict_iterator iter
;
2338 struct gdbarch
*gdbarch
;
2341 if (args
== 0 || *args
== 0)
2342 error (_("requires an argument (function, "
2343 "line or *addr) to define a scope"));
2345 sals
= decode_line_1 (&args
, 1, NULL
, 0, NULL
);
2346 if (sals
.nelts
== 0)
2347 return; /* Presumably decode_line_1 has already warned. */
2349 /* Resolve line numbers to PC. */
2350 resolve_sal_pc (&sals
.sals
[0]);
2351 block
= block_for_pc (sals
.sals
[0].pc
);
2355 QUIT
; /* Allow user to bail out with ^C. */
2356 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2358 QUIT
; /* Allow user to bail out with ^C. */
2360 printf_filtered ("Scope for %s:\n", save_args
);
2363 symname
= SYMBOL_PRINT_NAME (sym
);
2364 if (symname
== NULL
|| *symname
== '\0')
2365 continue; /* Probably botched, certainly useless. */
2367 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2369 printf_filtered ("Symbol %s is ", symname
);
2370 switch (SYMBOL_CLASS (sym
))
2373 case LOC_UNDEF
: /* Messed up symbol? */
2374 printf_filtered ("a bogus symbol, class %d.\n",
2375 SYMBOL_CLASS (sym
));
2376 count
--; /* Don't count this one. */
2379 printf_filtered ("a constant with value %ld (0x%lx)",
2380 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2382 case LOC_CONST_BYTES
:
2383 printf_filtered ("constant bytes: ");
2384 if (SYMBOL_TYPE (sym
))
2385 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2386 fprintf_filtered (gdb_stdout
, " %02x",
2387 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2390 printf_filtered ("in static storage at address ");
2391 printf_filtered ("%s", paddress (gdbarch
,
2392 SYMBOL_VALUE_ADDRESS (sym
)));
2395 /* GDBARCH is the architecture associated with the objfile
2396 the symbol is defined in; the target architecture may be
2397 different, and may provide additional registers. However,
2398 we do not know the target architecture at this point.
2399 We assume the objfile architecture will contain all the
2400 standard registers that occur in debug info in that
2402 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2405 if (SYMBOL_IS_ARGUMENT (sym
))
2406 printf_filtered ("an argument in register $%s",
2407 gdbarch_register_name (gdbarch
, regno
));
2409 printf_filtered ("a local variable in register $%s",
2410 gdbarch_register_name (gdbarch
, regno
));
2413 printf_filtered ("an argument at stack/frame offset %ld",
2414 SYMBOL_VALUE (sym
));
2417 printf_filtered ("a local variable at frame offset %ld",
2418 SYMBOL_VALUE (sym
));
2421 printf_filtered ("a reference argument at offset %ld",
2422 SYMBOL_VALUE (sym
));
2424 case LOC_REGPARM_ADDR
:
2425 /* Note comment at LOC_REGISTER. */
2426 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2428 printf_filtered ("the address of an argument, in register $%s",
2429 gdbarch_register_name (gdbarch
, regno
));
2432 printf_filtered ("a typedef.\n");
2435 printf_filtered ("a label at address ");
2436 printf_filtered ("%s", paddress (gdbarch
,
2437 SYMBOL_VALUE_ADDRESS (sym
)));
2440 printf_filtered ("a function at address ");
2441 printf_filtered ("%s",
2442 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2444 case LOC_UNRESOLVED
:
2445 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2448 printf_filtered ("Unresolved Static");
2451 printf_filtered ("static storage at address ");
2452 printf_filtered ("%s",
2453 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2456 case LOC_OPTIMIZED_OUT
:
2457 printf_filtered ("optimized out.\n");
2460 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2461 BLOCK_START (block
),
2465 if (SYMBOL_TYPE (sym
))
2466 printf_filtered (", length %d.\n",
2467 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2469 if (BLOCK_FUNCTION (block
))
2472 block
= BLOCK_SUPERBLOCK (block
);
2475 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2479 /* worker function (cleanup) */
2481 replace_comma (void *data
)
2488 /* Helper for trace_dump_command. Dump the action list starting at
2489 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2490 actions of the body of a while-stepping action. STEPPING_FRAME is
2491 set if the current traceframe was determined to be a while-stepping
2495 trace_dump_actions (struct command_line
*action
,
2496 int stepping_actions
, int stepping_frame
,
2499 char *action_exp
, *next_comma
;
2501 for (; action
!= NULL
; action
= action
->next
)
2503 struct cmd_list_element
*cmd
;
2505 QUIT
; /* Allow user to bail out with ^C. */
2506 action_exp
= action
->line
;
2507 while (isspace ((int) *action_exp
))
2510 /* The collection actions to be done while stepping are
2511 bracketed by the commands "while-stepping" and "end". */
2513 if (*action_exp
== '#') /* comment line */
2516 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2518 error (_("Bad action list item: %s"), action_exp
);
2520 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2524 for (i
= 0; i
< action
->body_count
; ++i
)
2525 trace_dump_actions (action
->body_list
[i
],
2526 1, stepping_frame
, from_tty
);
2528 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2530 /* Display the collected data.
2531 For the trap frame, display only what was collected at
2532 the trap. Likewise for stepping frames, display only
2533 what was collected while stepping. This means that the
2534 two boolean variables, STEPPING_FRAME and
2535 STEPPING_ACTIONS should be equal. */
2536 if (stepping_frame
== stepping_actions
)
2539 { /* Repeat over a comma-separated list. */
2540 QUIT
; /* Allow user to bail out with ^C. */
2541 if (*action_exp
== ',')
2543 while (isspace ((int) *action_exp
))
2546 next_comma
= strchr (action_exp
, ',');
2548 if (0 == strncasecmp (action_exp
, "$reg", 4))
2549 registers_info (NULL
, from_tty
);
2550 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2551 locals_info (NULL
, from_tty
);
2552 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2553 args_info (NULL
, from_tty
);
2558 make_cleanup (replace_comma
, next_comma
);
2561 printf_filtered ("%s = ", action_exp
);
2562 output_command (action_exp
, from_tty
);
2563 printf_filtered ("\n");
2567 action_exp
= next_comma
;
2569 while (action_exp
&& *action_exp
== ',');
2575 /* The tdump command. */
2578 trace_dump_command (char *args
, int from_tty
)
2580 struct regcache
*regcache
;
2581 struct breakpoint
*t
;
2582 int stepping_frame
= 0;
2583 struct bp_location
*loc
;
2584 char *line
, *default_collect_line
= NULL
;
2585 struct command_line
*actions
, *default_collect_action
= NULL
;
2586 struct cleanup
*old_chain
= NULL
;
2588 if (tracepoint_number
== -1)
2590 warning (_("No current trace frame."));
2594 t
= get_tracepoint (tracepoint_number
);
2597 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2600 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2601 tracepoint_number
, traceframe_number
);
2603 /* The current frame is a trap frame if the frame PC is equal
2604 to the tracepoint PC. If not, then the current frame was
2605 collected during single-stepping. */
2607 regcache
= get_current_regcache ();
2609 /* If the traceframe's address matches any of the tracepoint's
2610 locations, assume it is a direct hit rather than a while-stepping
2611 frame. (FIXME this is not reliable, should record each frame's
2614 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2615 if (loc
->address
== regcache_read_pc (regcache
))
2618 actions
= breakpoint_commands (t
);
2620 /* If there is a default-collect list, make up a collect command,
2621 prepend to the tracepoint's commands, and pass the whole mess to
2622 the trace dump scanner. We need to validate because
2623 default-collect might have been junked since the trace run. */
2624 if (*default_collect
)
2626 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2627 old_chain
= make_cleanup (xfree
, default_collect_line
);
2628 line
= default_collect_line
;
2629 validate_actionline (&line
, t
);
2630 default_collect_action
= xmalloc (sizeof (struct command_line
));
2631 make_cleanup (xfree
, default_collect_action
);
2632 default_collect_action
->next
= actions
;
2633 default_collect_action
->line
= line
;
2634 actions
= default_collect_action
;
2637 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2639 if (*default_collect
)
2640 do_cleanups (old_chain
);
2643 /* Encode a piece of a tracepoint's source-level definition in a form
2644 that is suitable for both protocol and saving in files. */
2645 /* This version does not do multiple encodes for long strings; it should
2646 return an offset to the next piece to encode. FIXME */
2649 encode_source_string (int tpnum
, ULONGEST addr
,
2650 char *srctype
, char *src
, char *buf
, int buf_size
)
2652 if (80 + strlen (srctype
) > buf_size
)
2653 error (_("Buffer too small for source encoding"));
2654 sprintf (buf
, "%x:%s:%s:%x:%x:",
2655 tpnum
, phex_nz (addr
, sizeof (addr
)),
2656 srctype
, 0, (int) strlen (src
));
2657 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2658 error (_("Source string too long for buffer"));
2659 bin2hex (src
, buf
+ strlen (buf
), 0);
2663 extern int trace_regblock_size
;
2665 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2666 non-zero, the save is performed on the target, otherwise GDB obtains all
2667 trace data and saves it locally. */
2670 trace_save (const char *filename
, int target_does_save
)
2672 struct cleanup
*cleanup
;
2674 struct trace_status
*ts
= current_trace_status ();
2677 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2678 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2682 ULONGEST offset
= 0;
2683 #define MAX_TRACE_UPLOAD 2000
2684 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2687 /* If the target is to save the data to a file on its own, then just
2688 send the command and be done with it. */
2689 if (target_does_save
)
2691 err
= target_save_trace_data (filename
);
2693 error (_("Target failed to save trace data to '%s'."),
2698 /* Get the trace status first before opening the file, so if the
2699 target is losing, we can get out without touching files. */
2700 status
= target_get_trace_status (ts
);
2702 pathname
= tilde_expand (filename
);
2703 cleanup
= make_cleanup (xfree
, pathname
);
2705 fp
= fopen (pathname
, "wb");
2707 error (_("Unable to open file '%s' for saving trace data (%s)"),
2708 filename
, safe_strerror (errno
));
2709 make_cleanup_fclose (fp
);
2711 /* Write a file header, with a high-bit-set char to indicate a
2712 binary file, plus a hint as what this file is, and a version
2713 number in case of future needs. */
2714 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2716 perror_with_name (pathname
);
2718 /* Write descriptive info. */
2720 /* Write out the size of a register block. */
2721 fprintf (fp
, "R %x\n", trace_regblock_size
);
2723 /* Write out status of the tracing run (aka "tstatus" info). */
2724 fprintf (fp
, "status %c;%s",
2725 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
2726 if (ts
->stop_reason
== tracepoint_error
)
2728 char *buf
= (char *) alloca (strlen (ts
->error_desc
) * 2 + 1);
2730 bin2hex ((gdb_byte
*) ts
->error_desc
, buf
, 0);
2731 fprintf (fp
, ":%s", buf
);
2733 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
2734 if (ts
->traceframe_count
>= 0)
2735 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
2736 if (ts
->traceframes_created
>= 0)
2737 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
2738 if (ts
->buffer_free
>= 0)
2739 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
2740 if (ts
->buffer_size
>= 0)
2741 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
2742 if (ts
->disconnected_tracing
)
2743 fprintf (fp
, ";disconn:%x", ts
->disconnected_tracing
);
2744 if (ts
->circular_buffer
)
2745 fprintf (fp
, ";circular:%x", ts
->circular_buffer
);
2748 /* Note that we want to upload tracepoints and save those, rather
2749 than simply writing out the local ones, because the user may have
2750 changed tracepoints in GDB in preparation for a future tracing
2751 run, or maybe just mass-deleted all types of breakpoints as part
2752 of cleaning up. So as not to contaminate the session, leave the
2753 data in its uploaded form, don't make into real tracepoints. */
2755 /* Get trace state variables first, they may be checked when parsing
2756 uploaded commands. */
2758 target_upload_trace_state_variables (&uploaded_tsvs
);
2760 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2766 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
2767 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
2770 fprintf (fp
, "tsv %x:%s:%x:%s\n",
2771 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
2772 utsv
->builtin
, buf
);
2778 free_uploaded_tsvs (&uploaded_tsvs
);
2780 target_upload_tracepoints (&uploaded_tps
);
2782 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
2784 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
2785 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2786 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
2787 if (utp
->type
== bp_fast_tracepoint
)
2788 fprintf (fp
, ":F%x", utp
->orig_size
);
2790 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
2793 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
2794 fprintf (fp
, "tp A%x:%s:%s\n",
2795 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
2796 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
2797 fprintf (fp
, "tp S%x:%s:%s\n",
2798 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
2801 encode_source_string (utp
->number
, utp
->addr
,
2802 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
2803 fprintf (fp
, "tp Z%s\n", buf
);
2805 if (utp
->cond_string
)
2807 encode_source_string (utp
->number
, utp
->addr
,
2808 "cond", utp
->cond_string
,
2809 buf
, MAX_TRACE_UPLOAD
);
2810 fprintf (fp
, "tp Z%s\n", buf
);
2812 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
2814 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
2815 buf
, MAX_TRACE_UPLOAD
);
2816 fprintf (fp
, "tp Z%s\n", buf
);
2820 free_uploaded_tps (&uploaded_tps
);
2822 /* Mark the end of the definition section. */
2825 /* Get and write the trace data proper. We ask for big blocks, in
2826 the hopes of efficiency, but will take less if the target has
2827 packet size limitations or some such. */
2830 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
2832 error (_("Failure to get requested trace buffer data"));
2833 /* No more data is forthcoming, we're done. */
2836 written
= fwrite (buf
, gotten
, 1, fp
);
2838 perror_with_name (pathname
);
2842 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
2843 written
= fwrite (&gotten
, 4, 1, fp
);
2845 perror_with_name (pathname
);
2847 do_cleanups (cleanup
);
2851 trace_save_command (char *args
, int from_tty
)
2853 int target_does_save
= 0;
2855 char *filename
= NULL
;
2856 struct cleanup
*back_to
;
2859 error_no_arg (_("file in which to save trace data"));
2861 argv
= gdb_buildargv (args
);
2862 back_to
= make_cleanup_freeargv (argv
);
2864 for (; *argv
; ++argv
)
2866 if (strcmp (*argv
, "-r") == 0)
2867 target_does_save
= 1;
2868 else if (**argv
== '-')
2869 error (_("unknown option `%s'"), *argv
);
2875 error_no_arg (_("file in which to save trace data"));
2877 trace_save (filename
, target_does_save
);
2880 printf_filtered (_("Trace data saved to file '%s'.\n"), args
);
2882 do_cleanups (back_to
);
2885 /* Tell the target what to do with an ongoing tracing run if GDB
2886 disconnects for some reason. */
2889 send_disconnected_tracing_value (int value
)
2891 target_set_disconnected_tracing (value
);
2895 set_disconnected_tracing (char *args
, int from_tty
,
2896 struct cmd_list_element
*c
)
2898 send_disconnected_tracing_value (disconnected_tracing
);
2902 set_circular_trace_buffer (char *args
, int from_tty
,
2903 struct cmd_list_element
*c
)
2905 target_set_circular_trace_buffer (circular_trace_buffer
);
2908 /* Convert the memory pointed to by mem into hex, placing result in buf.
2909 * Return a pointer to the last char put in buf (null)
2910 * "stolen" from sparc-stub.c
2913 static const char hexchars
[] = "0123456789abcdef";
2916 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2924 *buf
++ = hexchars
[ch
>> 4];
2925 *buf
++ = hexchars
[ch
& 0xf];
2934 get_traceframe_number (void)
2936 return traceframe_number
;
2939 /* Make the traceframe NUM be the current trace frame. Does nothing
2940 if NUM is already current. */
2943 set_current_traceframe (int num
)
2947 if (traceframe_number
== num
)
2949 /* Nothing to do. */
2953 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
2956 warning (_("could not change traceframe"));
2958 traceframe_number
= newnum
;
2960 /* Changing the traceframe changes our view of registers and of the
2962 registers_changed ();
2964 clear_traceframe_info ();
2967 /* Make the traceframe NUM be the current trace frame, and do nothing
2971 set_traceframe_number (int num
)
2973 traceframe_number
= num
;
2976 /* A cleanup used when switching away and back from tfind mode. */
2978 struct current_traceframe_cleanup
2980 /* The traceframe we were inspecting. */
2981 int traceframe_number
;
2985 do_restore_current_traceframe_cleanup (void *arg
)
2987 struct current_traceframe_cleanup
*old
= arg
;
2989 set_current_traceframe (old
->traceframe_number
);
2993 restore_current_traceframe_cleanup_dtor (void *arg
)
2995 struct current_traceframe_cleanup
*old
= arg
;
3001 make_cleanup_restore_current_traceframe (void)
3003 struct current_traceframe_cleanup
*old
;
3005 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3006 old
->traceframe_number
= traceframe_number
;
3008 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3009 restore_current_traceframe_cleanup_dtor
);
3013 make_cleanup_restore_traceframe_number (void)
3015 return make_cleanup_restore_integer (&traceframe_number
);
3018 /* Given a number and address, return an uploaded tracepoint with that
3019 number, creating if necessary. */
3021 struct uploaded_tp
*
3022 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3024 struct uploaded_tp
*utp
;
3026 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3027 if (utp
->number
== num
&& utp
->addr
== addr
)
3029 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3030 memset (utp
, 0, sizeof (struct uploaded_tp
));
3033 utp
->actions
= NULL
;
3034 utp
->step_actions
= NULL
;
3035 utp
->cmd_strings
= NULL
;
3042 free_uploaded_tps (struct uploaded_tp
**utpp
)
3044 struct uploaded_tp
*next_one
;
3048 next_one
= (*utpp
)->next
;
3054 /* Given a number and address, return an uploaded tracepoint with that
3055 number, creating if necessary. */
3057 struct uploaded_tsv
*
3058 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3060 struct uploaded_tsv
*utsv
;
3062 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3063 if (utsv
->number
== num
)
3065 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3066 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3068 utsv
->next
= *utsvp
;
3074 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3076 struct uploaded_tsv
*next_one
;
3080 next_one
= (*utsvp
)->next
;
3086 /* Look for an existing tracepoint that seems similar enough to the
3087 uploaded one. Enablement isn't compared, because the user can
3088 toggle that freely, and may have done so in anticipation of the
3092 find_matching_tracepoint (struct uploaded_tp
*utp
)
3094 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3096 struct breakpoint
*t
;
3097 struct bp_location
*loc
;
3099 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
3101 if (t
->type
== utp
->type
3102 && t
->step_count
== utp
->step
3103 && t
->pass_count
== utp
->pass
3104 /* FIXME also test conditionals and actions. */
3107 /* Scan the locations for an address match. */
3108 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
3110 if (loc
->address
== utp
->addr
)
3118 /* Given a list of tracepoints uploaded from a target, attempt to
3119 match them up with existing tracepoints, and create new ones if not
3123 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3125 struct uploaded_tp
*utp
;
3126 struct breakpoint
*t
;
3128 /* Look for GDB tracepoints that match up with our uploaded versions. */
3129 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3131 t
= find_matching_tracepoint (utp
);
3133 printf_filtered (_("Assuming tracepoint %d is same "
3134 "as target's tracepoint %d at %s.\n"),
3135 t
->number
, utp
->number
,
3136 paddress (get_current_arch (), utp
->addr
));
3139 t
= create_tracepoint_from_upload (utp
);
3141 printf_filtered (_("Created tracepoint %d for "
3142 "target's tracepoint %d at %s.\n"),
3143 t
->number
, utp
->number
,
3144 paddress (get_current_arch (), utp
->addr
));
3146 printf_filtered (_("Failed to create tracepoint for target's "
3147 "tracepoint %d at %s, skipping it.\n"),
3149 paddress (get_current_arch (), utp
->addr
));
3151 /* Whether found or created, record the number used by the
3152 target, to help with mapping target tracepoints back to their
3153 counterparts here. */
3155 t
->number_on_target
= utp
->number
;
3158 free_uploaded_tps (uploaded_tps
);
3161 /* Trace state variables don't have much to identify them beyond their
3162 name, so just use that to detect matches. */
3164 struct trace_state_variable
*
3165 find_matching_tsv (struct uploaded_tsv
*utsv
)
3170 return find_trace_state_variable (utsv
->name
);
3173 struct trace_state_variable
*
3174 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3176 const char *namebase
;
3179 struct trace_state_variable
*tsv
;
3183 namebase
= utsv
->name
;
3184 sprintf (buf
, "%s", namebase
);
3189 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3192 /* Fish for a name that is not in use. */
3193 /* (should check against all internal vars?) */
3194 while (find_trace_state_variable (buf
))
3195 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3197 /* We have an available name, create the variable. */
3198 tsv
= create_trace_state_variable (buf
);
3199 tsv
->initial_value
= utsv
->initial_value
;
3200 tsv
->builtin
= utsv
->builtin
;
3205 /* Given a list of uploaded trace state variables, try to match them
3206 up with existing variables, or create additional ones. */
3209 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3212 struct uploaded_tsv
*utsv
;
3213 struct trace_state_variable
*tsv
;
3216 /* Most likely some numbers will have to be reassigned as part of
3217 the merge, so clear them all in anticipation. */
3218 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3221 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3223 tsv
= find_matching_tsv (utsv
);
3227 printf_filtered (_("Assuming trace state variable $%s "
3228 "is same as target's variable %d.\n"),
3229 tsv
->name
, utsv
->number
);
3233 tsv
= create_tsv_from_upload (utsv
);
3235 printf_filtered (_("Created trace state variable "
3236 "$%s for target's variable %d.\n"),
3237 tsv
->name
, utsv
->number
);
3239 /* Give precedence to numberings that come from the target. */
3241 tsv
->number
= utsv
->number
;
3244 /* Renumber everything that didn't get a target-assigned number. */
3246 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3247 if (tsv
->number
> highest
)
3248 highest
= tsv
->number
;
3251 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3252 if (tsv
->number
== 0)
3253 tsv
->number
= highest
++;
3255 free_uploaded_tsvs (uploaded_tsvs
);
3258 /* target tfile command */
3260 struct target_ops tfile_ops
;
3262 /* Fill in tfile_ops with its defined operations and properties. */
3264 #define TRACE_HEADER_SIZE 8
3266 char *trace_filename
;
3268 off_t trace_frames_offset
;
3270 int cur_traceframe_number
;
3272 int trace_regblock_size
;
3274 static void tfile_interp_line (char *line
,
3275 struct uploaded_tp
**utpp
,
3276 struct uploaded_tsv
**utsvp
);
3278 /* Read SIZE bytes into READBUF from the trace frame, starting at
3279 TRACE_FD's current position. Note that this call `read'
3280 underneath, hence it advances the file's seek position. Throws an
3281 error if the `read' syscall fails, or less than SIZE bytes are
3285 tfile_read (gdb_byte
*readbuf
, int size
)
3289 gotten
= read (trace_fd
, readbuf
, size
);
3291 perror_with_name (trace_filename
);
3292 else if (gotten
< size
)
3293 error (_("Premature end of file while reading trace file"));
3297 tfile_open (char *filename
, int from_tty
)
3299 volatile struct gdb_exception ex
;
3301 struct cleanup
*old_chain
;
3304 char header
[TRACE_HEADER_SIZE
];
3305 char linebuf
[1000]; /* Should be max remote packet size or so. */
3308 struct trace_status
*ts
;
3309 struct uploaded_tp
*uploaded_tps
= NULL
;
3310 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3312 target_preopen (from_tty
);
3314 error (_("No trace file specified."));
3316 filename
= tilde_expand (filename
);
3317 if (!IS_ABSOLUTE_PATH(filename
))
3319 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
3324 old_chain
= make_cleanup (xfree
, filename
);
3326 flags
= O_BINARY
| O_LARGEFILE
;
3328 scratch_chan
= open (filename
, flags
, 0);
3329 if (scratch_chan
< 0)
3330 perror_with_name (filename
);
3332 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3334 discard_cleanups (old_chain
); /* Don't free filename any more. */
3335 unpush_target (&tfile_ops
);
3337 trace_filename
= xstrdup (filename
);
3338 trace_fd
= scratch_chan
;
3341 /* Read the file header and test for validity. */
3342 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
3344 bytes
+= TRACE_HEADER_SIZE
;
3345 if (!(header
[0] == 0x7f
3346 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3347 error (_("File is not a valid trace file."));
3349 push_target (&tfile_ops
);
3351 trace_regblock_size
= 0;
3352 ts
= current_trace_status ();
3353 /* We know we're working with a file. */
3355 /* Set defaults in case there is no status line. */
3356 ts
->running_known
= 0;
3357 ts
->stop_reason
= trace_stop_reason_unknown
;
3358 ts
->traceframe_count
= -1;
3359 ts
->buffer_free
= 0;
3360 ts
->disconnected_tracing
= 0;
3361 ts
->circular_buffer
= 0;
3363 cur_traceframe_number
= -1;
3365 TRY_CATCH (ex
, RETURN_MASK_ALL
)
3367 /* Read through a section of newline-terminated lines that
3368 define things like tracepoints. */
3372 tfile_read (&byte
, 1);
3377 /* Empty line marks end of the definition section. */
3382 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3385 linebuf
[i
++] = byte
;
3387 error (_("Excessively long lines in trace file"));
3390 /* Record the starting offset of the binary trace data. */
3391 trace_frames_offset
= bytes
;
3393 /* If we don't have a blocksize, we can't interpret the
3395 if (trace_regblock_size
== 0)
3396 error (_("No register block size recorded in trace file"));
3400 /* Pop the partially set up target. */
3402 throw_exception (ex
);
3405 inferior_appeared (current_inferior (), TFILE_PID
);
3406 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3407 add_thread_silent (inferior_ptid
);
3409 if (ts
->traceframe_count
<= 0)
3410 warning (_("No traceframes present in this file."));
3412 /* Add the file's tracepoints and variables into the current mix. */
3414 /* Get trace state variables first, they may be checked when parsing
3415 uploaded commands. */
3416 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3418 merge_uploaded_tracepoints (&uploaded_tps
);
3420 post_create_inferior (&tfile_ops
, from_tty
);
3423 /* Interpret the given line from the definitions part of the trace
3427 tfile_interp_line (char *line
,
3428 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3432 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3435 trace_regblock_size
= strtol (p
, &p
, 16);
3437 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3439 p
+= strlen ("status ");
3440 parse_trace_status (p
, current_trace_status ());
3442 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3444 p
+= strlen ("tp ");
3445 parse_tracepoint_definition (p
, utpp
);
3447 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3449 p
+= strlen ("tsv ");
3450 parse_tsv_definition (p
, utsvp
);
3453 warning (_("Ignoring trace file definition \"%s\""), line
);
3456 /* Parse the part of trace status syntax that is shared between
3457 the remote protocol and the trace file reader. */
3460 parse_trace_status (char *line
, struct trace_status
*ts
)
3462 char *p
= line
, *p1
, *p2
, *p_temp
;
3465 ts
->running_known
= 1;
3466 ts
->running
= (*p
++ == '1');
3467 ts
->stop_reason
= trace_stop_reason_unknown
;
3468 xfree (ts
->error_desc
);
3469 ts
->error_desc
= NULL
;
3470 ts
->traceframe_count
= -1;
3471 ts
->traceframes_created
= -1;
3472 ts
->buffer_free
= -1;
3473 ts
->buffer_size
= -1;
3474 ts
->disconnected_tracing
= 0;
3475 ts
->circular_buffer
= 0;
3479 p1
= strchr (p
, ':');
3481 error (_("Malformed trace status, at %s\n\
3482 Status line: '%s'\n"), p
, line
);
3483 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3485 p
= unpack_varlen_hex (++p1
, &val
);
3486 ts
->stop_reason
= trace_buffer_full
;
3488 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3490 p
= unpack_varlen_hex (++p1
, &val
);
3491 ts
->stop_reason
= trace_never_run
;
3493 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3496 p
= unpack_varlen_hex (++p1
, &val
);
3497 ts
->stop_reason
= tracepoint_passcount
;
3498 ts
->stopping_tracepoint
= val
;
3500 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3502 p
= unpack_varlen_hex (++p1
, &val
);
3503 ts
->stop_reason
= tstop_command
;
3505 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3507 p
= unpack_varlen_hex (++p1
, &val
);
3508 ts
->stop_reason
= trace_disconnected
;
3510 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3512 p2
= strchr (++p1
, ':');
3517 ts
->error_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3518 end
= hex2bin (p1
, ts
->error_desc
, (p2
- p1
) / 2);
3519 ts
->error_desc
[end
] = '\0';
3522 ts
->error_desc
= xstrdup ("");
3524 p
= unpack_varlen_hex (++p2
, &val
);
3525 ts
->stopping_tracepoint
= val
;
3526 ts
->stop_reason
= tracepoint_error
;
3528 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3530 p
= unpack_varlen_hex (++p1
, &val
);
3531 ts
->traceframe_count
= val
;
3533 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3535 p
= unpack_varlen_hex (++p1
, &val
);
3536 ts
->traceframes_created
= val
;
3538 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3540 p
= unpack_varlen_hex (++p1
, &val
);
3541 ts
->buffer_free
= val
;
3543 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3545 p
= unpack_varlen_hex (++p1
, &val
);
3546 ts
->buffer_size
= val
;
3548 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3550 p
= unpack_varlen_hex (++p1
, &val
);
3551 ts
->disconnected_tracing
= val
;
3553 else if (strncmp (p
, "circular", p1
- p
) == 0)
3555 p
= unpack_varlen_hex (++p1
, &val
);
3556 ts
->circular_buffer
= val
;
3560 /* Silently skip unknown optional info. */
3561 p_temp
= strchr (p1
+ 1, ';');
3565 /* Must be at the end. */
3571 /* Given a line of text defining a part of a tracepoint, parse it into
3572 an "uploaded tracepoint". */
3575 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3579 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3582 char *cond
, *srctype
, *buf
;
3583 struct uploaded_tp
*utp
= NULL
;
3586 /* Both tracepoint and action definitions start with the same number
3587 and address sequence. */
3589 p
= unpack_varlen_hex (p
, &num
);
3590 p
++; /* skip a colon */
3591 p
= unpack_varlen_hex (p
, &addr
);
3592 p
++; /* skip a colon */
3595 enabled
= (*p
++ == 'E');
3596 p
++; /* skip a colon */
3597 p
= unpack_varlen_hex (p
, &step
);
3598 p
++; /* skip a colon */
3599 p
= unpack_varlen_hex (p
, &pass
);
3600 type
= bp_tracepoint
;
3602 /* Thumb through optional fields. */
3605 p
++; /* skip a colon */
3608 type
= bp_fast_tracepoint
;
3610 p
= unpack_varlen_hex (p
, &orig_size
);
3614 type
= bp_static_tracepoint
;
3620 p
= unpack_varlen_hex (p
, &xlen
);
3621 p
++; /* skip a comma */
3622 cond
= (char *) xmalloc (2 * xlen
+ 1);
3623 strncpy (cond
, p
, 2 * xlen
);
3624 cond
[2 * xlen
] = '\0';
3628 warning (_("Unrecognized char '%c' in tracepoint "
3629 "definition, skipping rest"), *p
);
3631 utp
= get_uploaded_tp (num
, addr
, utpp
);
3633 utp
->enabled
= enabled
;
3638 else if (piece
== 'A')
3640 utp
= get_uploaded_tp (num
, addr
, utpp
);
3641 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
3643 else if (piece
== 'S')
3645 utp
= get_uploaded_tp (num
, addr
, utpp
);
3646 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
3648 else if (piece
== 'Z')
3650 /* Parse a chunk of source form definition. */
3651 utp
= get_uploaded_tp (num
, addr
, utpp
);
3653 p
= strchr (p
, ':');
3654 p
++; /* skip a colon */
3655 p
= unpack_varlen_hex (p
, &start
);
3656 p
++; /* skip a colon */
3657 p
= unpack_varlen_hex (p
, &xlen
);
3658 p
++; /* skip a colon */
3660 buf
= alloca (strlen (line
));
3662 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3665 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
3666 utp
->at_string
= xstrdup (buf
);
3667 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
3668 utp
->cond_string
= xstrdup (buf
);
3669 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
3670 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
3674 /* Don't error out, the target might be sending us optional
3675 info that we don't care about. */
3676 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3680 /* Convert a textual description of a trace state variable into an
3684 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3687 ULONGEST num
, initval
, builtin
;
3689 struct uploaded_tsv
*utsv
= NULL
;
3691 buf
= alloca (strlen (line
));
3694 p
= unpack_varlen_hex (p
, &num
);
3695 p
++; /* skip a colon */
3696 p
= unpack_varlen_hex (p
, &initval
);
3697 p
++; /* skip a colon */
3698 p
= unpack_varlen_hex (p
, &builtin
);
3699 p
++; /* skip a colon */
3700 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3703 utsv
= get_uploaded_tsv (num
, utsvp
);
3704 utsv
->initial_value
= initval
;
3705 utsv
->builtin
= builtin
;
3706 utsv
->name
= xstrdup (buf
);
3709 /* Close the trace file and generally clean up. */
3712 tfile_close (int quitting
)
3719 pid
= ptid_get_pid (inferior_ptid
);
3720 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff. */
3721 exit_inferior_silent (pid
);
3725 xfree (trace_filename
);
3726 trace_filename
= NULL
;
3730 tfile_files_info (struct target_ops
*t
)
3732 /* (it would be useful to mention the name of the file). */
3733 printf_filtered ("Looking at a trace file.\n");
3736 /* The trace status for a file is that tracing can never be run. */
3739 tfile_get_trace_status (struct trace_status
*ts
)
3741 /* Other bits of trace status were collected as part of opening the
3742 trace files, so nothing to do here. */
3747 /* Given the position of a traceframe in the file, figure out what
3748 address the frame was collected at. This would normally be the
3749 value of a collected PC register, but if not available, we
3753 tfile_get_traceframe_address (off_t tframe_offset
)
3757 struct breakpoint
*tp
;
3758 off_t saved_offset
= cur_offset
;
3760 /* FIXME dig pc out of collected registers. */
3762 /* Fall back to using tracepoint address. */
3763 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
3764 tfile_read ((gdb_byte
*) &tpnum
, 2);
3765 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
3769 tp
= get_tracepoint_by_number_on_target (tpnum
);
3770 /* FIXME this is a poor heuristic if multiple locations. */
3772 addr
= tp
->loc
->address
;
3774 /* Restore our seek position. */
3775 cur_offset
= saved_offset
;
3776 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3780 /* Make tfile's selected traceframe match GDB's selected
3784 set_tfile_traceframe (void)
3788 if (cur_traceframe_number
== get_traceframe_number ())
3791 /* Avoid recursion, tfile_trace_find calls us again. */
3792 cur_traceframe_number
= get_traceframe_number ();
3794 newnum
= target_trace_find (tfind_number
,
3795 get_traceframe_number (), 0, 0, NULL
);
3797 /* Should not happen. If it does, all bets are off. */
3798 if (newnum
!= get_traceframe_number ())
3799 warning (_("could not set tfile's traceframe"));
3802 /* Given a type of search and some parameters, scan the collection of
3803 traceframes in the file looking for a match. When found, return
3804 both the traceframe and tracepoint number, otherwise -1 for
3808 tfile_trace_find (enum trace_find_type type
, int num
,
3809 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
3812 int tfnum
= 0, found
= 0;
3813 unsigned int data_size
;
3814 struct breakpoint
*tp
;
3815 off_t offset
, tframe_offset
;
3818 /* Lookups other than by absolute frame number depend on the current
3819 trace selected, so make sure it is correct on the tfile end
3821 if (type
!= tfind_number
)
3822 set_tfile_traceframe ();
3830 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
3831 offset
= trace_frames_offset
;
3834 tframe_offset
= offset
;
3835 tfile_read ((gdb_byte
*) &tpnum
, 2);
3836 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
3842 tfile_read ((gdb_byte
*) &data_size
, 4);
3843 data_size
= (unsigned int) extract_unsigned_integer
3844 ((gdb_byte
*) &data_size
, 4,
3845 gdbarch_byte_order (target_gdbarch
));
3854 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3855 if (tfaddr
== addr1
)
3859 tp
= get_tracepoint (num
);
3860 if (tp
&& tpnum
== tp
->number_on_target
)
3864 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3865 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
3869 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3870 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
3874 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
3880 cur_offset
= offset
;
3881 cur_data_size
= data_size
;
3882 cur_traceframe_number
= tfnum
;
3885 /* Skip past the traceframe's data. */
3886 lseek (trace_fd
, data_size
, SEEK_CUR
);
3887 offset
+= data_size
;
3888 /* Update our own count of traceframes. */
3891 /* Did not find what we were looking for. */
3897 /* Prototype of the callback passed to tframe_walk_blocks. */
3898 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
3900 /* Callback for traceframe_walk_blocks, used to find a given block
3901 type in a traceframe. */
3904 match_blocktype (char blocktype
, void *data
)
3906 char *wantedp
= data
;
3908 if (*wantedp
== blocktype
)
3914 /* Walk over all traceframe block starting at POS offset from
3915 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
3916 unmodified. If CALLBACK returns true, this returns the position in
3917 the traceframe where the block is found, relative to the start of
3918 the traceframe (cur_offset). Returns -1 if no callback call
3919 returned true, indicating that all blocks have been walked. */
3922 traceframe_walk_blocks (walk_blocks_callback_func callback
,
3923 int pos
, void *data
)
3925 /* Iterate through a traceframe's blocks, looking for a block of the
3928 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
3929 while (pos
< cur_data_size
)
3931 unsigned short mlen
;
3934 tfile_read (&block_type
, 1);
3938 if ((*callback
) (block_type
, data
))
3944 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
3945 pos
+= trace_regblock_size
;
3948 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
3949 tfile_read ((gdb_byte
*) &mlen
, 2);
3950 mlen
= (unsigned short)
3951 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
3954 lseek (trace_fd
, mlen
, SEEK_CUR
);
3955 pos
+= (8 + 2 + mlen
);
3958 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
3962 error (_("Unknown block type '%c' (0x%x) in trace frame"),
3963 block_type
, block_type
);
3971 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
3972 position offset of a block of type TYPE_WANTED in the current trace
3973 frame, starting at POS. Returns -1 if no such block was found. */
3976 traceframe_find_block_type (char type_wanted
, int pos
)
3978 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
3981 /* Look for a block of saved registers in the traceframe, and get the
3982 requested register from it. */
3985 tfile_fetch_registers (struct target_ops
*ops
,
3986 struct regcache
*regcache
, int regno
)
3988 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3990 int pos
, offset
, regn
, regsize
, pc_regno
;
3991 unsigned short mlen
;
3994 /* An uninitialized reg size says we're not going to be
3995 successful at getting register blocks. */
3996 if (!trace_regblock_size
)
3999 set_tfile_traceframe ();
4001 regs
= alloca (trace_regblock_size
);
4003 if (traceframe_find_block_type ('R', 0) >= 0)
4005 tfile_read (regs
, trace_regblock_size
);
4007 /* Assume the block is laid out in GDB register number order,
4008 each register with the size that it has in GDB. */
4010 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4012 regsize
= register_size (gdbarch
, regn
);
4013 /* Make sure we stay within block bounds. */
4014 if (offset
+ regsize
>= trace_regblock_size
)
4016 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
4020 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
4023 else if (regno
== -1)
4025 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
4033 /* We get here if no register data has been found. Mark registers
4035 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4036 regcache_raw_supply (regcache
, regn
, NULL
);
4038 /* We can often usefully guess that the PC is going to be the same
4039 as the address of the tracepoint. */
4040 pc_regno
= gdbarch_pc_regnum (gdbarch
);
4041 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
4043 struct breakpoint
*tp
= get_tracepoint (tracepoint_number
);
4047 /* But don't try to guess if tracepoint is multi-location... */
4050 warning (_("Tracepoint %d has multiple "
4051 "locations, cannot infer $pc"),
4055 /* ... or does while-stepping. */
4056 if (tp
->step_count
> 0)
4058 warning (_("Tracepoint %d does while-stepping, "
4059 "cannot infer $pc"),
4064 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
4065 gdbarch_byte_order (gdbarch
),
4067 regcache_raw_supply (regcache
, pc_regno
, regs
);
4073 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4074 const char *annex
, gdb_byte
*readbuf
,
4075 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
4077 /* We're only doing regular memory for now. */
4078 if (object
!= TARGET_OBJECT_MEMORY
)
4081 if (readbuf
== NULL
)
4082 error (_("tfile_xfer_partial: trace file is read-only"));
4084 set_tfile_traceframe ();
4086 if (traceframe_number
!= -1)
4090 /* Iterate through the traceframe's blocks, looking for
4092 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
4094 ULONGEST maddr
, amt
;
4095 unsigned short mlen
;
4096 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
4098 tfile_read ((gdb_byte
*) &maddr
, 8);
4099 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
4101 tfile_read ((gdb_byte
*) &mlen
, 2);
4102 mlen
= (unsigned short)
4103 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
4105 /* If the block includes the first part of the desired
4106 range, return as much it has; GDB will re-request the
4107 remainder, which might be in a different block of this
4109 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
4111 amt
= (maddr
+ mlen
) - offset
;
4115 tfile_read (readbuf
, amt
);
4119 /* Skip over this block. */
4120 pos
+= (8 + 2 + mlen
);
4124 /* It's unduly pedantic to refuse to look at the executable for
4125 read-only pieces; so do the equivalent of readonly regions aka
4127 /* FIXME account for relocation at some point. */
4134 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
4136 if ((s
->flags
& SEC_LOAD
) == 0
4137 || (s
->flags
& SEC_READONLY
) == 0)
4141 size
= bfd_get_section_size (s
);
4142 if (vma
<= offset
&& offset
< (vma
+ size
))
4146 amt
= (vma
+ size
) - offset
;
4150 amt
= bfd_get_section_contents (exec_bfd
, s
,
4151 readbuf
, offset
- vma
, amt
);
4157 /* Indicate failure to find the requested memory block. */
4161 /* Iterate through the blocks of a trace frame, looking for a 'V'
4162 block with a matching tsv number. */
4165 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
4169 set_tfile_traceframe ();
4172 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
4176 tfile_read ((gdb_byte
*) &vnum
, 4);
4177 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
4182 tfile_read ((gdb_byte
*) val
, 8);
4183 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
4191 /* Didn't find anything. */
4196 tfile_has_all_memory (struct target_ops
*ops
)
4202 tfile_has_memory (struct target_ops
*ops
)
4208 tfile_has_stack (struct target_ops
*ops
)
4210 return traceframe_number
!= -1;
4214 tfile_has_registers (struct target_ops
*ops
)
4216 return traceframe_number
!= -1;
4220 tfile_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
4225 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
4226 object for the tfile target's current traceframe. */
4229 build_traceframe_info (char blocktype
, void *data
)
4231 struct traceframe_info
*info
= data
;
4237 struct mem_range
*r
;
4239 unsigned short mlen
;
4241 tfile_read ((gdb_byte
*) &maddr
, 8);
4242 tfile_read ((gdb_byte
*) &mlen
, 2);
4244 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4257 warning (_("Unhandled trace block type (%d) '%c ' "
4258 "while building trace frame info."),
4259 blocktype
, blocktype
);
4266 static struct traceframe_info
*
4267 tfile_traceframe_info (void)
4269 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
4271 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
4276 init_tfile_ops (void)
4278 tfile_ops
.to_shortname
= "tfile";
4279 tfile_ops
.to_longname
= "Local trace dump file";
4281 = "Use a trace file as a target. Specify the filename of the trace file.";
4282 tfile_ops
.to_open
= tfile_open
;
4283 tfile_ops
.to_close
= tfile_close
;
4284 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
4285 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
4286 tfile_ops
.to_files_info
= tfile_files_info
;
4287 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
4288 tfile_ops
.to_trace_find
= tfile_trace_find
;
4289 tfile_ops
.to_get_trace_state_variable_value
4290 = tfile_get_trace_state_variable_value
;
4291 tfile_ops
.to_stratum
= process_stratum
;
4292 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
4293 tfile_ops
.to_has_memory
= tfile_has_memory
;
4294 tfile_ops
.to_has_stack
= tfile_has_stack
;
4295 tfile_ops
.to_has_registers
= tfile_has_registers
;
4296 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
4297 tfile_ops
.to_thread_alive
= tfile_thread_alive
;
4298 tfile_ops
.to_magic
= OPS_MAGIC
;
4301 /* Given a line of text defining a static tracepoint marker, parse it
4302 into a "static tracepoint marker" object. Throws an error is
4303 parsing fails. If PP is non-null, it points to one past the end of
4304 the parsed marker definition. */
4307 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
4308 struct static_tracepoint_marker
*marker
)
4315 p
= unpack_varlen_hex (p
, &addr
);
4316 p
++; /* skip a colon */
4318 marker
->gdbarch
= target_gdbarch
;
4319 marker
->address
= (CORE_ADDR
) addr
;
4321 endp
= strchr (p
, ':');
4323 error (_("bad marker definition: %s"), line
);
4325 marker
->str_id
= xmalloc (endp
- p
+ 1);
4326 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
4327 marker
->str_id
[end
] = '\0';
4330 p
++; /* skip a colon */
4332 marker
->extra
= xmalloc (strlen (p
) + 1);
4333 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
4334 marker
->extra
[end
] = '\0';
4340 /* Release a static tracepoint marker's contents. Note that the
4341 object itself isn't released here. There objects are usually on
4345 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
4347 xfree (marker
->str_id
);
4348 marker
->str_id
= NULL
;
4351 /* Print MARKER to gdb_stdout. */
4354 print_one_static_tracepoint_marker (int count
,
4355 struct static_tracepoint_marker
*marker
)
4357 struct command_line
*l
;
4360 char wrap_indent
[80];
4361 char extra_field_indent
[80];
4362 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
4363 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4364 struct cleanup
*bkpt_chain
;
4365 VEC(breakpoint_p
) *tracepoints
;
4367 struct symtab_and_line sal
;
4371 sal
.pc
= marker
->address
;
4373 tracepoints
= static_tracepoints_here (marker
->address
);
4375 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
4377 /* A counter field to help readability. This is not a stable
4379 ui_out_field_int (uiout
, "count", count
);
4381 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
4383 ui_out_field_fmt (uiout
, "enabled", "%c",
4384 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
4385 ui_out_spaces (uiout
, 2);
4387 strcpy (wrap_indent
, " ");
4389 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
4390 strcat (wrap_indent
, " ");
4392 strcat (wrap_indent
, " ");
4394 strcpy (extra_field_indent
, " ");
4396 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
4398 sal
= find_pc_line (marker
->address
, 0);
4399 sym
= find_pc_sect_function (marker
->address
, NULL
);
4402 ui_out_text (uiout
, "in ");
4403 ui_out_field_string (uiout
, "func",
4404 SYMBOL_PRINT_NAME (sym
));
4405 ui_out_wrap_hint (uiout
, wrap_indent
);
4406 ui_out_text (uiout
, " at ");
4409 ui_out_field_skip (uiout
, "func");
4411 if (sal
.symtab
!= NULL
)
4413 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
4414 ui_out_text (uiout
, ":");
4416 if (ui_out_is_mi_like_p (uiout
))
4418 char *fullname
= symtab_to_fullname (sal
.symtab
);
4421 ui_out_field_string (uiout
, "fullname", fullname
);
4424 ui_out_field_skip (uiout
, "fullname");
4426 ui_out_field_int (uiout
, "line", sal
.line
);
4430 ui_out_field_skip (uiout
, "fullname");
4431 ui_out_field_skip (uiout
, "line");
4434 ui_out_text (uiout
, "\n");
4435 ui_out_text (uiout
, extra_field_indent
);
4436 ui_out_text (uiout
, _("Data: \""));
4437 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
4438 ui_out_text (uiout
, "\"\n");
4440 if (!VEC_empty (breakpoint_p
, tracepoints
))
4442 struct cleanup
*cleanup_chain
;
4444 struct breakpoint
*b
;
4446 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
4449 ui_out_text (uiout
, extra_field_indent
);
4450 ui_out_text (uiout
, _("Probed by static tracepoints: "));
4451 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
4454 ui_out_text (uiout
, ", ");
4455 ui_out_text (uiout
, "#");
4456 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
4459 do_cleanups (cleanup_chain
);
4461 if (ui_out_is_mi_like_p (uiout
))
4462 ui_out_field_int (uiout
, "number-of-tracepoints",
4463 VEC_length(breakpoint_p
, tracepoints
));
4465 ui_out_text (uiout
, "\n");
4467 VEC_free (breakpoint_p
, tracepoints
);
4469 do_cleanups (bkpt_chain
);
4470 do_cleanups (old_chain
);
4474 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
4476 VEC(static_tracepoint_marker_p
) *markers
;
4477 struct cleanup
*old_chain
;
4478 struct static_tracepoint_marker
*marker
;
4482 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
4483 "StaticTracepointMarkersTable");
4485 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
4487 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
4489 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
4490 if (gdbarch_addr_bit (target_gdbarch
) <= 32)
4491 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
4493 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
4494 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
4496 ui_out_table_body (uiout
);
4498 markers
= target_static_tracepoint_markers_by_strid (NULL
);
4499 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
4502 VEC_iterate (static_tracepoint_marker_p
,
4503 markers
, i
, marker
);
4506 print_one_static_tracepoint_marker (i
+ 1, marker
);
4507 release_static_tracepoint_marker (marker
);
4510 do_cleanups (old_chain
);
4513 /* The $_sdata convenience variable is a bit special. We don't know
4514 for sure type of the value until we actually have a chance to fetch
4515 the data --- the size of the object depends on what has been
4516 collected. We solve this by making $_sdata be an internalvar that
4517 creates a new value on access. */
4519 /* Return a new value with the correct type for the sdata object of
4520 the current trace frame. Return a void value if there's no object
4523 static struct value
*
4524 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
)
4529 /* We need to read the whole object before we know its size. */
4530 size
= target_read_alloc (¤t_target
,
4531 TARGET_OBJECT_STATIC_TRACE_DATA
,
4538 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
4540 v
= allocate_value (type
);
4541 memcpy (value_contents_raw (v
), buf
, size
);
4546 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
4549 #if !defined(HAVE_LIBEXPAT)
4551 struct traceframe_info
*
4552 parse_traceframe_info (const char *tframe_info
)
4554 static int have_warned
;
4559 warning (_("Can not parse XML trace frame info; XML support "
4560 "was disabled at compile time"));
4566 #else /* HAVE_LIBEXPAT */
4568 #include "xml-support.h"
4570 /* Handle the start of a <memory> element. */
4573 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
4574 const struct gdb_xml_element
*element
,
4575 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
4577 struct traceframe_info
*info
= user_data
;
4578 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4579 ULONGEST
*start_p
, *length_p
;
4581 start_p
= xml_find_attribute (attributes
, "start")->value
;
4582 length_p
= xml_find_attribute (attributes
, "length")->value
;
4584 r
->start
= *start_p
;
4585 r
->length
= *length_p
;
4588 /* Discard the constructed trace frame info (if an error occurs). */
4591 free_result (void *p
)
4593 struct traceframe_info
*result
= p
;
4595 free_traceframe_info (result
);
4598 /* The allowed elements and attributes for an XML memory map. */
4600 static const struct gdb_xml_attribute memory_attributes
[] = {
4601 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
4602 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
4603 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
4606 static const struct gdb_xml_element traceframe_info_children
[] = {
4607 { "memory", memory_attributes
, NULL
,
4608 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
4609 traceframe_info_start_memory
, NULL
},
4610 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
4613 static const struct gdb_xml_element traceframe_info_elements
[] = {
4614 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
4616 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
4619 /* Parse a traceframe-info XML document. */
4621 struct traceframe_info
*
4622 parse_traceframe_info (const char *tframe_info
)
4624 struct traceframe_info
*result
;
4625 struct cleanup
*back_to
;
4627 result
= XCNEW (struct traceframe_info
);
4628 back_to
= make_cleanup (free_result
, result
);
4630 if (gdb_xml_parse_quick (_("trace frame info"),
4631 "traceframe-info.dtd", traceframe_info_elements
,
4632 tframe_info
, result
) == 0)
4634 /* Parsed successfully, keep the result. */
4635 discard_cleanups (back_to
);
4640 do_cleanups (back_to
);
4644 #endif /* HAVE_LIBEXPAT */
4646 /* Returns the traceframe_info object for the current traceframe.
4647 This is where we avoid re-fetching the object from the target if we
4648 already have it cached. */
4650 struct traceframe_info
*
4651 get_traceframe_info (void)
4653 if (traceframe_info
== NULL
)
4654 traceframe_info
= target_traceframe_info ();
4656 return traceframe_info
;
4659 /* If the target supports the query, return in RESULT the set of
4660 collected memory in the current traceframe, found within the LEN
4661 bytes range starting at MEMADDR. Returns true if the target
4662 supports the query, otherwise returns false, and RESULT is left
4666 traceframe_available_memory (VEC(mem_range_s
) **result
,
4667 CORE_ADDR memaddr
, ULONGEST len
)
4669 struct traceframe_info
*info
= get_traceframe_info ();
4673 struct mem_range
*r
;
4678 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
4679 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
4681 ULONGEST lo1
, hi1
, lo2
, hi2
;
4682 struct mem_range
*nr
;
4685 hi1
= memaddr
+ len
;
4688 hi2
= r
->start
+ r
->length
;
4690 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
4692 nr
->start
= max (lo1
, lo2
);
4693 nr
->length
= min (hi1
, hi2
) - nr
->start
;
4696 normalize_mem_ranges (*result
);
4703 /* module initialization */
4705 _initialize_tracepoint (void)
4707 struct cmd_list_element
*c
;
4709 /* Explicitly create without lookup, since that tries to create a
4710 value with a void typed value, and when we get here, gdbarch
4711 isn't initialized yet. At this point, we're quite sure there
4712 isn't another convenience variable of the same name. */
4713 create_internalvar_type_lazy ("_sdata", sdata_make_value
);
4715 traceframe_number
= -1;
4716 tracepoint_number
= -1;
4718 if (tracepoint_list
.list
== NULL
)
4720 tracepoint_list
.listsize
= 128;
4721 tracepoint_list
.list
= xmalloc
4722 (tracepoint_list
.listsize
* sizeof (struct memrange
));
4724 if (tracepoint_list
.aexpr_list
== NULL
)
4726 tracepoint_list
.aexpr_listsize
= 128;
4727 tracepoint_list
.aexpr_list
= xmalloc
4728 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
4731 if (stepping_list
.list
== NULL
)
4733 stepping_list
.listsize
= 128;
4734 stepping_list
.list
= xmalloc
4735 (stepping_list
.listsize
* sizeof (struct memrange
));
4738 if (stepping_list
.aexpr_list
== NULL
)
4740 stepping_list
.aexpr_listsize
= 128;
4741 stepping_list
.aexpr_list
= xmalloc
4742 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
4745 add_info ("scope", scope_info
,
4746 _("List the variables local to a scope"));
4748 add_cmd ("tracepoints", class_trace
, NULL
,
4749 _("Tracing of program execution without stopping the program."),
4752 add_com ("tdump", class_trace
, trace_dump_command
,
4753 _("Print everything collected at the current tracepoint."));
4755 add_com ("tsave", class_trace
, trace_save_command
, _("\
4756 Save the trace data to a file.\n\
4757 Use the '-r' option to direct the target to save directly to the file,\n\
4758 using its own filesystem."));
4760 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
4761 Define a trace state variable.\n\
4762 Argument is a $-prefixed name, optionally followed\n\
4763 by '=' and an expression that sets the initial value\n\
4764 at the start of tracing."));
4765 set_cmd_completer (c
, expression_completer
);
4767 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
4768 Delete one or more trace state variables.\n\
4769 Arguments are the names of the variables to delete.\n\
4770 If no arguments are supplied, delete all variables."), &deletelist
);
4771 /* FIXME add a trace variable completer. */
4773 add_info ("tvariables", tvariables_info
, _("\
4774 Status of trace state variables and their values.\n\
4777 add_info ("static-tracepoint-markers",
4778 info_static_tracepoint_markers_command
, _("\
4779 List target static tracepoints markers.\n\
4782 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
4783 Select a trace frame;\n\
4784 No argument means forward by one frame; '-' means backward by one frame."),
4785 &tfindlist
, "tfind ", 1, &cmdlist
);
4787 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
4788 Select a trace frame whose PC is outside the given range (exclusive).\n\
4789 Usage: tfind outside addr1, addr2"),
4792 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
4793 Select a trace frame whose PC is in the given range (inclusive).\n\
4794 Usage: tfind range addr1,addr2"),
4797 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
4798 Select a trace frame by source line.\n\
4799 Argument can be a line number (with optional source file),\n\
4800 a function name, or '*' followed by an address.\n\
4801 Default argument is 'the next source line that was traced'."),
4804 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
4805 Select a trace frame by tracepoint number.\n\
4806 Default is the tracepoint for the current trace frame."),
4809 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
4810 Select a trace frame by PC.\n\
4811 Default is the current PC, or the PC of the current trace frame."),
4814 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
4815 Synonym for 'none'.\n\
4816 De-select any trace frame and resume 'live' debugging."),
4819 add_cmd ("none", class_trace
, trace_find_none_command
,
4820 _("De-select any trace frame and resume 'live' debugging."),
4823 add_cmd ("start", class_trace
, trace_find_start_command
,
4824 _("Select the first trace frame in the trace buffer."),
4827 add_com ("tstatus", class_trace
, trace_status_command
,
4828 _("Display the status of the current trace data collection."));
4830 add_com ("tstop", class_trace
, trace_stop_command
,
4831 _("Stop trace data collection."));
4833 add_com ("tstart", class_trace
, trace_start_command
,
4834 _("Start trace data collection."));
4836 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
4837 Ends a list of commands or actions.\n\
4838 Several GDB commands allow you to enter a list of commands or actions.\n\
4839 Entering \"end\" on a line by itself is the normal way to terminate\n\
4841 Note: the \"end\" command cannot be used at the gdb prompt."));
4843 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
4844 Specify single-stepping behavior at a tracepoint.\n\
4845 Argument is number of instructions to trace in single-step mode\n\
4846 following the tracepoint. This command is normally followed by\n\
4847 one or more \"collect\" commands, to specify what to collect\n\
4848 while single-stepping.\n\n\
4849 Note: this command can only be used in a tracepoint \"actions\" list."));
4851 add_com_alias ("ws", "while-stepping", class_alias
, 0);
4852 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
4854 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
4855 Specify one or more data items to be collected at a tracepoint.\n\
4856 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4857 collect all data (variables, registers) referenced by that expression.\n\
4858 Also accepts the following special arguments:\n\
4859 $regs -- all registers.\n\
4860 $args -- all function arguments.\n\
4861 $locals -- all variables local to the block/function scope.\n\
4862 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4863 Note: this command can only be used in a tracepoint \"actions\" list."));
4865 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4866 Specify one or more expressions to be evaluated at a tracepoint.\n\
4867 Accepts a comma-separated list of (one or more) expressions.\n\
4868 The result of each evaluation will be discarded.\n\
4869 Note: this command can only be used in a tracepoint \"actions\" list."));
4871 add_com ("actions", class_trace
, trace_actions_command
, _("\
4872 Specify the actions to be taken at a tracepoint.\n\
4873 Tracepoint actions may include collecting of specified data,\n\
4874 single-stepping, or enabling/disabling other tracepoints,\n\
4875 depending on target's capabilities."));
4877 default_collect
= xstrdup ("");
4878 add_setshow_string_cmd ("default-collect", class_trace
,
4879 &default_collect
, _("\
4880 Set the list of expressions to collect by default"), _("\
4881 Show the list of expressions to collect by default"), NULL
,
4883 &setlist
, &showlist
);
4885 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4886 &disconnected_tracing
, _("\
4887 Set whether tracing continues after GDB disconnects."), _("\
4888 Show whether tracing continues after GDB disconnects."), _("\
4889 Use this to continue a tracing run even if GDB disconnects\n\
4890 or detaches from the target. You can reconnect later and look at\n\
4891 trace data collected in the meantime."),
4892 set_disconnected_tracing
,
4897 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4898 &circular_trace_buffer
, _("\
4899 Set target's use of circular trace buffer."), _("\
4900 Show target's use of circular trace buffer."), _("\
4901 Use this to make the trace buffer into a circular buffer,\n\
4902 which will discard traceframes (oldest first) instead of filling\n\
4903 up and stopping the trace run."),
4904 set_circular_trace_buffer
,
4911 add_target (&tfile_ops
);