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
;
460 struct ui_out
*uiout
= current_uiout
;
462 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
464 printf_filtered (_("No trace state variables.\n"));
468 /* Try to acquire values from the target. */
469 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
470 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
473 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
474 count
, "trace-variables");
475 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
476 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
477 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
479 ui_out_table_body (uiout
);
481 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
483 struct cleanup
*back_to2
;
487 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
489 name
= concat ("$", tsv
->name
, (char *) NULL
);
490 make_cleanup (xfree
, name
);
491 ui_out_field_string (uiout
, "name", name
);
492 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
494 if (tsv
->value_known
)
495 c
= plongest (tsv
->value
);
496 else if (ui_out_is_mi_like_p (uiout
))
497 /* For MI, we prefer not to use magic string constants, but rather
498 omit the field completely. The difference between unknown and
499 undefined does not seem important enough to represent. */
501 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
502 /* The value is/was defined, but we don't have it. */
505 /* It is not meaningful to ask about the value. */
508 ui_out_field_string (uiout
, "current", c
);
509 ui_out_text (uiout
, "\n");
511 do_cleanups (back_to2
);
514 do_cleanups (back_to
);
517 /* List all the trace state variables. */
520 tvariables_info (char *args
, int from_tty
)
522 tvariables_info_1 ();
525 /* Stash definitions of tsvs into the given file. */
528 save_trace_state_variables (struct ui_file
*fp
)
530 struct trace_state_variable
*tsv
;
533 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
535 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
536 if (tsv
->initial_value
)
537 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
538 fprintf_unfiltered (fp
, "\n");
542 /* ACTIONS functions: */
544 /* The three functions:
545 collect_pseudocommand,
546 while_stepping_pseudocommand, and
547 end_actions_pseudocommand
548 are placeholders for "commands" that are actually ONLY to be used
549 within a tracepoint action list. If the actual function is ever called,
550 it means that somebody issued the "command" at the top level,
551 which is always an error. */
554 end_actions_pseudocommand (char *args
, int from_tty
)
556 error (_("This command cannot be used at the top level."));
560 while_stepping_pseudocommand (char *args
, int from_tty
)
562 error (_("This command can only be used in a tracepoint actions list."));
566 collect_pseudocommand (char *args
, int from_tty
)
568 error (_("This command can only be used in a tracepoint actions list."));
572 teval_pseudocommand (char *args
, int from_tty
)
574 error (_("This command can only be used in a tracepoint actions list."));
577 /* Enter a list of actions for a tracepoint. */
579 trace_actions_command (char *args
, int from_tty
)
581 struct tracepoint
*t
;
582 struct command_line
*l
;
584 t
= get_tracepoint_by_number (&args
, NULL
, 1);
588 xstrprintf ("Enter actions for tracepoint %d, one per line.",
590 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
592 l
= read_command_lines (tmpbuf
, from_tty
, 1,
593 check_tracepoint_command
, t
);
594 do_cleanups (cleanups
);
595 breakpoint_set_commands (&t
->base
, l
);
597 /* else just return */
600 /* Report the results of checking the agent expression, as errors or
604 report_agent_reqs_errors (struct agent_expr
*aexpr
)
606 /* All of the "flaws" are serious bytecode generation issues that
607 should never occur. */
608 if (aexpr
->flaw
!= agent_flaw_none
)
609 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
611 /* If analysis shows a stack underflow, GDB must have done something
612 badly wrong in its bytecode generation. */
613 if (aexpr
->min_height
< 0)
614 internal_error (__FILE__
, __LINE__
,
615 _("expression has min height < 0"));
617 /* Issue this error if the stack is predicted to get too deep. The
618 limit is rather arbitrary; a better scheme might be for the
619 target to report how much stack it will have available. The
620 depth roughly corresponds to parenthesization, so a limit of 20
621 amounts to 20 levels of expression nesting, which is actually
622 a pretty big hairy expression. */
623 if (aexpr
->max_height
> 20)
624 error (_("Expression is too complicated."));
627 /* worker function */
629 validate_actionline (char **line
, struct breakpoint
*b
)
631 struct cmd_list_element
*c
;
632 struct expression
*exp
= NULL
;
633 struct cleanup
*old_chain
= NULL
;
635 struct bp_location
*loc
;
636 struct agent_expr
*aexpr
;
637 struct tracepoint
*t
= (struct tracepoint
*) b
;
639 /* If EOF is typed, *line is NULL. */
643 for (p
= *line
; isspace ((int) *p
);)
646 /* Symbol lookup etc. */
647 if (*p
== '\0') /* empty line: just prompt for another line. */
650 if (*p
== '#') /* comment line */
653 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
655 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
657 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
660 { /* Repeat over a comma-separated list. */
661 QUIT
; /* Allow user to bail out with ^C. */
662 while (isspace ((int) *p
))
665 if (*p
== '$') /* Look for special pseudo-symbols. */
667 if (0 == strncasecmp ("reg", p
+ 1, 3)
668 || 0 == strncasecmp ("arg", p
+ 1, 3)
669 || 0 == strncasecmp ("loc", p
+ 1, 3)
670 || 0 == strncasecmp ("_ret", p
+ 1, 4)
671 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
676 /* else fall thru, treat p as an expression and parse it! */
679 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
682 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
683 old_chain
= make_cleanup (free_current_contents
, &exp
);
685 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
687 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
689 error (_("constant `%s' (value %ld) "
690 "will not be collected."),
691 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
692 SYMBOL_VALUE (exp
->elts
[2].symbol
));
694 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
695 == LOC_OPTIMIZED_OUT
)
697 error (_("`%s' is optimized away "
698 "and cannot be collected."),
699 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
703 /* We have something to collect, make sure that the expr to
704 bytecode translator can handle it and that it's not too
706 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
707 make_cleanup_free_agent_expr (aexpr
);
709 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
710 error (_("Expression is too complicated."));
714 report_agent_reqs_errors (aexpr
);
716 do_cleanups (old_chain
);
719 while (p
&& *p
++ == ',');
722 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
725 { /* Repeat over a comma-separated list. */
726 QUIT
; /* Allow user to bail out with ^C. */
727 while (isspace ((int) *p
))
731 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
734 /* Only expressions are allowed for this action. */
735 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
736 old_chain
= make_cleanup (free_current_contents
, &exp
);
738 /* We have something to evaluate, make sure that the expr to
739 bytecode translator can handle it and that it's not too
741 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
742 make_cleanup_free_agent_expr (aexpr
);
744 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
745 error (_("Expression is too complicated."));
748 report_agent_reqs_errors (aexpr
);
750 do_cleanups (old_chain
);
753 while (p
&& *p
++ == ',');
756 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
758 char *steparg
; /* In case warning is necessary. */
760 while (isspace ((int) *p
))
764 if (*p
== '\0' || (t
->step_count
= strtol (p
, &p
, 0)) == 0)
765 error (_("while-stepping step count `%s' is malformed."), *line
);
768 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
772 error (_("`%s' is not a supported tracepoint action."), *line
);
776 memrange_absolute
= -1
781 int type
; /* memrange_absolute for absolute memory range,
782 else basereg number. */
783 bfd_signed_vma start
;
787 struct collection_list
789 unsigned char regs_mask
[32]; /* room for up to 256 regs */
792 struct memrange
*list
;
793 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
795 struct agent_expr
**aexpr_list
;
797 /* True is the user requested a collection of "$_sdata", "static
801 tracepoint_list
, stepping_list
;
803 /* MEMRANGE functions: */
805 static int memrange_cmp (const void *, const void *);
807 /* Compare memranges for qsort. */
809 memrange_cmp (const void *va
, const void *vb
)
811 const struct memrange
*a
= va
, *b
= vb
;
813 if (a
->type
< b
->type
)
815 if (a
->type
> b
->type
)
817 if (a
->type
== memrange_absolute
)
819 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
821 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
826 if (a
->start
< b
->start
)
828 if (a
->start
> b
->start
)
834 /* Sort the memrange list using qsort, and merge adjacent memranges. */
836 memrange_sortmerge (struct collection_list
*memranges
)
840 qsort (memranges
->list
, memranges
->next_memrange
,
841 sizeof (struct memrange
), memrange_cmp
);
842 if (memranges
->next_memrange
> 0)
844 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
846 /* If memrange b overlaps or is adjacent to memrange a,
848 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
849 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
851 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
852 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
853 continue; /* next b, same a */
857 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
858 sizeof (struct memrange
));
860 memranges
->next_memrange
= a
+ 1;
864 /* Add a register to a collection list. */
866 add_register (struct collection_list
*collection
, unsigned int regno
)
869 printf_filtered ("collect register %d\n", regno
);
870 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
871 error (_("Internal: register number %d too large for tracepoint"),
873 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
876 /* Add a memrange to a collection list. */
878 add_memrange (struct collection_list
*memranges
,
879 int type
, bfd_signed_vma base
,
884 printf_filtered ("(%d,", type
);
886 printf_filtered (",%ld)\n", len
);
889 /* type: memrange_absolute == memory, other n == basereg */
890 memranges
->list
[memranges
->next_memrange
].type
= type
;
891 /* base: addr if memory, offset if reg relative. */
892 memranges
->list
[memranges
->next_memrange
].start
= base
;
893 /* len: we actually save end (base + len) for convenience */
894 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
895 memranges
->next_memrange
++;
896 if (memranges
->next_memrange
>= memranges
->listsize
)
898 memranges
->listsize
*= 2;
899 memranges
->list
= xrealloc (memranges
->list
,
900 memranges
->listsize
);
903 if (type
!= memrange_absolute
) /* Better collect the base register! */
904 add_register (memranges
, type
);
907 /* Add a symbol to a collection list. */
909 collect_symbol (struct collection_list
*collect
,
911 struct gdbarch
*gdbarch
,
912 long frame_regno
, long frame_offset
,
917 bfd_signed_vma offset
;
918 int treat_as_expr
= 0;
920 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
921 switch (SYMBOL_CLASS (sym
))
924 printf_filtered ("%s: don't know symbol class %d\n",
925 SYMBOL_PRINT_NAME (sym
),
929 printf_filtered ("constant %s (value %ld) will not be collected.\n",
930 SYMBOL_PRINT_NAME (sym
), SYMBOL_VALUE (sym
));
933 offset
= SYMBOL_VALUE_ADDRESS (sym
);
938 sprintf_vma (tmp
, offset
);
939 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
940 SYMBOL_PRINT_NAME (sym
), len
,
943 /* A struct may be a C++ class with static fields, go to general
944 expression handling. */
945 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
948 add_memrange (collect
, memrange_absolute
, offset
, len
);
951 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
953 printf_filtered ("LOC_REG[parm] %s: ",
954 SYMBOL_PRINT_NAME (sym
));
955 add_register (collect
, reg
);
956 /* Check for doubles stored in two registers. */
957 /* FIXME: how about larger types stored in 3 or more regs? */
958 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
959 len
> register_size (gdbarch
, reg
))
960 add_register (collect
, reg
+ 1);
963 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
964 printf_filtered (" (will not collect %s)\n",
965 SYMBOL_PRINT_NAME (sym
));
969 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
972 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
973 SYMBOL_PRINT_NAME (sym
), len
);
975 printf_filtered (" from frame ptr reg %d\n", reg
);
977 add_memrange (collect
, reg
, offset
, len
);
979 case LOC_REGPARM_ADDR
:
980 reg
= SYMBOL_VALUE (sym
);
984 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
985 SYMBOL_PRINT_NAME (sym
), len
);
987 printf_filtered (" from reg %d\n", reg
);
989 add_memrange (collect
, reg
, offset
, len
);
993 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
996 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
997 SYMBOL_PRINT_NAME (sym
), len
);
999 printf_filtered (" from frame ptr reg %d\n", reg
);
1001 add_memrange (collect
, reg
, offset
, len
);
1004 case LOC_UNRESOLVED
:
1008 case LOC_OPTIMIZED_OUT
:
1009 printf_filtered ("%s has been optimized out of existence.\n",
1010 SYMBOL_PRINT_NAME (sym
));
1018 /* Expressions are the most general case. */
1021 struct agent_expr
*aexpr
;
1022 struct cleanup
*old_chain1
= NULL
;
1024 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
1026 /* It can happen that the symbol is recorded as a computed
1027 location, but it's been optimized away and doesn't actually
1028 have a location expression. */
1031 printf_filtered ("%s has been optimized out of existence.\n",
1032 SYMBOL_PRINT_NAME (sym
));
1036 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1040 report_agent_reqs_errors (aexpr
);
1042 discard_cleanups (old_chain1
);
1043 add_aexpr (collect
, aexpr
);
1045 /* Take care of the registers. */
1046 if (aexpr
->reg_mask_len
> 0)
1050 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1052 QUIT
; /* Allow user to bail out with ^C. */
1053 if (aexpr
->reg_mask
[ndx1
] != 0)
1055 /* Assume chars have 8 bits. */
1056 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1057 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1058 /* It's used -- record it. */
1059 add_register (collect
, ndx1
* 8 + ndx2
);
1066 /* Data to be passed around in the calls to the locals and args
1069 struct add_local_symbols_data
1071 struct collection_list
*collect
;
1072 struct gdbarch
*gdbarch
;
1079 /* The callback for the locals and args iterators. */
1082 do_collect_symbol (const char *print_name
,
1086 struct add_local_symbols_data
*p
= cb_data
;
1088 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1089 p
->frame_offset
, p
->pc
);
1093 /* Add all locals (or args) symbols to collection list. */
1095 add_local_symbols (struct collection_list
*collect
,
1096 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1097 long frame_regno
, long frame_offset
, int type
)
1099 struct block
*block
;
1100 struct add_local_symbols_data cb_data
;
1102 cb_data
.collect
= collect
;
1103 cb_data
.gdbarch
= gdbarch
;
1105 cb_data
.frame_regno
= frame_regno
;
1106 cb_data
.frame_offset
= frame_offset
;
1111 block
= block_for_pc (pc
);
1114 warning (_("Can't collect locals; "
1115 "no symbol table info available.\n"));
1119 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1120 if (cb_data
.count
== 0)
1121 warning (_("No locals found in scope."));
1125 pc
= get_pc_function_start (pc
);
1126 block
= block_for_pc (pc
);
1129 warning (_("Can't collect args; no symbol table info available."));
1133 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1134 if (cb_data
.count
== 0)
1135 warning (_("No args found in scope."));
1140 add_static_trace_data (struct collection_list
*collection
)
1143 printf_filtered ("collect static trace data\n");
1144 collection
->strace_data
= 1;
1147 /* worker function */
1149 clear_collection_list (struct collection_list
*list
)
1153 list
->next_memrange
= 0;
1154 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1156 free_agent_expr (list
->aexpr_list
[ndx
]);
1157 list
->aexpr_list
[ndx
] = NULL
;
1159 list
->next_aexpr_elt
= 0;
1160 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1161 list
->strace_data
= 0;
1164 /* Reduce a collection list to string form (for gdb protocol). */
1166 stringify_collection_list (struct collection_list
*list
, char *string
)
1168 char temp_buf
[2048];
1172 char *(*str_list
)[];
1176 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1177 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1179 if (list
->strace_data
)
1182 printf_filtered ("\nCollecting static trace data\n");
1185 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1189 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1190 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1192 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1195 printf_filtered ("\nCollecting registers (mask): 0x");
1200 QUIT
; /* Allow user to bail out with ^C. */
1202 printf_filtered ("%02X", list
->regs_mask
[i
]);
1203 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1206 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1210 printf_filtered ("\n");
1211 if (list
->next_memrange
> 0 && info_verbose
)
1212 printf_filtered ("Collecting memranges: \n");
1213 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1215 QUIT
; /* Allow user to bail out with ^C. */
1216 sprintf_vma (tmp2
, list
->list
[i
].start
);
1219 printf_filtered ("(%d, %s, %ld)\n",
1222 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1224 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1226 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1233 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1235 /* The "%X" conversion specifier expects an unsigned argument,
1236 so passing -1 (memrange_absolute) to it directly gives you
1237 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1239 if (list
->list
[i
].type
== memrange_absolute
)
1240 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1242 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1245 count
+= strlen (end
);
1246 end
= temp_buf
+ count
;
1249 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1251 QUIT
; /* Allow user to bail out with ^C. */
1252 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1254 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1259 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1260 end
+= 10; /* 'X' + 8 hex digits + ',' */
1263 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1264 end
, list
->aexpr_list
[i
]->len
);
1265 count
+= 2 * list
->aexpr_list
[i
]->len
;
1270 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1275 (*str_list
)[ndx
] = NULL
;
1288 encode_actions_1 (struct command_line
*action
,
1289 struct breakpoint
*t
,
1290 struct bp_location
*tloc
,
1292 LONGEST frame_offset
,
1293 struct collection_list
*collect
,
1294 struct collection_list
*stepping_list
)
1297 struct expression
*exp
= NULL
;
1299 struct value
*tempval
;
1300 struct cmd_list_element
*cmd
;
1301 struct agent_expr
*aexpr
;
1303 for (; action
; action
= action
->next
)
1305 QUIT
; /* Allow user to bail out with ^C. */
1306 action_exp
= action
->line
;
1307 while (isspace ((int) *action_exp
))
1310 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1312 error (_("Bad action list item: %s"), action_exp
);
1314 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1317 { /* Repeat over a comma-separated list. */
1318 QUIT
; /* Allow user to bail out with ^C. */
1319 while (isspace ((int) *action_exp
))
1322 if (0 == strncasecmp ("$reg", action_exp
, 4))
1324 for (i
= 0; i
< gdbarch_num_regs (t
->gdbarch
); i
++)
1325 add_register (collect
, i
);
1326 action_exp
= strchr (action_exp
, ','); /* more? */
1328 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1330 add_local_symbols (collect
,
1336 action_exp
= strchr (action_exp
, ','); /* more? */
1338 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1340 add_local_symbols (collect
,
1346 action_exp
= strchr (action_exp
, ','); /* more? */
1348 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1350 struct cleanup
*old_chain1
= NULL
;
1352 aexpr
= gen_trace_for_return_address (tloc
->address
,
1355 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1358 report_agent_reqs_errors (aexpr
);
1360 discard_cleanups (old_chain1
);
1361 add_aexpr (collect
, aexpr
);
1363 /* take care of the registers */
1364 if (aexpr
->reg_mask_len
> 0)
1368 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1370 QUIT
; /* allow user to bail out with ^C */
1371 if (aexpr
->reg_mask
[ndx1
] != 0)
1373 /* assume chars have 8 bits */
1374 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1375 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1376 /* it's used -- record it */
1377 add_register (collect
,
1383 action_exp
= strchr (action_exp
, ','); /* more? */
1385 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1387 add_static_trace_data (collect
);
1388 action_exp
= strchr (action_exp
, ','); /* more? */
1392 unsigned long addr
, len
;
1393 struct cleanup
*old_chain
= NULL
;
1394 struct cleanup
*old_chain1
= NULL
;
1396 exp
= parse_exp_1 (&action_exp
,
1397 block_for_pc (tloc
->address
), 1);
1398 old_chain
= make_cleanup (free_current_contents
, &exp
);
1400 switch (exp
->elts
[0].opcode
)
1404 const char *name
= &exp
->elts
[2].string
;
1406 i
= user_reg_map_name_to_regnum (t
->gdbarch
,
1407 name
, strlen (name
));
1409 internal_error (__FILE__
, __LINE__
,
1410 _("Register $%s not available"),
1413 printf_filtered ("OP_REGISTER: ");
1414 add_register (collect
, i
);
1419 /* Safe because we know it's a simple expression. */
1420 tempval
= evaluate_expression (exp
);
1421 addr
= value_address (tempval
);
1422 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1423 add_memrange (collect
, memrange_absolute
, addr
, len
);
1427 collect_symbol (collect
,
1428 exp
->elts
[2].symbol
,
1435 default: /* Full-fledged expression. */
1436 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1438 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1442 report_agent_reqs_errors (aexpr
);
1444 discard_cleanups (old_chain1
);
1445 add_aexpr (collect
, aexpr
);
1447 /* Take care of the registers. */
1448 if (aexpr
->reg_mask_len
> 0)
1453 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1455 QUIT
; /* Allow user to bail out with ^C. */
1456 if (aexpr
->reg_mask
[ndx1
] != 0)
1458 /* Assume chars have 8 bits. */
1459 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1460 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1461 /* It's used -- record it. */
1462 add_register (collect
,
1469 do_cleanups (old_chain
);
1472 while (action_exp
&& *action_exp
++ == ',');
1474 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1477 { /* Repeat over a comma-separated list. */
1478 QUIT
; /* Allow user to bail out with ^C. */
1479 while (isspace ((int) *action_exp
))
1483 struct cleanup
*old_chain
= NULL
;
1484 struct cleanup
*old_chain1
= NULL
;
1486 exp
= parse_exp_1 (&action_exp
,
1487 block_for_pc (tloc
->address
), 1);
1488 old_chain
= make_cleanup (free_current_contents
, &exp
);
1490 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1491 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1494 report_agent_reqs_errors (aexpr
);
1496 discard_cleanups (old_chain1
);
1497 /* Even though we're not officially collecting, add
1498 to the collect list anyway. */
1499 add_aexpr (collect
, aexpr
);
1501 do_cleanups (old_chain
);
1504 while (action_exp
&& *action_exp
++ == ',');
1506 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1508 /* We check against nested while-stepping when setting
1509 breakpoint action, so no way to run into nested
1511 gdb_assert (stepping_list
);
1513 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
,
1514 frame_offset
, stepping_list
, NULL
);
1517 error (_("Invalid tracepoint command '%s'"), action
->line
);
1521 /* Render all actions into gdb protocol. */
1523 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1524 char ***tdp_actions
, char ***stepping_actions
)
1526 static char tdp_buff
[2048], step_buff
[2048];
1527 char *default_collect_line
= NULL
;
1528 struct command_line
*actions
;
1529 struct command_line
*default_collect_action
= NULL
;
1531 LONGEST frame_offset
;
1532 struct cleanup
*back_to
;
1534 back_to
= make_cleanup (null_cleanup
, NULL
);
1536 clear_collection_list (&tracepoint_list
);
1537 clear_collection_list (&stepping_list
);
1539 *tdp_actions
= NULL
;
1540 *stepping_actions
= NULL
;
1542 gdbarch_virtual_frame_pointer (t
->gdbarch
,
1543 t
->loc
->address
, &frame_reg
, &frame_offset
);
1545 actions
= breakpoint_commands (t
);
1547 /* If there are default expressions to collect, make up a collect
1548 action and prepend to the action list to encode. Note that since
1549 validation is per-tracepoint (local var "xyz" might be valid for
1550 one tracepoint and not another, etc), we make up the action on
1551 the fly, and don't cache it. */
1552 if (*default_collect
)
1556 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1557 make_cleanup (xfree
, default_collect_line
);
1559 line
= default_collect_line
;
1560 validate_actionline (&line
, t
);
1562 default_collect_action
= xmalloc (sizeof (struct command_line
));
1563 make_cleanup (xfree
, default_collect_action
);
1564 default_collect_action
->next
= actions
;
1565 default_collect_action
->line
= line
;
1566 actions
= default_collect_action
;
1568 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1569 &tracepoint_list
, &stepping_list
);
1571 memrange_sortmerge (&tracepoint_list
);
1572 memrange_sortmerge (&stepping_list
);
1574 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1576 *stepping_actions
= stringify_collection_list (&stepping_list
,
1579 do_cleanups (back_to
);
1583 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1585 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1587 collect
->aexpr_list
=
1588 xrealloc (collect
->aexpr_list
,
1589 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1590 collect
->aexpr_listsize
*= 2;
1592 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1593 collect
->next_aexpr_elt
++;
1598 start_tracing (void)
1600 VEC(breakpoint_p
) *tp_vec
= NULL
;
1602 struct breakpoint
*b
;
1603 struct trace_state_variable
*tsv
;
1604 int any_enabled
= 0, num_to_download
= 0;
1606 tp_vec
= all_tracepoints ();
1608 /* No point in tracing without any tracepoints... */
1609 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1611 VEC_free (breakpoint_p
, tp_vec
);
1612 error (_("No tracepoints defined, not starting trace"));
1615 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1617 struct tracepoint
*t
= (struct tracepoint
*) b
;
1619 if (b
->enable_state
== bp_enabled
)
1622 if ((b
->type
== bp_fast_tracepoint
1623 ? may_insert_fast_tracepoints
1624 : may_insert_tracepoints
))
1627 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1628 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1633 if (target_supports_enable_disable_tracepoint ())
1634 warning (_("No tracepoints enabled"));
1637 /* No point in tracing with only disabled tracepoints that
1638 cannot be re-enabled. */
1639 VEC_free (breakpoint_p
, tp_vec
);
1640 error (_("No tracepoints enabled, not starting trace"));
1644 if (num_to_download
<= 0)
1646 VEC_free (breakpoint_p
, tp_vec
);
1647 error (_("No tracepoints that may be downloaded, not starting trace"));
1650 target_trace_init ();
1652 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1654 struct tracepoint
*t
= (struct tracepoint
*) b
;
1656 if ((b
->type
== bp_fast_tracepoint
1657 ? !may_insert_fast_tracepoints
1658 : !may_insert_tracepoints
))
1661 t
->number_on_target
= 0;
1662 target_download_tracepoint (b
);
1663 t
->number_on_target
= b
->number
;
1665 VEC_free (breakpoint_p
, tp_vec
);
1667 /* Send down all the trace state variables too. */
1668 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1670 target_download_trace_state_variable (tsv
);
1673 /* Tell target to treat text-like sections as transparent. */
1674 target_trace_set_readonly_regions ();
1675 /* Set some mode flags. */
1676 target_set_disconnected_tracing (disconnected_tracing
);
1677 target_set_circular_trace_buffer (circular_trace_buffer
);
1679 /* Now insert traps and begin collecting data. */
1680 target_trace_start ();
1682 /* Reset our local state. */
1683 set_traceframe_num (-1);
1684 set_tracepoint_num (-1);
1685 set_traceframe_context (NULL
);
1686 current_trace_status()->running
= 1;
1687 clear_traceframe_info ();
1692 Tell target to clear any previous trace experiment.
1693 Walk the list of tracepoints, and send them (and their actions)
1694 to the target. If no errors,
1695 Tell target to start a new trace experiment. */
1698 trace_start_command (char *args
, int from_tty
)
1700 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1702 if (current_trace_status ()->running
)
1705 && !query (_("A trace is running already. Start a new run? ")))
1706 error (_("New trace run not started."));
1714 trace_stop_command (char *args
, int from_tty
)
1716 if (!current_trace_status ()->running
)
1717 error (_("Trace is not running."));
1725 target_trace_stop ();
1726 /* Should change in response to reply? */
1727 current_trace_status ()->running
= 0;
1730 /* tstatus command */
1732 trace_status_command (char *args
, int from_tty
)
1734 struct trace_status
*ts
= current_trace_status ();
1737 status
= target_get_trace_status (ts
);
1742 printf_filtered (_("Using a trace file.\n"));
1745 printf_filtered (_("Trace can not be run on this target.\n"));
1750 if (!ts
->running_known
)
1752 printf_filtered (_("Run/stop status is unknown.\n"));
1754 else if (ts
->running
)
1756 printf_filtered (_("Trace is running on the target.\n"));
1760 switch (ts
->stop_reason
)
1762 case trace_never_run
:
1763 printf_filtered (_("No trace has been run on the target.\n"));
1766 printf_filtered (_("Trace stopped by a tstop command.\n"));
1768 case trace_buffer_full
:
1769 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1771 case trace_disconnected
:
1772 printf_filtered (_("Trace stopped because of disconnection.\n"));
1774 case tracepoint_passcount
:
1775 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1776 ts
->stopping_tracepoint
);
1778 case tracepoint_error
:
1779 if (ts
->stopping_tracepoint
)
1780 printf_filtered (_("Trace stopped by an "
1781 "error (%s, tracepoint %d).\n"),
1782 ts
->error_desc
, ts
->stopping_tracepoint
);
1784 printf_filtered (_("Trace stopped by an error (%s).\n"),
1787 case trace_stop_reason_unknown
:
1788 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1791 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1797 if (ts
->traceframes_created
>= 0
1798 && ts
->traceframe_count
!= ts
->traceframes_created
)
1800 printf_filtered (_("Buffer contains %d trace "
1801 "frames (of %d created total).\n"),
1802 ts
->traceframe_count
, ts
->traceframes_created
);
1804 else if (ts
->traceframe_count
>= 0)
1806 printf_filtered (_("Collected %d trace frames.\n"),
1807 ts
->traceframe_count
);
1810 if (ts
->buffer_free
>= 0)
1812 if (ts
->buffer_size
>= 0)
1814 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1815 ts
->buffer_free
, ts
->buffer_size
);
1816 if (ts
->buffer_size
> 0)
1817 printf_filtered (_(" (%d%% full)"),
1818 ((int) ((((long long) (ts
->buffer_size
1819 - ts
->buffer_free
)) * 100)
1820 / ts
->buffer_size
)));
1821 printf_filtered (_(".\n"));
1824 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1828 if (ts
->disconnected_tracing
)
1829 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1831 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1833 if (ts
->circular_buffer
)
1834 printf_filtered (_("Trace buffer is circular.\n"));
1836 /* Now report on what we're doing with tfind. */
1837 if (traceframe_number
>= 0)
1838 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1839 traceframe_number
, tracepoint_number
);
1841 printf_filtered (_("Not looking at any trace frame.\n"));
1844 /* Report the trace status to uiout, in a way suitable for MI, and not
1845 suitable for CLI. If ON_STOP is true, suppress a few fields that
1846 are not meaningful in the -trace-stop response.
1848 The implementation is essentially parallel to trace_status_command, but
1849 merging them will result in unreadable code. */
1851 trace_status_mi (int on_stop
)
1853 struct ui_out
*uiout
= current_uiout
;
1854 struct trace_status
*ts
= current_trace_status ();
1857 status
= target_get_trace_status (ts
);
1859 if (status
== -1 && !ts
->from_file
)
1861 ui_out_field_string (uiout
, "supported", "0");
1866 ui_out_field_string (uiout
, "supported", "file");
1868 ui_out_field_string (uiout
, "supported", "1");
1870 gdb_assert (ts
->running_known
);
1874 ui_out_field_string (uiout
, "running", "1");
1876 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1877 Given that the frontend gets the status either on -trace-stop, or from
1878 -trace-status after re-connection, it does not seem like this
1879 information is necessary for anything. It is not necessary for either
1880 figuring the vital state of the target nor for navigation of trace
1881 frames. If the frontend wants to show the current state is some
1882 configure dialog, it can request the value when such dialog is
1883 invoked by the user. */
1887 char *stop_reason
= NULL
;
1888 int stopping_tracepoint
= -1;
1891 ui_out_field_string (uiout
, "running", "0");
1893 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
1895 switch (ts
->stop_reason
)
1898 stop_reason
= "request";
1900 case trace_buffer_full
:
1901 stop_reason
= "overflow";
1903 case trace_disconnected
:
1904 stop_reason
= "disconnection";
1906 case tracepoint_passcount
:
1907 stop_reason
= "passcount";
1908 stopping_tracepoint
= ts
->stopping_tracepoint
;
1910 case tracepoint_error
:
1911 stop_reason
= "error";
1912 stopping_tracepoint
= ts
->stopping_tracepoint
;
1918 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
1919 if (stopping_tracepoint
!= -1)
1920 ui_out_field_int (uiout
, "stopping-tracepoint",
1921 stopping_tracepoint
);
1922 if (ts
->stop_reason
== tracepoint_error
)
1923 ui_out_field_string (uiout
, "error-description",
1929 if (ts
->traceframe_count
!= -1)
1930 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
1931 if (ts
->traceframes_created
!= -1)
1932 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
1933 if (ts
->buffer_size
!= -1)
1934 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
1935 if (ts
->buffer_free
!= -1)
1936 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
1938 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
1939 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
1942 /* This function handles the details of what to do about an ongoing
1943 tracing run if the user has asked to detach or otherwise disconnect
1946 disconnect_tracing (int from_tty
)
1948 /* It can happen that the target that was tracing went away on its
1949 own, and we didn't notice. Get a status update, and if the
1950 current target doesn't even do tracing, then assume it's not
1952 if (target_get_trace_status (current_trace_status ()) < 0)
1953 current_trace_status ()->running
= 0;
1955 /* If running interactively, give the user the option to cancel and
1956 then decide what to do differently with the run. Scripts are
1957 just going to disconnect and let the target deal with it,
1958 according to how it's been instructed previously via
1959 disconnected-tracing. */
1960 if (current_trace_status ()->running
&& from_tty
)
1962 if (current_trace_status ()->disconnected_tracing
)
1964 if (!query (_("Trace is running and will "
1965 "continue after detach; detach anyway? ")))
1966 error (_("Not confirmed."));
1970 if (!query (_("Trace is running but will "
1971 "stop on detach; detach anyway? ")))
1972 error (_("Not confirmed."));
1976 /* Also we want to be out of tfind mode, otherwise things can get
1977 confusing upon reconnection. Just use these calls instead of
1978 full tfind_1 behavior because we're in the middle of detaching,
1979 and there's no point to updating current stack frame etc. */
1980 set_current_traceframe (-1);
1981 set_traceframe_context (NULL
);
1984 /* Worker function for the various flavors of the tfind command. */
1986 tfind_1 (enum trace_find_type type
, int num
,
1987 ULONGEST addr1
, ULONGEST addr2
,
1990 int target_frameno
= -1, target_tracept
= -1;
1991 struct frame_id old_frame_id
= null_frame_id
;
1992 struct tracepoint
*tp
;
1993 struct ui_out
*uiout
= current_uiout
;
1995 /* Only try to get the current stack frame if we have a chance of
1996 succeeding. In particular, if we're trying to get a first trace
1997 frame while all threads are running, it's not going to succeed,
1998 so leave it with a default value and let the frame comparison
1999 below (correctly) decide to print out the source location of the
2001 if (!(type
== tfind_number
&& num
== -1)
2002 && (has_stack_frames () || traceframe_number
>= 0))
2003 old_frame_id
= get_frame_id (get_current_frame ());
2005 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2008 if (type
== tfind_number
2010 && target_frameno
== -1)
2012 /* We told the target to get out of tfind mode, and it did. */
2014 else if (target_frameno
== -1)
2016 /* A request for a non-existent trace frame has failed.
2017 Our response will be different, depending on FROM_TTY:
2019 If FROM_TTY is true, meaning that this command was
2020 typed interactively by the user, then give an error
2021 and DO NOT change the state of traceframe_number etc.
2023 However if FROM_TTY is false, meaning that we're either
2024 in a script, a loop, or a user-defined command, then
2025 DON'T give an error, but DO change the state of
2026 traceframe_number etc. to invalid.
2028 The rationalle is that if you typed the command, you
2029 might just have committed a typo or something, and you'd
2030 like to NOT lose your current debugging state. However
2031 if you're in a user-defined command or especially in a
2032 loop, then you need a way to detect that the command
2033 failed WITHOUT aborting. This allows you to write
2034 scripts that search thru the trace buffer until the end,
2035 and then continue on to do something else. */
2038 error (_("Target failed to find requested trace frame."));
2042 printf_filtered ("End of trace buffer.\n");
2043 #if 0 /* dubious now? */
2044 /* The following will not recurse, since it's
2046 trace_find_command ("-1", from_tty
);
2051 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2053 reinit_frame_cache ();
2054 registers_changed ();
2055 target_dcache_invalidate ();
2056 set_traceframe_num (target_frameno
);
2057 clear_traceframe_info ();
2058 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2059 if (target_frameno
== -1)
2060 set_traceframe_context (NULL
);
2062 set_traceframe_context (get_current_frame ());
2064 if (traceframe_number
>= 0)
2066 /* Use different branches for MI and CLI to make CLI messages
2068 if (ui_out_is_mi_like_p (uiout
))
2070 ui_out_field_string (uiout
, "found", "1");
2071 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2072 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2076 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2077 traceframe_number
, tracepoint_number
);
2082 if (ui_out_is_mi_like_p (uiout
))
2083 ui_out_field_string (uiout
, "found", "0");
2084 else if (type
== tfind_number
&& num
== -1)
2085 printf_unfiltered (_("No longer looking at any trace frame\n"));
2086 else /* This case may never occur, check. */
2087 printf_unfiltered (_("No trace frame found\n"));
2090 /* If we're in nonstop mode and getting out of looking at trace
2091 frames, there won't be any current frame to go back to and
2094 && (has_stack_frames () || traceframe_number
>= 0))
2096 enum print_what print_what
;
2098 /* NOTE: in imitation of the step command, try to determine
2099 whether we have made a transition from one function to
2100 another. If so, we'll print the "stack frame" (ie. the new
2101 function and it's arguments) -- otherwise we'll just show the
2104 if (frame_id_eq (old_frame_id
,
2105 get_frame_id (get_current_frame ())))
2106 print_what
= SRC_LINE
;
2108 print_what
= SRC_AND_LOC
;
2110 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2115 /* trace_find_command takes a trace frame number n,
2116 sends "QTFrame:<n>" to the target,
2117 and accepts a reply that may contain several optional pieces
2118 of information: a frame number, a tracepoint number, and an
2119 indication of whether this is a trap frame or a stepping frame.
2121 The minimal response is just "OK" (which indicates that the
2122 target does not give us a frame number or a tracepoint number).
2123 Instead of that, the target may send us a string containing
2125 F<hexnum> (gives the selected frame number)
2126 T<hexnum> (gives the selected tracepoint number)
2131 trace_find_command (char *args
, int from_tty
)
2132 { /* This should only be called with a numeric argument. */
2135 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2136 error (_("May not look at trace frames while trace is running."));
2138 if (args
== 0 || *args
== 0)
2139 { /* TFIND with no args means find NEXT trace frame. */
2140 if (traceframe_number
== -1)
2141 frameno
= 0; /* "next" is first one. */
2143 frameno
= traceframe_number
+ 1;
2145 else if (0 == strcmp (args
, "-"))
2147 if (traceframe_number
== -1)
2148 error (_("not debugging trace buffer"));
2149 else if (from_tty
&& traceframe_number
== 0)
2150 error (_("already at start of trace buffer"));
2152 frameno
= traceframe_number
- 1;
2154 /* A hack to work around eval's need for fp to have been collected. */
2155 else if (0 == strcmp (args
, "-1"))
2158 frameno
= parse_and_eval_long (args
);
2161 error (_("invalid input (%d is less than zero)"), frameno
);
2163 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2168 trace_find_end_command (char *args
, int from_tty
)
2170 trace_find_command ("-1", from_tty
);
2175 trace_find_none_command (char *args
, int from_tty
)
2177 trace_find_command ("-1", from_tty
);
2182 trace_find_start_command (char *args
, int from_tty
)
2184 trace_find_command ("0", from_tty
);
2187 /* tfind pc command */
2189 trace_find_pc_command (char *args
, int from_tty
)
2193 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2194 error (_("May not look at trace frames while trace is running."));
2196 if (args
== 0 || *args
== 0)
2197 pc
= regcache_read_pc (get_current_regcache ());
2199 pc
= parse_and_eval_address (args
);
2201 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2204 /* tfind tracepoint command */
2206 trace_find_tracepoint_command (char *args
, int from_tty
)
2209 struct tracepoint
*tp
;
2211 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2212 error (_("May not look at trace frames while trace is running."));
2214 if (args
== 0 || *args
== 0)
2216 if (tracepoint_number
== -1)
2217 error (_("No current tracepoint -- please supply an argument."));
2219 tdp
= tracepoint_number
; /* Default is current TDP. */
2222 tdp
= parse_and_eval_long (args
);
2224 /* If we have the tracepoint on hand, use the number that the
2225 target knows about (which may be different if we disconnected
2226 and reconnected). */
2227 tp
= get_tracepoint (tdp
);
2229 tdp
= tp
->number_on_target
;
2231 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2234 /* TFIND LINE command:
2236 This command will take a sourceline for argument, just like BREAK
2237 or TRACE (ie. anything that "decode_line_1" can handle).
2239 With no argument, this command will find the next trace frame
2240 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2243 trace_find_line_command (char *args
, int from_tty
)
2245 static CORE_ADDR start_pc
, end_pc
;
2246 struct symtabs_and_lines sals
;
2247 struct symtab_and_line sal
;
2248 struct cleanup
*old_chain
;
2250 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2251 error (_("May not look at trace frames while trace is running."));
2253 if (args
== 0 || *args
== 0)
2255 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2257 sals
.sals
= (struct symtab_and_line
*)
2258 xmalloc (sizeof (struct symtab_and_line
));
2263 sals
= decode_line_spec (args
, 1);
2267 old_chain
= make_cleanup (xfree
, sals
.sals
);
2268 if (sal
.symtab
== 0)
2269 error (_("No line number information available."));
2271 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2273 if (start_pc
== end_pc
)
2275 printf_filtered ("Line %d of \"%s\"",
2276 sal
.line
, sal
.symtab
->filename
);
2278 printf_filtered (" is at address ");
2279 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2281 printf_filtered (" but contains no code.\n");
2282 sal
= find_pc_line (start_pc
, 0);
2284 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2285 && start_pc
!= end_pc
)
2286 printf_filtered ("Attempting to find line %d instead.\n",
2289 error (_("Cannot find a good line."));
2293 /* Is there any case in which we get here, and have an address
2294 which the user would want to see? If we have debugging
2295 symbols and no line numbers? */
2296 error (_("Line number %d is out of range for \"%s\"."),
2297 sal
.line
, sal
.symtab
->filename
);
2299 /* Find within range of stated line. */
2301 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2303 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2304 do_cleanups (old_chain
);
2307 /* tfind range command */
2309 trace_find_range_command (char *args
, int from_tty
)
2311 static CORE_ADDR start
, stop
;
2314 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2315 error (_("May not look at trace frames while trace is running."));
2317 if (args
== 0 || *args
== 0)
2318 { /* XXX FIXME: what should default behavior be? */
2319 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2323 if (0 != (tmp
= strchr (args
, ',')))
2325 *tmp
++ = '\0'; /* Terminate start address. */
2326 while (isspace ((int) *tmp
))
2328 start
= parse_and_eval_address (args
);
2329 stop
= parse_and_eval_address (tmp
);
2332 { /* No explicit end address? */
2333 start
= parse_and_eval_address (args
);
2334 stop
= start
+ 1; /* ??? */
2337 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2340 /* tfind outside command */
2342 trace_find_outside_command (char *args
, int from_tty
)
2344 CORE_ADDR start
, stop
;
2347 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2348 error (_("May not look at trace frames while trace is running."));
2350 if (args
== 0 || *args
== 0)
2351 { /* XXX FIXME: what should default behavior be? */
2352 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2356 if (0 != (tmp
= strchr (args
, ',')))
2358 *tmp
++ = '\0'; /* Terminate start address. */
2359 while (isspace ((int) *tmp
))
2361 start
= parse_and_eval_address (args
);
2362 stop
= parse_and_eval_address (tmp
);
2365 { /* No explicit end address? */
2366 start
= parse_and_eval_address (args
);
2367 stop
= start
+ 1; /* ??? */
2370 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2373 /* info scope command: list the locals for a scope. */
2375 scope_info (char *args
, int from_tty
)
2377 struct symtabs_and_lines sals
;
2379 struct minimal_symbol
*msym
;
2380 struct block
*block
;
2381 char *symname
, *save_args
= args
;
2382 struct dict_iterator iter
;
2384 struct gdbarch
*gdbarch
;
2387 if (args
== 0 || *args
== 0)
2388 error (_("requires an argument (function, "
2389 "line or *addr) to define a scope"));
2391 sals
= decode_line_1 (&args
, 1, NULL
, 0, NULL
);
2392 if (sals
.nelts
== 0)
2393 return; /* Presumably decode_line_1 has already warned. */
2395 /* Resolve line numbers to PC. */
2396 resolve_sal_pc (&sals
.sals
[0]);
2397 block
= block_for_pc (sals
.sals
[0].pc
);
2401 QUIT
; /* Allow user to bail out with ^C. */
2402 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2404 QUIT
; /* Allow user to bail out with ^C. */
2406 printf_filtered ("Scope for %s:\n", save_args
);
2409 symname
= SYMBOL_PRINT_NAME (sym
);
2410 if (symname
== NULL
|| *symname
== '\0')
2411 continue; /* Probably botched, certainly useless. */
2413 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2415 printf_filtered ("Symbol %s is ", symname
);
2416 switch (SYMBOL_CLASS (sym
))
2419 case LOC_UNDEF
: /* Messed up symbol? */
2420 printf_filtered ("a bogus symbol, class %d.\n",
2421 SYMBOL_CLASS (sym
));
2422 count
--; /* Don't count this one. */
2425 printf_filtered ("a constant with value %ld (0x%lx)",
2426 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2428 case LOC_CONST_BYTES
:
2429 printf_filtered ("constant bytes: ");
2430 if (SYMBOL_TYPE (sym
))
2431 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2432 fprintf_filtered (gdb_stdout
, " %02x",
2433 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2436 printf_filtered ("in static storage at address ");
2437 printf_filtered ("%s", paddress (gdbarch
,
2438 SYMBOL_VALUE_ADDRESS (sym
)));
2441 /* GDBARCH is the architecture associated with the objfile
2442 the symbol is defined in; the target architecture may be
2443 different, and may provide additional registers. However,
2444 we do not know the target architecture at this point.
2445 We assume the objfile architecture will contain all the
2446 standard registers that occur in debug info in that
2448 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2451 if (SYMBOL_IS_ARGUMENT (sym
))
2452 printf_filtered ("an argument in register $%s",
2453 gdbarch_register_name (gdbarch
, regno
));
2455 printf_filtered ("a local variable in register $%s",
2456 gdbarch_register_name (gdbarch
, regno
));
2459 printf_filtered ("an argument at stack/frame offset %ld",
2460 SYMBOL_VALUE (sym
));
2463 printf_filtered ("a local variable at frame offset %ld",
2464 SYMBOL_VALUE (sym
));
2467 printf_filtered ("a reference argument at offset %ld",
2468 SYMBOL_VALUE (sym
));
2470 case LOC_REGPARM_ADDR
:
2471 /* Note comment at LOC_REGISTER. */
2472 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2474 printf_filtered ("the address of an argument, in register $%s",
2475 gdbarch_register_name (gdbarch
, regno
));
2478 printf_filtered ("a typedef.\n");
2481 printf_filtered ("a label at address ");
2482 printf_filtered ("%s", paddress (gdbarch
,
2483 SYMBOL_VALUE_ADDRESS (sym
)));
2486 printf_filtered ("a function at address ");
2487 printf_filtered ("%s",
2488 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2490 case LOC_UNRESOLVED
:
2491 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2494 printf_filtered ("Unresolved Static");
2497 printf_filtered ("static storage at address ");
2498 printf_filtered ("%s",
2499 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2502 case LOC_OPTIMIZED_OUT
:
2503 printf_filtered ("optimized out.\n");
2506 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2507 BLOCK_START (block
),
2511 if (SYMBOL_TYPE (sym
))
2512 printf_filtered (", length %d.\n",
2513 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2515 if (BLOCK_FUNCTION (block
))
2518 block
= BLOCK_SUPERBLOCK (block
);
2521 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2525 /* worker function (cleanup) */
2527 replace_comma (void *data
)
2534 /* Helper for trace_dump_command. Dump the action list starting at
2535 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2536 actions of the body of a while-stepping action. STEPPING_FRAME is
2537 set if the current traceframe was determined to be a while-stepping
2541 trace_dump_actions (struct command_line
*action
,
2542 int stepping_actions
, int stepping_frame
,
2545 char *action_exp
, *next_comma
;
2547 for (; action
!= NULL
; action
= action
->next
)
2549 struct cmd_list_element
*cmd
;
2551 QUIT
; /* Allow user to bail out with ^C. */
2552 action_exp
= action
->line
;
2553 while (isspace ((int) *action_exp
))
2556 /* The collection actions to be done while stepping are
2557 bracketed by the commands "while-stepping" and "end". */
2559 if (*action_exp
== '#') /* comment line */
2562 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2564 error (_("Bad action list item: %s"), action_exp
);
2566 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2570 for (i
= 0; i
< action
->body_count
; ++i
)
2571 trace_dump_actions (action
->body_list
[i
],
2572 1, stepping_frame
, from_tty
);
2574 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2576 /* Display the collected data.
2577 For the trap frame, display only what was collected at
2578 the trap. Likewise for stepping frames, display only
2579 what was collected while stepping. This means that the
2580 two boolean variables, STEPPING_FRAME and
2581 STEPPING_ACTIONS should be equal. */
2582 if (stepping_frame
== stepping_actions
)
2585 { /* Repeat over a comma-separated list. */
2586 QUIT
; /* Allow user to bail out with ^C. */
2587 if (*action_exp
== ',')
2589 while (isspace ((int) *action_exp
))
2592 next_comma
= strchr (action_exp
, ',');
2594 if (0 == strncasecmp (action_exp
, "$reg", 4))
2595 registers_info (NULL
, from_tty
);
2596 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2598 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2599 locals_info (NULL
, from_tty
);
2600 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2601 args_info (NULL
, from_tty
);
2606 make_cleanup (replace_comma
, next_comma
);
2609 printf_filtered ("%s = ", action_exp
);
2610 output_command (action_exp
, from_tty
);
2611 printf_filtered ("\n");
2615 action_exp
= next_comma
;
2617 while (action_exp
&& *action_exp
== ',');
2623 /* The tdump command. */
2626 trace_dump_command (char *args
, int from_tty
)
2628 struct regcache
*regcache
;
2629 struct tracepoint
*t
;
2630 int stepping_frame
= 0;
2631 struct bp_location
*loc
;
2632 char *line
, *default_collect_line
= NULL
;
2633 struct command_line
*actions
, *default_collect_action
= NULL
;
2634 struct cleanup
*old_chain
= NULL
;
2636 if (tracepoint_number
== -1)
2638 warning (_("No current trace frame."));
2642 t
= get_tracepoint (tracepoint_number
);
2645 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2648 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2649 tracepoint_number
, traceframe_number
);
2651 /* The current frame is a trap frame if the frame PC is equal
2652 to the tracepoint PC. If not, then the current frame was
2653 collected during single-stepping. */
2655 regcache
= get_current_regcache ();
2657 /* If the traceframe's address matches any of the tracepoint's
2658 locations, assume it is a direct hit rather than a while-stepping
2659 frame. (FIXME this is not reliable, should record each frame's
2662 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
2663 if (loc
->address
== regcache_read_pc (regcache
))
2666 actions
= breakpoint_commands (&t
->base
);
2668 /* If there is a default-collect list, make up a collect command,
2669 prepend to the tracepoint's commands, and pass the whole mess to
2670 the trace dump scanner. We need to validate because
2671 default-collect might have been junked since the trace run. */
2672 if (*default_collect
)
2674 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2675 old_chain
= make_cleanup (xfree
, default_collect_line
);
2676 line
= default_collect_line
;
2677 validate_actionline (&line
, &t
->base
);
2678 default_collect_action
= xmalloc (sizeof (struct command_line
));
2679 make_cleanup (xfree
, default_collect_action
);
2680 default_collect_action
->next
= actions
;
2681 default_collect_action
->line
= line
;
2682 actions
= default_collect_action
;
2685 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2687 if (*default_collect
)
2688 do_cleanups (old_chain
);
2691 /* Encode a piece of a tracepoint's source-level definition in a form
2692 that is suitable for both protocol and saving in files. */
2693 /* This version does not do multiple encodes for long strings; it should
2694 return an offset to the next piece to encode. FIXME */
2697 encode_source_string (int tpnum
, ULONGEST addr
,
2698 char *srctype
, char *src
, char *buf
, int buf_size
)
2700 if (80 + strlen (srctype
) > buf_size
)
2701 error (_("Buffer too small for source encoding"));
2702 sprintf (buf
, "%x:%s:%s:%x:%x:",
2703 tpnum
, phex_nz (addr
, sizeof (addr
)),
2704 srctype
, 0, (int) strlen (src
));
2705 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2706 error (_("Source string too long for buffer"));
2707 bin2hex (src
, buf
+ strlen (buf
), 0);
2711 extern int trace_regblock_size
;
2713 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2714 non-zero, the save is performed on the target, otherwise GDB obtains all
2715 trace data and saves it locally. */
2718 trace_save (const char *filename
, int target_does_save
)
2720 struct cleanup
*cleanup
;
2722 struct trace_status
*ts
= current_trace_status ();
2725 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2726 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2730 ULONGEST offset
= 0;
2731 #define MAX_TRACE_UPLOAD 2000
2732 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2735 /* If the target is to save the data to a file on its own, then just
2736 send the command and be done with it. */
2737 if (target_does_save
)
2739 err
= target_save_trace_data (filename
);
2741 error (_("Target failed to save trace data to '%s'."),
2746 /* Get the trace status first before opening the file, so if the
2747 target is losing, we can get out without touching files. */
2748 status
= target_get_trace_status (ts
);
2750 pathname
= tilde_expand (filename
);
2751 cleanup
= make_cleanup (xfree
, pathname
);
2753 fp
= fopen (pathname
, "wb");
2755 error (_("Unable to open file '%s' for saving trace data (%s)"),
2756 filename
, safe_strerror (errno
));
2757 make_cleanup_fclose (fp
);
2759 /* Write a file header, with a high-bit-set char to indicate a
2760 binary file, plus a hint as what this file is, and a version
2761 number in case of future needs. */
2762 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2764 perror_with_name (pathname
);
2766 /* Write descriptive info. */
2768 /* Write out the size of a register block. */
2769 fprintf (fp
, "R %x\n", trace_regblock_size
);
2771 /* Write out status of the tracing run (aka "tstatus" info). */
2772 fprintf (fp
, "status %c;%s",
2773 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
2774 if (ts
->stop_reason
== tracepoint_error
)
2776 char *buf
= (char *) alloca (strlen (ts
->error_desc
) * 2 + 1);
2778 bin2hex ((gdb_byte
*) ts
->error_desc
, buf
, 0);
2779 fprintf (fp
, ":%s", buf
);
2781 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
2782 if (ts
->traceframe_count
>= 0)
2783 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
2784 if (ts
->traceframes_created
>= 0)
2785 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
2786 if (ts
->buffer_free
>= 0)
2787 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
2788 if (ts
->buffer_size
>= 0)
2789 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
2790 if (ts
->disconnected_tracing
)
2791 fprintf (fp
, ";disconn:%x", ts
->disconnected_tracing
);
2792 if (ts
->circular_buffer
)
2793 fprintf (fp
, ";circular:%x", ts
->circular_buffer
);
2796 /* Note that we want to upload tracepoints and save those, rather
2797 than simply writing out the local ones, because the user may have
2798 changed tracepoints in GDB in preparation for a future tracing
2799 run, or maybe just mass-deleted all types of breakpoints as part
2800 of cleaning up. So as not to contaminate the session, leave the
2801 data in its uploaded form, don't make into real tracepoints. */
2803 /* Get trace state variables first, they may be checked when parsing
2804 uploaded commands. */
2806 target_upload_trace_state_variables (&uploaded_tsvs
);
2808 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2814 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
2815 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
2818 fprintf (fp
, "tsv %x:%s:%x:%s\n",
2819 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
2820 utsv
->builtin
, buf
);
2826 free_uploaded_tsvs (&uploaded_tsvs
);
2828 target_upload_tracepoints (&uploaded_tps
);
2830 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
2832 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
2833 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2834 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
2835 if (utp
->type
== bp_fast_tracepoint
)
2836 fprintf (fp
, ":F%x", utp
->orig_size
);
2838 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
2841 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
2842 fprintf (fp
, "tp A%x:%s:%s\n",
2843 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
2844 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
2845 fprintf (fp
, "tp S%x:%s:%s\n",
2846 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
2849 encode_source_string (utp
->number
, utp
->addr
,
2850 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
2851 fprintf (fp
, "tp Z%s\n", buf
);
2853 if (utp
->cond_string
)
2855 encode_source_string (utp
->number
, utp
->addr
,
2856 "cond", utp
->cond_string
,
2857 buf
, MAX_TRACE_UPLOAD
);
2858 fprintf (fp
, "tp Z%s\n", buf
);
2860 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
2862 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
2863 buf
, MAX_TRACE_UPLOAD
);
2864 fprintf (fp
, "tp Z%s\n", buf
);
2868 free_uploaded_tps (&uploaded_tps
);
2870 /* Mark the end of the definition section. */
2873 /* Get and write the trace data proper. We ask for big blocks, in
2874 the hopes of efficiency, but will take less if the target has
2875 packet size limitations or some such. */
2878 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
2880 error (_("Failure to get requested trace buffer data"));
2881 /* No more data is forthcoming, we're done. */
2884 written
= fwrite (buf
, gotten
, 1, fp
);
2886 perror_with_name (pathname
);
2890 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
2891 written
= fwrite (&gotten
, 4, 1, fp
);
2893 perror_with_name (pathname
);
2895 do_cleanups (cleanup
);
2899 trace_save_command (char *args
, int from_tty
)
2901 int target_does_save
= 0;
2903 char *filename
= NULL
;
2904 struct cleanup
*back_to
;
2907 error_no_arg (_("file in which to save trace data"));
2909 argv
= gdb_buildargv (args
);
2910 back_to
= make_cleanup_freeargv (argv
);
2912 for (; *argv
; ++argv
)
2914 if (strcmp (*argv
, "-r") == 0)
2915 target_does_save
= 1;
2916 else if (**argv
== '-')
2917 error (_("unknown option `%s'"), *argv
);
2923 error_no_arg (_("file in which to save trace data"));
2925 trace_save (filename
, target_does_save
);
2928 printf_filtered (_("Trace data saved to file '%s'.\n"), filename
);
2930 do_cleanups (back_to
);
2933 /* Tell the target what to do with an ongoing tracing run if GDB
2934 disconnects for some reason. */
2937 send_disconnected_tracing_value (int value
)
2939 target_set_disconnected_tracing (value
);
2943 set_disconnected_tracing (char *args
, int from_tty
,
2944 struct cmd_list_element
*c
)
2946 send_disconnected_tracing_value (disconnected_tracing
);
2950 set_circular_trace_buffer (char *args
, int from_tty
,
2951 struct cmd_list_element
*c
)
2953 target_set_circular_trace_buffer (circular_trace_buffer
);
2956 /* Convert the memory pointed to by mem into hex, placing result in buf.
2957 * Return a pointer to the last char put in buf (null)
2958 * "stolen" from sparc-stub.c
2961 static const char hexchars
[] = "0123456789abcdef";
2964 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2972 *buf
++ = hexchars
[ch
>> 4];
2973 *buf
++ = hexchars
[ch
& 0xf];
2982 get_traceframe_number (void)
2984 return traceframe_number
;
2987 /* Make the traceframe NUM be the current trace frame. Does nothing
2988 if NUM is already current. */
2991 set_current_traceframe (int num
)
2995 if (traceframe_number
== num
)
2997 /* Nothing to do. */
3001 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3004 warning (_("could not change traceframe"));
3006 traceframe_number
= newnum
;
3008 /* Changing the traceframe changes our view of registers and of the
3010 registers_changed ();
3012 clear_traceframe_info ();
3015 /* Make the traceframe NUM be the current trace frame, and do nothing
3019 set_traceframe_number (int num
)
3021 traceframe_number
= num
;
3024 /* A cleanup used when switching away and back from tfind mode. */
3026 struct current_traceframe_cleanup
3028 /* The traceframe we were inspecting. */
3029 int traceframe_number
;
3033 do_restore_current_traceframe_cleanup (void *arg
)
3035 struct current_traceframe_cleanup
*old
= arg
;
3037 set_current_traceframe (old
->traceframe_number
);
3041 restore_current_traceframe_cleanup_dtor (void *arg
)
3043 struct current_traceframe_cleanup
*old
= arg
;
3049 make_cleanup_restore_current_traceframe (void)
3051 struct current_traceframe_cleanup
*old
;
3053 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3054 old
->traceframe_number
= traceframe_number
;
3056 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3057 restore_current_traceframe_cleanup_dtor
);
3061 make_cleanup_restore_traceframe_number (void)
3063 return make_cleanup_restore_integer (&traceframe_number
);
3066 /* Given a number and address, return an uploaded tracepoint with that
3067 number, creating if necessary. */
3069 struct uploaded_tp
*
3070 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3072 struct uploaded_tp
*utp
;
3074 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3075 if (utp
->number
== num
&& utp
->addr
== addr
)
3077 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3078 memset (utp
, 0, sizeof (struct uploaded_tp
));
3081 utp
->actions
= NULL
;
3082 utp
->step_actions
= NULL
;
3083 utp
->cmd_strings
= NULL
;
3090 free_uploaded_tps (struct uploaded_tp
**utpp
)
3092 struct uploaded_tp
*next_one
;
3096 next_one
= (*utpp
)->next
;
3102 /* Given a number and address, return an uploaded tracepoint with that
3103 number, creating if necessary. */
3105 struct uploaded_tsv
*
3106 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3108 struct uploaded_tsv
*utsv
;
3110 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3111 if (utsv
->number
== num
)
3113 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3114 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3116 utsv
->next
= *utsvp
;
3122 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3124 struct uploaded_tsv
*next_one
;
3128 next_one
= (*utsvp
)->next
;
3134 /* FIXME this function is heuristic and will miss the cases where the
3135 conditional is semantically identical but differs in whitespace,
3136 such as "x == 0" vs "x==0". */
3139 cond_string_is_same (char *str1
, char *str2
)
3141 if (str1
== NULL
|| str2
== NULL
)
3142 return (str1
== str2
);
3144 return (strcmp (str1
, str2
) == 0);
3147 /* Look for an existing tracepoint that seems similar enough to the
3148 uploaded one. Enablement isn't compared, because the user can
3149 toggle that freely, and may have done so in anticipation of the
3153 find_matching_tracepoint (struct uploaded_tp
*utp
)
3155 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3157 struct breakpoint
*b
;
3158 struct bp_location
*loc
;
3160 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3162 struct tracepoint
*t
= (struct tracepoint
*) b
;
3164 if (b
->type
== utp
->type
3165 && t
->step_count
== utp
->step
3166 && t
->pass_count
== utp
->pass
3167 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3168 /* FIXME also test actions. */
3171 /* Scan the locations for an address match. */
3172 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3174 if (loc
->address
== utp
->addr
)
3182 /* Given a list of tracepoints uploaded from a target, attempt to
3183 match them up with existing tracepoints, and create new ones if not
3187 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3189 struct uploaded_tp
*utp
;
3190 struct tracepoint
*t
;
3192 /* Look for GDB tracepoints that match up with our uploaded versions. */
3193 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3195 t
= find_matching_tracepoint (utp
);
3197 printf_filtered (_("Assuming tracepoint %d is same "
3198 "as target's tracepoint %d at %s.\n"),
3199 t
->base
.number
, utp
->number
,
3200 paddress (get_current_arch (), utp
->addr
));
3203 t
= create_tracepoint_from_upload (utp
);
3205 printf_filtered (_("Created tracepoint %d for "
3206 "target's tracepoint %d at %s.\n"),
3207 t
->base
.number
, utp
->number
,
3208 paddress (get_current_arch (), utp
->addr
));
3210 printf_filtered (_("Failed to create tracepoint for target's "
3211 "tracepoint %d at %s, skipping it.\n"),
3213 paddress (get_current_arch (), utp
->addr
));
3215 /* Whether found or created, record the number used by the
3216 target, to help with mapping target tracepoints back to their
3217 counterparts here. */
3219 t
->number_on_target
= utp
->number
;
3222 free_uploaded_tps (uploaded_tps
);
3225 /* Trace state variables don't have much to identify them beyond their
3226 name, so just use that to detect matches. */
3228 struct trace_state_variable
*
3229 find_matching_tsv (struct uploaded_tsv
*utsv
)
3234 return find_trace_state_variable (utsv
->name
);
3237 struct trace_state_variable
*
3238 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3240 const char *namebase
;
3243 struct trace_state_variable
*tsv
;
3247 namebase
= utsv
->name
;
3248 sprintf (buf
, "%s", namebase
);
3253 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3256 /* Fish for a name that is not in use. */
3257 /* (should check against all internal vars?) */
3258 while (find_trace_state_variable (buf
))
3259 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3261 /* We have an available name, create the variable. */
3262 tsv
= create_trace_state_variable (buf
);
3263 tsv
->initial_value
= utsv
->initial_value
;
3264 tsv
->builtin
= utsv
->builtin
;
3269 /* Given a list of uploaded trace state variables, try to match them
3270 up with existing variables, or create additional ones. */
3273 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3276 struct uploaded_tsv
*utsv
;
3277 struct trace_state_variable
*tsv
;
3280 /* Most likely some numbers will have to be reassigned as part of
3281 the merge, so clear them all in anticipation. */
3282 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3285 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3287 tsv
= find_matching_tsv (utsv
);
3291 printf_filtered (_("Assuming trace state variable $%s "
3292 "is same as target's variable %d.\n"),
3293 tsv
->name
, utsv
->number
);
3297 tsv
= create_tsv_from_upload (utsv
);
3299 printf_filtered (_("Created trace state variable "
3300 "$%s for target's variable %d.\n"),
3301 tsv
->name
, utsv
->number
);
3303 /* Give precedence to numberings that come from the target. */
3305 tsv
->number
= utsv
->number
;
3308 /* Renumber everything that didn't get a target-assigned number. */
3310 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3311 if (tsv
->number
> highest
)
3312 highest
= tsv
->number
;
3315 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3316 if (tsv
->number
== 0)
3317 tsv
->number
= highest
++;
3319 free_uploaded_tsvs (uploaded_tsvs
);
3322 /* target tfile command */
3324 struct target_ops tfile_ops
;
3326 /* Fill in tfile_ops with its defined operations and properties. */
3328 #define TRACE_HEADER_SIZE 8
3330 char *trace_filename
;
3332 off_t trace_frames_offset
;
3334 int cur_traceframe_number
;
3336 int trace_regblock_size
;
3338 static void tfile_interp_line (char *line
,
3339 struct uploaded_tp
**utpp
,
3340 struct uploaded_tsv
**utsvp
);
3342 /* Read SIZE bytes into READBUF from the trace frame, starting at
3343 TRACE_FD's current position. Note that this call `read'
3344 underneath, hence it advances the file's seek position. Throws an
3345 error if the `read' syscall fails, or less than SIZE bytes are
3349 tfile_read (gdb_byte
*readbuf
, int size
)
3353 gotten
= read (trace_fd
, readbuf
, size
);
3355 perror_with_name (trace_filename
);
3356 else if (gotten
< size
)
3357 error (_("Premature end of file while reading trace file"));
3361 tfile_open (char *filename
, int from_tty
)
3363 volatile struct gdb_exception ex
;
3365 struct cleanup
*old_chain
;
3368 char header
[TRACE_HEADER_SIZE
];
3369 char linebuf
[1000]; /* Should be max remote packet size or so. */
3372 struct trace_status
*ts
;
3373 struct uploaded_tp
*uploaded_tps
= NULL
;
3374 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3376 target_preopen (from_tty
);
3378 error (_("No trace file specified."));
3380 filename
= tilde_expand (filename
);
3381 if (!IS_ABSOLUTE_PATH(filename
))
3383 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
3388 old_chain
= make_cleanup (xfree
, filename
);
3390 flags
= O_BINARY
| O_LARGEFILE
;
3392 scratch_chan
= open (filename
, flags
, 0);
3393 if (scratch_chan
< 0)
3394 perror_with_name (filename
);
3396 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3398 discard_cleanups (old_chain
); /* Don't free filename any more. */
3399 unpush_target (&tfile_ops
);
3401 trace_filename
= xstrdup (filename
);
3402 trace_fd
= scratch_chan
;
3405 /* Read the file header and test for validity. */
3406 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
3408 bytes
+= TRACE_HEADER_SIZE
;
3409 if (!(header
[0] == 0x7f
3410 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3411 error (_("File is not a valid trace file."));
3413 push_target (&tfile_ops
);
3415 trace_regblock_size
= 0;
3416 ts
= current_trace_status ();
3417 /* We know we're working with a file. */
3419 /* Set defaults in case there is no status line. */
3420 ts
->running_known
= 0;
3421 ts
->stop_reason
= trace_stop_reason_unknown
;
3422 ts
->traceframe_count
= -1;
3423 ts
->buffer_free
= 0;
3424 ts
->disconnected_tracing
= 0;
3425 ts
->circular_buffer
= 0;
3427 cur_traceframe_number
= -1;
3429 TRY_CATCH (ex
, RETURN_MASK_ALL
)
3431 /* Read through a section of newline-terminated lines that
3432 define things like tracepoints. */
3436 tfile_read (&byte
, 1);
3441 /* Empty line marks end of the definition section. */
3446 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3449 linebuf
[i
++] = byte
;
3451 error (_("Excessively long lines in trace file"));
3454 /* Record the starting offset of the binary trace data. */
3455 trace_frames_offset
= bytes
;
3457 /* If we don't have a blocksize, we can't interpret the
3459 if (trace_regblock_size
== 0)
3460 error (_("No register block size recorded in trace file"));
3464 /* Pop the partially set up target. */
3466 throw_exception (ex
);
3469 inferior_appeared (current_inferior (), TFILE_PID
);
3470 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3471 add_thread_silent (inferior_ptid
);
3473 if (ts
->traceframe_count
<= 0)
3474 warning (_("No traceframes present in this file."));
3476 /* Add the file's tracepoints and variables into the current mix. */
3478 /* Get trace state variables first, they may be checked when parsing
3479 uploaded commands. */
3480 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3482 merge_uploaded_tracepoints (&uploaded_tps
);
3484 post_create_inferior (&tfile_ops
, from_tty
);
3487 /* Interpret the given line from the definitions part of the trace
3491 tfile_interp_line (char *line
,
3492 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3496 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3499 trace_regblock_size
= strtol (p
, &p
, 16);
3501 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3503 p
+= strlen ("status ");
3504 parse_trace_status (p
, current_trace_status ());
3506 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3508 p
+= strlen ("tp ");
3509 parse_tracepoint_definition (p
, utpp
);
3511 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3513 p
+= strlen ("tsv ");
3514 parse_tsv_definition (p
, utsvp
);
3517 warning (_("Ignoring trace file definition \"%s\""), line
);
3520 /* Parse the part of trace status syntax that is shared between
3521 the remote protocol and the trace file reader. */
3524 parse_trace_status (char *line
, struct trace_status
*ts
)
3526 char *p
= line
, *p1
, *p2
, *p_temp
;
3529 ts
->running_known
= 1;
3530 ts
->running
= (*p
++ == '1');
3531 ts
->stop_reason
= trace_stop_reason_unknown
;
3532 xfree (ts
->error_desc
);
3533 ts
->error_desc
= NULL
;
3534 ts
->traceframe_count
= -1;
3535 ts
->traceframes_created
= -1;
3536 ts
->buffer_free
= -1;
3537 ts
->buffer_size
= -1;
3538 ts
->disconnected_tracing
= 0;
3539 ts
->circular_buffer
= 0;
3543 p1
= strchr (p
, ':');
3545 error (_("Malformed trace status, at %s\n\
3546 Status line: '%s'\n"), p
, line
);
3547 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3549 p
= unpack_varlen_hex (++p1
, &val
);
3550 ts
->stop_reason
= trace_buffer_full
;
3552 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3554 p
= unpack_varlen_hex (++p1
, &val
);
3555 ts
->stop_reason
= trace_never_run
;
3557 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3560 p
= unpack_varlen_hex (++p1
, &val
);
3561 ts
->stop_reason
= tracepoint_passcount
;
3562 ts
->stopping_tracepoint
= val
;
3564 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3566 p
= unpack_varlen_hex (++p1
, &val
);
3567 ts
->stop_reason
= tstop_command
;
3569 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3571 p
= unpack_varlen_hex (++p1
, &val
);
3572 ts
->stop_reason
= trace_disconnected
;
3574 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3576 p2
= strchr (++p1
, ':');
3581 ts
->error_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3582 end
= hex2bin (p1
, ts
->error_desc
, (p2
- p1
) / 2);
3583 ts
->error_desc
[end
] = '\0';
3586 ts
->error_desc
= xstrdup ("");
3588 p
= unpack_varlen_hex (++p2
, &val
);
3589 ts
->stopping_tracepoint
= val
;
3590 ts
->stop_reason
= tracepoint_error
;
3592 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3594 p
= unpack_varlen_hex (++p1
, &val
);
3595 ts
->traceframe_count
= val
;
3597 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3599 p
= unpack_varlen_hex (++p1
, &val
);
3600 ts
->traceframes_created
= val
;
3602 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3604 p
= unpack_varlen_hex (++p1
, &val
);
3605 ts
->buffer_free
= val
;
3607 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3609 p
= unpack_varlen_hex (++p1
, &val
);
3610 ts
->buffer_size
= val
;
3612 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3614 p
= unpack_varlen_hex (++p1
, &val
);
3615 ts
->disconnected_tracing
= val
;
3617 else if (strncmp (p
, "circular", p1
- p
) == 0)
3619 p
= unpack_varlen_hex (++p1
, &val
);
3620 ts
->circular_buffer
= val
;
3624 /* Silently skip unknown optional info. */
3625 p_temp
= strchr (p1
+ 1, ';');
3629 /* Must be at the end. */
3635 /* Given a line of text defining a part of a tracepoint, parse it into
3636 an "uploaded tracepoint". */
3639 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3643 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3646 char *cond
, *srctype
, *buf
;
3647 struct uploaded_tp
*utp
= NULL
;
3650 /* Both tracepoint and action definitions start with the same number
3651 and address sequence. */
3653 p
= unpack_varlen_hex (p
, &num
);
3654 p
++; /* skip a colon */
3655 p
= unpack_varlen_hex (p
, &addr
);
3656 p
++; /* skip a colon */
3659 enabled
= (*p
++ == 'E');
3660 p
++; /* skip a colon */
3661 p
= unpack_varlen_hex (p
, &step
);
3662 p
++; /* skip a colon */
3663 p
= unpack_varlen_hex (p
, &pass
);
3664 type
= bp_tracepoint
;
3666 /* Thumb through optional fields. */
3669 p
++; /* skip a colon */
3672 type
= bp_fast_tracepoint
;
3674 p
= unpack_varlen_hex (p
, &orig_size
);
3678 type
= bp_static_tracepoint
;
3684 p
= unpack_varlen_hex (p
, &xlen
);
3685 p
++; /* skip a comma */
3686 cond
= (char *) xmalloc (2 * xlen
+ 1);
3687 strncpy (cond
, p
, 2 * xlen
);
3688 cond
[2 * xlen
] = '\0';
3692 warning (_("Unrecognized char '%c' in tracepoint "
3693 "definition, skipping rest"), *p
);
3695 utp
= get_uploaded_tp (num
, addr
, utpp
);
3697 utp
->enabled
= enabled
;
3702 else if (piece
== 'A')
3704 utp
= get_uploaded_tp (num
, addr
, utpp
);
3705 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
3707 else if (piece
== 'S')
3709 utp
= get_uploaded_tp (num
, addr
, utpp
);
3710 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
3712 else if (piece
== 'Z')
3714 /* Parse a chunk of source form definition. */
3715 utp
= get_uploaded_tp (num
, addr
, utpp
);
3717 p
= strchr (p
, ':');
3718 p
++; /* skip a colon */
3719 p
= unpack_varlen_hex (p
, &start
);
3720 p
++; /* skip a colon */
3721 p
= unpack_varlen_hex (p
, &xlen
);
3722 p
++; /* skip a colon */
3724 buf
= alloca (strlen (line
));
3726 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3729 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
3730 utp
->at_string
= xstrdup (buf
);
3731 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
3732 utp
->cond_string
= xstrdup (buf
);
3733 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
3734 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
3738 /* Don't error out, the target might be sending us optional
3739 info that we don't care about. */
3740 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3744 /* Convert a textual description of a trace state variable into an
3748 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3751 ULONGEST num
, initval
, builtin
;
3753 struct uploaded_tsv
*utsv
= NULL
;
3755 buf
= alloca (strlen (line
));
3758 p
= unpack_varlen_hex (p
, &num
);
3759 p
++; /* skip a colon */
3760 p
= unpack_varlen_hex (p
, &initval
);
3761 p
++; /* skip a colon */
3762 p
= unpack_varlen_hex (p
, &builtin
);
3763 p
++; /* skip a colon */
3764 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3767 utsv
= get_uploaded_tsv (num
, utsvp
);
3768 utsv
->initial_value
= initval
;
3769 utsv
->builtin
= builtin
;
3770 utsv
->name
= xstrdup (buf
);
3773 /* Close the trace file and generally clean up. */
3776 tfile_close (int quitting
)
3783 pid
= ptid_get_pid (inferior_ptid
);
3784 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff. */
3785 exit_inferior_silent (pid
);
3789 xfree (trace_filename
);
3790 trace_filename
= NULL
;
3794 tfile_files_info (struct target_ops
*t
)
3796 /* (it would be useful to mention the name of the file). */
3797 printf_filtered ("Looking at a trace file.\n");
3800 /* The trace status for a file is that tracing can never be run. */
3803 tfile_get_trace_status (struct trace_status
*ts
)
3805 /* Other bits of trace status were collected as part of opening the
3806 trace files, so nothing to do here. */
3811 /* Given the position of a traceframe in the file, figure out what
3812 address the frame was collected at. This would normally be the
3813 value of a collected PC register, but if not available, we
3817 tfile_get_traceframe_address (off_t tframe_offset
)
3821 struct tracepoint
*tp
;
3822 off_t saved_offset
= cur_offset
;
3824 /* FIXME dig pc out of collected registers. */
3826 /* Fall back to using tracepoint address. */
3827 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
3828 tfile_read ((gdb_byte
*) &tpnum
, 2);
3829 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
3833 tp
= get_tracepoint_by_number_on_target (tpnum
);
3834 /* FIXME this is a poor heuristic if multiple locations. */
3835 if (tp
&& tp
->base
.loc
)
3836 addr
= tp
->base
.loc
->address
;
3838 /* Restore our seek position. */
3839 cur_offset
= saved_offset
;
3840 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3844 /* Make tfile's selected traceframe match GDB's selected
3848 set_tfile_traceframe (void)
3852 if (cur_traceframe_number
== get_traceframe_number ())
3855 /* Avoid recursion, tfile_trace_find calls us again. */
3856 cur_traceframe_number
= get_traceframe_number ();
3858 newnum
= target_trace_find (tfind_number
,
3859 get_traceframe_number (), 0, 0, NULL
);
3861 /* Should not happen. If it does, all bets are off. */
3862 if (newnum
!= get_traceframe_number ())
3863 warning (_("could not set tfile's traceframe"));
3866 /* Given a type of search and some parameters, scan the collection of
3867 traceframes in the file looking for a match. When found, return
3868 both the traceframe and tracepoint number, otherwise -1 for
3872 tfile_trace_find (enum trace_find_type type
, int num
,
3873 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
3876 int tfnum
= 0, found
= 0;
3877 unsigned int data_size
;
3878 struct tracepoint
*tp
;
3879 off_t offset
, tframe_offset
;
3882 /* Lookups other than by absolute frame number depend on the current
3883 trace selected, so make sure it is correct on the tfile end
3885 if (type
!= tfind_number
)
3886 set_tfile_traceframe ();
3894 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
3895 offset
= trace_frames_offset
;
3898 tframe_offset
= offset
;
3899 tfile_read ((gdb_byte
*) &tpnum
, 2);
3900 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
3906 tfile_read ((gdb_byte
*) &data_size
, 4);
3907 data_size
= (unsigned int) extract_unsigned_integer
3908 ((gdb_byte
*) &data_size
, 4,
3909 gdbarch_byte_order (target_gdbarch
));
3918 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3919 if (tfaddr
== addr1
)
3923 tp
= get_tracepoint (num
);
3924 if (tp
&& tpnum
== tp
->number_on_target
)
3928 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3929 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
3933 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3934 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
3938 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
3944 cur_offset
= offset
;
3945 cur_data_size
= data_size
;
3946 cur_traceframe_number
= tfnum
;
3949 /* Skip past the traceframe's data. */
3950 lseek (trace_fd
, data_size
, SEEK_CUR
);
3951 offset
+= data_size
;
3952 /* Update our own count of traceframes. */
3955 /* Did not find what we were looking for. */
3961 /* Prototype of the callback passed to tframe_walk_blocks. */
3962 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
3964 /* Callback for traceframe_walk_blocks, used to find a given block
3965 type in a traceframe. */
3968 match_blocktype (char blocktype
, void *data
)
3970 char *wantedp
= data
;
3972 if (*wantedp
== blocktype
)
3978 /* Walk over all traceframe block starting at POS offset from
3979 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
3980 unmodified. If CALLBACK returns true, this returns the position in
3981 the traceframe where the block is found, relative to the start of
3982 the traceframe (cur_offset). Returns -1 if no callback call
3983 returned true, indicating that all blocks have been walked. */
3986 traceframe_walk_blocks (walk_blocks_callback_func callback
,
3987 int pos
, void *data
)
3989 /* Iterate through a traceframe's blocks, looking for a block of the
3992 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
3993 while (pos
< cur_data_size
)
3995 unsigned short mlen
;
3998 tfile_read (&block_type
, 1);
4002 if ((*callback
) (block_type
, data
))
4008 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4009 pos
+= trace_regblock_size
;
4012 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4013 tfile_read ((gdb_byte
*) &mlen
, 2);
4014 mlen
= (unsigned short)
4015 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4018 lseek (trace_fd
, mlen
, SEEK_CUR
);
4019 pos
+= (8 + 2 + mlen
);
4022 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
4026 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4027 block_type
, block_type
);
4035 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4036 position offset of a block of type TYPE_WANTED in the current trace
4037 frame, starting at POS. Returns -1 if no such block was found. */
4040 traceframe_find_block_type (char type_wanted
, int pos
)
4042 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
4045 /* Look for a block of saved registers in the traceframe, and get the
4046 requested register from it. */
4049 tfile_fetch_registers (struct target_ops
*ops
,
4050 struct regcache
*regcache
, int regno
)
4052 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4054 int pos
, offset
, regn
, regsize
, pc_regno
;
4055 unsigned short mlen
;
4058 /* An uninitialized reg size says we're not going to be
4059 successful at getting register blocks. */
4060 if (!trace_regblock_size
)
4063 set_tfile_traceframe ();
4065 regs
= alloca (trace_regblock_size
);
4067 if (traceframe_find_block_type ('R', 0) >= 0)
4069 tfile_read (regs
, trace_regblock_size
);
4071 /* Assume the block is laid out in GDB register number order,
4072 each register with the size that it has in GDB. */
4074 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4076 regsize
= register_size (gdbarch
, regn
);
4077 /* Make sure we stay within block bounds. */
4078 if (offset
+ regsize
>= trace_regblock_size
)
4080 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
4084 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
4087 else if (regno
== -1)
4089 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
4097 /* We get here if no register data has been found. Mark registers
4099 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4100 regcache_raw_supply (regcache
, regn
, NULL
);
4102 /* We can often usefully guess that the PC is going to be the same
4103 as the address of the tracepoint. */
4104 pc_regno
= gdbarch_pc_regnum (gdbarch
);
4105 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
4107 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
4109 if (tp
&& tp
->base
.loc
)
4111 /* But don't try to guess if tracepoint is multi-location... */
4112 if (tp
->base
.loc
->next
)
4114 warning (_("Tracepoint %d has multiple "
4115 "locations, cannot infer $pc"),
4119 /* ... or does while-stepping. */
4120 if (tp
->step_count
> 0)
4122 warning (_("Tracepoint %d does while-stepping, "
4123 "cannot infer $pc"),
4128 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
4129 gdbarch_byte_order (gdbarch
),
4130 tp
->base
.loc
->address
);
4131 regcache_raw_supply (regcache
, pc_regno
, regs
);
4137 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4138 const char *annex
, gdb_byte
*readbuf
,
4139 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
4141 /* We're only doing regular memory for now. */
4142 if (object
!= TARGET_OBJECT_MEMORY
)
4145 if (readbuf
== NULL
)
4146 error (_("tfile_xfer_partial: trace file is read-only"));
4148 set_tfile_traceframe ();
4150 if (traceframe_number
!= -1)
4154 /* Iterate through the traceframe's blocks, looking for
4156 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
4158 ULONGEST maddr
, amt
;
4159 unsigned short mlen
;
4160 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
4162 tfile_read ((gdb_byte
*) &maddr
, 8);
4163 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
4165 tfile_read ((gdb_byte
*) &mlen
, 2);
4166 mlen
= (unsigned short)
4167 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
4169 /* If the block includes the first part of the desired
4170 range, return as much it has; GDB will re-request the
4171 remainder, which might be in a different block of this
4173 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
4175 amt
= (maddr
+ mlen
) - offset
;
4179 tfile_read (readbuf
, amt
);
4183 /* Skip over this block. */
4184 pos
+= (8 + 2 + mlen
);
4188 /* It's unduly pedantic to refuse to look at the executable for
4189 read-only pieces; so do the equivalent of readonly regions aka
4191 /* FIXME account for relocation at some point. */
4198 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
4200 if ((s
->flags
& SEC_LOAD
) == 0
4201 || (s
->flags
& SEC_READONLY
) == 0)
4205 size
= bfd_get_section_size (s
);
4206 if (vma
<= offset
&& offset
< (vma
+ size
))
4210 amt
= (vma
+ size
) - offset
;
4214 amt
= bfd_get_section_contents (exec_bfd
, s
,
4215 readbuf
, offset
- vma
, amt
);
4221 /* Indicate failure to find the requested memory block. */
4225 /* Iterate through the blocks of a trace frame, looking for a 'V'
4226 block with a matching tsv number. */
4229 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
4233 set_tfile_traceframe ();
4236 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
4240 tfile_read ((gdb_byte
*) &vnum
, 4);
4241 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
4246 tfile_read ((gdb_byte
*) val
, 8);
4247 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
4255 /* Didn't find anything. */
4260 tfile_has_all_memory (struct target_ops
*ops
)
4266 tfile_has_memory (struct target_ops
*ops
)
4272 tfile_has_stack (struct target_ops
*ops
)
4274 return traceframe_number
!= -1;
4278 tfile_has_registers (struct target_ops
*ops
)
4280 return traceframe_number
!= -1;
4284 tfile_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
4289 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
4290 object for the tfile target's current traceframe. */
4293 build_traceframe_info (char blocktype
, void *data
)
4295 struct traceframe_info
*info
= data
;
4301 struct mem_range
*r
;
4303 unsigned short mlen
;
4305 tfile_read ((gdb_byte
*) &maddr
, 8);
4306 tfile_read ((gdb_byte
*) &mlen
, 2);
4308 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4321 warning (_("Unhandled trace block type (%d) '%c ' "
4322 "while building trace frame info."),
4323 blocktype
, blocktype
);
4330 static struct traceframe_info
*
4331 tfile_traceframe_info (void)
4333 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
4335 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
4340 init_tfile_ops (void)
4342 tfile_ops
.to_shortname
= "tfile";
4343 tfile_ops
.to_longname
= "Local trace dump file";
4345 = "Use a trace file as a target. Specify the filename of the trace file.";
4346 tfile_ops
.to_open
= tfile_open
;
4347 tfile_ops
.to_close
= tfile_close
;
4348 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
4349 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
4350 tfile_ops
.to_files_info
= tfile_files_info
;
4351 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
4352 tfile_ops
.to_trace_find
= tfile_trace_find
;
4353 tfile_ops
.to_get_trace_state_variable_value
4354 = tfile_get_trace_state_variable_value
;
4355 tfile_ops
.to_stratum
= process_stratum
;
4356 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
4357 tfile_ops
.to_has_memory
= tfile_has_memory
;
4358 tfile_ops
.to_has_stack
= tfile_has_stack
;
4359 tfile_ops
.to_has_registers
= tfile_has_registers
;
4360 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
4361 tfile_ops
.to_thread_alive
= tfile_thread_alive
;
4362 tfile_ops
.to_magic
= OPS_MAGIC
;
4365 /* Given a line of text defining a static tracepoint marker, parse it
4366 into a "static tracepoint marker" object. Throws an error is
4367 parsing fails. If PP is non-null, it points to one past the end of
4368 the parsed marker definition. */
4371 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
4372 struct static_tracepoint_marker
*marker
)
4379 p
= unpack_varlen_hex (p
, &addr
);
4380 p
++; /* skip a colon */
4382 marker
->gdbarch
= target_gdbarch
;
4383 marker
->address
= (CORE_ADDR
) addr
;
4385 endp
= strchr (p
, ':');
4387 error (_("bad marker definition: %s"), line
);
4389 marker
->str_id
= xmalloc (endp
- p
+ 1);
4390 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
4391 marker
->str_id
[end
] = '\0';
4394 p
++; /* skip a colon */
4396 marker
->extra
= xmalloc (strlen (p
) + 1);
4397 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
4398 marker
->extra
[end
] = '\0';
4404 /* Release a static tracepoint marker's contents. Note that the
4405 object itself isn't released here. There objects are usually on
4409 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
4411 xfree (marker
->str_id
);
4412 marker
->str_id
= NULL
;
4415 /* Print MARKER to gdb_stdout. */
4418 print_one_static_tracepoint_marker (int count
,
4419 struct static_tracepoint_marker
*marker
)
4421 struct command_line
*l
;
4424 char wrap_indent
[80];
4425 char extra_field_indent
[80];
4426 struct ui_out
*uiout
= current_uiout
;
4427 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
4428 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4429 struct cleanup
*bkpt_chain
;
4430 VEC(breakpoint_p
) *tracepoints
;
4432 struct symtab_and_line sal
;
4436 sal
.pc
= marker
->address
;
4438 tracepoints
= static_tracepoints_here (marker
->address
);
4440 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
4442 /* A counter field to help readability. This is not a stable
4444 ui_out_field_int (uiout
, "count", count
);
4446 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
4448 ui_out_field_fmt (uiout
, "enabled", "%c",
4449 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
4450 ui_out_spaces (uiout
, 2);
4452 strcpy (wrap_indent
, " ");
4454 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
4455 strcat (wrap_indent
, " ");
4457 strcat (wrap_indent
, " ");
4459 strcpy (extra_field_indent
, " ");
4461 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
4463 sal
= find_pc_line (marker
->address
, 0);
4464 sym
= find_pc_sect_function (marker
->address
, NULL
);
4467 ui_out_text (uiout
, "in ");
4468 ui_out_field_string (uiout
, "func",
4469 SYMBOL_PRINT_NAME (sym
));
4470 ui_out_wrap_hint (uiout
, wrap_indent
);
4471 ui_out_text (uiout
, " at ");
4474 ui_out_field_skip (uiout
, "func");
4476 if (sal
.symtab
!= NULL
)
4478 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
4479 ui_out_text (uiout
, ":");
4481 if (ui_out_is_mi_like_p (uiout
))
4483 char *fullname
= symtab_to_fullname (sal
.symtab
);
4486 ui_out_field_string (uiout
, "fullname", fullname
);
4489 ui_out_field_skip (uiout
, "fullname");
4491 ui_out_field_int (uiout
, "line", sal
.line
);
4495 ui_out_field_skip (uiout
, "fullname");
4496 ui_out_field_skip (uiout
, "line");
4499 ui_out_text (uiout
, "\n");
4500 ui_out_text (uiout
, extra_field_indent
);
4501 ui_out_text (uiout
, _("Data: \""));
4502 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
4503 ui_out_text (uiout
, "\"\n");
4505 if (!VEC_empty (breakpoint_p
, tracepoints
))
4507 struct cleanup
*cleanup_chain
;
4509 struct breakpoint
*b
;
4511 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
4514 ui_out_text (uiout
, extra_field_indent
);
4515 ui_out_text (uiout
, _("Probed by static tracepoints: "));
4516 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
4519 ui_out_text (uiout
, ", ");
4520 ui_out_text (uiout
, "#");
4521 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
4524 do_cleanups (cleanup_chain
);
4526 if (ui_out_is_mi_like_p (uiout
))
4527 ui_out_field_int (uiout
, "number-of-tracepoints",
4528 VEC_length(breakpoint_p
, tracepoints
));
4530 ui_out_text (uiout
, "\n");
4532 VEC_free (breakpoint_p
, tracepoints
);
4534 do_cleanups (bkpt_chain
);
4535 do_cleanups (old_chain
);
4539 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
4541 VEC(static_tracepoint_marker_p
) *markers
;
4542 struct cleanup
*old_chain
;
4543 struct static_tracepoint_marker
*marker
;
4544 struct ui_out
*uiout
= current_uiout
;
4548 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
4549 "StaticTracepointMarkersTable");
4551 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
4553 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
4555 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
4556 if (gdbarch_addr_bit (target_gdbarch
) <= 32)
4557 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
4559 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
4560 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
4562 ui_out_table_body (uiout
);
4564 markers
= target_static_tracepoint_markers_by_strid (NULL
);
4565 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
4568 VEC_iterate (static_tracepoint_marker_p
,
4569 markers
, i
, marker
);
4572 print_one_static_tracepoint_marker (i
+ 1, marker
);
4573 release_static_tracepoint_marker (marker
);
4576 do_cleanups (old_chain
);
4579 /* The $_sdata convenience variable is a bit special. We don't know
4580 for sure type of the value until we actually have a chance to fetch
4581 the data --- the size of the object depends on what has been
4582 collected. We solve this by making $_sdata be an internalvar that
4583 creates a new value on access. */
4585 /* Return a new value with the correct type for the sdata object of
4586 the current trace frame. Return a void value if there's no object
4589 static struct value
*
4590 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
)
4595 /* We need to read the whole object before we know its size. */
4596 size
= target_read_alloc (¤t_target
,
4597 TARGET_OBJECT_STATIC_TRACE_DATA
,
4604 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
4606 v
= allocate_value (type
);
4607 memcpy (value_contents_raw (v
), buf
, size
);
4612 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
4615 #if !defined(HAVE_LIBEXPAT)
4617 struct traceframe_info
*
4618 parse_traceframe_info (const char *tframe_info
)
4620 static int have_warned
;
4625 warning (_("Can not parse XML trace frame info; XML support "
4626 "was disabled at compile time"));
4632 #else /* HAVE_LIBEXPAT */
4634 #include "xml-support.h"
4636 /* Handle the start of a <memory> element. */
4639 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
4640 const struct gdb_xml_element
*element
,
4641 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
4643 struct traceframe_info
*info
= user_data
;
4644 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4645 ULONGEST
*start_p
, *length_p
;
4647 start_p
= xml_find_attribute (attributes
, "start")->value
;
4648 length_p
= xml_find_attribute (attributes
, "length")->value
;
4650 r
->start
= *start_p
;
4651 r
->length
= *length_p
;
4654 /* Discard the constructed trace frame info (if an error occurs). */
4657 free_result (void *p
)
4659 struct traceframe_info
*result
= p
;
4661 free_traceframe_info (result
);
4664 /* The allowed elements and attributes for an XML memory map. */
4666 static const struct gdb_xml_attribute memory_attributes
[] = {
4667 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
4668 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
4669 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
4672 static const struct gdb_xml_element traceframe_info_children
[] = {
4673 { "memory", memory_attributes
, NULL
,
4674 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
4675 traceframe_info_start_memory
, NULL
},
4676 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
4679 static const struct gdb_xml_element traceframe_info_elements
[] = {
4680 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
4682 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
4685 /* Parse a traceframe-info XML document. */
4687 struct traceframe_info
*
4688 parse_traceframe_info (const char *tframe_info
)
4690 struct traceframe_info
*result
;
4691 struct cleanup
*back_to
;
4693 result
= XCNEW (struct traceframe_info
);
4694 back_to
= make_cleanup (free_result
, result
);
4696 if (gdb_xml_parse_quick (_("trace frame info"),
4697 "traceframe-info.dtd", traceframe_info_elements
,
4698 tframe_info
, result
) == 0)
4700 /* Parsed successfully, keep the result. */
4701 discard_cleanups (back_to
);
4706 do_cleanups (back_to
);
4710 #endif /* HAVE_LIBEXPAT */
4712 /* Returns the traceframe_info object for the current traceframe.
4713 This is where we avoid re-fetching the object from the target if we
4714 already have it cached. */
4716 struct traceframe_info
*
4717 get_traceframe_info (void)
4719 if (traceframe_info
== NULL
)
4720 traceframe_info
= target_traceframe_info ();
4722 return traceframe_info
;
4725 /* If the target supports the query, return in RESULT the set of
4726 collected memory in the current traceframe, found within the LEN
4727 bytes range starting at MEMADDR. Returns true if the target
4728 supports the query, otherwise returns false, and RESULT is left
4732 traceframe_available_memory (VEC(mem_range_s
) **result
,
4733 CORE_ADDR memaddr
, ULONGEST len
)
4735 struct traceframe_info
*info
= get_traceframe_info ();
4739 struct mem_range
*r
;
4744 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
4745 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
4747 ULONGEST lo1
, hi1
, lo2
, hi2
;
4748 struct mem_range
*nr
;
4751 hi1
= memaddr
+ len
;
4754 hi2
= r
->start
+ r
->length
;
4756 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
4758 nr
->start
= max (lo1
, lo2
);
4759 nr
->length
= min (hi1
, hi2
) - nr
->start
;
4762 normalize_mem_ranges (*result
);
4769 /* module initialization */
4771 _initialize_tracepoint (void)
4773 struct cmd_list_element
*c
;
4775 /* Explicitly create without lookup, since that tries to create a
4776 value with a void typed value, and when we get here, gdbarch
4777 isn't initialized yet. At this point, we're quite sure there
4778 isn't another convenience variable of the same name. */
4779 create_internalvar_type_lazy ("_sdata", sdata_make_value
);
4781 traceframe_number
= -1;
4782 tracepoint_number
= -1;
4784 if (tracepoint_list
.list
== NULL
)
4786 tracepoint_list
.listsize
= 128;
4787 tracepoint_list
.list
= xmalloc
4788 (tracepoint_list
.listsize
* sizeof (struct memrange
));
4790 if (tracepoint_list
.aexpr_list
== NULL
)
4792 tracepoint_list
.aexpr_listsize
= 128;
4793 tracepoint_list
.aexpr_list
= xmalloc
4794 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
4797 if (stepping_list
.list
== NULL
)
4799 stepping_list
.listsize
= 128;
4800 stepping_list
.list
= xmalloc
4801 (stepping_list
.listsize
* sizeof (struct memrange
));
4804 if (stepping_list
.aexpr_list
== NULL
)
4806 stepping_list
.aexpr_listsize
= 128;
4807 stepping_list
.aexpr_list
= xmalloc
4808 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
4811 add_info ("scope", scope_info
,
4812 _("List the variables local to a scope"));
4814 add_cmd ("tracepoints", class_trace
, NULL
,
4815 _("Tracing of program execution without stopping the program."),
4818 add_com ("tdump", class_trace
, trace_dump_command
,
4819 _("Print everything collected at the current tracepoint."));
4821 add_com ("tsave", class_trace
, trace_save_command
, _("\
4822 Save the trace data to a file.\n\
4823 Use the '-r' option to direct the target to save directly to the file,\n\
4824 using its own filesystem."));
4826 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
4827 Define a trace state variable.\n\
4828 Argument is a $-prefixed name, optionally followed\n\
4829 by '=' and an expression that sets the initial value\n\
4830 at the start of tracing."));
4831 set_cmd_completer (c
, expression_completer
);
4833 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
4834 Delete one or more trace state variables.\n\
4835 Arguments are the names of the variables to delete.\n\
4836 If no arguments are supplied, delete all variables."), &deletelist
);
4837 /* FIXME add a trace variable completer. */
4839 add_info ("tvariables", tvariables_info
, _("\
4840 Status of trace state variables and their values.\n\
4843 add_info ("static-tracepoint-markers",
4844 info_static_tracepoint_markers_command
, _("\
4845 List target static tracepoints markers.\n\
4848 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
4849 Select a trace frame;\n\
4850 No argument means forward by one frame; '-' means backward by one frame."),
4851 &tfindlist
, "tfind ", 1, &cmdlist
);
4853 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
4854 Select a trace frame whose PC is outside the given range (exclusive).\n\
4855 Usage: tfind outside addr1, addr2"),
4858 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
4859 Select a trace frame whose PC is in the given range (inclusive).\n\
4860 Usage: tfind range addr1,addr2"),
4863 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
4864 Select a trace frame by source line.\n\
4865 Argument can be a line number (with optional source file),\n\
4866 a function name, or '*' followed by an address.\n\
4867 Default argument is 'the next source line that was traced'."),
4870 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
4871 Select a trace frame by tracepoint number.\n\
4872 Default is the tracepoint for the current trace frame."),
4875 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
4876 Select a trace frame by PC.\n\
4877 Default is the current PC, or the PC of the current trace frame."),
4880 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
4881 Synonym for 'none'.\n\
4882 De-select any trace frame and resume 'live' debugging."),
4885 add_cmd ("none", class_trace
, trace_find_none_command
,
4886 _("De-select any trace frame and resume 'live' debugging."),
4889 add_cmd ("start", class_trace
, trace_find_start_command
,
4890 _("Select the first trace frame in the trace buffer."),
4893 add_com ("tstatus", class_trace
, trace_status_command
,
4894 _("Display the status of the current trace data collection."));
4896 add_com ("tstop", class_trace
, trace_stop_command
,
4897 _("Stop trace data collection."));
4899 add_com ("tstart", class_trace
, trace_start_command
,
4900 _("Start trace data collection."));
4902 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
4903 Ends a list of commands or actions.\n\
4904 Several GDB commands allow you to enter a list of commands or actions.\n\
4905 Entering \"end\" on a line by itself is the normal way to terminate\n\
4907 Note: the \"end\" command cannot be used at the gdb prompt."));
4909 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
4910 Specify single-stepping behavior at a tracepoint.\n\
4911 Argument is number of instructions to trace in single-step mode\n\
4912 following the tracepoint. This command is normally followed by\n\
4913 one or more \"collect\" commands, to specify what to collect\n\
4914 while single-stepping.\n\n\
4915 Note: this command can only be used in a tracepoint \"actions\" list."));
4917 add_com_alias ("ws", "while-stepping", class_alias
, 0);
4918 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
4920 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
4921 Specify one or more data items to be collected at a tracepoint.\n\
4922 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4923 collect all data (variables, registers) referenced by that expression.\n\
4924 Also accepts the following special arguments:\n\
4925 $regs -- all registers.\n\
4926 $args -- all function arguments.\n\
4927 $locals -- all variables local to the block/function scope.\n\
4928 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4929 Note: this command can only be used in a tracepoint \"actions\" list."));
4931 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4932 Specify one or more expressions to be evaluated at a tracepoint.\n\
4933 Accepts a comma-separated list of (one or more) expressions.\n\
4934 The result of each evaluation will be discarded.\n\
4935 Note: this command can only be used in a tracepoint \"actions\" list."));
4937 add_com ("actions", class_trace
, trace_actions_command
, _("\
4938 Specify the actions to be taken at a tracepoint.\n\
4939 Tracepoint actions may include collecting of specified data,\n\
4940 single-stepping, or enabling/disabling other tracepoints,\n\
4941 depending on target's capabilities."));
4943 default_collect
= xstrdup ("");
4944 add_setshow_string_cmd ("default-collect", class_trace
,
4945 &default_collect
, _("\
4946 Set the list of expressions to collect by default"), _("\
4947 Show the list of expressions to collect by default"), NULL
,
4949 &setlist
, &showlist
);
4951 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4952 &disconnected_tracing
, _("\
4953 Set whether tracing continues after GDB disconnects."), _("\
4954 Show whether tracing continues after GDB disconnects."), _("\
4955 Use this to continue a tracing run even if GDB disconnects\n\
4956 or detaches from the target. You can reconnect later and look at\n\
4957 trace data collected in the meantime."),
4958 set_disconnected_tracing
,
4963 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4964 &circular_trace_buffer
, _("\
4965 Set target's use of circular trace buffer."), _("\
4966 Show target's use of circular trace buffer."), _("\
4967 Use this to make the trace buffer into a circular buffer,\n\
4968 which will discard traceframes (oldest first) instead of filling\n\
4969 up and stopping the trace run."),
4970 set_circular_trace_buffer
,
4977 add_target (&tfile_ops
);