1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2012 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
25 #include "expression.h"
30 #include "gdb_string.h"
32 #include "breakpoint.h"
33 #include "tracepoint.h"
36 #include "completer.h"
38 #include "dictionary.h"
40 #include "user-regs.h"
44 #include "filenames.h"
45 #include "gdbthread.h"
53 #include "exceptions.h"
54 #include "cli/cli-utils.h"
57 /* readline include files */
58 #include "readline/readline.h"
59 #include "readline/history.h"
61 /* readline defines this. */
72 extern int hex2bin (const char *hex
, gdb_byte
*bin
, int count
);
73 extern int bin2hex (const gdb_byte
*bin
, char *hex
, int count
);
75 /* Maximum length of an agent aexpression.
76 This accounts for the fact that packets are limited to 400 bytes
77 (which includes everything -- including the checksum), and assumes
78 the worst case of maximum length for each of the pieces of a
81 NOTE: expressions get mem2hex'ed otherwise this would be twice as
82 large. (400 - 31)/2 == 184 */
83 #define MAX_AGENT_EXPR_LEN 184
87 /* A hook used to notify the UI of tracepoint operations. */
89 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
90 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
92 extern void (*deprecated_readline_begin_hook
) (char *, ...);
93 extern char *(*deprecated_readline_hook
) (char *);
94 extern void (*deprecated_readline_end_hook
) (void);
96 /* GDB commands implemented in other modules:
99 extern void output_command (char *, int);
104 This module defines the following debugger commands:
105 trace : set a tracepoint on a function, line, or address.
106 info trace : list all debugger-defined tracepoints.
107 delete trace : delete one or more tracepoints.
108 enable trace : enable one or more tracepoints.
109 disable trace : disable one or more tracepoints.
110 actions : specify actions to be taken at a tracepoint.
111 passcount : specify a pass count for a tracepoint.
112 tstart : start a trace experiment.
113 tstop : stop a trace experiment.
114 tstatus : query the status of a trace experiment.
115 tfind : find a trace frame in the trace buffer.
116 tdump : print everything collected at the current tracepoint.
117 save-tracepoints : write tracepoint setup into a file.
119 This module defines the following user-visible debugger variables:
120 $trace_frame : sequence number of trace frame currently being debugged.
121 $trace_line : source line of trace frame currently being debugged.
122 $trace_file : source file of trace frame currently being debugged.
123 $tracepoint : tracepoint number of trace frame currently being debugged.
127 /* ======= Important global variables: ======= */
129 /* The list of all trace state variables. We don't retain pointers to
130 any of these for any reason - API is by name or number only - so it
131 works to have a vector of objects. */
133 typedef struct trace_state_variable tsv_s
;
136 /* An object describing the contents of a traceframe. */
138 struct traceframe_info
140 /* Collected memory. */
141 VEC(mem_range_s
) *memory
;
144 static VEC(tsv_s
) *tvariables
;
146 /* The next integer to assign to a variable. */
148 static int next_tsv_number
= 1;
150 /* Number of last traceframe collected. */
151 static int traceframe_number
;
153 /* Tracepoint for last traceframe collected. */
154 static int tracepoint_number
;
156 /* Symbol for function for last traceframe collected. */
157 static struct symbol
*traceframe_fun
;
159 /* Symtab and line for last traceframe collected. */
160 static struct symtab_and_line traceframe_sal
;
162 /* The traceframe info of the current traceframe. NULL if we haven't
163 yet attempted to fetch it, or if the target does not support
164 fetching this object, or if we're not inspecting a traceframe
166 static struct traceframe_info
*traceframe_info
;
168 /* Tracing command lists. */
169 static struct cmd_list_element
*tfindlist
;
171 /* List of expressions to collect by default at each tracepoint hit. */
172 char *default_collect
= "";
174 static int disconnected_tracing
;
176 /* This variable controls whether we ask the target for a linear or
177 circular trace buffer. */
179 static int circular_trace_buffer
;
181 /* Textual notes applying to the current and/or future trace runs. */
183 char *trace_user
= NULL
;
185 /* Textual notes applying to the current and/or future trace runs. */
187 char *trace_notes
= NULL
;
189 /* Textual notes applying to the stopping of a trace. */
191 char *trace_stop_notes
= NULL
;
193 /* ======= Important command functions: ======= */
194 static void trace_actions_command (char *, int);
195 static void trace_start_command (char *, int);
196 static void trace_stop_command (char *, int);
197 static void trace_status_command (char *, int);
198 static void trace_find_command (char *, int);
199 static void trace_find_pc_command (char *, int);
200 static void trace_find_tracepoint_command (char *, int);
201 static void trace_find_line_command (char *, int);
202 static void trace_find_range_command (char *, int);
203 static void trace_find_outside_command (char *, int);
204 static void trace_dump_command (char *, int);
206 /* support routines */
208 struct collection_list
;
209 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
210 static char *mem2hex (gdb_byte
*, char *, int);
211 static void add_register (struct collection_list
*collection
,
214 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
215 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
218 extern void _initialize_tracepoint (void);
220 static struct trace_status trace_status
;
222 char *stop_reason_names
[] = {
232 struct trace_status
*
233 current_trace_status (void)
235 return &trace_status
;
241 free_traceframe_info (struct traceframe_info
*info
)
245 VEC_free (mem_range_s
, info
->memory
);
251 /* Free and clear the traceframe info cache of the current
255 clear_traceframe_info (void)
257 free_traceframe_info (traceframe_info
);
258 traceframe_info
= NULL
;
261 /* Set traceframe number to NUM. */
263 set_traceframe_num (int num
)
265 traceframe_number
= num
;
266 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
269 /* Set tracepoint number to NUM. */
271 set_tracepoint_num (int num
)
273 tracepoint_number
= num
;
274 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
277 /* Set externally visible debug variables for querying/printing
278 the traceframe context (line, function, file). */
281 set_traceframe_context (struct frame_info
*trace_frame
)
285 /* Save as globals for internal use. */
286 if (trace_frame
!= NULL
287 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
289 traceframe_sal
= find_pc_line (trace_pc
, 0);
290 traceframe_fun
= find_pc_function (trace_pc
);
292 /* Save linenumber as "$trace_line", a debugger variable visible to
294 set_internalvar_integer (lookup_internalvar ("trace_line"),
295 traceframe_sal
.line
);
299 init_sal (&traceframe_sal
);
300 traceframe_fun
= NULL
;
301 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
304 /* Save func name as "$trace_func", a debugger variable visible to
306 if (traceframe_fun
== NULL
307 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
308 clear_internalvar (lookup_internalvar ("trace_func"));
310 set_internalvar_string (lookup_internalvar ("trace_func"),
311 SYMBOL_LINKAGE_NAME (traceframe_fun
));
313 /* Save file name as "$trace_file", a debugger variable visible to
315 if (traceframe_sal
.symtab
== NULL
316 || traceframe_sal
.symtab
->filename
== NULL
)
317 clear_internalvar (lookup_internalvar ("trace_file"));
319 set_internalvar_string (lookup_internalvar ("trace_file"),
320 traceframe_sal
.symtab
->filename
);
323 /* Create a new trace state variable with the given name. */
325 struct trace_state_variable
*
326 create_trace_state_variable (const char *name
)
328 struct trace_state_variable tsv
;
330 memset (&tsv
, 0, sizeof (tsv
));
331 tsv
.name
= xstrdup (name
);
332 tsv
.number
= next_tsv_number
++;
333 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
336 /* Look for a trace state variable of the given name. */
338 struct trace_state_variable
*
339 find_trace_state_variable (const char *name
)
341 struct trace_state_variable
*tsv
;
344 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
345 if (strcmp (name
, tsv
->name
) == 0)
352 delete_trace_state_variable (const char *name
)
354 struct trace_state_variable
*tsv
;
357 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
358 if (strcmp (name
, tsv
->name
) == 0)
360 xfree ((void *)tsv
->name
);
361 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
365 warning (_("No trace variable named \"$%s\", not deleting"), name
);
368 /* The 'tvariable' command collects a name and optional expression to
369 evaluate into an initial value. */
372 trace_variable_command (char *args
, int from_tty
)
374 struct expression
*expr
;
375 struct cleanup
*old_chain
;
376 struct internalvar
*intvar
= NULL
;
378 struct trace_state_variable
*tsv
;
381 error_no_arg (_("trace state variable name"));
383 /* All the possible valid arguments are expressions. */
384 expr
= parse_expression (args
);
385 old_chain
= make_cleanup (free_current_contents
, &expr
);
387 if (expr
->nelts
== 0)
388 error (_("No expression?"));
390 /* Only allow two syntaxes; "$name" and "$name=value". */
391 if (expr
->elts
[0].opcode
== OP_INTERNALVAR
)
393 intvar
= expr
->elts
[1].internalvar
;
395 else if (expr
->elts
[0].opcode
== BINOP_ASSIGN
396 && expr
->elts
[1].opcode
== OP_INTERNALVAR
)
398 intvar
= expr
->elts
[2].internalvar
;
399 initval
= value_as_long (evaluate_subexpression_type (expr
, 4));
402 error (_("Syntax must be $NAME [ = EXPR ]"));
405 error (_("No name given"));
407 if (strlen (internalvar_name (intvar
)) <= 0)
408 error (_("Must supply a non-empty variable name"));
410 /* If the variable already exists, just change its initial value. */
411 tsv
= find_trace_state_variable (internalvar_name (intvar
));
414 tsv
->initial_value
= initval
;
415 printf_filtered (_("Trace state variable $%s "
416 "now has initial value %s.\n"),
417 tsv
->name
, plongest (tsv
->initial_value
));
418 do_cleanups (old_chain
);
422 /* Create a new variable. */
423 tsv
= create_trace_state_variable (internalvar_name (intvar
));
424 tsv
->initial_value
= initval
;
426 printf_filtered (_("Trace state variable $%s "
427 "created, with initial value %s.\n"),
428 tsv
->name
, plongest (tsv
->initial_value
));
430 do_cleanups (old_chain
);
434 delete_trace_variable_command (char *args
, int from_tty
)
438 struct cleanup
*back_to
;
442 if (query (_("Delete all trace state variables? ")))
443 VEC_free (tsv_s
, tvariables
);
448 argv
= gdb_buildargv (args
);
449 back_to
= make_cleanup_freeargv (argv
);
451 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
453 if (*argv
[ix
] == '$')
454 delete_trace_state_variable (argv
[ix
] + 1);
456 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
459 do_cleanups (back_to
);
465 tvariables_info_1 (void)
467 struct trace_state_variable
*tsv
;
470 struct cleanup
*back_to
;
471 struct ui_out
*uiout
= current_uiout
;
473 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
475 printf_filtered (_("No trace state variables.\n"));
479 /* Try to acquire values from the target. */
480 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
481 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
484 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
485 count
, "trace-variables");
486 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
487 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
488 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
490 ui_out_table_body (uiout
);
492 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
494 struct cleanup
*back_to2
;
498 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
500 name
= concat ("$", tsv
->name
, (char *) NULL
);
501 make_cleanup (xfree
, name
);
502 ui_out_field_string (uiout
, "name", name
);
503 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
505 if (tsv
->value_known
)
506 c
= plongest (tsv
->value
);
507 else if (ui_out_is_mi_like_p (uiout
))
508 /* For MI, we prefer not to use magic string constants, but rather
509 omit the field completely. The difference between unknown and
510 undefined does not seem important enough to represent. */
512 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
513 /* The value is/was defined, but we don't have it. */
516 /* It is not meaningful to ask about the value. */
519 ui_out_field_string (uiout
, "current", c
);
520 ui_out_text (uiout
, "\n");
522 do_cleanups (back_to2
);
525 do_cleanups (back_to
);
528 /* List all the trace state variables. */
531 tvariables_info (char *args
, int from_tty
)
533 tvariables_info_1 ();
536 /* Stash definitions of tsvs into the given file. */
539 save_trace_state_variables (struct ui_file
*fp
)
541 struct trace_state_variable
*tsv
;
544 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
546 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
547 if (tsv
->initial_value
)
548 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
549 fprintf_unfiltered (fp
, "\n");
553 /* ACTIONS functions: */
555 /* The three functions:
556 collect_pseudocommand,
557 while_stepping_pseudocommand, and
558 end_actions_pseudocommand
559 are placeholders for "commands" that are actually ONLY to be used
560 within a tracepoint action list. If the actual function is ever called,
561 it means that somebody issued the "command" at the top level,
562 which is always an error. */
565 end_actions_pseudocommand (char *args
, int from_tty
)
567 error (_("This command cannot be used at the top level."));
571 while_stepping_pseudocommand (char *args
, int from_tty
)
573 error (_("This command can only be used in a tracepoint actions list."));
577 collect_pseudocommand (char *args
, int from_tty
)
579 error (_("This command can only be used in a tracepoint actions list."));
583 teval_pseudocommand (char *args
, int from_tty
)
585 error (_("This command can only be used in a tracepoint actions list."));
588 /* Parse any collection options, such as /s for strings. */
591 decode_agent_options (char *exp
)
593 struct value_print_options opts
;
598 /* Call this to borrow the print elements default for collection
600 get_user_print_options (&opts
);
605 if (target_supports_string_tracing ())
607 /* Allow an optional decimal number giving an explicit maximum
608 string length, defaulting it to the "print elements" value;
609 so "collect/s80 mystr" gets at most 80 bytes of string. */
610 trace_string_kludge
= opts
.print_max
;
612 if (*exp
>= '0' && *exp
<= '9')
613 trace_string_kludge
= atoi (exp
);
614 while (*exp
>= '0' && *exp
<= '9')
618 error (_("Target does not support \"/s\" option for string tracing."));
621 error (_("Undefined collection format \"%c\"."), *exp
);
623 exp
= skip_spaces (exp
);
628 /* Enter a list of actions for a tracepoint. */
630 trace_actions_command (char *args
, int from_tty
)
632 struct tracepoint
*t
;
633 struct command_line
*l
;
635 t
= get_tracepoint_by_number (&args
, NULL
, 1);
639 xstrprintf ("Enter actions for tracepoint %d, one per line.",
641 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
643 l
= read_command_lines (tmpbuf
, from_tty
, 1,
644 check_tracepoint_command
, t
);
645 do_cleanups (cleanups
);
646 breakpoint_set_commands (&t
->base
, l
);
648 /* else just return */
651 /* Report the results of checking the agent expression, as errors or
655 report_agent_reqs_errors (struct agent_expr
*aexpr
)
657 /* All of the "flaws" are serious bytecode generation issues that
658 should never occur. */
659 if (aexpr
->flaw
!= agent_flaw_none
)
660 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
662 /* If analysis shows a stack underflow, GDB must have done something
663 badly wrong in its bytecode generation. */
664 if (aexpr
->min_height
< 0)
665 internal_error (__FILE__
, __LINE__
,
666 _("expression has min height < 0"));
668 /* Issue this error if the stack is predicted to get too deep. The
669 limit is rather arbitrary; a better scheme might be for the
670 target to report how much stack it will have available. The
671 depth roughly corresponds to parenthesization, so a limit of 20
672 amounts to 20 levels of expression nesting, which is actually
673 a pretty big hairy expression. */
674 if (aexpr
->max_height
> 20)
675 error (_("Expression is too complicated."));
678 /* worker function */
680 validate_actionline (char **line
, struct breakpoint
*b
)
682 struct cmd_list_element
*c
;
683 struct expression
*exp
= NULL
;
684 struct cleanup
*old_chain
= NULL
;
686 struct bp_location
*loc
;
687 struct agent_expr
*aexpr
;
688 struct tracepoint
*t
= (struct tracepoint
*) b
;
690 /* If EOF is typed, *line is NULL. */
694 for (p
= *line
; isspace ((int) *p
);)
697 /* Symbol lookup etc. */
698 if (*p
== '\0') /* empty line: just prompt for another line. */
701 if (*p
== '#') /* comment line */
704 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
706 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
708 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
710 trace_string_kludge
= 0;
712 p
= decode_agent_options (p
);
715 { /* Repeat over a comma-separated list. */
716 QUIT
; /* Allow user to bail out with ^C. */
717 while (isspace ((int) *p
))
720 if (*p
== '$') /* Look for special pseudo-symbols. */
722 if (0 == strncasecmp ("reg", p
+ 1, 3)
723 || 0 == strncasecmp ("arg", p
+ 1, 3)
724 || 0 == strncasecmp ("loc", p
+ 1, 3)
725 || 0 == strncasecmp ("_ret", p
+ 1, 4)
726 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
731 /* else fall thru, treat p as an expression and parse it! */
734 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
737 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
738 old_chain
= make_cleanup (free_current_contents
, &exp
);
740 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
742 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
744 error (_("constant `%s' (value %s) "
745 "will not be collected."),
746 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
747 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
749 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
750 == LOC_OPTIMIZED_OUT
)
752 error (_("`%s' is optimized away "
753 "and cannot be collected."),
754 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
758 /* We have something to collect, make sure that the expr to
759 bytecode translator can handle it and that it's not too
761 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
762 make_cleanup_free_agent_expr (aexpr
);
764 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
765 error (_("Expression is too complicated."));
769 report_agent_reqs_errors (aexpr
);
771 do_cleanups (old_chain
);
774 while (p
&& *p
++ == ',');
777 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
780 { /* Repeat over a comma-separated list. */
781 QUIT
; /* Allow user to bail out with ^C. */
782 while (isspace ((int) *p
))
786 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
789 /* Only expressions are allowed for this action. */
790 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
791 old_chain
= make_cleanup (free_current_contents
, &exp
);
793 /* We have something to evaluate, make sure that the expr to
794 bytecode translator can handle it and that it's not too
796 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
797 make_cleanup_free_agent_expr (aexpr
);
799 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
800 error (_("Expression is too complicated."));
803 report_agent_reqs_errors (aexpr
);
805 do_cleanups (old_chain
);
808 while (p
&& *p
++ == ',');
811 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
813 char *steparg
; /* In case warning is necessary. */
815 while (isspace ((int) *p
))
819 if (*p
== '\0' || (t
->step_count
= strtol (p
, &p
, 0)) == 0)
820 error (_("while-stepping step count `%s' is malformed."), *line
);
823 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
827 error (_("`%s' is not a supported tracepoint action."), *line
);
831 memrange_absolute
= -1
836 int type
; /* memrange_absolute for absolute memory range,
837 else basereg number. */
838 bfd_signed_vma start
;
842 struct collection_list
844 unsigned char regs_mask
[32]; /* room for up to 256 regs */
847 struct memrange
*list
;
848 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
850 struct agent_expr
**aexpr_list
;
852 /* True is the user requested a collection of "$_sdata", "static
856 tracepoint_list
, stepping_list
;
858 /* MEMRANGE functions: */
860 static int memrange_cmp (const void *, const void *);
862 /* Compare memranges for qsort. */
864 memrange_cmp (const void *va
, const void *vb
)
866 const struct memrange
*a
= va
, *b
= vb
;
868 if (a
->type
< b
->type
)
870 if (a
->type
> b
->type
)
872 if (a
->type
== memrange_absolute
)
874 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
876 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
881 if (a
->start
< b
->start
)
883 if (a
->start
> b
->start
)
889 /* Sort the memrange list using qsort, and merge adjacent memranges. */
891 memrange_sortmerge (struct collection_list
*memranges
)
895 qsort (memranges
->list
, memranges
->next_memrange
,
896 sizeof (struct memrange
), memrange_cmp
);
897 if (memranges
->next_memrange
> 0)
899 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
901 /* If memrange b overlaps or is adjacent to memrange a,
903 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
904 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
906 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
907 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
908 continue; /* next b, same a */
912 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
913 sizeof (struct memrange
));
915 memranges
->next_memrange
= a
+ 1;
919 /* Add a register to a collection list. */
921 add_register (struct collection_list
*collection
, unsigned int regno
)
924 printf_filtered ("collect register %d\n", regno
);
925 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
926 error (_("Internal: register number %d too large for tracepoint"),
928 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
931 /* Add a memrange to a collection list. */
933 add_memrange (struct collection_list
*memranges
,
934 int type
, bfd_signed_vma base
,
939 printf_filtered ("(%d,", type
);
941 printf_filtered (",%ld)\n", len
);
944 /* type: memrange_absolute == memory, other n == basereg */
945 memranges
->list
[memranges
->next_memrange
].type
= type
;
946 /* base: addr if memory, offset if reg relative. */
947 memranges
->list
[memranges
->next_memrange
].start
= base
;
948 /* len: we actually save end (base + len) for convenience */
949 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
950 memranges
->next_memrange
++;
951 if (memranges
->next_memrange
>= memranges
->listsize
)
953 memranges
->listsize
*= 2;
954 memranges
->list
= xrealloc (memranges
->list
,
955 memranges
->listsize
);
958 if (type
!= memrange_absolute
) /* Better collect the base register! */
959 add_register (memranges
, type
);
962 /* Add a symbol to a collection list. */
964 collect_symbol (struct collection_list
*collect
,
966 struct gdbarch
*gdbarch
,
967 long frame_regno
, long frame_offset
,
972 bfd_signed_vma offset
;
973 int treat_as_expr
= 0;
975 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
976 switch (SYMBOL_CLASS (sym
))
979 printf_filtered ("%s: don't know symbol class %d\n",
980 SYMBOL_PRINT_NAME (sym
),
984 printf_filtered ("constant %s (value %s) will not be collected.\n",
985 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
988 offset
= SYMBOL_VALUE_ADDRESS (sym
);
993 sprintf_vma (tmp
, offset
);
994 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
995 SYMBOL_PRINT_NAME (sym
), len
,
998 /* A struct may be a C++ class with static fields, go to general
999 expression handling. */
1000 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
1003 add_memrange (collect
, memrange_absolute
, offset
, len
);
1006 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1008 printf_filtered ("LOC_REG[parm] %s: ",
1009 SYMBOL_PRINT_NAME (sym
));
1010 add_register (collect
, reg
);
1011 /* Check for doubles stored in two registers. */
1012 /* FIXME: how about larger types stored in 3 or more regs? */
1013 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1014 len
> register_size (gdbarch
, reg
))
1015 add_register (collect
, reg
+ 1);
1018 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1019 printf_filtered (" (will not collect %s)\n",
1020 SYMBOL_PRINT_NAME (sym
));
1024 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1027 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1028 SYMBOL_PRINT_NAME (sym
), len
);
1029 printf_vma (offset
);
1030 printf_filtered (" from frame ptr reg %d\n", reg
);
1032 add_memrange (collect
, reg
, offset
, len
);
1034 case LOC_REGPARM_ADDR
:
1035 reg
= SYMBOL_VALUE (sym
);
1039 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1040 SYMBOL_PRINT_NAME (sym
), len
);
1041 printf_vma (offset
);
1042 printf_filtered (" from reg %d\n", reg
);
1044 add_memrange (collect
, reg
, offset
, len
);
1048 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1051 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1052 SYMBOL_PRINT_NAME (sym
), len
);
1053 printf_vma (offset
);
1054 printf_filtered (" from frame ptr reg %d\n", reg
);
1056 add_memrange (collect
, reg
, offset
, len
);
1059 case LOC_UNRESOLVED
:
1063 case LOC_OPTIMIZED_OUT
:
1064 printf_filtered ("%s has been optimized out of existence.\n",
1065 SYMBOL_PRINT_NAME (sym
));
1073 /* Expressions are the most general case. */
1076 struct agent_expr
*aexpr
;
1077 struct cleanup
*old_chain1
= NULL
;
1079 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
1081 /* It can happen that the symbol is recorded as a computed
1082 location, but it's been optimized away and doesn't actually
1083 have a location expression. */
1086 printf_filtered ("%s has been optimized out of existence.\n",
1087 SYMBOL_PRINT_NAME (sym
));
1091 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1095 report_agent_reqs_errors (aexpr
);
1097 discard_cleanups (old_chain1
);
1098 add_aexpr (collect
, aexpr
);
1100 /* Take care of the registers. */
1101 if (aexpr
->reg_mask_len
> 0)
1105 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1107 QUIT
; /* Allow user to bail out with ^C. */
1108 if (aexpr
->reg_mask
[ndx1
] != 0)
1110 /* Assume chars have 8 bits. */
1111 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1112 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1113 /* It's used -- record it. */
1114 add_register (collect
, ndx1
* 8 + ndx2
);
1121 /* Data to be passed around in the calls to the locals and args
1124 struct add_local_symbols_data
1126 struct collection_list
*collect
;
1127 struct gdbarch
*gdbarch
;
1134 /* The callback for the locals and args iterators. */
1137 do_collect_symbol (const char *print_name
,
1141 struct add_local_symbols_data
*p
= cb_data
;
1143 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1144 p
->frame_offset
, p
->pc
);
1148 /* Add all locals (or args) symbols to collection list. */
1150 add_local_symbols (struct collection_list
*collect
,
1151 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1152 long frame_regno
, long frame_offset
, int type
)
1154 struct block
*block
;
1155 struct add_local_symbols_data cb_data
;
1157 cb_data
.collect
= collect
;
1158 cb_data
.gdbarch
= gdbarch
;
1160 cb_data
.frame_regno
= frame_regno
;
1161 cb_data
.frame_offset
= frame_offset
;
1166 block
= block_for_pc (pc
);
1169 warning (_("Can't collect locals; "
1170 "no symbol table info available.\n"));
1174 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1175 if (cb_data
.count
== 0)
1176 warning (_("No locals found in scope."));
1180 pc
= get_pc_function_start (pc
);
1181 block
= block_for_pc (pc
);
1184 warning (_("Can't collect args; no symbol table info available."));
1188 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1189 if (cb_data
.count
== 0)
1190 warning (_("No args found in scope."));
1195 add_static_trace_data (struct collection_list
*collection
)
1198 printf_filtered ("collect static trace data\n");
1199 collection
->strace_data
= 1;
1202 /* worker function */
1204 clear_collection_list (struct collection_list
*list
)
1208 list
->next_memrange
= 0;
1209 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1211 free_agent_expr (list
->aexpr_list
[ndx
]);
1212 list
->aexpr_list
[ndx
] = NULL
;
1214 list
->next_aexpr_elt
= 0;
1215 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1216 list
->strace_data
= 0;
1219 /* Reduce a collection list to string form (for gdb protocol). */
1221 stringify_collection_list (struct collection_list
*list
, char *string
)
1223 char temp_buf
[2048];
1227 char *(*str_list
)[];
1231 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1232 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1234 if (list
->strace_data
)
1237 printf_filtered ("\nCollecting static trace data\n");
1240 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1244 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1245 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1247 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1250 printf_filtered ("\nCollecting registers (mask): 0x");
1255 QUIT
; /* Allow user to bail out with ^C. */
1257 printf_filtered ("%02X", list
->regs_mask
[i
]);
1258 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1261 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1265 printf_filtered ("\n");
1266 if (list
->next_memrange
> 0 && info_verbose
)
1267 printf_filtered ("Collecting memranges: \n");
1268 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1270 QUIT
; /* Allow user to bail out with ^C. */
1271 sprintf_vma (tmp2
, list
->list
[i
].start
);
1274 printf_filtered ("(%d, %s, %ld)\n",
1277 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1279 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1281 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1288 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1290 /* The "%X" conversion specifier expects an unsigned argument,
1291 so passing -1 (memrange_absolute) to it directly gives you
1292 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1294 if (list
->list
[i
].type
== memrange_absolute
)
1295 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1297 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1300 count
+= strlen (end
);
1301 end
= temp_buf
+ count
;
1304 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1306 QUIT
; /* Allow user to bail out with ^C. */
1307 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1309 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1314 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1315 end
+= 10; /* 'X' + 8 hex digits + ',' */
1318 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1319 end
, list
->aexpr_list
[i
]->len
);
1320 count
+= 2 * list
->aexpr_list
[i
]->len
;
1325 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1330 (*str_list
)[ndx
] = NULL
;
1343 encode_actions_1 (struct command_line
*action
,
1344 struct breakpoint
*t
,
1345 struct bp_location
*tloc
,
1347 LONGEST frame_offset
,
1348 struct collection_list
*collect
,
1349 struct collection_list
*stepping_list
)
1352 struct expression
*exp
= NULL
;
1354 struct value
*tempval
;
1355 struct cmd_list_element
*cmd
;
1356 struct agent_expr
*aexpr
;
1358 for (; action
; action
= action
->next
)
1360 QUIT
; /* Allow user to bail out with ^C. */
1361 action_exp
= action
->line
;
1362 while (isspace ((int) *action_exp
))
1365 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1367 error (_("Bad action list item: %s"), action_exp
);
1369 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1371 trace_string_kludge
= 0;
1372 if (*action_exp
== '/')
1373 action_exp
= decode_agent_options (action_exp
);
1376 { /* Repeat over a comma-separated list. */
1377 QUIT
; /* Allow user to bail out with ^C. */
1378 while (isspace ((int) *action_exp
))
1381 if (0 == strncasecmp ("$reg", action_exp
, 4))
1383 for (i
= 0; i
< gdbarch_num_regs (tloc
->gdbarch
); i
++)
1384 add_register (collect
, i
);
1385 action_exp
= strchr (action_exp
, ','); /* more? */
1387 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1389 add_local_symbols (collect
,
1395 action_exp
= strchr (action_exp
, ','); /* more? */
1397 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1399 add_local_symbols (collect
,
1405 action_exp
= strchr (action_exp
, ','); /* more? */
1407 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1409 struct cleanup
*old_chain1
= NULL
;
1411 aexpr
= gen_trace_for_return_address (tloc
->address
,
1414 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1417 report_agent_reqs_errors (aexpr
);
1419 discard_cleanups (old_chain1
);
1420 add_aexpr (collect
, aexpr
);
1422 /* take care of the registers */
1423 if (aexpr
->reg_mask_len
> 0)
1427 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1429 QUIT
; /* allow user to bail out with ^C */
1430 if (aexpr
->reg_mask
[ndx1
] != 0)
1432 /* assume chars have 8 bits */
1433 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1434 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1435 /* it's used -- record it */
1436 add_register (collect
,
1442 action_exp
= strchr (action_exp
, ','); /* more? */
1444 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1446 add_static_trace_data (collect
);
1447 action_exp
= strchr (action_exp
, ','); /* more? */
1451 unsigned long addr
, len
;
1452 struct cleanup
*old_chain
= NULL
;
1453 struct cleanup
*old_chain1
= NULL
;
1455 exp
= parse_exp_1 (&action_exp
,
1456 block_for_pc (tloc
->address
), 1);
1457 old_chain
= make_cleanup (free_current_contents
, &exp
);
1459 switch (exp
->elts
[0].opcode
)
1463 const char *name
= &exp
->elts
[2].string
;
1465 i
= user_reg_map_name_to_regnum (tloc
->gdbarch
,
1466 name
, strlen (name
));
1468 internal_error (__FILE__
, __LINE__
,
1469 _("Register $%s not available"),
1472 printf_filtered ("OP_REGISTER: ");
1473 add_register (collect
, i
);
1478 /* Safe because we know it's a simple expression. */
1479 tempval
= evaluate_expression (exp
);
1480 addr
= value_address (tempval
);
1481 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1482 add_memrange (collect
, memrange_absolute
, addr
, len
);
1486 collect_symbol (collect
,
1487 exp
->elts
[2].symbol
,
1494 default: /* Full-fledged expression. */
1495 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1497 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1501 report_agent_reqs_errors (aexpr
);
1503 discard_cleanups (old_chain1
);
1504 add_aexpr (collect
, aexpr
);
1506 /* Take care of the registers. */
1507 if (aexpr
->reg_mask_len
> 0)
1512 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1514 QUIT
; /* Allow user to bail out with ^C. */
1515 if (aexpr
->reg_mask
[ndx1
] != 0)
1517 /* Assume chars have 8 bits. */
1518 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1519 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1520 /* It's used -- record it. */
1521 add_register (collect
,
1528 do_cleanups (old_chain
);
1531 while (action_exp
&& *action_exp
++ == ',');
1533 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1536 { /* Repeat over a comma-separated list. */
1537 QUIT
; /* Allow user to bail out with ^C. */
1538 while (isspace ((int) *action_exp
))
1542 struct cleanup
*old_chain
= NULL
;
1543 struct cleanup
*old_chain1
= NULL
;
1545 exp
= parse_exp_1 (&action_exp
,
1546 block_for_pc (tloc
->address
), 1);
1547 old_chain
= make_cleanup (free_current_contents
, &exp
);
1549 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1550 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1553 report_agent_reqs_errors (aexpr
);
1555 discard_cleanups (old_chain1
);
1556 /* Even though we're not officially collecting, add
1557 to the collect list anyway. */
1558 add_aexpr (collect
, aexpr
);
1560 do_cleanups (old_chain
);
1563 while (action_exp
&& *action_exp
++ == ',');
1565 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1567 /* We check against nested while-stepping when setting
1568 breakpoint action, so no way to run into nested
1570 gdb_assert (stepping_list
);
1572 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
,
1573 frame_offset
, stepping_list
, NULL
);
1576 error (_("Invalid tracepoint command '%s'"), action
->line
);
1580 /* Render all actions into gdb protocol. */
1583 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1584 char ***tdp_actions
, char ***stepping_actions
)
1586 static char tdp_buff
[2048], step_buff
[2048];
1587 char *default_collect_line
= NULL
;
1588 struct command_line
*actions
;
1589 struct command_line
*default_collect_action
= NULL
;
1591 LONGEST frame_offset
;
1592 struct cleanup
*back_to
;
1594 back_to
= make_cleanup (null_cleanup
, NULL
);
1596 clear_collection_list (&tracepoint_list
);
1597 clear_collection_list (&stepping_list
);
1599 *tdp_actions
= NULL
;
1600 *stepping_actions
= NULL
;
1602 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1603 tloc
->address
, &frame_reg
, &frame_offset
);
1605 actions
= breakpoint_commands (t
);
1607 /* If there are default expressions to collect, make up a collect
1608 action and prepend to the action list to encode. Note that since
1609 validation is per-tracepoint (local var "xyz" might be valid for
1610 one tracepoint and not another, etc), we make up the action on
1611 the fly, and don't cache it. */
1612 if (*default_collect
)
1616 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1617 make_cleanup (xfree
, default_collect_line
);
1619 line
= default_collect_line
;
1620 validate_actionline (&line
, t
);
1622 default_collect_action
= xmalloc (sizeof (struct command_line
));
1623 make_cleanup (xfree
, default_collect_action
);
1624 default_collect_action
->next
= actions
;
1625 default_collect_action
->line
= line
;
1626 actions
= default_collect_action
;
1628 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1629 &tracepoint_list
, &stepping_list
);
1631 memrange_sortmerge (&tracepoint_list
);
1632 memrange_sortmerge (&stepping_list
);
1634 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1636 *stepping_actions
= stringify_collection_list (&stepping_list
,
1639 do_cleanups (back_to
);
1643 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1645 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1647 collect
->aexpr_list
=
1648 xrealloc (collect
->aexpr_list
,
1649 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1650 collect
->aexpr_listsize
*= 2;
1652 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1653 collect
->next_aexpr_elt
++;
1657 process_tracepoint_on_disconnect (void)
1659 VEC(breakpoint_p
) *tp_vec
= NULL
;
1661 struct breakpoint
*b
;
1662 int has_pending_p
= 0;
1664 /* Check whether we still have pending tracepoint. If we have, warn the
1665 user that pending tracepoint will no longer work. */
1666 tp_vec
= all_tracepoints ();
1667 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1676 struct bp_location
*loc1
;
1678 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1680 if (loc1
->shlib_disabled
)
1691 VEC_free (breakpoint_p
, tp_vec
);
1694 warning (_("Pending tracepoints will not be resolved while"
1695 " GDB is disconnected\n"));
1700 start_tracing (char *notes
)
1702 VEC(breakpoint_p
) *tp_vec
= NULL
;
1704 struct breakpoint
*b
;
1705 struct trace_state_variable
*tsv
;
1706 int any_enabled
= 0, num_to_download
= 0;
1709 tp_vec
= all_tracepoints ();
1711 /* No point in tracing without any tracepoints... */
1712 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1714 VEC_free (breakpoint_p
, tp_vec
);
1715 error (_("No tracepoints defined, not starting trace"));
1718 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1720 struct tracepoint
*t
= (struct tracepoint
*) b
;
1721 struct bp_location
*loc
;
1723 if (b
->enable_state
== bp_enabled
)
1726 if ((b
->type
== bp_fast_tracepoint
1727 ? may_insert_fast_tracepoints
1728 : may_insert_tracepoints
))
1731 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1732 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1737 if (target_supports_enable_disable_tracepoint ())
1738 warning (_("No tracepoints enabled"));
1741 /* No point in tracing with only disabled tracepoints that
1742 cannot be re-enabled. */
1743 VEC_free (breakpoint_p
, tp_vec
);
1744 error (_("No tracepoints enabled, not starting trace"));
1748 if (num_to_download
<= 0)
1750 VEC_free (breakpoint_p
, tp_vec
);
1751 error (_("No tracepoints that may be downloaded, not starting trace"));
1754 target_trace_init ();
1756 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1758 struct tracepoint
*t
= (struct tracepoint
*) b
;
1759 struct bp_location
*loc
;
1761 /* Clear `inserted' flag. */
1762 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1765 if ((b
->type
== bp_fast_tracepoint
1766 ? !may_insert_fast_tracepoints
1767 : !may_insert_tracepoints
))
1770 t
->number_on_target
= 0;
1772 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1774 /* Since tracepoint locations are never duplicated, `inserted'
1775 flag should be zero. */
1776 gdb_assert (!loc
->inserted
);
1778 target_download_tracepoint (loc
);
1783 t
->number_on_target
= b
->number
;
1785 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1786 loc
->probe
->pops
->set_semaphore (loc
->probe
, loc
->gdbarch
);
1788 VEC_free (breakpoint_p
, tp_vec
);
1790 /* Send down all the trace state variables too. */
1791 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1793 target_download_trace_state_variable (tsv
);
1796 /* Tell target to treat text-like sections as transparent. */
1797 target_trace_set_readonly_regions ();
1798 /* Set some mode flags. */
1799 target_set_disconnected_tracing (disconnected_tracing
);
1800 target_set_circular_trace_buffer (circular_trace_buffer
);
1803 notes
= trace_notes
;
1804 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1806 if (!ret
&& (trace_user
|| notes
))
1807 warning ("Target does not support trace user/notes, info ignored");
1809 /* Now insert traps and begin collecting data. */
1810 target_trace_start ();
1812 /* Reset our local state. */
1813 set_traceframe_num (-1);
1814 set_tracepoint_num (-1);
1815 set_traceframe_context (NULL
);
1816 current_trace_status()->running
= 1;
1817 clear_traceframe_info ();
1820 /* The tstart command requests the target to start a new trace run.
1821 The command passes any arguments it has to the target verbatim, as
1822 an optional "trace note". This is useful as for instance a warning
1823 to other users if the trace runs disconnected, and you don't want
1824 anybody else messing with the target. */
1827 trace_start_command (char *args
, int from_tty
)
1829 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1831 if (current_trace_status ()->running
)
1834 && !query (_("A trace is running already. Start a new run? ")))
1835 error (_("New trace run not started."));
1838 start_tracing (args
);
1841 /* The tstop command stops the tracing run. The command passes any
1842 supplied arguments to the target verbatim as a "stop note"; if the
1843 target supports trace notes, then it will be reported back as part
1844 of the trace run's status. */
1847 trace_stop_command (char *args
, int from_tty
)
1849 if (!current_trace_status ()->running
)
1850 error (_("Trace is not running."));
1852 stop_tracing (args
);
1856 stop_tracing (char *note
)
1859 VEC(breakpoint_p
) *tp_vec
= NULL
;
1861 struct breakpoint
*t
;
1863 target_trace_stop ();
1865 tp_vec
= all_tracepoints ();
1866 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1868 struct bp_location
*loc
;
1870 if ((t
->type
== bp_fast_tracepoint
1871 ? !may_insert_fast_tracepoints
1872 : !may_insert_tracepoints
))
1875 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1877 /* GDB can be totally absent in some disconnected trace scenarios,
1878 but we don't really care if this semaphore goes out of sync.
1879 That's why we are decrementing it here, but not taking care
1881 loc
->probe
->pops
->clear_semaphore (loc
->probe
, loc
->gdbarch
);
1885 VEC_free (breakpoint_p
, tp_vec
);
1888 note
= trace_stop_notes
;
1889 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1892 warning ("Target does not support trace notes, note ignored");
1894 /* Should change in response to reply? */
1895 current_trace_status ()->running
= 0;
1898 /* tstatus command */
1900 trace_status_command (char *args
, int from_tty
)
1902 struct trace_status
*ts
= current_trace_status ();
1904 VEC(breakpoint_p
) *tp_vec
= NULL
;
1905 struct breakpoint
*t
;
1907 status
= target_get_trace_status (ts
);
1912 printf_filtered (_("Using a trace file.\n"));
1915 printf_filtered (_("Trace can not be run on this target.\n"));
1920 if (!ts
->running_known
)
1922 printf_filtered (_("Run/stop status is unknown.\n"));
1924 else if (ts
->running
)
1926 printf_filtered (_("Trace is running on the target.\n"));
1930 switch (ts
->stop_reason
)
1932 case trace_never_run
:
1933 printf_filtered (_("No trace has been run on the target.\n"));
1937 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1940 printf_filtered (_("Trace stopped by a tstop command.\n"));
1942 case trace_buffer_full
:
1943 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1945 case trace_disconnected
:
1946 printf_filtered (_("Trace stopped because of disconnection.\n"));
1948 case tracepoint_passcount
:
1949 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1950 ts
->stopping_tracepoint
);
1952 case tracepoint_error
:
1953 if (ts
->stopping_tracepoint
)
1954 printf_filtered (_("Trace stopped by an "
1955 "error (%s, tracepoint %d).\n"),
1956 ts
->stop_desc
, ts
->stopping_tracepoint
);
1958 printf_filtered (_("Trace stopped by an error (%s).\n"),
1961 case trace_stop_reason_unknown
:
1962 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1965 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1971 if (ts
->traceframes_created
>= 0
1972 && ts
->traceframe_count
!= ts
->traceframes_created
)
1974 printf_filtered (_("Buffer contains %d trace "
1975 "frames (of %d created total).\n"),
1976 ts
->traceframe_count
, ts
->traceframes_created
);
1978 else if (ts
->traceframe_count
>= 0)
1980 printf_filtered (_("Collected %d trace frames.\n"),
1981 ts
->traceframe_count
);
1984 if (ts
->buffer_free
>= 0)
1986 if (ts
->buffer_size
>= 0)
1988 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1989 ts
->buffer_free
, ts
->buffer_size
);
1990 if (ts
->buffer_size
> 0)
1991 printf_filtered (_(" (%d%% full)"),
1992 ((int) ((((long long) (ts
->buffer_size
1993 - ts
->buffer_free
)) * 100)
1994 / ts
->buffer_size
)));
1995 printf_filtered (_(".\n"));
1998 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2002 if (ts
->disconnected_tracing
)
2003 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2005 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2007 if (ts
->circular_buffer
)
2008 printf_filtered (_("Trace buffer is circular.\n"));
2010 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
2011 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
2013 if (ts
->notes
&& strlen (ts
->notes
) > 0)
2014 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
2016 /* Now report on what we're doing with tfind. */
2017 if (traceframe_number
>= 0)
2018 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2019 traceframe_number
, tracepoint_number
);
2021 printf_filtered (_("Not looking at any trace frame.\n"));
2023 /* Report start/stop times if supplied. */
2028 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
2030 /* Reporting a run time is more readable than two long numbers. */
2031 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2032 (long int) ts
->start_time
/ 1000000,
2033 (long int) ts
->start_time
% 1000000,
2034 (long int) run_time
/ 1000000,
2035 (long int) run_time
% 1000000);
2038 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2039 (long int) ts
->start_time
/ 1000000,
2040 (long int) ts
->start_time
% 1000000);
2042 else if (ts
->stop_time
)
2043 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2044 (long int) ts
->stop_time
/ 1000000,
2045 (long int) ts
->stop_time
% 1000000);
2047 /* Now report any per-tracepoint status available. */
2048 tp_vec
= all_tracepoints ();
2050 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2051 target_get_tracepoint_status (t
, NULL
);
2053 VEC_free (breakpoint_p
, tp_vec
);
2056 /* Report the trace status to uiout, in a way suitable for MI, and not
2057 suitable for CLI. If ON_STOP is true, suppress a few fields that
2058 are not meaningful in the -trace-stop response.
2060 The implementation is essentially parallel to trace_status_command, but
2061 merging them will result in unreadable code. */
2063 trace_status_mi (int on_stop
)
2065 struct ui_out
*uiout
= current_uiout
;
2066 struct trace_status
*ts
= current_trace_status ();
2069 status
= target_get_trace_status (ts
);
2071 if (status
== -1 && !ts
->from_file
)
2073 ui_out_field_string (uiout
, "supported", "0");
2078 ui_out_field_string (uiout
, "supported", "file");
2080 ui_out_field_string (uiout
, "supported", "1");
2082 gdb_assert (ts
->running_known
);
2086 ui_out_field_string (uiout
, "running", "1");
2088 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2089 Given that the frontend gets the status either on -trace-stop, or from
2090 -trace-status after re-connection, it does not seem like this
2091 information is necessary for anything. It is not necessary for either
2092 figuring the vital state of the target nor for navigation of trace
2093 frames. If the frontend wants to show the current state is some
2094 configure dialog, it can request the value when such dialog is
2095 invoked by the user. */
2099 char *stop_reason
= NULL
;
2100 int stopping_tracepoint
= -1;
2103 ui_out_field_string (uiout
, "running", "0");
2105 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2107 switch (ts
->stop_reason
)
2110 stop_reason
= "request";
2112 case trace_buffer_full
:
2113 stop_reason
= "overflow";
2115 case trace_disconnected
:
2116 stop_reason
= "disconnection";
2118 case tracepoint_passcount
:
2119 stop_reason
= "passcount";
2120 stopping_tracepoint
= ts
->stopping_tracepoint
;
2122 case tracepoint_error
:
2123 stop_reason
= "error";
2124 stopping_tracepoint
= ts
->stopping_tracepoint
;
2130 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2131 if (stopping_tracepoint
!= -1)
2132 ui_out_field_int (uiout
, "stopping-tracepoint",
2133 stopping_tracepoint
);
2134 if (ts
->stop_reason
== tracepoint_error
)
2135 ui_out_field_string (uiout
, "error-description",
2141 if (ts
->traceframe_count
!= -1)
2142 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2143 if (ts
->traceframes_created
!= -1)
2144 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2145 if (ts
->buffer_size
!= -1)
2146 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2147 if (ts
->buffer_free
!= -1)
2148 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2150 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2151 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2153 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2154 ui_out_field_string (uiout
, "notes", ts
->notes
);
2159 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2160 (long int) ts
->start_time
/ 1000000,
2161 (long int) ts
->start_time
% 1000000);
2162 ui_out_field_string (uiout
, "start-time", buf
);
2163 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2164 (long int) ts
->stop_time
/ 1000000,
2165 (long int) ts
->stop_time
% 1000000);
2166 ui_out_field_string (uiout
, "stop-time", buf
);
2170 /* This function handles the details of what to do about an ongoing
2171 tracing run if the user has asked to detach or otherwise disconnect
2174 disconnect_tracing (int from_tty
)
2176 /* It can happen that the target that was tracing went away on its
2177 own, and we didn't notice. Get a status update, and if the
2178 current target doesn't even do tracing, then assume it's not
2180 if (target_get_trace_status (current_trace_status ()) < 0)
2181 current_trace_status ()->running
= 0;
2183 /* If running interactively, give the user the option to cancel and
2184 then decide what to do differently with the run. Scripts are
2185 just going to disconnect and let the target deal with it,
2186 according to how it's been instructed previously via
2187 disconnected-tracing. */
2188 if (current_trace_status ()->running
&& from_tty
)
2190 process_tracepoint_on_disconnect ();
2192 if (current_trace_status ()->disconnected_tracing
)
2194 if (!query (_("Trace is running and will "
2195 "continue after detach; detach anyway? ")))
2196 error (_("Not confirmed."));
2200 if (!query (_("Trace is running but will "
2201 "stop on detach; detach anyway? ")))
2202 error (_("Not confirmed."));
2206 /* Also we want to be out of tfind mode, otherwise things can get
2207 confusing upon reconnection. Just use these calls instead of
2208 full tfind_1 behavior because we're in the middle of detaching,
2209 and there's no point to updating current stack frame etc. */
2210 set_current_traceframe (-1);
2211 set_traceframe_context (NULL
);
2214 /* Worker function for the various flavors of the tfind command. */
2216 tfind_1 (enum trace_find_type type
, int num
,
2217 ULONGEST addr1
, ULONGEST addr2
,
2220 int target_frameno
= -1, target_tracept
= -1;
2221 struct frame_id old_frame_id
= null_frame_id
;
2222 struct tracepoint
*tp
;
2223 struct ui_out
*uiout
= current_uiout
;
2225 /* Only try to get the current stack frame if we have a chance of
2226 succeeding. In particular, if we're trying to get a first trace
2227 frame while all threads are running, it's not going to succeed,
2228 so leave it with a default value and let the frame comparison
2229 below (correctly) decide to print out the source location of the
2231 if (!(type
== tfind_number
&& num
== -1)
2232 && (has_stack_frames () || traceframe_number
>= 0))
2233 old_frame_id
= get_frame_id (get_current_frame ());
2235 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2238 if (type
== tfind_number
2240 && target_frameno
== -1)
2242 /* We told the target to get out of tfind mode, and it did. */
2244 else if (target_frameno
== -1)
2246 /* A request for a non-existent trace frame has failed.
2247 Our response will be different, depending on FROM_TTY:
2249 If FROM_TTY is true, meaning that this command was
2250 typed interactively by the user, then give an error
2251 and DO NOT change the state of traceframe_number etc.
2253 However if FROM_TTY is false, meaning that we're either
2254 in a script, a loop, or a user-defined command, then
2255 DON'T give an error, but DO change the state of
2256 traceframe_number etc. to invalid.
2258 The rationalle is that if you typed the command, you
2259 might just have committed a typo or something, and you'd
2260 like to NOT lose your current debugging state. However
2261 if you're in a user-defined command or especially in a
2262 loop, then you need a way to detect that the command
2263 failed WITHOUT aborting. This allows you to write
2264 scripts that search thru the trace buffer until the end,
2265 and then continue on to do something else. */
2268 error (_("Target failed to find requested trace frame."));
2272 printf_filtered ("End of trace buffer.\n");
2273 #if 0 /* dubious now? */
2274 /* The following will not recurse, since it's
2276 trace_find_command ("-1", from_tty
);
2281 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2283 reinit_frame_cache ();
2284 registers_changed ();
2285 target_dcache_invalidate ();
2286 set_traceframe_num (target_frameno
);
2287 clear_traceframe_info ();
2288 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2289 if (target_frameno
== -1)
2290 set_traceframe_context (NULL
);
2292 set_traceframe_context (get_current_frame ());
2294 if (traceframe_number
>= 0)
2296 /* Use different branches for MI and CLI to make CLI messages
2298 if (ui_out_is_mi_like_p (uiout
))
2300 ui_out_field_string (uiout
, "found", "1");
2301 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2302 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2306 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2307 traceframe_number
, tracepoint_number
);
2312 if (ui_out_is_mi_like_p (uiout
))
2313 ui_out_field_string (uiout
, "found", "0");
2314 else if (type
== tfind_number
&& num
== -1)
2315 printf_unfiltered (_("No longer looking at any trace frame\n"));
2316 else /* This case may never occur, check. */
2317 printf_unfiltered (_("No trace frame found\n"));
2320 /* If we're in nonstop mode and getting out of looking at trace
2321 frames, there won't be any current frame to go back to and
2324 && (has_stack_frames () || traceframe_number
>= 0))
2326 enum print_what print_what
;
2328 /* NOTE: in imitation of the step command, try to determine
2329 whether we have made a transition from one function to
2330 another. If so, we'll print the "stack frame" (ie. the new
2331 function and it's arguments) -- otherwise we'll just show the
2334 if (frame_id_eq (old_frame_id
,
2335 get_frame_id (get_current_frame ())))
2336 print_what
= SRC_LINE
;
2338 print_what
= SRC_AND_LOC
;
2340 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2345 /* trace_find_command takes a trace frame number n,
2346 sends "QTFrame:<n>" to the target,
2347 and accepts a reply that may contain several optional pieces
2348 of information: a frame number, a tracepoint number, and an
2349 indication of whether this is a trap frame or a stepping frame.
2351 The minimal response is just "OK" (which indicates that the
2352 target does not give us a frame number or a tracepoint number).
2353 Instead of that, the target may send us a string containing
2355 F<hexnum> (gives the selected frame number)
2356 T<hexnum> (gives the selected tracepoint number)
2361 trace_find_command (char *args
, int from_tty
)
2362 { /* This should only be called with a numeric argument. */
2365 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2366 error (_("May not look at trace frames while trace is running."));
2368 if (args
== 0 || *args
== 0)
2369 { /* TFIND with no args means find NEXT trace frame. */
2370 if (traceframe_number
== -1)
2371 frameno
= 0; /* "next" is first one. */
2373 frameno
= traceframe_number
+ 1;
2375 else if (0 == strcmp (args
, "-"))
2377 if (traceframe_number
== -1)
2378 error (_("not debugging trace buffer"));
2379 else if (from_tty
&& traceframe_number
== 0)
2380 error (_("already at start of trace buffer"));
2382 frameno
= traceframe_number
- 1;
2384 /* A hack to work around eval's need for fp to have been collected. */
2385 else if (0 == strcmp (args
, "-1"))
2388 frameno
= parse_and_eval_long (args
);
2391 error (_("invalid input (%d is less than zero)"), frameno
);
2393 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2398 trace_find_end_command (char *args
, int from_tty
)
2400 trace_find_command ("-1", from_tty
);
2405 trace_find_none_command (char *args
, int from_tty
)
2407 trace_find_command ("-1", from_tty
);
2412 trace_find_start_command (char *args
, int from_tty
)
2414 trace_find_command ("0", from_tty
);
2417 /* tfind pc command */
2419 trace_find_pc_command (char *args
, int from_tty
)
2423 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2424 error (_("May not look at trace frames while trace is running."));
2426 if (args
== 0 || *args
== 0)
2427 pc
= regcache_read_pc (get_current_regcache ());
2429 pc
= parse_and_eval_address (args
);
2431 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2434 /* tfind tracepoint command */
2436 trace_find_tracepoint_command (char *args
, int from_tty
)
2439 struct tracepoint
*tp
;
2441 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2442 error (_("May not look at trace frames while trace is running."));
2444 if (args
== 0 || *args
== 0)
2446 if (tracepoint_number
== -1)
2447 error (_("No current tracepoint -- please supply an argument."));
2449 tdp
= tracepoint_number
; /* Default is current TDP. */
2452 tdp
= parse_and_eval_long (args
);
2454 /* If we have the tracepoint on hand, use the number that the
2455 target knows about (which may be different if we disconnected
2456 and reconnected). */
2457 tp
= get_tracepoint (tdp
);
2459 tdp
= tp
->number_on_target
;
2461 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2464 /* TFIND LINE command:
2466 This command will take a sourceline for argument, just like BREAK
2467 or TRACE (ie. anything that "decode_line_1" can handle).
2469 With no argument, this command will find the next trace frame
2470 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2473 trace_find_line_command (char *args
, int from_tty
)
2475 static CORE_ADDR start_pc
, end_pc
;
2476 struct symtabs_and_lines sals
;
2477 struct symtab_and_line sal
;
2478 struct cleanup
*old_chain
;
2480 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2481 error (_("May not look at trace frames while trace is running."));
2483 if (args
== 0 || *args
== 0)
2485 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2487 sals
.sals
= (struct symtab_and_line
*)
2488 xmalloc (sizeof (struct symtab_and_line
));
2493 sals
= decode_line_spec (args
, DECODE_LINE_FUNFIRSTLINE
);
2497 old_chain
= make_cleanup (xfree
, sals
.sals
);
2498 if (sal
.symtab
== 0)
2499 error (_("No line number information available."));
2501 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2503 if (start_pc
== end_pc
)
2505 printf_filtered ("Line %d of \"%s\"",
2506 sal
.line
, sal
.symtab
->filename
);
2508 printf_filtered (" is at address ");
2509 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2511 printf_filtered (" but contains no code.\n");
2512 sal
= find_pc_line (start_pc
, 0);
2514 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2515 && start_pc
!= end_pc
)
2516 printf_filtered ("Attempting to find line %d instead.\n",
2519 error (_("Cannot find a good line."));
2523 /* Is there any case in which we get here, and have an address
2524 which the user would want to see? If we have debugging
2525 symbols and no line numbers? */
2526 error (_("Line number %d is out of range for \"%s\"."),
2527 sal
.line
, sal
.symtab
->filename
);
2529 /* Find within range of stated line. */
2531 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2533 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2534 do_cleanups (old_chain
);
2537 /* tfind range command */
2539 trace_find_range_command (char *args
, int from_tty
)
2541 static CORE_ADDR start
, stop
;
2544 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2545 error (_("May not look at trace frames while trace is running."));
2547 if (args
== 0 || *args
== 0)
2548 { /* XXX FIXME: what should default behavior be? */
2549 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2553 if (0 != (tmp
= strchr (args
, ',')))
2555 *tmp
++ = '\0'; /* Terminate start address. */
2556 while (isspace ((int) *tmp
))
2558 start
= parse_and_eval_address (args
);
2559 stop
= parse_and_eval_address (tmp
);
2562 { /* No explicit end address? */
2563 start
= parse_and_eval_address (args
);
2564 stop
= start
+ 1; /* ??? */
2567 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2570 /* tfind outside command */
2572 trace_find_outside_command (char *args
, int from_tty
)
2574 CORE_ADDR start
, stop
;
2577 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2578 error (_("May not look at trace frames while trace is running."));
2580 if (args
== 0 || *args
== 0)
2581 { /* XXX FIXME: what should default behavior be? */
2582 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2586 if (0 != (tmp
= strchr (args
, ',')))
2588 *tmp
++ = '\0'; /* Terminate start address. */
2589 while (isspace ((int) *tmp
))
2591 start
= parse_and_eval_address (args
);
2592 stop
= parse_and_eval_address (tmp
);
2595 { /* No explicit end address? */
2596 start
= parse_and_eval_address (args
);
2597 stop
= start
+ 1; /* ??? */
2600 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2603 /* info scope command: list the locals for a scope. */
2605 scope_info (char *args
, int from_tty
)
2607 struct symtabs_and_lines sals
;
2609 struct minimal_symbol
*msym
;
2610 struct block
*block
;
2611 const char *symname
;
2612 char *save_args
= args
;
2613 struct dict_iterator iter
;
2615 struct gdbarch
*gdbarch
;
2618 if (args
== 0 || *args
== 0)
2619 error (_("requires an argument (function, "
2620 "line or *addr) to define a scope"));
2622 sals
= decode_line_1 (&args
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2623 if (sals
.nelts
== 0)
2624 return; /* Presumably decode_line_1 has already warned. */
2626 /* Resolve line numbers to PC. */
2627 resolve_sal_pc (&sals
.sals
[0]);
2628 block
= block_for_pc (sals
.sals
[0].pc
);
2632 QUIT
; /* Allow user to bail out with ^C. */
2633 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2635 QUIT
; /* Allow user to bail out with ^C. */
2637 printf_filtered ("Scope for %s:\n", save_args
);
2640 symname
= SYMBOL_PRINT_NAME (sym
);
2641 if (symname
== NULL
|| *symname
== '\0')
2642 continue; /* Probably botched, certainly useless. */
2644 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2646 printf_filtered ("Symbol %s is ", symname
);
2647 switch (SYMBOL_CLASS (sym
))
2650 case LOC_UNDEF
: /* Messed up symbol? */
2651 printf_filtered ("a bogus symbol, class %d.\n",
2652 SYMBOL_CLASS (sym
));
2653 count
--; /* Don't count this one. */
2656 printf_filtered ("a constant with value %s (%s)",
2657 plongest (SYMBOL_VALUE (sym
)),
2658 hex_string (SYMBOL_VALUE (sym
)));
2660 case LOC_CONST_BYTES
:
2661 printf_filtered ("constant bytes: ");
2662 if (SYMBOL_TYPE (sym
))
2663 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2664 fprintf_filtered (gdb_stdout
, " %02x",
2665 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2668 printf_filtered ("in static storage at address ");
2669 printf_filtered ("%s", paddress (gdbarch
,
2670 SYMBOL_VALUE_ADDRESS (sym
)));
2673 /* GDBARCH is the architecture associated with the objfile
2674 the symbol is defined in; the target architecture may be
2675 different, and may provide additional registers. However,
2676 we do not know the target architecture at this point.
2677 We assume the objfile architecture will contain all the
2678 standard registers that occur in debug info in that
2680 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2683 if (SYMBOL_IS_ARGUMENT (sym
))
2684 printf_filtered ("an argument in register $%s",
2685 gdbarch_register_name (gdbarch
, regno
));
2687 printf_filtered ("a local variable in register $%s",
2688 gdbarch_register_name (gdbarch
, regno
));
2691 printf_filtered ("an argument at stack/frame offset %s",
2692 plongest (SYMBOL_VALUE (sym
)));
2695 printf_filtered ("a local variable at frame offset %s",
2696 plongest (SYMBOL_VALUE (sym
)));
2699 printf_filtered ("a reference argument at offset %s",
2700 plongest (SYMBOL_VALUE (sym
)));
2702 case LOC_REGPARM_ADDR
:
2703 /* Note comment at LOC_REGISTER. */
2704 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2706 printf_filtered ("the address of an argument, in register $%s",
2707 gdbarch_register_name (gdbarch
, regno
));
2710 printf_filtered ("a typedef.\n");
2713 printf_filtered ("a label at address ");
2714 printf_filtered ("%s", paddress (gdbarch
,
2715 SYMBOL_VALUE_ADDRESS (sym
)));
2718 printf_filtered ("a function at address ");
2719 printf_filtered ("%s",
2720 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2722 case LOC_UNRESOLVED
:
2723 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2726 printf_filtered ("Unresolved Static");
2729 printf_filtered ("static storage at address ");
2730 printf_filtered ("%s",
2731 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2734 case LOC_OPTIMIZED_OUT
:
2735 printf_filtered ("optimized out.\n");
2738 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2739 BLOCK_START (block
),
2743 if (SYMBOL_TYPE (sym
))
2744 printf_filtered (", length %d.\n",
2745 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2747 if (BLOCK_FUNCTION (block
))
2750 block
= BLOCK_SUPERBLOCK (block
);
2753 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2757 /* worker function (cleanup) */
2759 replace_comma (void *data
)
2766 /* Helper for trace_dump_command. Dump the action list starting at
2767 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2768 actions of the body of a while-stepping action. STEPPING_FRAME is
2769 set if the current traceframe was determined to be a while-stepping
2773 trace_dump_actions (struct command_line
*action
,
2774 int stepping_actions
, int stepping_frame
,
2777 char *action_exp
, *next_comma
;
2779 for (; action
!= NULL
; action
= action
->next
)
2781 struct cmd_list_element
*cmd
;
2783 QUIT
; /* Allow user to bail out with ^C. */
2784 action_exp
= action
->line
;
2785 while (isspace ((int) *action_exp
))
2788 /* The collection actions to be done while stepping are
2789 bracketed by the commands "while-stepping" and "end". */
2791 if (*action_exp
== '#') /* comment line */
2794 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2796 error (_("Bad action list item: %s"), action_exp
);
2798 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2802 for (i
= 0; i
< action
->body_count
; ++i
)
2803 trace_dump_actions (action
->body_list
[i
],
2804 1, stepping_frame
, from_tty
);
2806 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2808 /* Display the collected data.
2809 For the trap frame, display only what was collected at
2810 the trap. Likewise for stepping frames, display only
2811 what was collected while stepping. This means that the
2812 two boolean variables, STEPPING_FRAME and
2813 STEPPING_ACTIONS should be equal. */
2814 if (stepping_frame
== stepping_actions
)
2816 if (*action_exp
== '/')
2817 action_exp
= decode_agent_options (action_exp
);
2820 { /* Repeat over a comma-separated list. */
2821 QUIT
; /* Allow user to bail out with ^C. */
2822 if (*action_exp
== ',')
2824 while (isspace ((int) *action_exp
))
2827 next_comma
= strchr (action_exp
, ',');
2829 if (0 == strncasecmp (action_exp
, "$reg", 4))
2830 registers_info (NULL
, from_tty
);
2831 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2833 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2834 locals_info (NULL
, from_tty
);
2835 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2836 args_info (NULL
, from_tty
);
2841 make_cleanup (replace_comma
, next_comma
);
2844 printf_filtered ("%s = ", action_exp
);
2845 output_command (action_exp
, from_tty
);
2846 printf_filtered ("\n");
2850 action_exp
= next_comma
;
2852 while (action_exp
&& *action_exp
== ',');
2858 /* The tdump command. */
2861 trace_dump_command (char *args
, int from_tty
)
2863 struct regcache
*regcache
;
2864 struct tracepoint
*t
;
2865 int stepping_frame
= 0;
2866 struct bp_location
*loc
;
2867 char *line
, *default_collect_line
= NULL
;
2868 struct command_line
*actions
, *default_collect_action
= NULL
;
2869 struct cleanup
*old_chain
= NULL
;
2871 if (tracepoint_number
== -1)
2873 warning (_("No current trace frame."));
2877 t
= get_tracepoint (tracepoint_number
);
2880 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2883 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2884 tracepoint_number
, traceframe_number
);
2886 /* The current frame is a trap frame if the frame PC is equal
2887 to the tracepoint PC. If not, then the current frame was
2888 collected during single-stepping. */
2890 regcache
= get_current_regcache ();
2892 /* If the traceframe's address matches any of the tracepoint's
2893 locations, assume it is a direct hit rather than a while-stepping
2894 frame. (FIXME this is not reliable, should record each frame's
2897 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
2898 if (loc
->address
== regcache_read_pc (regcache
))
2901 actions
= breakpoint_commands (&t
->base
);
2903 /* If there is a default-collect list, make up a collect command,
2904 prepend to the tracepoint's commands, and pass the whole mess to
2905 the trace dump scanner. We need to validate because
2906 default-collect might have been junked since the trace run. */
2907 if (*default_collect
)
2909 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2910 old_chain
= make_cleanup (xfree
, default_collect_line
);
2911 line
= default_collect_line
;
2912 validate_actionline (&line
, &t
->base
);
2913 default_collect_action
= xmalloc (sizeof (struct command_line
));
2914 make_cleanup (xfree
, default_collect_action
);
2915 default_collect_action
->next
= actions
;
2916 default_collect_action
->line
= line
;
2917 actions
= default_collect_action
;
2920 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2922 if (*default_collect
)
2923 do_cleanups (old_chain
);
2926 /* Encode a piece of a tracepoint's source-level definition in a form
2927 that is suitable for both protocol and saving in files. */
2928 /* This version does not do multiple encodes for long strings; it should
2929 return an offset to the next piece to encode. FIXME */
2932 encode_source_string (int tpnum
, ULONGEST addr
,
2933 char *srctype
, char *src
, char *buf
, int buf_size
)
2935 if (80 + strlen (srctype
) > buf_size
)
2936 error (_("Buffer too small for source encoding"));
2937 sprintf (buf
, "%x:%s:%s:%x:%x:",
2938 tpnum
, phex_nz (addr
, sizeof (addr
)),
2939 srctype
, 0, (int) strlen (src
));
2940 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2941 error (_("Source string too long for buffer"));
2942 bin2hex (src
, buf
+ strlen (buf
), 0);
2946 extern int trace_regblock_size
;
2948 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2949 non-zero, the save is performed on the target, otherwise GDB obtains all
2950 trace data and saves it locally. */
2953 trace_save (const char *filename
, int target_does_save
)
2955 struct cleanup
*cleanup
;
2957 struct trace_status
*ts
= current_trace_status ();
2960 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2961 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2965 ULONGEST offset
= 0;
2966 #define MAX_TRACE_UPLOAD 2000
2967 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2970 /* If the target is to save the data to a file on its own, then just
2971 send the command and be done with it. */
2972 if (target_does_save
)
2974 err
= target_save_trace_data (filename
);
2976 error (_("Target failed to save trace data to '%s'."),
2981 /* Get the trace status first before opening the file, so if the
2982 target is losing, we can get out without touching files. */
2983 status
= target_get_trace_status (ts
);
2985 pathname
= tilde_expand (filename
);
2986 cleanup
= make_cleanup (xfree
, pathname
);
2988 fp
= fopen (pathname
, "wb");
2990 error (_("Unable to open file '%s' for saving trace data (%s)"),
2991 filename
, safe_strerror (errno
));
2992 make_cleanup_fclose (fp
);
2994 /* Write a file header, with a high-bit-set char to indicate a
2995 binary file, plus a hint as what this file is, and a version
2996 number in case of future needs. */
2997 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2999 perror_with_name (pathname
);
3001 /* Write descriptive info. */
3003 /* Write out the size of a register block. */
3004 fprintf (fp
, "R %x\n", trace_regblock_size
);
3006 /* Write out status of the tracing run (aka "tstatus" info). */
3007 fprintf (fp
, "status %c;%s",
3008 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
3009 if (ts
->stop_reason
== tracepoint_error
)
3011 char *buf
= (char *) alloca (strlen (ts
->stop_desc
) * 2 + 1);
3013 bin2hex ((gdb_byte
*) ts
->stop_desc
, buf
, 0);
3014 fprintf (fp
, ":%s", buf
);
3016 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
3017 if (ts
->traceframe_count
>= 0)
3018 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
3019 if (ts
->traceframes_created
>= 0)
3020 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
3021 if (ts
->buffer_free
>= 0)
3022 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
3023 if (ts
->buffer_size
>= 0)
3024 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
3025 if (ts
->disconnected_tracing
)
3026 fprintf (fp
, ";disconn:%x", ts
->disconnected_tracing
);
3027 if (ts
->circular_buffer
)
3028 fprintf (fp
, ";circular:%x", ts
->circular_buffer
);
3031 /* Note that we want to upload tracepoints and save those, rather
3032 than simply writing out the local ones, because the user may have
3033 changed tracepoints in GDB in preparation for a future tracing
3034 run, or maybe just mass-deleted all types of breakpoints as part
3035 of cleaning up. So as not to contaminate the session, leave the
3036 data in its uploaded form, don't make into real tracepoints. */
3038 /* Get trace state variables first, they may be checked when parsing
3039 uploaded commands. */
3041 target_upload_trace_state_variables (&uploaded_tsvs
);
3043 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3049 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
3050 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
3053 fprintf (fp
, "tsv %x:%s:%x:%s\n",
3054 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
3055 utsv
->builtin
, buf
);
3061 free_uploaded_tsvs (&uploaded_tsvs
);
3063 target_upload_tracepoints (&uploaded_tps
);
3065 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3066 target_get_tracepoint_status (NULL
, utp
);
3068 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3070 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
3071 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3072 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
3073 if (utp
->type
== bp_fast_tracepoint
)
3074 fprintf (fp
, ":F%x", utp
->orig_size
);
3076 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
3079 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
3080 fprintf (fp
, "tp A%x:%s:%s\n",
3081 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3082 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
3083 fprintf (fp
, "tp S%x:%s:%s\n",
3084 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3087 encode_source_string (utp
->number
, utp
->addr
,
3088 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
3089 fprintf (fp
, "tp Z%s\n", buf
);
3091 if (utp
->cond_string
)
3093 encode_source_string (utp
->number
, utp
->addr
,
3094 "cond", utp
->cond_string
,
3095 buf
, MAX_TRACE_UPLOAD
);
3096 fprintf (fp
, "tp Z%s\n", buf
);
3098 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
3100 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
3101 buf
, MAX_TRACE_UPLOAD
);
3102 fprintf (fp
, "tp Z%s\n", buf
);
3104 fprintf (fp
, "tp V%x:%s:%x:%s\n",
3105 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3107 phex_nz (utp
->traceframe_usage
,
3108 sizeof (utp
->traceframe_usage
)));
3111 free_uploaded_tps (&uploaded_tps
);
3113 /* Mark the end of the definition section. */
3116 /* Get and write the trace data proper. We ask for big blocks, in
3117 the hopes of efficiency, but will take less if the target has
3118 packet size limitations or some such. */
3121 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
3123 error (_("Failure to get requested trace buffer data"));
3124 /* No more data is forthcoming, we're done. */
3127 written
= fwrite (buf
, gotten
, 1, fp
);
3129 perror_with_name (pathname
);
3133 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
3134 written
= fwrite (&gotten
, 4, 1, fp
);
3136 perror_with_name (pathname
);
3138 do_cleanups (cleanup
);
3142 trace_save_command (char *args
, int from_tty
)
3144 int target_does_save
= 0;
3146 char *filename
= NULL
;
3147 struct cleanup
*back_to
;
3150 error_no_arg (_("file in which to save trace data"));
3152 argv
= gdb_buildargv (args
);
3153 back_to
= make_cleanup_freeargv (argv
);
3155 for (; *argv
; ++argv
)
3157 if (strcmp (*argv
, "-r") == 0)
3158 target_does_save
= 1;
3159 else if (**argv
== '-')
3160 error (_("unknown option `%s'"), *argv
);
3166 error_no_arg (_("file in which to save trace data"));
3168 trace_save (filename
, target_does_save
);
3171 printf_filtered (_("Trace data saved to file '%s'.\n"), filename
);
3173 do_cleanups (back_to
);
3176 /* Tell the target what to do with an ongoing tracing run if GDB
3177 disconnects for some reason. */
3180 set_disconnected_tracing (char *args
, int from_tty
,
3181 struct cmd_list_element
*c
)
3183 target_set_disconnected_tracing (disconnected_tracing
);
3187 set_circular_trace_buffer (char *args
, int from_tty
,
3188 struct cmd_list_element
*c
)
3190 target_set_circular_trace_buffer (circular_trace_buffer
);
3194 set_trace_user (char *args
, int from_tty
,
3195 struct cmd_list_element
*c
)
3199 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3202 warning ("Target does not support trace notes, user ignored");
3206 set_trace_notes (char *args
, int from_tty
,
3207 struct cmd_list_element
*c
)
3211 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3214 warning ("Target does not support trace notes, note ignored");
3218 set_trace_stop_notes (char *args
, int from_tty
,
3219 struct cmd_list_element
*c
)
3223 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3226 warning ("Target does not support trace notes, stop note ignored");
3229 /* Convert the memory pointed to by mem into hex, placing result in buf.
3230 * Return a pointer to the last char put in buf (null)
3231 * "stolen" from sparc-stub.c
3234 static const char hexchars
[] = "0123456789abcdef";
3237 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3245 *buf
++ = hexchars
[ch
>> 4];
3246 *buf
++ = hexchars
[ch
& 0xf];
3255 get_traceframe_number (void)
3257 return traceframe_number
;
3260 /* Make the traceframe NUM be the current trace frame. Does nothing
3261 if NUM is already current. */
3264 set_current_traceframe (int num
)
3268 if (traceframe_number
== num
)
3270 /* Nothing to do. */
3274 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3277 warning (_("could not change traceframe"));
3279 traceframe_number
= newnum
;
3281 /* Changing the traceframe changes our view of registers and of the
3283 registers_changed ();
3285 clear_traceframe_info ();
3288 /* Make the traceframe NUM be the current trace frame, and do nothing
3292 set_traceframe_number (int num
)
3294 traceframe_number
= num
;
3297 /* A cleanup used when switching away and back from tfind mode. */
3299 struct current_traceframe_cleanup
3301 /* The traceframe we were inspecting. */
3302 int traceframe_number
;
3306 do_restore_current_traceframe_cleanup (void *arg
)
3308 struct current_traceframe_cleanup
*old
= arg
;
3310 set_current_traceframe (old
->traceframe_number
);
3314 restore_current_traceframe_cleanup_dtor (void *arg
)
3316 struct current_traceframe_cleanup
*old
= arg
;
3322 make_cleanup_restore_current_traceframe (void)
3324 struct current_traceframe_cleanup
*old
;
3326 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3327 old
->traceframe_number
= traceframe_number
;
3329 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3330 restore_current_traceframe_cleanup_dtor
);
3334 make_cleanup_restore_traceframe_number (void)
3336 return make_cleanup_restore_integer (&traceframe_number
);
3339 /* Given a number and address, return an uploaded tracepoint with that
3340 number, creating if necessary. */
3342 struct uploaded_tp
*
3343 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3345 struct uploaded_tp
*utp
;
3347 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3348 if (utp
->number
== num
&& utp
->addr
== addr
)
3350 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3351 memset (utp
, 0, sizeof (struct uploaded_tp
));
3354 utp
->actions
= NULL
;
3355 utp
->step_actions
= NULL
;
3356 utp
->cmd_strings
= NULL
;
3363 free_uploaded_tps (struct uploaded_tp
**utpp
)
3365 struct uploaded_tp
*next_one
;
3369 next_one
= (*utpp
)->next
;
3375 /* Given a number and address, return an uploaded tracepoint with that
3376 number, creating if necessary. */
3378 static struct uploaded_tsv
*
3379 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3381 struct uploaded_tsv
*utsv
;
3383 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3384 if (utsv
->number
== num
)
3386 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3387 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3389 utsv
->next
= *utsvp
;
3395 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3397 struct uploaded_tsv
*next_one
;
3401 next_one
= (*utsvp
)->next
;
3407 /* FIXME this function is heuristic and will miss the cases where the
3408 conditional is semantically identical but differs in whitespace,
3409 such as "x == 0" vs "x==0". */
3412 cond_string_is_same (char *str1
, char *str2
)
3414 if (str1
== NULL
|| str2
== NULL
)
3415 return (str1
== str2
);
3417 return (strcmp (str1
, str2
) == 0);
3420 /* Look for an existing tracepoint that seems similar enough to the
3421 uploaded one. Enablement isn't compared, because the user can
3422 toggle that freely, and may have done so in anticipation of the
3423 next trace run. Return the location of matched tracepoint. */
3425 static struct bp_location
*
3426 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3428 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3430 struct breakpoint
*b
;
3431 struct bp_location
*loc
;
3433 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3435 struct tracepoint
*t
= (struct tracepoint
*) b
;
3437 if (b
->type
== utp
->type
3438 && t
->step_count
== utp
->step
3439 && t
->pass_count
== utp
->pass
3440 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3441 /* FIXME also test actions. */
3444 /* Scan the locations for an address match. */
3445 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3447 if (loc
->address
== utp
->addr
)
3455 /* Given a list of tracepoints uploaded from a target, attempt to
3456 match them up with existing tracepoints, and create new ones if not
3460 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3462 struct uploaded_tp
*utp
;
3464 /* Look for GDB tracepoints that match up with our uploaded versions. */
3465 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3467 struct bp_location
*loc
;
3468 struct tracepoint
*t
;
3470 loc
= find_matching_tracepoint_location (utp
);
3473 /* Mark this location as already inserted. */
3475 t
= (struct tracepoint
*) loc
->owner
;
3476 printf_filtered (_("Assuming tracepoint %d is same "
3477 "as target's tracepoint %d at %s.\n"),
3478 loc
->owner
->number
, utp
->number
,
3479 paddress (loc
->gdbarch
, utp
->addr
));
3483 t
= create_tracepoint_from_upload (utp
);
3485 printf_filtered (_("Created tracepoint %d for "
3486 "target's tracepoint %d at %s.\n"),
3487 t
->base
.number
, utp
->number
,
3488 paddress (get_current_arch (), utp
->addr
));
3490 printf_filtered (_("Failed to create tracepoint for target's "
3491 "tracepoint %d at %s, skipping it.\n"),
3493 paddress (get_current_arch (), utp
->addr
));
3495 /* Whether found or created, record the number used by the
3496 target, to help with mapping target tracepoints back to their
3497 counterparts here. */
3499 t
->number_on_target
= utp
->number
;
3502 free_uploaded_tps (uploaded_tps
);
3505 /* Trace state variables don't have much to identify them beyond their
3506 name, so just use that to detect matches. */
3508 static struct trace_state_variable
*
3509 find_matching_tsv (struct uploaded_tsv
*utsv
)
3514 return find_trace_state_variable (utsv
->name
);
3517 static struct trace_state_variable
*
3518 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3520 const char *namebase
;
3523 struct trace_state_variable
*tsv
;
3524 struct cleanup
*old_chain
;
3528 namebase
= utsv
->name
;
3529 buf
= xstrprintf ("%s", namebase
);
3534 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3537 /* Fish for a name that is not in use. */
3538 /* (should check against all internal vars?) */
3539 while (find_trace_state_variable (buf
))
3542 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3545 old_chain
= make_cleanup (xfree
, buf
);
3547 /* We have an available name, create the variable. */
3548 tsv
= create_trace_state_variable (buf
);
3549 tsv
->initial_value
= utsv
->initial_value
;
3550 tsv
->builtin
= utsv
->builtin
;
3552 do_cleanups (old_chain
);
3557 /* Given a list of uploaded trace state variables, try to match them
3558 up with existing variables, or create additional ones. */
3561 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3564 struct uploaded_tsv
*utsv
;
3565 struct trace_state_variable
*tsv
;
3568 /* Most likely some numbers will have to be reassigned as part of
3569 the merge, so clear them all in anticipation. */
3570 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3573 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3575 tsv
= find_matching_tsv (utsv
);
3579 printf_filtered (_("Assuming trace state variable $%s "
3580 "is same as target's variable %d.\n"),
3581 tsv
->name
, utsv
->number
);
3585 tsv
= create_tsv_from_upload (utsv
);
3587 printf_filtered (_("Created trace state variable "
3588 "$%s for target's variable %d.\n"),
3589 tsv
->name
, utsv
->number
);
3591 /* Give precedence to numberings that come from the target. */
3593 tsv
->number
= utsv
->number
;
3596 /* Renumber everything that didn't get a target-assigned number. */
3598 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3599 if (tsv
->number
> highest
)
3600 highest
= tsv
->number
;
3603 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3604 if (tsv
->number
== 0)
3605 tsv
->number
= highest
++;
3607 free_uploaded_tsvs (uploaded_tsvs
);
3610 /* target tfile command */
3612 struct target_ops tfile_ops
;
3614 /* Fill in tfile_ops with its defined operations and properties. */
3616 #define TRACE_HEADER_SIZE 8
3618 char *trace_filename
;
3620 off_t trace_frames_offset
;
3622 int cur_traceframe_number
;
3624 int trace_regblock_size
;
3626 static void tfile_interp_line (char *line
,
3627 struct uploaded_tp
**utpp
,
3628 struct uploaded_tsv
**utsvp
);
3630 /* Read SIZE bytes into READBUF from the trace frame, starting at
3631 TRACE_FD's current position. Note that this call `read'
3632 underneath, hence it advances the file's seek position. Throws an
3633 error if the `read' syscall fails, or less than SIZE bytes are
3637 tfile_read (gdb_byte
*readbuf
, int size
)
3641 gotten
= read (trace_fd
, readbuf
, size
);
3643 perror_with_name (trace_filename
);
3644 else if (gotten
< size
)
3645 error (_("Premature end of file while reading trace file"));
3649 tfile_open (char *filename
, int from_tty
)
3651 volatile struct gdb_exception ex
;
3653 struct cleanup
*old_chain
;
3656 char header
[TRACE_HEADER_SIZE
];
3657 char linebuf
[1000]; /* Should be max remote packet size or so. */
3660 struct trace_status
*ts
;
3661 struct uploaded_tp
*uploaded_tps
= NULL
;
3662 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3664 target_preopen (from_tty
);
3666 error (_("No trace file specified."));
3668 filename
= tilde_expand (filename
);
3669 if (!IS_ABSOLUTE_PATH(filename
))
3671 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
3676 old_chain
= make_cleanup (xfree
, filename
);
3678 flags
= O_BINARY
| O_LARGEFILE
;
3680 scratch_chan
= open (filename
, flags
, 0);
3681 if (scratch_chan
< 0)
3682 perror_with_name (filename
);
3684 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3686 discard_cleanups (old_chain
); /* Don't free filename any more. */
3687 unpush_target (&tfile_ops
);
3689 trace_filename
= xstrdup (filename
);
3690 trace_fd
= scratch_chan
;
3693 /* Read the file header and test for validity. */
3694 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
3696 bytes
+= TRACE_HEADER_SIZE
;
3697 if (!(header
[0] == 0x7f
3698 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3699 error (_("File is not a valid trace file."));
3701 push_target (&tfile_ops
);
3703 trace_regblock_size
= 0;
3704 ts
= current_trace_status ();
3705 /* We know we're working with a file. */
3707 /* Set defaults in case there is no status line. */
3708 ts
->running_known
= 0;
3709 ts
->stop_reason
= trace_stop_reason_unknown
;
3710 ts
->traceframe_count
= -1;
3711 ts
->buffer_free
= 0;
3712 ts
->disconnected_tracing
= 0;
3713 ts
->circular_buffer
= 0;
3715 cur_traceframe_number
= -1;
3717 TRY_CATCH (ex
, RETURN_MASK_ALL
)
3719 /* Read through a section of newline-terminated lines that
3720 define things like tracepoints. */
3724 tfile_read (&byte
, 1);
3729 /* Empty line marks end of the definition section. */
3734 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3737 linebuf
[i
++] = byte
;
3739 error (_("Excessively long lines in trace file"));
3742 /* Record the starting offset of the binary trace data. */
3743 trace_frames_offset
= bytes
;
3745 /* If we don't have a blocksize, we can't interpret the
3747 if (trace_regblock_size
== 0)
3748 error (_("No register block size recorded in trace file"));
3752 /* Pop the partially set up target. */
3754 throw_exception (ex
);
3757 inferior_appeared (current_inferior (), TFILE_PID
);
3758 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3759 add_thread_silent (inferior_ptid
);
3761 if (ts
->traceframe_count
<= 0)
3762 warning (_("No traceframes present in this file."));
3764 /* Add the file's tracepoints and variables into the current mix. */
3766 /* Get trace state variables first, they may be checked when parsing
3767 uploaded commands. */
3768 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3770 merge_uploaded_tracepoints (&uploaded_tps
);
3772 post_create_inferior (&tfile_ops
, from_tty
);
3775 /* Interpret the given line from the definitions part of the trace
3779 tfile_interp_line (char *line
,
3780 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3784 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3787 trace_regblock_size
= strtol (p
, &p
, 16);
3789 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3791 p
+= strlen ("status ");
3792 parse_trace_status (p
, current_trace_status ());
3794 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3796 p
+= strlen ("tp ");
3797 parse_tracepoint_definition (p
, utpp
);
3799 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3801 p
+= strlen ("tsv ");
3802 parse_tsv_definition (p
, utsvp
);
3805 warning (_("Ignoring trace file definition \"%s\""), line
);
3808 /* Parse the part of trace status syntax that is shared between
3809 the remote protocol and the trace file reader. */
3812 parse_trace_status (char *line
, struct trace_status
*ts
)
3814 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
3818 ts
->running_known
= 1;
3819 ts
->running
= (*p
++ == '1');
3820 ts
->stop_reason
= trace_stop_reason_unknown
;
3821 xfree (ts
->stop_desc
);
3822 ts
->stop_desc
= NULL
;
3823 ts
->traceframe_count
= -1;
3824 ts
->traceframes_created
= -1;
3825 ts
->buffer_free
= -1;
3826 ts
->buffer_size
= -1;
3827 ts
->disconnected_tracing
= 0;
3828 ts
->circular_buffer
= 0;
3829 xfree (ts
->user_name
);
3830 ts
->user_name
= NULL
;
3833 ts
->start_time
= ts
->stop_time
= 0;
3837 p1
= strchr (p
, ':');
3839 error (_("Malformed trace status, at %s\n\
3840 Status line: '%s'\n"), p
, line
);
3841 p3
= strchr (p
, ';');
3843 p3
= p
+ strlen (p
);
3844 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3846 p
= unpack_varlen_hex (++p1
, &val
);
3847 ts
->stop_reason
= trace_buffer_full
;
3849 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3851 p
= unpack_varlen_hex (++p1
, &val
);
3852 ts
->stop_reason
= trace_never_run
;
3854 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3857 p
= unpack_varlen_hex (++p1
, &val
);
3858 ts
->stop_reason
= tracepoint_passcount
;
3859 ts
->stopping_tracepoint
= val
;
3861 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3863 p2
= strchr (++p1
, ':');
3871 ts
->stop_desc
= xmalloc (strlen (line
));
3872 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
3873 ts
->stop_desc
[end
] = '\0';
3876 ts
->stop_desc
= xstrdup ("");
3878 p
= unpack_varlen_hex (++p2
, &val
);
3879 ts
->stop_reason
= tstop_command
;
3881 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3883 p
= unpack_varlen_hex (++p1
, &val
);
3884 ts
->stop_reason
= trace_disconnected
;
3886 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3888 p2
= strchr (++p1
, ':');
3891 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3892 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
3893 ts
->stop_desc
[end
] = '\0';
3896 ts
->stop_desc
= xstrdup ("");
3898 p
= unpack_varlen_hex (++p2
, &val
);
3899 ts
->stopping_tracepoint
= val
;
3900 ts
->stop_reason
= tracepoint_error
;
3902 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3904 p
= unpack_varlen_hex (++p1
, &val
);
3905 ts
->traceframe_count
= val
;
3907 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3909 p
= unpack_varlen_hex (++p1
, &val
);
3910 ts
->traceframes_created
= val
;
3912 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3914 p
= unpack_varlen_hex (++p1
, &val
);
3915 ts
->buffer_free
= val
;
3917 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3919 p
= unpack_varlen_hex (++p1
, &val
);
3920 ts
->buffer_size
= val
;
3922 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3924 p
= unpack_varlen_hex (++p1
, &val
);
3925 ts
->disconnected_tracing
= val
;
3927 else if (strncmp (p
, "circular", p1
- p
) == 0)
3929 p
= unpack_varlen_hex (++p1
, &val
);
3930 ts
->circular_buffer
= val
;
3932 else if (strncmp (p
, "starttime", p1
- p
) == 0)
3934 p
= unpack_varlen_hex (++p1
, &val
);
3935 ts
->start_time
= val
;
3937 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
3939 p
= unpack_varlen_hex (++p1
, &val
);
3940 ts
->stop_time
= val
;
3942 else if (strncmp (p
, "username", p1
- p
) == 0)
3945 ts
->user_name
= xmalloc (strlen (p
) / 2);
3946 end
= hex2bin (p1
, ts
->user_name
, (p3
- p1
) / 2);
3947 ts
->user_name
[end
] = '\0';
3950 else if (strncmp (p
, "notes", p1
- p
) == 0)
3953 ts
->notes
= xmalloc (strlen (p
) / 2);
3954 end
= hex2bin (p1
, ts
->notes
, (p3
- p1
) / 2);
3955 ts
->notes
[end
] = '\0';
3960 /* Silently skip unknown optional info. */
3961 p_temp
= strchr (p1
+ 1, ';');
3965 /* Must be at the end. */
3972 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
3973 struct uploaded_tp
*utp
)
3976 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
3978 p
= unpack_varlen_hex (p
, &uval
);
3980 tp
->base
.hit_count
+= uval
;
3982 utp
->hit_count
+= uval
;
3983 p
= unpack_varlen_hex (p
+ 1, &uval
);
3985 tp
->traceframe_usage
+= uval
;
3987 utp
->traceframe_usage
+= uval
;
3988 /* Ignore any extra, allowing for future extensions. */
3991 /* Given a line of text defining a part of a tracepoint, parse it into
3992 an "uploaded tracepoint". */
3995 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3999 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
4002 char *cond
, *srctype
, *buf
;
4003 struct uploaded_tp
*utp
= NULL
;
4006 /* Both tracepoint and action definitions start with the same number
4007 and address sequence. */
4009 p
= unpack_varlen_hex (p
, &num
);
4010 p
++; /* skip a colon */
4011 p
= unpack_varlen_hex (p
, &addr
);
4012 p
++; /* skip a colon */
4015 enabled
= (*p
++ == 'E');
4016 p
++; /* skip a colon */
4017 p
= unpack_varlen_hex (p
, &step
);
4018 p
++; /* skip a colon */
4019 p
= unpack_varlen_hex (p
, &pass
);
4020 type
= bp_tracepoint
;
4022 /* Thumb through optional fields. */
4025 p
++; /* skip a colon */
4028 type
= bp_fast_tracepoint
;
4030 p
= unpack_varlen_hex (p
, &orig_size
);
4034 type
= bp_static_tracepoint
;
4040 p
= unpack_varlen_hex (p
, &xlen
);
4041 p
++; /* skip a comma */
4042 cond
= (char *) xmalloc (2 * xlen
+ 1);
4043 strncpy (cond
, p
, 2 * xlen
);
4044 cond
[2 * xlen
] = '\0';
4048 warning (_("Unrecognized char '%c' in tracepoint "
4049 "definition, skipping rest"), *p
);
4051 utp
= get_uploaded_tp (num
, addr
, utpp
);
4053 utp
->enabled
= enabled
;
4058 else if (piece
== 'A')
4060 utp
= get_uploaded_tp (num
, addr
, utpp
);
4061 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
4063 else if (piece
== 'S')
4065 utp
= get_uploaded_tp (num
, addr
, utpp
);
4066 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
4068 else if (piece
== 'Z')
4070 /* Parse a chunk of source form definition. */
4071 utp
= get_uploaded_tp (num
, addr
, utpp
);
4073 p
= strchr (p
, ':');
4074 p
++; /* skip a colon */
4075 p
= unpack_varlen_hex (p
, &start
);
4076 p
++; /* skip a colon */
4077 p
= unpack_varlen_hex (p
, &xlen
);
4078 p
++; /* skip a colon */
4080 buf
= alloca (strlen (line
));
4082 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4085 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
4086 utp
->at_string
= xstrdup (buf
);
4087 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
4088 utp
->cond_string
= xstrdup (buf
);
4089 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
4090 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
4092 else if (piece
== 'V')
4094 utp
= get_uploaded_tp (num
, addr
, utpp
);
4096 parse_tracepoint_status (p
, NULL
, utp
);
4100 /* Don't error out, the target might be sending us optional
4101 info that we don't care about. */
4102 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
4106 /* Convert a textual description of a trace state variable into an
4110 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
4113 ULONGEST num
, initval
, builtin
;
4115 struct uploaded_tsv
*utsv
= NULL
;
4117 buf
= alloca (strlen (line
));
4120 p
= unpack_varlen_hex (p
, &num
);
4121 p
++; /* skip a colon */
4122 p
= unpack_varlen_hex (p
, &initval
);
4123 p
++; /* skip a colon */
4124 p
= unpack_varlen_hex (p
, &builtin
);
4125 p
++; /* skip a colon */
4126 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4129 utsv
= get_uploaded_tsv (num
, utsvp
);
4130 utsv
->initial_value
= initval
;
4131 utsv
->builtin
= builtin
;
4132 utsv
->name
= xstrdup (buf
);
4135 /* Close the trace file and generally clean up. */
4138 tfile_close (int quitting
)
4145 pid
= ptid_get_pid (inferior_ptid
);
4146 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff. */
4147 exit_inferior_silent (pid
);
4151 xfree (trace_filename
);
4152 trace_filename
= NULL
;
4156 tfile_files_info (struct target_ops
*t
)
4158 /* (it would be useful to mention the name of the file). */
4159 printf_filtered ("Looking at a trace file.\n");
4162 /* The trace status for a file is that tracing can never be run. */
4165 tfile_get_trace_status (struct trace_status
*ts
)
4167 /* Other bits of trace status were collected as part of opening the
4168 trace files, so nothing to do here. */
4174 tfile_get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
4176 /* Other bits of trace status were collected as part of opening the
4177 trace files, so nothing to do here. */
4180 /* Given the position of a traceframe in the file, figure out what
4181 address the frame was collected at. This would normally be the
4182 value of a collected PC register, but if not available, we
4186 tfile_get_traceframe_address (off_t tframe_offset
)
4190 struct tracepoint
*tp
;
4191 off_t saved_offset
= cur_offset
;
4193 /* FIXME dig pc out of collected registers. */
4195 /* Fall back to using tracepoint address. */
4196 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
4197 tfile_read ((gdb_byte
*) &tpnum
, 2);
4198 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4202 tp
= get_tracepoint_by_number_on_target (tpnum
);
4203 /* FIXME this is a poor heuristic if multiple locations. */
4204 if (tp
&& tp
->base
.loc
)
4205 addr
= tp
->base
.loc
->address
;
4207 /* Restore our seek position. */
4208 cur_offset
= saved_offset
;
4209 lseek (trace_fd
, cur_offset
, SEEK_SET
);
4213 /* Make tfile's selected traceframe match GDB's selected
4217 set_tfile_traceframe (void)
4221 if (cur_traceframe_number
== get_traceframe_number ())
4224 /* Avoid recursion, tfile_trace_find calls us again. */
4225 cur_traceframe_number
= get_traceframe_number ();
4227 newnum
= target_trace_find (tfind_number
,
4228 get_traceframe_number (), 0, 0, NULL
);
4230 /* Should not happen. If it does, all bets are off. */
4231 if (newnum
!= get_traceframe_number ())
4232 warning (_("could not set tfile's traceframe"));
4235 /* Given a type of search and some parameters, scan the collection of
4236 traceframes in the file looking for a match. When found, return
4237 both the traceframe and tracepoint number, otherwise -1 for
4241 tfile_trace_find (enum trace_find_type type
, int num
,
4242 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
4245 int tfnum
= 0, found
= 0;
4246 unsigned int data_size
;
4247 struct tracepoint
*tp
;
4248 off_t offset
, tframe_offset
;
4251 /* Lookups other than by absolute frame number depend on the current
4252 trace selected, so make sure it is correct on the tfile end
4254 if (type
!= tfind_number
)
4255 set_tfile_traceframe ();
4263 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
4264 offset
= trace_frames_offset
;
4267 tframe_offset
= offset
;
4268 tfile_read ((gdb_byte
*) &tpnum
, 2);
4269 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4275 tfile_read ((gdb_byte
*) &data_size
, 4);
4276 data_size
= (unsigned int) extract_unsigned_integer
4277 ((gdb_byte
*) &data_size
, 4,
4278 gdbarch_byte_order (target_gdbarch
));
4287 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4288 if (tfaddr
== addr1
)
4292 tp
= get_tracepoint (num
);
4293 if (tp
&& tpnum
== tp
->number_on_target
)
4297 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4298 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
4302 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4303 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
4307 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
4313 cur_offset
= offset
;
4314 cur_data_size
= data_size
;
4315 cur_traceframe_number
= tfnum
;
4318 /* Skip past the traceframe's data. */
4319 lseek (trace_fd
, data_size
, SEEK_CUR
);
4320 offset
+= data_size
;
4321 /* Update our own count of traceframes. */
4324 /* Did not find what we were looking for. */
4330 /* Prototype of the callback passed to tframe_walk_blocks. */
4331 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
4333 /* Callback for traceframe_walk_blocks, used to find a given block
4334 type in a traceframe. */
4337 match_blocktype (char blocktype
, void *data
)
4339 char *wantedp
= data
;
4341 if (*wantedp
== blocktype
)
4347 /* Walk over all traceframe block starting at POS offset from
4348 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4349 unmodified. If CALLBACK returns true, this returns the position in
4350 the traceframe where the block is found, relative to the start of
4351 the traceframe (cur_offset). Returns -1 if no callback call
4352 returned true, indicating that all blocks have been walked. */
4355 traceframe_walk_blocks (walk_blocks_callback_func callback
,
4356 int pos
, void *data
)
4358 /* Iterate through a traceframe's blocks, looking for a block of the
4361 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
4362 while (pos
< cur_data_size
)
4364 unsigned short mlen
;
4367 tfile_read (&block_type
, 1);
4371 if ((*callback
) (block_type
, data
))
4377 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4378 pos
+= trace_regblock_size
;
4381 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4382 tfile_read ((gdb_byte
*) &mlen
, 2);
4383 mlen
= (unsigned short)
4384 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4387 lseek (trace_fd
, mlen
, SEEK_CUR
);
4388 pos
+= (8 + 2 + mlen
);
4391 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
4395 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4396 block_type
, block_type
);
4404 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4405 position offset of a block of type TYPE_WANTED in the current trace
4406 frame, starting at POS. Returns -1 if no such block was found. */
4409 traceframe_find_block_type (char type_wanted
, int pos
)
4411 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
4414 /* Look for a block of saved registers in the traceframe, and get the
4415 requested register from it. */
4418 tfile_fetch_registers (struct target_ops
*ops
,
4419 struct regcache
*regcache
, int regno
)
4421 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4423 int pos
, offset
, regn
, regsize
, pc_regno
;
4424 unsigned short mlen
;
4427 /* An uninitialized reg size says we're not going to be
4428 successful at getting register blocks. */
4429 if (!trace_regblock_size
)
4432 set_tfile_traceframe ();
4434 regs
= alloca (trace_regblock_size
);
4436 if (traceframe_find_block_type ('R', 0) >= 0)
4438 tfile_read (regs
, trace_regblock_size
);
4440 /* Assume the block is laid out in GDB register number order,
4441 each register with the size that it has in GDB. */
4443 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4445 regsize
= register_size (gdbarch
, regn
);
4446 /* Make sure we stay within block bounds. */
4447 if (offset
+ regsize
>= trace_regblock_size
)
4449 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
4453 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
4456 else if (regno
== -1)
4458 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
4466 /* We get here if no register data has been found. Mark registers
4468 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4469 regcache_raw_supply (regcache
, regn
, NULL
);
4471 /* We can often usefully guess that the PC is going to be the same
4472 as the address of the tracepoint. */
4473 pc_regno
= gdbarch_pc_regnum (gdbarch
);
4474 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
4476 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
4478 if (tp
&& tp
->base
.loc
)
4480 /* But don't try to guess if tracepoint is multi-location... */
4481 if (tp
->base
.loc
->next
)
4483 warning (_("Tracepoint %d has multiple "
4484 "locations, cannot infer $pc"),
4488 /* ... or does while-stepping. */
4489 if (tp
->step_count
> 0)
4491 warning (_("Tracepoint %d does while-stepping, "
4492 "cannot infer $pc"),
4497 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
4498 gdbarch_byte_order (gdbarch
),
4499 tp
->base
.loc
->address
);
4500 regcache_raw_supply (regcache
, pc_regno
, regs
);
4506 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4507 const char *annex
, gdb_byte
*readbuf
,
4508 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
4510 /* We're only doing regular memory for now. */
4511 if (object
!= TARGET_OBJECT_MEMORY
)
4514 if (readbuf
== NULL
)
4515 error (_("tfile_xfer_partial: trace file is read-only"));
4517 set_tfile_traceframe ();
4519 if (traceframe_number
!= -1)
4523 /* Iterate through the traceframe's blocks, looking for
4525 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
4527 ULONGEST maddr
, amt
;
4528 unsigned short mlen
;
4529 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
4531 tfile_read ((gdb_byte
*) &maddr
, 8);
4532 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
4534 tfile_read ((gdb_byte
*) &mlen
, 2);
4535 mlen
= (unsigned short)
4536 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
4538 /* If the block includes the first part of the desired
4539 range, return as much it has; GDB will re-request the
4540 remainder, which might be in a different block of this
4542 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
4544 amt
= (maddr
+ mlen
) - offset
;
4548 tfile_read (readbuf
, amt
);
4552 /* Skip over this block. */
4553 pos
+= (8 + 2 + mlen
);
4557 /* It's unduly pedantic to refuse to look at the executable for
4558 read-only pieces; so do the equivalent of readonly regions aka
4560 /* FIXME account for relocation at some point. */
4567 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
4569 if ((s
->flags
& SEC_LOAD
) == 0
4570 || (s
->flags
& SEC_READONLY
) == 0)
4574 size
= bfd_get_section_size (s
);
4575 if (vma
<= offset
&& offset
< (vma
+ size
))
4579 amt
= (vma
+ size
) - offset
;
4583 amt
= bfd_get_section_contents (exec_bfd
, s
,
4584 readbuf
, offset
- vma
, amt
);
4590 /* Indicate failure to find the requested memory block. */
4594 /* Iterate through the blocks of a trace frame, looking for a 'V'
4595 block with a matching tsv number. */
4598 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
4602 set_tfile_traceframe ();
4605 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
4609 tfile_read ((gdb_byte
*) &vnum
, 4);
4610 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
4615 tfile_read ((gdb_byte
*) val
, 8);
4616 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
4624 /* Didn't find anything. */
4629 tfile_has_all_memory (struct target_ops
*ops
)
4635 tfile_has_memory (struct target_ops
*ops
)
4641 tfile_has_stack (struct target_ops
*ops
)
4643 return traceframe_number
!= -1;
4647 tfile_has_registers (struct target_ops
*ops
)
4649 return traceframe_number
!= -1;
4653 tfile_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
4658 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
4659 object for the tfile target's current traceframe. */
4662 build_traceframe_info (char blocktype
, void *data
)
4664 struct traceframe_info
*info
= data
;
4670 struct mem_range
*r
;
4672 unsigned short mlen
;
4674 tfile_read ((gdb_byte
*) &maddr
, 8);
4675 tfile_read ((gdb_byte
*) &mlen
, 2);
4677 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4690 warning (_("Unhandled trace block type (%d) '%c ' "
4691 "while building trace frame info."),
4692 blocktype
, blocktype
);
4699 static struct traceframe_info
*
4700 tfile_traceframe_info (void)
4702 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
4704 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
4709 init_tfile_ops (void)
4711 tfile_ops
.to_shortname
= "tfile";
4712 tfile_ops
.to_longname
= "Local trace dump file";
4714 = "Use a trace file as a target. Specify the filename of the trace file.";
4715 tfile_ops
.to_open
= tfile_open
;
4716 tfile_ops
.to_close
= tfile_close
;
4717 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
4718 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
4719 tfile_ops
.to_files_info
= tfile_files_info
;
4720 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
4721 tfile_ops
.to_get_tracepoint_status
= tfile_get_tracepoint_status
;
4722 tfile_ops
.to_trace_find
= tfile_trace_find
;
4723 tfile_ops
.to_get_trace_state_variable_value
4724 = tfile_get_trace_state_variable_value
;
4725 tfile_ops
.to_stratum
= process_stratum
;
4726 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
4727 tfile_ops
.to_has_memory
= tfile_has_memory
;
4728 tfile_ops
.to_has_stack
= tfile_has_stack
;
4729 tfile_ops
.to_has_registers
= tfile_has_registers
;
4730 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
4731 tfile_ops
.to_thread_alive
= tfile_thread_alive
;
4732 tfile_ops
.to_magic
= OPS_MAGIC
;
4736 free_current_marker (void *arg
)
4738 struct static_tracepoint_marker
**marker_p
= arg
;
4740 if (*marker_p
!= NULL
)
4742 release_static_tracepoint_marker (*marker_p
);
4749 /* Given a line of text defining a static tracepoint marker, parse it
4750 into a "static tracepoint marker" object. Throws an error is
4751 parsing fails. If PP is non-null, it points to one past the end of
4752 the parsed marker definition. */
4755 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
4756 struct static_tracepoint_marker
*marker
)
4763 p
= unpack_varlen_hex (p
, &addr
);
4764 p
++; /* skip a colon */
4766 marker
->gdbarch
= target_gdbarch
;
4767 marker
->address
= (CORE_ADDR
) addr
;
4769 endp
= strchr (p
, ':');
4771 error (_("bad marker definition: %s"), line
);
4773 marker
->str_id
= xmalloc (endp
- p
+ 1);
4774 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
4775 marker
->str_id
[end
] = '\0';
4778 p
++; /* skip a colon */
4780 marker
->extra
= xmalloc (strlen (p
) + 1);
4781 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
4782 marker
->extra
[end
] = '\0';
4788 /* Release a static tracepoint marker's contents. Note that the
4789 object itself isn't released here. There objects are usually on
4793 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
4795 xfree (marker
->str_id
);
4796 marker
->str_id
= NULL
;
4799 /* Print MARKER to gdb_stdout. */
4802 print_one_static_tracepoint_marker (int count
,
4803 struct static_tracepoint_marker
*marker
)
4805 struct command_line
*l
;
4808 char wrap_indent
[80];
4809 char extra_field_indent
[80];
4810 struct ui_out
*uiout
= current_uiout
;
4811 struct cleanup
*bkpt_chain
;
4812 VEC(breakpoint_p
) *tracepoints
;
4814 struct symtab_and_line sal
;
4818 sal
.pc
= marker
->address
;
4820 tracepoints
= static_tracepoints_here (marker
->address
);
4822 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
4824 /* A counter field to help readability. This is not a stable
4826 ui_out_field_int (uiout
, "count", count
);
4828 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
4830 ui_out_field_fmt (uiout
, "enabled", "%c",
4831 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
4832 ui_out_spaces (uiout
, 2);
4834 strcpy (wrap_indent
, " ");
4836 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
4837 strcat (wrap_indent
, " ");
4839 strcat (wrap_indent
, " ");
4841 strcpy (extra_field_indent
, " ");
4843 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
4845 sal
= find_pc_line (marker
->address
, 0);
4846 sym
= find_pc_sect_function (marker
->address
, NULL
);
4849 ui_out_text (uiout
, "in ");
4850 ui_out_field_string (uiout
, "func",
4851 SYMBOL_PRINT_NAME (sym
));
4852 ui_out_wrap_hint (uiout
, wrap_indent
);
4853 ui_out_text (uiout
, " at ");
4856 ui_out_field_skip (uiout
, "func");
4858 if (sal
.symtab
!= NULL
)
4860 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
4861 ui_out_text (uiout
, ":");
4863 if (ui_out_is_mi_like_p (uiout
))
4865 char *fullname
= symtab_to_fullname (sal
.symtab
);
4868 ui_out_field_string (uiout
, "fullname", fullname
);
4871 ui_out_field_skip (uiout
, "fullname");
4873 ui_out_field_int (uiout
, "line", sal
.line
);
4877 ui_out_field_skip (uiout
, "fullname");
4878 ui_out_field_skip (uiout
, "line");
4881 ui_out_text (uiout
, "\n");
4882 ui_out_text (uiout
, extra_field_indent
);
4883 ui_out_text (uiout
, _("Data: \""));
4884 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
4885 ui_out_text (uiout
, "\"\n");
4887 if (!VEC_empty (breakpoint_p
, tracepoints
))
4889 struct cleanup
*cleanup_chain
;
4891 struct breakpoint
*b
;
4893 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
4896 ui_out_text (uiout
, extra_field_indent
);
4897 ui_out_text (uiout
, _("Probed by static tracepoints: "));
4898 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
4901 ui_out_text (uiout
, ", ");
4902 ui_out_text (uiout
, "#");
4903 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
4906 do_cleanups (cleanup_chain
);
4908 if (ui_out_is_mi_like_p (uiout
))
4909 ui_out_field_int (uiout
, "number-of-tracepoints",
4910 VEC_length(breakpoint_p
, tracepoints
));
4912 ui_out_text (uiout
, "\n");
4914 VEC_free (breakpoint_p
, tracepoints
);
4916 do_cleanups (bkpt_chain
);
4920 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
4922 VEC(static_tracepoint_marker_p
) *markers
;
4923 struct cleanup
*old_chain
;
4924 struct static_tracepoint_marker
*marker
;
4925 struct ui_out
*uiout
= current_uiout
;
4928 /* We don't have to check target_can_use_agent and agent's capability on
4929 static tracepoint here, in order to be compatible with older GDBserver.
4930 We don't check USE_AGENT is true or not, because static tracepoints
4931 don't work without in-process agent, so we don't bother users to type
4932 `set agent on' when to use static tracepoint. */
4935 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
4936 "StaticTracepointMarkersTable");
4938 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
4940 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
4942 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
4943 if (gdbarch_addr_bit (target_gdbarch
) <= 32)
4944 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
4946 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
4947 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
4949 ui_out_table_body (uiout
);
4951 markers
= target_static_tracepoint_markers_by_strid (NULL
);
4952 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
4955 VEC_iterate (static_tracepoint_marker_p
,
4956 markers
, i
, marker
);
4959 print_one_static_tracepoint_marker (i
+ 1, marker
);
4960 release_static_tracepoint_marker (marker
);
4963 do_cleanups (old_chain
);
4966 /* The $_sdata convenience variable is a bit special. We don't know
4967 for sure type of the value until we actually have a chance to fetch
4968 the data --- the size of the object depends on what has been
4969 collected. We solve this by making $_sdata be an internalvar that
4970 creates a new value on access. */
4972 /* Return a new value with the correct type for the sdata object of
4973 the current trace frame. Return a void value if there's no object
4976 static struct value
*
4977 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
4983 /* We need to read the whole object before we know its size. */
4984 size
= target_read_alloc (¤t_target
,
4985 TARGET_OBJECT_STATIC_TRACE_DATA
,
4992 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
4994 v
= allocate_value (type
);
4995 memcpy (value_contents_raw (v
), buf
, size
);
5000 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
5003 #if !defined(HAVE_LIBEXPAT)
5005 struct traceframe_info
*
5006 parse_traceframe_info (const char *tframe_info
)
5008 static int have_warned
;
5013 warning (_("Can not parse XML trace frame info; XML support "
5014 "was disabled at compile time"));
5020 #else /* HAVE_LIBEXPAT */
5022 #include "xml-support.h"
5024 /* Handle the start of a <memory> element. */
5027 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
5028 const struct gdb_xml_element
*element
,
5029 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
5031 struct traceframe_info
*info
= user_data
;
5032 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5033 ULONGEST
*start_p
, *length_p
;
5035 start_p
= xml_find_attribute (attributes
, "start")->value
;
5036 length_p
= xml_find_attribute (attributes
, "length")->value
;
5038 r
->start
= *start_p
;
5039 r
->length
= *length_p
;
5042 /* Discard the constructed trace frame info (if an error occurs). */
5045 free_result (void *p
)
5047 struct traceframe_info
*result
= p
;
5049 free_traceframe_info (result
);
5052 /* The allowed elements and attributes for an XML memory map. */
5054 static const struct gdb_xml_attribute memory_attributes
[] = {
5055 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5056 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5057 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5060 static const struct gdb_xml_element traceframe_info_children
[] = {
5061 { "memory", memory_attributes
, NULL
,
5062 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5063 traceframe_info_start_memory
, NULL
},
5064 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5067 static const struct gdb_xml_element traceframe_info_elements
[] = {
5068 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
5070 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5073 /* Parse a traceframe-info XML document. */
5075 struct traceframe_info
*
5076 parse_traceframe_info (const char *tframe_info
)
5078 struct traceframe_info
*result
;
5079 struct cleanup
*back_to
;
5081 result
= XCNEW (struct traceframe_info
);
5082 back_to
= make_cleanup (free_result
, result
);
5084 if (gdb_xml_parse_quick (_("trace frame info"),
5085 "traceframe-info.dtd", traceframe_info_elements
,
5086 tframe_info
, result
) == 0)
5088 /* Parsed successfully, keep the result. */
5089 discard_cleanups (back_to
);
5094 do_cleanups (back_to
);
5098 #endif /* HAVE_LIBEXPAT */
5100 /* Returns the traceframe_info object for the current traceframe.
5101 This is where we avoid re-fetching the object from the target if we
5102 already have it cached. */
5104 static struct traceframe_info
*
5105 get_traceframe_info (void)
5107 if (traceframe_info
== NULL
)
5108 traceframe_info
= target_traceframe_info ();
5110 return traceframe_info
;
5113 /* If the target supports the query, return in RESULT the set of
5114 collected memory in the current traceframe, found within the LEN
5115 bytes range starting at MEMADDR. Returns true if the target
5116 supports the query, otherwise returns false, and RESULT is left
5120 traceframe_available_memory (VEC(mem_range_s
) **result
,
5121 CORE_ADDR memaddr
, ULONGEST len
)
5123 struct traceframe_info
*info
= get_traceframe_info ();
5127 struct mem_range
*r
;
5132 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
5133 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
5135 ULONGEST lo1
, hi1
, lo2
, hi2
;
5136 struct mem_range
*nr
;
5139 hi1
= memaddr
+ len
;
5142 hi2
= r
->start
+ r
->length
;
5144 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
5146 nr
->start
= max (lo1
, lo2
);
5147 nr
->length
= min (hi1
, hi2
) - nr
->start
;
5150 normalize_mem_ranges (*result
);
5157 /* Implementation of `sdata' variable. */
5159 static const struct internalvar_funcs sdata_funcs
=
5166 /* module initialization */
5168 _initialize_tracepoint (void)
5170 struct cmd_list_element
*c
;
5172 /* Explicitly create without lookup, since that tries to create a
5173 value with a void typed value, and when we get here, gdbarch
5174 isn't initialized yet. At this point, we're quite sure there
5175 isn't another convenience variable of the same name. */
5176 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
5178 traceframe_number
= -1;
5179 tracepoint_number
= -1;
5181 if (tracepoint_list
.list
== NULL
)
5183 tracepoint_list
.listsize
= 128;
5184 tracepoint_list
.list
= xmalloc
5185 (tracepoint_list
.listsize
* sizeof (struct memrange
));
5187 if (tracepoint_list
.aexpr_list
== NULL
)
5189 tracepoint_list
.aexpr_listsize
= 128;
5190 tracepoint_list
.aexpr_list
= xmalloc
5191 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5194 if (stepping_list
.list
== NULL
)
5196 stepping_list
.listsize
= 128;
5197 stepping_list
.list
= xmalloc
5198 (stepping_list
.listsize
* sizeof (struct memrange
));
5201 if (stepping_list
.aexpr_list
== NULL
)
5203 stepping_list
.aexpr_listsize
= 128;
5204 stepping_list
.aexpr_list
= xmalloc
5205 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5208 add_info ("scope", scope_info
,
5209 _("List the variables local to a scope"));
5211 add_cmd ("tracepoints", class_trace
, NULL
,
5212 _("Tracing of program execution without stopping the program."),
5215 add_com ("tdump", class_trace
, trace_dump_command
,
5216 _("Print everything collected at the current tracepoint."));
5218 add_com ("tsave", class_trace
, trace_save_command
, _("\
5219 Save the trace data to a file.\n\
5220 Use the '-r' option to direct the target to save directly to the file,\n\
5221 using its own filesystem."));
5223 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
5224 Define a trace state variable.\n\
5225 Argument is a $-prefixed name, optionally followed\n\
5226 by '=' and an expression that sets the initial value\n\
5227 at the start of tracing."));
5228 set_cmd_completer (c
, expression_completer
);
5230 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
5231 Delete one or more trace state variables.\n\
5232 Arguments are the names of the variables to delete.\n\
5233 If no arguments are supplied, delete all variables."), &deletelist
);
5234 /* FIXME add a trace variable completer. */
5236 add_info ("tvariables", tvariables_info
, _("\
5237 Status of trace state variables and their values.\n\
5240 add_info ("static-tracepoint-markers",
5241 info_static_tracepoint_markers_command
, _("\
5242 List target static tracepoints markers.\n\
5245 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
5246 Select a trace frame;\n\
5247 No argument means forward by one frame; '-' means backward by one frame."),
5248 &tfindlist
, "tfind ", 1, &cmdlist
);
5250 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
5251 Select a trace frame whose PC is outside the given range (exclusive).\n\
5252 Usage: tfind outside addr1, addr2"),
5255 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
5256 Select a trace frame whose PC is in the given range (inclusive).\n\
5257 Usage: tfind range addr1,addr2"),
5260 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
5261 Select a trace frame by source line.\n\
5262 Argument can be a line number (with optional source file),\n\
5263 a function name, or '*' followed by an address.\n\
5264 Default argument is 'the next source line that was traced'."),
5267 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
5268 Select a trace frame by tracepoint number.\n\
5269 Default is the tracepoint for the current trace frame."),
5272 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
5273 Select a trace frame by PC.\n\
5274 Default is the current PC, or the PC of the current trace frame."),
5277 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
5278 Synonym for 'none'.\n\
5279 De-select any trace frame and resume 'live' debugging."),
5282 add_cmd ("none", class_trace
, trace_find_none_command
,
5283 _("De-select any trace frame and resume 'live' debugging."),
5286 add_cmd ("start", class_trace
, trace_find_start_command
,
5287 _("Select the first trace frame in the trace buffer."),
5290 add_com ("tstatus", class_trace
, trace_status_command
,
5291 _("Display the status of the current trace data collection."));
5293 add_com ("tstop", class_trace
, trace_stop_command
, _("\
5294 Stop trace data collection.\n\
5295 Usage: tstop [ <notes> ... ]\n\
5296 Any arguments supplied are recorded with the trace as a stop reason and\n\
5297 reported by tstatus (if the target supports trace notes)."));
5299 add_com ("tstart", class_trace
, trace_start_command
, _("\
5300 Start trace data collection.\n\
5301 Usage: tstart [ <notes> ... ]\n\
5302 Any arguments supplied are recorded with the trace as a note and\n\
5303 reported by tstatus (if the target supports trace notes)."));
5305 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
5306 Ends a list of commands or actions.\n\
5307 Several GDB commands allow you to enter a list of commands or actions.\n\
5308 Entering \"end\" on a line by itself is the normal way to terminate\n\
5310 Note: the \"end\" command cannot be used at the gdb prompt."));
5312 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
5313 Specify single-stepping behavior at a tracepoint.\n\
5314 Argument is number of instructions to trace in single-step mode\n\
5315 following the tracepoint. This command is normally followed by\n\
5316 one or more \"collect\" commands, to specify what to collect\n\
5317 while single-stepping.\n\n\
5318 Note: this command can only be used in a tracepoint \"actions\" list."));
5320 add_com_alias ("ws", "while-stepping", class_alias
, 0);
5321 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
5323 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
5324 Specify one or more data items to be collected at a tracepoint.\n\
5325 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5326 collect all data (variables, registers) referenced by that expression.\n\
5327 Also accepts the following special arguments:\n\
5328 $regs -- all registers.\n\
5329 $args -- all function arguments.\n\
5330 $locals -- all variables local to the block/function scope.\n\
5331 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5332 Note: this command can only be used in a tracepoint \"actions\" list."));
5334 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
5335 Specify one or more expressions to be evaluated at a tracepoint.\n\
5336 Accepts a comma-separated list of (one or more) expressions.\n\
5337 The result of each evaluation will be discarded.\n\
5338 Note: this command can only be used in a tracepoint \"actions\" list."));
5340 add_com ("actions", class_trace
, trace_actions_command
, _("\
5341 Specify the actions to be taken at a tracepoint.\n\
5342 Tracepoint actions may include collecting of specified data,\n\
5343 single-stepping, or enabling/disabling other tracepoints,\n\
5344 depending on target's capabilities."));
5346 default_collect
= xstrdup ("");
5347 add_setshow_string_cmd ("default-collect", class_trace
,
5348 &default_collect
, _("\
5349 Set the list of expressions to collect by default"), _("\
5350 Show the list of expressions to collect by default"), NULL
,
5352 &setlist
, &showlist
);
5354 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
5355 &disconnected_tracing
, _("\
5356 Set whether tracing continues after GDB disconnects."), _("\
5357 Show whether tracing continues after GDB disconnects."), _("\
5358 Use this to continue a tracing run even if GDB disconnects\n\
5359 or detaches from the target. You can reconnect later and look at\n\
5360 trace data collected in the meantime."),
5361 set_disconnected_tracing
,
5366 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
5367 &circular_trace_buffer
, _("\
5368 Set target's use of circular trace buffer."), _("\
5369 Show target's use of circular trace buffer."), _("\
5370 Use this to make the trace buffer into a circular buffer,\n\
5371 which will discard traceframes (oldest first) instead of filling\n\
5372 up and stopping the trace run."),
5373 set_circular_trace_buffer
,
5378 add_setshow_string_cmd ("trace-user", class_trace
,
5380 Set the user name to use for current and future trace runs"), _("\
5381 Show the user name to use for current and future trace runs"), NULL
,
5382 set_trace_user
, NULL
,
5383 &setlist
, &showlist
);
5385 add_setshow_string_cmd ("trace-notes", class_trace
,
5387 Set notes string to use for current and future trace runs"), _("\
5388 Show the notes string to use for current and future trace runs"), NULL
,
5389 set_trace_notes
, NULL
,
5390 &setlist
, &showlist
);
5392 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
5393 &trace_stop_notes
, _("\
5394 Set notes string to use for future tstop commands"), _("\
5395 Show the notes string to use for future tstop commands"), NULL
,
5396 set_trace_stop_notes
, NULL
,
5397 &setlist
, &showlist
);
5401 add_target (&tfile_ops
);