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
, loc
->address
,
738 block_for_pc (loc
->address
), 1);
739 old_chain
= make_cleanup (free_current_contents
, &exp
);
741 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
743 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
745 error (_("constant `%s' (value %s) "
746 "will not be collected."),
747 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
748 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
750 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
751 == LOC_OPTIMIZED_OUT
)
753 error (_("`%s' is optimized away "
754 "and cannot be collected."),
755 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
759 /* We have something to collect, make sure that the expr to
760 bytecode translator can handle it and that it's not too
762 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
763 make_cleanup_free_agent_expr (aexpr
);
765 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
766 error (_("Expression is too complicated."));
770 report_agent_reqs_errors (aexpr
);
772 do_cleanups (old_chain
);
775 while (p
&& *p
++ == ',');
778 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
781 { /* Repeat over a comma-separated list. */
782 QUIT
; /* Allow user to bail out with ^C. */
783 while (isspace ((int) *p
))
787 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
790 /* Only expressions are allowed for this action. */
791 exp
= parse_exp_1 (&p
, loc
->address
,
792 block_for_pc (loc
->address
), 1);
793 old_chain
= make_cleanup (free_current_contents
, &exp
);
795 /* We have something to evaluate, make sure that the expr to
796 bytecode translator can handle it and that it's not too
798 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
799 make_cleanup_free_agent_expr (aexpr
);
801 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
802 error (_("Expression is too complicated."));
805 report_agent_reqs_errors (aexpr
);
807 do_cleanups (old_chain
);
810 while (p
&& *p
++ == ',');
813 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
815 char *steparg
; /* In case warning is necessary. */
817 while (isspace ((int) *p
))
821 if (*p
== '\0' || (t
->step_count
= strtol (p
, &p
, 0)) == 0)
822 error (_("while-stepping step count `%s' is malformed."), *line
);
825 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
829 error (_("`%s' is not a supported tracepoint action."), *line
);
833 memrange_absolute
= -1
838 int type
; /* memrange_absolute for absolute memory range,
839 else basereg number. */
840 bfd_signed_vma start
;
844 struct collection_list
846 unsigned char regs_mask
[32]; /* room for up to 256 regs */
849 struct memrange
*list
;
850 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
852 struct agent_expr
**aexpr_list
;
854 /* True is the user requested a collection of "$_sdata", "static
858 tracepoint_list
, stepping_list
;
860 /* MEMRANGE functions: */
862 static int memrange_cmp (const void *, const void *);
864 /* Compare memranges for qsort. */
866 memrange_cmp (const void *va
, const void *vb
)
868 const struct memrange
*a
= va
, *b
= vb
;
870 if (a
->type
< b
->type
)
872 if (a
->type
> b
->type
)
874 if (a
->type
== memrange_absolute
)
876 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
878 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
883 if (a
->start
< b
->start
)
885 if (a
->start
> b
->start
)
891 /* Sort the memrange list using qsort, and merge adjacent memranges. */
893 memrange_sortmerge (struct collection_list
*memranges
)
897 qsort (memranges
->list
, memranges
->next_memrange
,
898 sizeof (struct memrange
), memrange_cmp
);
899 if (memranges
->next_memrange
> 0)
901 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
903 /* If memrange b overlaps or is adjacent to memrange a,
905 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
906 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
908 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
909 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
910 continue; /* next b, same a */
914 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
915 sizeof (struct memrange
));
917 memranges
->next_memrange
= a
+ 1;
921 /* Add a register to a collection list. */
923 add_register (struct collection_list
*collection
, unsigned int regno
)
926 printf_filtered ("collect register %d\n", regno
);
927 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
928 error (_("Internal: register number %d too large for tracepoint"),
930 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
933 /* Add a memrange to a collection list. */
935 add_memrange (struct collection_list
*memranges
,
936 int type
, bfd_signed_vma base
,
941 printf_filtered ("(%d,", type
);
943 printf_filtered (",%ld)\n", len
);
946 /* type: memrange_absolute == memory, other n == basereg */
947 memranges
->list
[memranges
->next_memrange
].type
= type
;
948 /* base: addr if memory, offset if reg relative. */
949 memranges
->list
[memranges
->next_memrange
].start
= base
;
950 /* len: we actually save end (base + len) for convenience */
951 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
952 memranges
->next_memrange
++;
953 if (memranges
->next_memrange
>= memranges
->listsize
)
955 memranges
->listsize
*= 2;
956 memranges
->list
= xrealloc (memranges
->list
,
957 memranges
->listsize
);
960 if (type
!= memrange_absolute
) /* Better collect the base register! */
961 add_register (memranges
, type
);
964 /* Add a symbol to a collection list. */
966 collect_symbol (struct collection_list
*collect
,
968 struct gdbarch
*gdbarch
,
969 long frame_regno
, long frame_offset
,
974 bfd_signed_vma offset
;
975 int treat_as_expr
= 0;
977 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
978 switch (SYMBOL_CLASS (sym
))
981 printf_filtered ("%s: don't know symbol class %d\n",
982 SYMBOL_PRINT_NAME (sym
),
986 printf_filtered ("constant %s (value %s) will not be collected.\n",
987 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
990 offset
= SYMBOL_VALUE_ADDRESS (sym
);
995 sprintf_vma (tmp
, offset
);
996 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
997 SYMBOL_PRINT_NAME (sym
), len
,
1000 /* A struct may be a C++ class with static fields, go to general
1001 expression handling. */
1002 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
1005 add_memrange (collect
, memrange_absolute
, offset
, len
);
1008 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1010 printf_filtered ("LOC_REG[parm] %s: ",
1011 SYMBOL_PRINT_NAME (sym
));
1012 add_register (collect
, reg
);
1013 /* Check for doubles stored in two registers. */
1014 /* FIXME: how about larger types stored in 3 or more regs? */
1015 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1016 len
> register_size (gdbarch
, reg
))
1017 add_register (collect
, reg
+ 1);
1020 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1021 printf_filtered (" (will not collect %s)\n",
1022 SYMBOL_PRINT_NAME (sym
));
1026 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1029 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1030 SYMBOL_PRINT_NAME (sym
), len
);
1031 printf_vma (offset
);
1032 printf_filtered (" from frame ptr reg %d\n", reg
);
1034 add_memrange (collect
, reg
, offset
, len
);
1036 case LOC_REGPARM_ADDR
:
1037 reg
= SYMBOL_VALUE (sym
);
1041 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1042 SYMBOL_PRINT_NAME (sym
), len
);
1043 printf_vma (offset
);
1044 printf_filtered (" from reg %d\n", reg
);
1046 add_memrange (collect
, reg
, offset
, len
);
1050 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1053 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1054 SYMBOL_PRINT_NAME (sym
), len
);
1055 printf_vma (offset
);
1056 printf_filtered (" from frame ptr reg %d\n", reg
);
1058 add_memrange (collect
, reg
, offset
, len
);
1061 case LOC_UNRESOLVED
:
1065 case LOC_OPTIMIZED_OUT
:
1066 printf_filtered ("%s has been optimized out of existence.\n",
1067 SYMBOL_PRINT_NAME (sym
));
1075 /* Expressions are the most general case. */
1078 struct agent_expr
*aexpr
;
1079 struct cleanup
*old_chain1
= NULL
;
1081 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
1083 /* It can happen that the symbol is recorded as a computed
1084 location, but it's been optimized away and doesn't actually
1085 have a location expression. */
1088 printf_filtered ("%s has been optimized out of existence.\n",
1089 SYMBOL_PRINT_NAME (sym
));
1093 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1097 report_agent_reqs_errors (aexpr
);
1099 discard_cleanups (old_chain1
);
1100 add_aexpr (collect
, aexpr
);
1102 /* Take care of the registers. */
1103 if (aexpr
->reg_mask_len
> 0)
1107 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1109 QUIT
; /* Allow user to bail out with ^C. */
1110 if (aexpr
->reg_mask
[ndx1
] != 0)
1112 /* Assume chars have 8 bits. */
1113 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1114 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1115 /* It's used -- record it. */
1116 add_register (collect
, ndx1
* 8 + ndx2
);
1123 /* Data to be passed around in the calls to the locals and args
1126 struct add_local_symbols_data
1128 struct collection_list
*collect
;
1129 struct gdbarch
*gdbarch
;
1136 /* The callback for the locals and args iterators. */
1139 do_collect_symbol (const char *print_name
,
1143 struct add_local_symbols_data
*p
= cb_data
;
1145 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1146 p
->frame_offset
, p
->pc
);
1150 /* Add all locals (or args) symbols to collection list. */
1152 add_local_symbols (struct collection_list
*collect
,
1153 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1154 long frame_regno
, long frame_offset
, int type
)
1156 struct block
*block
;
1157 struct add_local_symbols_data cb_data
;
1159 cb_data
.collect
= collect
;
1160 cb_data
.gdbarch
= gdbarch
;
1162 cb_data
.frame_regno
= frame_regno
;
1163 cb_data
.frame_offset
= frame_offset
;
1168 block
= block_for_pc (pc
);
1171 warning (_("Can't collect locals; "
1172 "no symbol table info available.\n"));
1176 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1177 if (cb_data
.count
== 0)
1178 warning (_("No locals found in scope."));
1182 pc
= get_pc_function_start (pc
);
1183 block
= block_for_pc (pc
);
1186 warning (_("Can't collect args; no symbol table info available."));
1190 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1191 if (cb_data
.count
== 0)
1192 warning (_("No args found in scope."));
1197 add_static_trace_data (struct collection_list
*collection
)
1200 printf_filtered ("collect static trace data\n");
1201 collection
->strace_data
= 1;
1204 /* worker function */
1206 clear_collection_list (struct collection_list
*list
)
1210 list
->next_memrange
= 0;
1211 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1213 free_agent_expr (list
->aexpr_list
[ndx
]);
1214 list
->aexpr_list
[ndx
] = NULL
;
1216 list
->next_aexpr_elt
= 0;
1217 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1218 list
->strace_data
= 0;
1221 /* Reduce a collection list to string form (for gdb protocol). */
1223 stringify_collection_list (struct collection_list
*list
, char *string
)
1225 char temp_buf
[2048];
1229 char *(*str_list
)[];
1233 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1234 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1236 if (list
->strace_data
)
1239 printf_filtered ("\nCollecting static trace data\n");
1242 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1246 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1247 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1249 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1252 printf_filtered ("\nCollecting registers (mask): 0x");
1257 QUIT
; /* Allow user to bail out with ^C. */
1259 printf_filtered ("%02X", list
->regs_mask
[i
]);
1260 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1263 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1267 printf_filtered ("\n");
1268 if (list
->next_memrange
> 0 && info_verbose
)
1269 printf_filtered ("Collecting memranges: \n");
1270 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1272 QUIT
; /* Allow user to bail out with ^C. */
1273 sprintf_vma (tmp2
, list
->list
[i
].start
);
1276 printf_filtered ("(%d, %s, %ld)\n",
1279 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1281 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1283 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1290 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1292 /* The "%X" conversion specifier expects an unsigned argument,
1293 so passing -1 (memrange_absolute) to it directly gives you
1294 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1296 if (list
->list
[i
].type
== memrange_absolute
)
1297 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1299 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1302 count
+= strlen (end
);
1303 end
= temp_buf
+ count
;
1306 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1308 QUIT
; /* Allow user to bail out with ^C. */
1309 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1311 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1316 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1317 end
+= 10; /* 'X' + 8 hex digits + ',' */
1320 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1321 end
, list
->aexpr_list
[i
]->len
);
1322 count
+= 2 * list
->aexpr_list
[i
]->len
;
1327 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1332 (*str_list
)[ndx
] = NULL
;
1345 encode_actions_1 (struct command_line
*action
,
1346 struct breakpoint
*t
,
1347 struct bp_location
*tloc
,
1349 LONGEST frame_offset
,
1350 struct collection_list
*collect
,
1351 struct collection_list
*stepping_list
)
1354 struct expression
*exp
= NULL
;
1356 struct value
*tempval
;
1357 struct cmd_list_element
*cmd
;
1358 struct agent_expr
*aexpr
;
1360 for (; action
; action
= action
->next
)
1362 QUIT
; /* Allow user to bail out with ^C. */
1363 action_exp
= action
->line
;
1364 while (isspace ((int) *action_exp
))
1367 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1369 error (_("Bad action list item: %s"), action_exp
);
1371 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1373 trace_string_kludge
= 0;
1374 if (*action_exp
== '/')
1375 action_exp
= decode_agent_options (action_exp
);
1378 { /* Repeat over a comma-separated list. */
1379 QUIT
; /* Allow user to bail out with ^C. */
1380 while (isspace ((int) *action_exp
))
1383 if (0 == strncasecmp ("$reg", action_exp
, 4))
1385 for (i
= 0; i
< gdbarch_num_regs (tloc
->gdbarch
); i
++)
1386 add_register (collect
, i
);
1387 action_exp
= strchr (action_exp
, ','); /* more? */
1389 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1391 add_local_symbols (collect
,
1397 action_exp
= strchr (action_exp
, ','); /* more? */
1399 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1401 add_local_symbols (collect
,
1407 action_exp
= strchr (action_exp
, ','); /* more? */
1409 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1411 struct cleanup
*old_chain1
= NULL
;
1413 aexpr
= gen_trace_for_return_address (tloc
->address
,
1416 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1419 report_agent_reqs_errors (aexpr
);
1421 discard_cleanups (old_chain1
);
1422 add_aexpr (collect
, aexpr
);
1424 /* take care of the registers */
1425 if (aexpr
->reg_mask_len
> 0)
1429 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1431 QUIT
; /* allow user to bail out with ^C */
1432 if (aexpr
->reg_mask
[ndx1
] != 0)
1434 /* assume chars have 8 bits */
1435 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1436 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1437 /* it's used -- record it */
1438 add_register (collect
,
1444 action_exp
= strchr (action_exp
, ','); /* more? */
1446 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1448 add_static_trace_data (collect
);
1449 action_exp
= strchr (action_exp
, ','); /* more? */
1453 unsigned long addr
, len
;
1454 struct cleanup
*old_chain
= NULL
;
1455 struct cleanup
*old_chain1
= NULL
;
1457 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1458 block_for_pc (tloc
->address
), 1);
1459 old_chain
= make_cleanup (free_current_contents
, &exp
);
1461 switch (exp
->elts
[0].opcode
)
1465 const char *name
= &exp
->elts
[2].string
;
1467 i
= user_reg_map_name_to_regnum (tloc
->gdbarch
,
1468 name
, strlen (name
));
1470 internal_error (__FILE__
, __LINE__
,
1471 _("Register $%s not available"),
1474 printf_filtered ("OP_REGISTER: ");
1475 add_register (collect
, i
);
1480 /* Safe because we know it's a simple expression. */
1481 tempval
= evaluate_expression (exp
);
1482 addr
= value_address (tempval
);
1483 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1484 add_memrange (collect
, memrange_absolute
, addr
, len
);
1488 collect_symbol (collect
,
1489 exp
->elts
[2].symbol
,
1496 default: /* Full-fledged expression. */
1497 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1499 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1503 report_agent_reqs_errors (aexpr
);
1505 discard_cleanups (old_chain1
);
1506 add_aexpr (collect
, aexpr
);
1508 /* Take care of the registers. */
1509 if (aexpr
->reg_mask_len
> 0)
1514 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1516 QUIT
; /* Allow user to bail out with ^C. */
1517 if (aexpr
->reg_mask
[ndx1
] != 0)
1519 /* Assume chars have 8 bits. */
1520 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1521 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1522 /* It's used -- record it. */
1523 add_register (collect
,
1530 do_cleanups (old_chain
);
1533 while (action_exp
&& *action_exp
++ == ',');
1535 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1538 { /* Repeat over a comma-separated list. */
1539 QUIT
; /* Allow user to bail out with ^C. */
1540 while (isspace ((int) *action_exp
))
1544 struct cleanup
*old_chain
= NULL
;
1545 struct cleanup
*old_chain1
= NULL
;
1547 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1548 block_for_pc (tloc
->address
), 1);
1549 old_chain
= make_cleanup (free_current_contents
, &exp
);
1551 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1552 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1555 report_agent_reqs_errors (aexpr
);
1557 discard_cleanups (old_chain1
);
1558 /* Even though we're not officially collecting, add
1559 to the collect list anyway. */
1560 add_aexpr (collect
, aexpr
);
1562 do_cleanups (old_chain
);
1565 while (action_exp
&& *action_exp
++ == ',');
1567 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1569 /* We check against nested while-stepping when setting
1570 breakpoint action, so no way to run into nested
1572 gdb_assert (stepping_list
);
1574 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
,
1575 frame_offset
, stepping_list
, NULL
);
1578 error (_("Invalid tracepoint command '%s'"), action
->line
);
1582 /* Render all actions into gdb protocol. */
1585 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1586 char ***tdp_actions
, char ***stepping_actions
)
1588 static char tdp_buff
[2048], step_buff
[2048];
1589 char *default_collect_line
= NULL
;
1590 struct command_line
*actions
;
1591 struct command_line
*default_collect_action
= NULL
;
1593 LONGEST frame_offset
;
1594 struct cleanup
*back_to
;
1596 back_to
= make_cleanup (null_cleanup
, NULL
);
1598 clear_collection_list (&tracepoint_list
);
1599 clear_collection_list (&stepping_list
);
1601 *tdp_actions
= NULL
;
1602 *stepping_actions
= NULL
;
1604 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1605 tloc
->address
, &frame_reg
, &frame_offset
);
1607 actions
= breakpoint_commands (t
);
1609 /* If there are default expressions to collect, make up a collect
1610 action and prepend to the action list to encode. Note that since
1611 validation is per-tracepoint (local var "xyz" might be valid for
1612 one tracepoint and not another, etc), we make up the action on
1613 the fly, and don't cache it. */
1614 if (*default_collect
)
1618 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1619 make_cleanup (xfree
, default_collect_line
);
1621 line
= default_collect_line
;
1622 validate_actionline (&line
, t
);
1624 default_collect_action
= xmalloc (sizeof (struct command_line
));
1625 make_cleanup (xfree
, default_collect_action
);
1626 default_collect_action
->next
= actions
;
1627 default_collect_action
->line
= line
;
1628 actions
= default_collect_action
;
1630 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1631 &tracepoint_list
, &stepping_list
);
1633 memrange_sortmerge (&tracepoint_list
);
1634 memrange_sortmerge (&stepping_list
);
1636 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1638 *stepping_actions
= stringify_collection_list (&stepping_list
,
1641 do_cleanups (back_to
);
1645 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1647 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1649 collect
->aexpr_list
=
1650 xrealloc (collect
->aexpr_list
,
1651 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1652 collect
->aexpr_listsize
*= 2;
1654 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1655 collect
->next_aexpr_elt
++;
1659 process_tracepoint_on_disconnect (void)
1661 VEC(breakpoint_p
) *tp_vec
= NULL
;
1663 struct breakpoint
*b
;
1664 int has_pending_p
= 0;
1666 /* Check whether we still have pending tracepoint. If we have, warn the
1667 user that pending tracepoint will no longer work. */
1668 tp_vec
= all_tracepoints ();
1669 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1678 struct bp_location
*loc1
;
1680 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1682 if (loc1
->shlib_disabled
)
1693 VEC_free (breakpoint_p
, tp_vec
);
1696 warning (_("Pending tracepoints will not be resolved while"
1697 " GDB is disconnected\n"));
1702 start_tracing (char *notes
)
1704 VEC(breakpoint_p
) *tp_vec
= NULL
;
1706 struct breakpoint
*b
;
1707 struct trace_state_variable
*tsv
;
1708 int any_enabled
= 0, num_to_download
= 0;
1711 tp_vec
= all_tracepoints ();
1713 /* No point in tracing without any tracepoints... */
1714 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1716 VEC_free (breakpoint_p
, tp_vec
);
1717 error (_("No tracepoints defined, not starting trace"));
1720 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1722 struct tracepoint
*t
= (struct tracepoint
*) b
;
1723 struct bp_location
*loc
;
1725 if (b
->enable_state
== bp_enabled
)
1728 if ((b
->type
== bp_fast_tracepoint
1729 ? may_insert_fast_tracepoints
1730 : may_insert_tracepoints
))
1733 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1734 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1739 if (target_supports_enable_disable_tracepoint ())
1740 warning (_("No tracepoints enabled"));
1743 /* No point in tracing with only disabled tracepoints that
1744 cannot be re-enabled. */
1745 VEC_free (breakpoint_p
, tp_vec
);
1746 error (_("No tracepoints enabled, not starting trace"));
1750 if (num_to_download
<= 0)
1752 VEC_free (breakpoint_p
, tp_vec
);
1753 error (_("No tracepoints that may be downloaded, not starting trace"));
1756 target_trace_init ();
1758 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1760 struct tracepoint
*t
= (struct tracepoint
*) b
;
1761 struct bp_location
*loc
;
1763 /* Clear `inserted' flag. */
1764 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1767 if ((b
->type
== bp_fast_tracepoint
1768 ? !may_insert_fast_tracepoints
1769 : !may_insert_tracepoints
))
1772 t
->number_on_target
= 0;
1774 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1776 /* Since tracepoint locations are never duplicated, `inserted'
1777 flag should be zero. */
1778 gdb_assert (!loc
->inserted
);
1780 target_download_tracepoint (loc
);
1785 t
->number_on_target
= b
->number
;
1787 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1788 if (loc
->probe
!= NULL
)
1789 loc
->probe
->pops
->set_semaphore (loc
->probe
, loc
->gdbarch
);
1791 VEC_free (breakpoint_p
, tp_vec
);
1793 /* Send down all the trace state variables too. */
1794 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1796 target_download_trace_state_variable (tsv
);
1799 /* Tell target to treat text-like sections as transparent. */
1800 target_trace_set_readonly_regions ();
1801 /* Set some mode flags. */
1802 target_set_disconnected_tracing (disconnected_tracing
);
1803 target_set_circular_trace_buffer (circular_trace_buffer
);
1806 notes
= trace_notes
;
1807 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1809 if (!ret
&& (trace_user
|| notes
))
1810 warning (_("Target does not support trace user/notes, info ignored"));
1812 /* Now insert traps and begin collecting data. */
1813 target_trace_start ();
1815 /* Reset our local state. */
1816 set_traceframe_num (-1);
1817 set_tracepoint_num (-1);
1818 set_traceframe_context (NULL
);
1819 current_trace_status()->running
= 1;
1820 clear_traceframe_info ();
1823 /* The tstart command requests the target to start a new trace run.
1824 The command passes any arguments it has to the target verbatim, as
1825 an optional "trace note". This is useful as for instance a warning
1826 to other users if the trace runs disconnected, and you don't want
1827 anybody else messing with the target. */
1830 trace_start_command (char *args
, int from_tty
)
1832 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1834 if (current_trace_status ()->running
)
1837 && !query (_("A trace is running already. Start a new run? ")))
1838 error (_("New trace run not started."));
1841 start_tracing (args
);
1844 /* The tstop command stops the tracing run. The command passes any
1845 supplied arguments to the target verbatim as a "stop note"; if the
1846 target supports trace notes, then it will be reported back as part
1847 of the trace run's status. */
1850 trace_stop_command (char *args
, int from_tty
)
1852 if (!current_trace_status ()->running
)
1853 error (_("Trace is not running."));
1855 stop_tracing (args
);
1859 stop_tracing (char *note
)
1862 VEC(breakpoint_p
) *tp_vec
= NULL
;
1864 struct breakpoint
*t
;
1866 target_trace_stop ();
1868 tp_vec
= all_tracepoints ();
1869 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1871 struct bp_location
*loc
;
1873 if ((t
->type
== bp_fast_tracepoint
1874 ? !may_insert_fast_tracepoints
1875 : !may_insert_tracepoints
))
1878 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1880 /* GDB can be totally absent in some disconnected trace scenarios,
1881 but we don't really care if this semaphore goes out of sync.
1882 That's why we are decrementing it here, but not taking care
1884 if (loc
->probe
!= NULL
)
1885 loc
->probe
->pops
->clear_semaphore (loc
->probe
, loc
->gdbarch
);
1889 VEC_free (breakpoint_p
, tp_vec
);
1892 note
= trace_stop_notes
;
1893 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1896 warning (_("Target does not support trace notes, note ignored"));
1898 /* Should change in response to reply? */
1899 current_trace_status ()->running
= 0;
1902 /* tstatus command */
1904 trace_status_command (char *args
, int from_tty
)
1906 struct trace_status
*ts
= current_trace_status ();
1908 VEC(breakpoint_p
) *tp_vec
= NULL
;
1909 struct breakpoint
*t
;
1911 status
= target_get_trace_status (ts
);
1916 printf_filtered (_("Using a trace file.\n"));
1919 printf_filtered (_("Trace can not be run on this target.\n"));
1924 if (!ts
->running_known
)
1926 printf_filtered (_("Run/stop status is unknown.\n"));
1928 else if (ts
->running
)
1930 printf_filtered (_("Trace is running on the target.\n"));
1934 switch (ts
->stop_reason
)
1936 case trace_never_run
:
1937 printf_filtered (_("No trace has been run on the target.\n"));
1941 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1944 printf_filtered (_("Trace stopped by a tstop command.\n"));
1946 case trace_buffer_full
:
1947 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1949 case trace_disconnected
:
1950 printf_filtered (_("Trace stopped because of disconnection.\n"));
1952 case tracepoint_passcount
:
1953 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1954 ts
->stopping_tracepoint
);
1956 case tracepoint_error
:
1957 if (ts
->stopping_tracepoint
)
1958 printf_filtered (_("Trace stopped by an "
1959 "error (%s, tracepoint %d).\n"),
1960 ts
->stop_desc
, ts
->stopping_tracepoint
);
1962 printf_filtered (_("Trace stopped by an error (%s).\n"),
1965 case trace_stop_reason_unknown
:
1966 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1969 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1975 if (ts
->traceframes_created
>= 0
1976 && ts
->traceframe_count
!= ts
->traceframes_created
)
1978 printf_filtered (_("Buffer contains %d trace "
1979 "frames (of %d created total).\n"),
1980 ts
->traceframe_count
, ts
->traceframes_created
);
1982 else if (ts
->traceframe_count
>= 0)
1984 printf_filtered (_("Collected %d trace frames.\n"),
1985 ts
->traceframe_count
);
1988 if (ts
->buffer_free
>= 0)
1990 if (ts
->buffer_size
>= 0)
1992 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1993 ts
->buffer_free
, ts
->buffer_size
);
1994 if (ts
->buffer_size
> 0)
1995 printf_filtered (_(" (%d%% full)"),
1996 ((int) ((((long long) (ts
->buffer_size
1997 - ts
->buffer_free
)) * 100)
1998 / ts
->buffer_size
)));
1999 printf_filtered (_(".\n"));
2002 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2006 if (ts
->disconnected_tracing
)
2007 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2009 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2011 if (ts
->circular_buffer
)
2012 printf_filtered (_("Trace buffer is circular.\n"));
2014 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
2015 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
2017 if (ts
->notes
&& strlen (ts
->notes
) > 0)
2018 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
2020 /* Now report on what we're doing with tfind. */
2021 if (traceframe_number
>= 0)
2022 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2023 traceframe_number
, tracepoint_number
);
2025 printf_filtered (_("Not looking at any trace frame.\n"));
2027 /* Report start/stop times if supplied. */
2032 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
2034 /* Reporting a run time is more readable than two long numbers. */
2035 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2036 (long int) ts
->start_time
/ 1000000,
2037 (long int) ts
->start_time
% 1000000,
2038 (long int) run_time
/ 1000000,
2039 (long int) run_time
% 1000000);
2042 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2043 (long int) ts
->start_time
/ 1000000,
2044 (long int) ts
->start_time
% 1000000);
2046 else if (ts
->stop_time
)
2047 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2048 (long int) ts
->stop_time
/ 1000000,
2049 (long int) ts
->stop_time
% 1000000);
2051 /* Now report any per-tracepoint status available. */
2052 tp_vec
= all_tracepoints ();
2054 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2055 target_get_tracepoint_status (t
, NULL
);
2057 VEC_free (breakpoint_p
, tp_vec
);
2060 /* Report the trace status to uiout, in a way suitable for MI, and not
2061 suitable for CLI. If ON_STOP is true, suppress a few fields that
2062 are not meaningful in the -trace-stop response.
2064 The implementation is essentially parallel to trace_status_command, but
2065 merging them will result in unreadable code. */
2067 trace_status_mi (int on_stop
)
2069 struct ui_out
*uiout
= current_uiout
;
2070 struct trace_status
*ts
= current_trace_status ();
2073 status
= target_get_trace_status (ts
);
2075 if (status
== -1 && !ts
->from_file
)
2077 ui_out_field_string (uiout
, "supported", "0");
2082 ui_out_field_string (uiout
, "supported", "file");
2084 ui_out_field_string (uiout
, "supported", "1");
2086 gdb_assert (ts
->running_known
);
2090 ui_out_field_string (uiout
, "running", "1");
2092 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2093 Given that the frontend gets the status either on -trace-stop, or from
2094 -trace-status after re-connection, it does not seem like this
2095 information is necessary for anything. It is not necessary for either
2096 figuring the vital state of the target nor for navigation of trace
2097 frames. If the frontend wants to show the current state is some
2098 configure dialog, it can request the value when such dialog is
2099 invoked by the user. */
2103 char *stop_reason
= NULL
;
2104 int stopping_tracepoint
= -1;
2107 ui_out_field_string (uiout
, "running", "0");
2109 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2111 switch (ts
->stop_reason
)
2114 stop_reason
= "request";
2116 case trace_buffer_full
:
2117 stop_reason
= "overflow";
2119 case trace_disconnected
:
2120 stop_reason
= "disconnection";
2122 case tracepoint_passcount
:
2123 stop_reason
= "passcount";
2124 stopping_tracepoint
= ts
->stopping_tracepoint
;
2126 case tracepoint_error
:
2127 stop_reason
= "error";
2128 stopping_tracepoint
= ts
->stopping_tracepoint
;
2134 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2135 if (stopping_tracepoint
!= -1)
2136 ui_out_field_int (uiout
, "stopping-tracepoint",
2137 stopping_tracepoint
);
2138 if (ts
->stop_reason
== tracepoint_error
)
2139 ui_out_field_string (uiout
, "error-description",
2145 if (ts
->traceframe_count
!= -1)
2146 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2147 if (ts
->traceframes_created
!= -1)
2148 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2149 if (ts
->buffer_size
!= -1)
2150 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2151 if (ts
->buffer_free
!= -1)
2152 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2154 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2155 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2157 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2158 ui_out_field_string (uiout
, "notes", ts
->notes
);
2163 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2164 (long int) ts
->start_time
/ 1000000,
2165 (long int) ts
->start_time
% 1000000);
2166 ui_out_field_string (uiout
, "start-time", buf
);
2167 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2168 (long int) ts
->stop_time
/ 1000000,
2169 (long int) ts
->stop_time
% 1000000);
2170 ui_out_field_string (uiout
, "stop-time", buf
);
2174 /* This function handles the details of what to do about an ongoing
2175 tracing run if the user has asked to detach or otherwise disconnect
2178 disconnect_tracing (int from_tty
)
2180 /* It can happen that the target that was tracing went away on its
2181 own, and we didn't notice. Get a status update, and if the
2182 current target doesn't even do tracing, then assume it's not
2184 if (target_get_trace_status (current_trace_status ()) < 0)
2185 current_trace_status ()->running
= 0;
2187 /* If running interactively, give the user the option to cancel and
2188 then decide what to do differently with the run. Scripts are
2189 just going to disconnect and let the target deal with it,
2190 according to how it's been instructed previously via
2191 disconnected-tracing. */
2192 if (current_trace_status ()->running
&& from_tty
)
2194 process_tracepoint_on_disconnect ();
2196 if (current_trace_status ()->disconnected_tracing
)
2198 if (!query (_("Trace is running and will "
2199 "continue after detach; detach anyway? ")))
2200 error (_("Not confirmed."));
2204 if (!query (_("Trace is running but will "
2205 "stop on detach; detach anyway? ")))
2206 error (_("Not confirmed."));
2210 /* Also we want to be out of tfind mode, otherwise things can get
2211 confusing upon reconnection. Just use these calls instead of
2212 full tfind_1 behavior because we're in the middle of detaching,
2213 and there's no point to updating current stack frame etc. */
2214 set_current_traceframe (-1);
2215 set_traceframe_context (NULL
);
2218 /* Worker function for the various flavors of the tfind command. */
2220 tfind_1 (enum trace_find_type type
, int num
,
2221 ULONGEST addr1
, ULONGEST addr2
,
2224 int target_frameno
= -1, target_tracept
= -1;
2225 struct frame_id old_frame_id
= null_frame_id
;
2226 struct tracepoint
*tp
;
2227 struct ui_out
*uiout
= current_uiout
;
2229 /* Only try to get the current stack frame if we have a chance of
2230 succeeding. In particular, if we're trying to get a first trace
2231 frame while all threads are running, it's not going to succeed,
2232 so leave it with a default value and let the frame comparison
2233 below (correctly) decide to print out the source location of the
2235 if (!(type
== tfind_number
&& num
== -1)
2236 && (has_stack_frames () || traceframe_number
>= 0))
2237 old_frame_id
= get_frame_id (get_current_frame ());
2239 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2242 if (type
== tfind_number
2244 && target_frameno
== -1)
2246 /* We told the target to get out of tfind mode, and it did. */
2248 else if (target_frameno
== -1)
2250 /* A request for a non-existent trace frame has failed.
2251 Our response will be different, depending on FROM_TTY:
2253 If FROM_TTY is true, meaning that this command was
2254 typed interactively by the user, then give an error
2255 and DO NOT change the state of traceframe_number etc.
2257 However if FROM_TTY is false, meaning that we're either
2258 in a script, a loop, or a user-defined command, then
2259 DON'T give an error, but DO change the state of
2260 traceframe_number etc. to invalid.
2262 The rationalle is that if you typed the command, you
2263 might just have committed a typo or something, and you'd
2264 like to NOT lose your current debugging state. However
2265 if you're in a user-defined command or especially in a
2266 loop, then you need a way to detect that the command
2267 failed WITHOUT aborting. This allows you to write
2268 scripts that search thru the trace buffer until the end,
2269 and then continue on to do something else. */
2272 error (_("Target failed to find requested trace frame."));
2276 printf_filtered ("End of trace buffer.\n");
2277 #if 0 /* dubious now? */
2278 /* The following will not recurse, since it's
2280 trace_find_command ("-1", from_tty
);
2285 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2287 reinit_frame_cache ();
2288 registers_changed ();
2289 target_dcache_invalidate ();
2290 set_traceframe_num (target_frameno
);
2291 clear_traceframe_info ();
2292 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2293 if (target_frameno
== -1)
2294 set_traceframe_context (NULL
);
2296 set_traceframe_context (get_current_frame ());
2298 if (traceframe_number
>= 0)
2300 /* Use different branches for MI and CLI to make CLI messages
2302 if (ui_out_is_mi_like_p (uiout
))
2304 ui_out_field_string (uiout
, "found", "1");
2305 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2306 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2310 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2311 traceframe_number
, tracepoint_number
);
2316 if (ui_out_is_mi_like_p (uiout
))
2317 ui_out_field_string (uiout
, "found", "0");
2318 else if (type
== tfind_number
&& num
== -1)
2319 printf_unfiltered (_("No longer looking at any trace frame\n"));
2320 else /* This case may never occur, check. */
2321 printf_unfiltered (_("No trace frame found\n"));
2324 /* If we're in nonstop mode and getting out of looking at trace
2325 frames, there won't be any current frame to go back to and
2328 && (has_stack_frames () || traceframe_number
>= 0))
2330 enum print_what print_what
;
2332 /* NOTE: in imitation of the step command, try to determine
2333 whether we have made a transition from one function to
2334 another. If so, we'll print the "stack frame" (ie. the new
2335 function and it's arguments) -- otherwise we'll just show the
2338 if (frame_id_eq (old_frame_id
,
2339 get_frame_id (get_current_frame ())))
2340 print_what
= SRC_LINE
;
2342 print_what
= SRC_AND_LOC
;
2344 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2349 /* trace_find_command takes a trace frame number n,
2350 sends "QTFrame:<n>" to the target,
2351 and accepts a reply that may contain several optional pieces
2352 of information: a frame number, a tracepoint number, and an
2353 indication of whether this is a trap frame or a stepping frame.
2355 The minimal response is just "OK" (which indicates that the
2356 target does not give us a frame number or a tracepoint number).
2357 Instead of that, the target may send us a string containing
2359 F<hexnum> (gives the selected frame number)
2360 T<hexnum> (gives the selected tracepoint number)
2365 trace_find_command (char *args
, int from_tty
)
2366 { /* This should only be called with a numeric argument. */
2369 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2370 error (_("May not look at trace frames while trace is running."));
2372 if (args
== 0 || *args
== 0)
2373 { /* TFIND with no args means find NEXT trace frame. */
2374 if (traceframe_number
== -1)
2375 frameno
= 0; /* "next" is first one. */
2377 frameno
= traceframe_number
+ 1;
2379 else if (0 == strcmp (args
, "-"))
2381 if (traceframe_number
== -1)
2382 error (_("not debugging trace buffer"));
2383 else if (from_tty
&& traceframe_number
== 0)
2384 error (_("already at start of trace buffer"));
2386 frameno
= traceframe_number
- 1;
2388 /* A hack to work around eval's need for fp to have been collected. */
2389 else if (0 == strcmp (args
, "-1"))
2392 frameno
= parse_and_eval_long (args
);
2395 error (_("invalid input (%d is less than zero)"), frameno
);
2397 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2402 trace_find_end_command (char *args
, int from_tty
)
2404 trace_find_command ("-1", from_tty
);
2409 trace_find_none_command (char *args
, int from_tty
)
2411 trace_find_command ("-1", from_tty
);
2416 trace_find_start_command (char *args
, int from_tty
)
2418 trace_find_command ("0", from_tty
);
2421 /* tfind pc command */
2423 trace_find_pc_command (char *args
, int from_tty
)
2427 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2428 error (_("May not look at trace frames while trace is running."));
2430 if (args
== 0 || *args
== 0)
2431 pc
= regcache_read_pc (get_current_regcache ());
2433 pc
= parse_and_eval_address (args
);
2435 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2438 /* tfind tracepoint command */
2440 trace_find_tracepoint_command (char *args
, int from_tty
)
2443 struct tracepoint
*tp
;
2445 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2446 error (_("May not look at trace frames while trace is running."));
2448 if (args
== 0 || *args
== 0)
2450 if (tracepoint_number
== -1)
2451 error (_("No current tracepoint -- please supply an argument."));
2453 tdp
= tracepoint_number
; /* Default is current TDP. */
2456 tdp
= parse_and_eval_long (args
);
2458 /* If we have the tracepoint on hand, use the number that the
2459 target knows about (which may be different if we disconnected
2460 and reconnected). */
2461 tp
= get_tracepoint (tdp
);
2463 tdp
= tp
->number_on_target
;
2465 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2468 /* TFIND LINE command:
2470 This command will take a sourceline for argument, just like BREAK
2471 or TRACE (ie. anything that "decode_line_1" can handle).
2473 With no argument, this command will find the next trace frame
2474 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2477 trace_find_line_command (char *args
, int from_tty
)
2479 static CORE_ADDR start_pc
, end_pc
;
2480 struct symtabs_and_lines sals
;
2481 struct symtab_and_line sal
;
2482 struct cleanup
*old_chain
;
2484 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2485 error (_("May not look at trace frames while trace is running."));
2487 if (args
== 0 || *args
== 0)
2489 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2491 sals
.sals
= (struct symtab_and_line
*)
2492 xmalloc (sizeof (struct symtab_and_line
));
2497 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2501 old_chain
= make_cleanup (xfree
, sals
.sals
);
2502 if (sal
.symtab
== 0)
2503 error (_("No line number information available."));
2505 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2507 if (start_pc
== end_pc
)
2509 printf_filtered ("Line %d of \"%s\"",
2510 sal
.line
, sal
.symtab
->filename
);
2512 printf_filtered (" is at address ");
2513 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2515 printf_filtered (" but contains no code.\n");
2516 sal
= find_pc_line (start_pc
, 0);
2518 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2519 && start_pc
!= end_pc
)
2520 printf_filtered ("Attempting to find line %d instead.\n",
2523 error (_("Cannot find a good line."));
2527 /* Is there any case in which we get here, and have an address
2528 which the user would want to see? If we have debugging
2529 symbols and no line numbers? */
2530 error (_("Line number %d is out of range for \"%s\"."),
2531 sal
.line
, sal
.symtab
->filename
);
2533 /* Find within range of stated line. */
2535 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2537 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2538 do_cleanups (old_chain
);
2541 /* tfind range command */
2543 trace_find_range_command (char *args
, int from_tty
)
2545 static CORE_ADDR start
, stop
;
2548 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2549 error (_("May not look at trace frames while trace is running."));
2551 if (args
== 0 || *args
== 0)
2552 { /* XXX FIXME: what should default behavior be? */
2553 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2557 if (0 != (tmp
= strchr (args
, ',')))
2559 *tmp
++ = '\0'; /* Terminate start address. */
2560 while (isspace ((int) *tmp
))
2562 start
= parse_and_eval_address (args
);
2563 stop
= parse_and_eval_address (tmp
);
2566 { /* No explicit end address? */
2567 start
= parse_and_eval_address (args
);
2568 stop
= start
+ 1; /* ??? */
2571 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2574 /* tfind outside command */
2576 trace_find_outside_command (char *args
, int from_tty
)
2578 CORE_ADDR start
, stop
;
2581 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2582 error (_("May not look at trace frames while trace is running."));
2584 if (args
== 0 || *args
== 0)
2585 { /* XXX FIXME: what should default behavior be? */
2586 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2590 if (0 != (tmp
= strchr (args
, ',')))
2592 *tmp
++ = '\0'; /* Terminate start address. */
2593 while (isspace ((int) *tmp
))
2595 start
= parse_and_eval_address (args
);
2596 stop
= parse_and_eval_address (tmp
);
2599 { /* No explicit end address? */
2600 start
= parse_and_eval_address (args
);
2601 stop
= start
+ 1; /* ??? */
2604 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2607 /* info scope command: list the locals for a scope. */
2609 scope_info (char *args
, int from_tty
)
2611 struct symtabs_and_lines sals
;
2613 struct minimal_symbol
*msym
;
2614 struct block
*block
;
2615 const char *symname
;
2616 char *save_args
= args
;
2617 struct block_iterator iter
;
2619 struct gdbarch
*gdbarch
;
2622 if (args
== 0 || *args
== 0)
2623 error (_("requires an argument (function, "
2624 "line or *addr) to define a scope"));
2626 sals
= decode_line_1 (&args
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2627 if (sals
.nelts
== 0)
2628 return; /* Presumably decode_line_1 has already warned. */
2630 /* Resolve line numbers to PC. */
2631 resolve_sal_pc (&sals
.sals
[0]);
2632 block
= block_for_pc (sals
.sals
[0].pc
);
2636 QUIT
; /* Allow user to bail out with ^C. */
2637 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2639 QUIT
; /* Allow user to bail out with ^C. */
2641 printf_filtered ("Scope for %s:\n", save_args
);
2644 symname
= SYMBOL_PRINT_NAME (sym
);
2645 if (symname
== NULL
|| *symname
== '\0')
2646 continue; /* Probably botched, certainly useless. */
2648 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2650 printf_filtered ("Symbol %s is ", symname
);
2651 switch (SYMBOL_CLASS (sym
))
2654 case LOC_UNDEF
: /* Messed up symbol? */
2655 printf_filtered ("a bogus symbol, class %d.\n",
2656 SYMBOL_CLASS (sym
));
2657 count
--; /* Don't count this one. */
2660 printf_filtered ("a constant with value %s (%s)",
2661 plongest (SYMBOL_VALUE (sym
)),
2662 hex_string (SYMBOL_VALUE (sym
)));
2664 case LOC_CONST_BYTES
:
2665 printf_filtered ("constant bytes: ");
2666 if (SYMBOL_TYPE (sym
))
2667 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2668 fprintf_filtered (gdb_stdout
, " %02x",
2669 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2672 printf_filtered ("in static storage at address ");
2673 printf_filtered ("%s", paddress (gdbarch
,
2674 SYMBOL_VALUE_ADDRESS (sym
)));
2677 /* GDBARCH is the architecture associated with the objfile
2678 the symbol is defined in; the target architecture may be
2679 different, and may provide additional registers. However,
2680 we do not know the target architecture at this point.
2681 We assume the objfile architecture will contain all the
2682 standard registers that occur in debug info in that
2684 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2687 if (SYMBOL_IS_ARGUMENT (sym
))
2688 printf_filtered ("an argument in register $%s",
2689 gdbarch_register_name (gdbarch
, regno
));
2691 printf_filtered ("a local variable in register $%s",
2692 gdbarch_register_name (gdbarch
, regno
));
2695 printf_filtered ("an argument at stack/frame offset %s",
2696 plongest (SYMBOL_VALUE (sym
)));
2699 printf_filtered ("a local variable at frame offset %s",
2700 plongest (SYMBOL_VALUE (sym
)));
2703 printf_filtered ("a reference argument at offset %s",
2704 plongest (SYMBOL_VALUE (sym
)));
2706 case LOC_REGPARM_ADDR
:
2707 /* Note comment at LOC_REGISTER. */
2708 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2710 printf_filtered ("the address of an argument, in register $%s",
2711 gdbarch_register_name (gdbarch
, regno
));
2714 printf_filtered ("a typedef.\n");
2717 printf_filtered ("a label at address ");
2718 printf_filtered ("%s", paddress (gdbarch
,
2719 SYMBOL_VALUE_ADDRESS (sym
)));
2722 printf_filtered ("a function at address ");
2723 printf_filtered ("%s",
2724 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2726 case LOC_UNRESOLVED
:
2727 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2730 printf_filtered ("Unresolved Static");
2733 printf_filtered ("static storage at address ");
2734 printf_filtered ("%s",
2735 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2738 case LOC_OPTIMIZED_OUT
:
2739 printf_filtered ("optimized out.\n");
2742 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2743 BLOCK_START (block
),
2747 if (SYMBOL_TYPE (sym
))
2748 printf_filtered (", length %d.\n",
2749 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2751 if (BLOCK_FUNCTION (block
))
2754 block
= BLOCK_SUPERBLOCK (block
);
2757 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2761 /* worker function (cleanup) */
2763 replace_comma (void *data
)
2770 /* Helper for trace_dump_command. Dump the action list starting at
2771 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2772 actions of the body of a while-stepping action. STEPPING_FRAME is
2773 set if the current traceframe was determined to be a while-stepping
2777 trace_dump_actions (struct command_line
*action
,
2778 int stepping_actions
, int stepping_frame
,
2781 char *action_exp
, *next_comma
;
2783 for (; action
!= NULL
; action
= action
->next
)
2785 struct cmd_list_element
*cmd
;
2787 QUIT
; /* Allow user to bail out with ^C. */
2788 action_exp
= action
->line
;
2789 while (isspace ((int) *action_exp
))
2792 /* The collection actions to be done while stepping are
2793 bracketed by the commands "while-stepping" and "end". */
2795 if (*action_exp
== '#') /* comment line */
2798 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2800 error (_("Bad action list item: %s"), action_exp
);
2802 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2806 for (i
= 0; i
< action
->body_count
; ++i
)
2807 trace_dump_actions (action
->body_list
[i
],
2808 1, stepping_frame
, from_tty
);
2810 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2812 /* Display the collected data.
2813 For the trap frame, display only what was collected at
2814 the trap. Likewise for stepping frames, display only
2815 what was collected while stepping. This means that the
2816 two boolean variables, STEPPING_FRAME and
2817 STEPPING_ACTIONS should be equal. */
2818 if (stepping_frame
== stepping_actions
)
2820 if (*action_exp
== '/')
2821 action_exp
= decode_agent_options (action_exp
);
2824 { /* Repeat over a comma-separated list. */
2825 QUIT
; /* Allow user to bail out with ^C. */
2826 if (*action_exp
== ',')
2828 while (isspace ((int) *action_exp
))
2831 next_comma
= strchr (action_exp
, ',');
2833 if (0 == strncasecmp (action_exp
, "$reg", 4))
2834 registers_info (NULL
, from_tty
);
2835 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2837 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2838 locals_info (NULL
, from_tty
);
2839 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2840 args_info (NULL
, from_tty
);
2845 make_cleanup (replace_comma
, next_comma
);
2848 printf_filtered ("%s = ", action_exp
);
2849 output_command (action_exp
, from_tty
);
2850 printf_filtered ("\n");
2854 action_exp
= next_comma
;
2856 while (action_exp
&& *action_exp
== ',');
2862 /* The tdump command. */
2865 trace_dump_command (char *args
, int from_tty
)
2867 struct regcache
*regcache
;
2868 struct tracepoint
*t
;
2869 int stepping_frame
= 0;
2870 struct bp_location
*loc
;
2871 char *line
, *default_collect_line
= NULL
;
2872 struct command_line
*actions
, *default_collect_action
= NULL
;
2873 struct cleanup
*old_chain
= NULL
;
2875 if (tracepoint_number
== -1)
2877 warning (_("No current trace frame."));
2881 t
= get_tracepoint (tracepoint_number
);
2884 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2887 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2888 tracepoint_number
, traceframe_number
);
2890 /* The current frame is a trap frame if the frame PC is equal
2891 to the tracepoint PC. If not, then the current frame was
2892 collected during single-stepping. */
2894 regcache
= get_current_regcache ();
2896 /* If the traceframe's address matches any of the tracepoint's
2897 locations, assume it is a direct hit rather than a while-stepping
2898 frame. (FIXME this is not reliable, should record each frame's
2901 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
2902 if (loc
->address
== regcache_read_pc (regcache
))
2905 actions
= breakpoint_commands (&t
->base
);
2907 /* If there is a default-collect list, make up a collect command,
2908 prepend to the tracepoint's commands, and pass the whole mess to
2909 the trace dump scanner. We need to validate because
2910 default-collect might have been junked since the trace run. */
2911 if (*default_collect
)
2913 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2914 old_chain
= make_cleanup (xfree
, default_collect_line
);
2915 line
= default_collect_line
;
2916 validate_actionline (&line
, &t
->base
);
2917 default_collect_action
= xmalloc (sizeof (struct command_line
));
2918 make_cleanup (xfree
, default_collect_action
);
2919 default_collect_action
->next
= actions
;
2920 default_collect_action
->line
= line
;
2921 actions
= default_collect_action
;
2924 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2926 if (*default_collect
)
2927 do_cleanups (old_chain
);
2930 /* Encode a piece of a tracepoint's source-level definition in a form
2931 that is suitable for both protocol and saving in files. */
2932 /* This version does not do multiple encodes for long strings; it should
2933 return an offset to the next piece to encode. FIXME */
2936 encode_source_string (int tpnum
, ULONGEST addr
,
2937 char *srctype
, char *src
, char *buf
, int buf_size
)
2939 if (80 + strlen (srctype
) > buf_size
)
2940 error (_("Buffer too small for source encoding"));
2941 sprintf (buf
, "%x:%s:%s:%x:%x:",
2942 tpnum
, phex_nz (addr
, sizeof (addr
)),
2943 srctype
, 0, (int) strlen (src
));
2944 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2945 error (_("Source string too long for buffer"));
2946 bin2hex (src
, buf
+ strlen (buf
), 0);
2950 extern int trace_regblock_size
;
2952 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2953 non-zero, the save is performed on the target, otherwise GDB obtains all
2954 trace data and saves it locally. */
2957 trace_save (const char *filename
, int target_does_save
)
2959 struct cleanup
*cleanup
;
2961 struct trace_status
*ts
= current_trace_status ();
2964 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2965 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2969 ULONGEST offset
= 0;
2970 #define MAX_TRACE_UPLOAD 2000
2971 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2974 /* If the target is to save the data to a file on its own, then just
2975 send the command and be done with it. */
2976 if (target_does_save
)
2978 err
= target_save_trace_data (filename
);
2980 error (_("Target failed to save trace data to '%s'."),
2985 /* Get the trace status first before opening the file, so if the
2986 target is losing, we can get out without touching files. */
2987 status
= target_get_trace_status (ts
);
2989 pathname
= tilde_expand (filename
);
2990 cleanup
= make_cleanup (xfree
, pathname
);
2992 fp
= fopen (pathname
, "wb");
2994 error (_("Unable to open file '%s' for saving trace data (%s)"),
2995 filename
, safe_strerror (errno
));
2996 make_cleanup_fclose (fp
);
2998 /* Write a file header, with a high-bit-set char to indicate a
2999 binary file, plus a hint as what this file is, and a version
3000 number in case of future needs. */
3001 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
3003 perror_with_name (pathname
);
3005 /* Write descriptive info. */
3007 /* Write out the size of a register block. */
3008 fprintf (fp
, "R %x\n", trace_regblock_size
);
3010 /* Write out status of the tracing run (aka "tstatus" info). */
3011 fprintf (fp
, "status %c;%s",
3012 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
3013 if (ts
->stop_reason
== tracepoint_error
)
3015 char *buf
= (char *) alloca (strlen (ts
->stop_desc
) * 2 + 1);
3017 bin2hex ((gdb_byte
*) ts
->stop_desc
, buf
, 0);
3018 fprintf (fp
, ":%s", buf
);
3020 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
3021 if (ts
->traceframe_count
>= 0)
3022 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
3023 if (ts
->traceframes_created
>= 0)
3024 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
3025 if (ts
->buffer_free
>= 0)
3026 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
3027 if (ts
->buffer_size
>= 0)
3028 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
3029 if (ts
->disconnected_tracing
)
3030 fprintf (fp
, ";disconn:%x", ts
->disconnected_tracing
);
3031 if (ts
->circular_buffer
)
3032 fprintf (fp
, ";circular:%x", ts
->circular_buffer
);
3035 /* Note that we want to upload tracepoints and save those, rather
3036 than simply writing out the local ones, because the user may have
3037 changed tracepoints in GDB in preparation for a future tracing
3038 run, or maybe just mass-deleted all types of breakpoints as part
3039 of cleaning up. So as not to contaminate the session, leave the
3040 data in its uploaded form, don't make into real tracepoints. */
3042 /* Get trace state variables first, they may be checked when parsing
3043 uploaded commands. */
3045 target_upload_trace_state_variables (&uploaded_tsvs
);
3047 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3053 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
3054 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
3057 fprintf (fp
, "tsv %x:%s:%x:%s\n",
3058 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
3059 utsv
->builtin
, buf
);
3065 free_uploaded_tsvs (&uploaded_tsvs
);
3067 target_upload_tracepoints (&uploaded_tps
);
3069 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3070 target_get_tracepoint_status (NULL
, utp
);
3072 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3074 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
3075 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3076 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
3077 if (utp
->type
== bp_fast_tracepoint
)
3078 fprintf (fp
, ":F%x", utp
->orig_size
);
3080 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
3083 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
3084 fprintf (fp
, "tp A%x:%s:%s\n",
3085 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3086 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
3087 fprintf (fp
, "tp S%x:%s:%s\n",
3088 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3091 encode_source_string (utp
->number
, utp
->addr
,
3092 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
3093 fprintf (fp
, "tp Z%s\n", buf
);
3095 if (utp
->cond_string
)
3097 encode_source_string (utp
->number
, utp
->addr
,
3098 "cond", utp
->cond_string
,
3099 buf
, MAX_TRACE_UPLOAD
);
3100 fprintf (fp
, "tp Z%s\n", buf
);
3102 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
3104 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
3105 buf
, MAX_TRACE_UPLOAD
);
3106 fprintf (fp
, "tp Z%s\n", buf
);
3108 fprintf (fp
, "tp V%x:%s:%x:%s\n",
3109 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3111 phex_nz (utp
->traceframe_usage
,
3112 sizeof (utp
->traceframe_usage
)));
3115 free_uploaded_tps (&uploaded_tps
);
3117 /* Mark the end of the definition section. */
3120 /* Get and write the trace data proper. We ask for big blocks, in
3121 the hopes of efficiency, but will take less if the target has
3122 packet size limitations or some such. */
3125 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
3127 error (_("Failure to get requested trace buffer data"));
3128 /* No more data is forthcoming, we're done. */
3131 written
= fwrite (buf
, gotten
, 1, fp
);
3133 perror_with_name (pathname
);
3137 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
3138 written
= fwrite (&gotten
, 4, 1, fp
);
3140 perror_with_name (pathname
);
3142 do_cleanups (cleanup
);
3146 trace_save_command (char *args
, int from_tty
)
3148 int target_does_save
= 0;
3150 char *filename
= NULL
;
3151 struct cleanup
*back_to
;
3154 error_no_arg (_("file in which to save trace data"));
3156 argv
= gdb_buildargv (args
);
3157 back_to
= make_cleanup_freeargv (argv
);
3159 for (; *argv
; ++argv
)
3161 if (strcmp (*argv
, "-r") == 0)
3162 target_does_save
= 1;
3163 else if (**argv
== '-')
3164 error (_("unknown option `%s'"), *argv
);
3170 error_no_arg (_("file in which to save trace data"));
3172 trace_save (filename
, target_does_save
);
3175 printf_filtered (_("Trace data saved to file '%s'.\n"), filename
);
3177 do_cleanups (back_to
);
3180 /* Tell the target what to do with an ongoing tracing run if GDB
3181 disconnects for some reason. */
3184 set_disconnected_tracing (char *args
, int from_tty
,
3185 struct cmd_list_element
*c
)
3187 target_set_disconnected_tracing (disconnected_tracing
);
3191 set_circular_trace_buffer (char *args
, int from_tty
,
3192 struct cmd_list_element
*c
)
3194 target_set_circular_trace_buffer (circular_trace_buffer
);
3198 set_trace_user (char *args
, int from_tty
,
3199 struct cmd_list_element
*c
)
3203 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3206 warning (_("Target does not support trace notes, user ignored"));
3210 set_trace_notes (char *args
, int from_tty
,
3211 struct cmd_list_element
*c
)
3215 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3218 warning (_("Target does not support trace notes, note ignored"));
3222 set_trace_stop_notes (char *args
, int from_tty
,
3223 struct cmd_list_element
*c
)
3227 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3230 warning (_("Target does not support trace notes, stop note ignored"));
3233 /* Convert the memory pointed to by mem into hex, placing result in buf.
3234 * Return a pointer to the last char put in buf (null)
3235 * "stolen" from sparc-stub.c
3238 static const char hexchars
[] = "0123456789abcdef";
3241 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3249 *buf
++ = hexchars
[ch
>> 4];
3250 *buf
++ = hexchars
[ch
& 0xf];
3259 get_traceframe_number (void)
3261 return traceframe_number
;
3264 /* Make the traceframe NUM be the current trace frame. Does nothing
3265 if NUM is already current. */
3268 set_current_traceframe (int num
)
3272 if (traceframe_number
== num
)
3274 /* Nothing to do. */
3278 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3281 warning (_("could not change traceframe"));
3283 traceframe_number
= newnum
;
3285 /* Changing the traceframe changes our view of registers and of the
3287 registers_changed ();
3289 clear_traceframe_info ();
3292 /* Make the traceframe NUM be the current trace frame, and do nothing
3296 set_traceframe_number (int num
)
3298 traceframe_number
= num
;
3301 /* A cleanup used when switching away and back from tfind mode. */
3303 struct current_traceframe_cleanup
3305 /* The traceframe we were inspecting. */
3306 int traceframe_number
;
3310 do_restore_current_traceframe_cleanup (void *arg
)
3312 struct current_traceframe_cleanup
*old
= arg
;
3314 set_current_traceframe (old
->traceframe_number
);
3318 restore_current_traceframe_cleanup_dtor (void *arg
)
3320 struct current_traceframe_cleanup
*old
= arg
;
3326 make_cleanup_restore_current_traceframe (void)
3328 struct current_traceframe_cleanup
*old
;
3330 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3331 old
->traceframe_number
= traceframe_number
;
3333 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3334 restore_current_traceframe_cleanup_dtor
);
3338 make_cleanup_restore_traceframe_number (void)
3340 return make_cleanup_restore_integer (&traceframe_number
);
3343 /* Given a number and address, return an uploaded tracepoint with that
3344 number, creating if necessary. */
3346 struct uploaded_tp
*
3347 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3349 struct uploaded_tp
*utp
;
3351 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3352 if (utp
->number
== num
&& utp
->addr
== addr
)
3354 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3355 memset (utp
, 0, sizeof (struct uploaded_tp
));
3358 utp
->actions
= NULL
;
3359 utp
->step_actions
= NULL
;
3360 utp
->cmd_strings
= NULL
;
3367 free_uploaded_tps (struct uploaded_tp
**utpp
)
3369 struct uploaded_tp
*next_one
;
3373 next_one
= (*utpp
)->next
;
3379 /* Given a number and address, return an uploaded tracepoint with that
3380 number, creating if necessary. */
3382 static struct uploaded_tsv
*
3383 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3385 struct uploaded_tsv
*utsv
;
3387 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3388 if (utsv
->number
== num
)
3390 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3391 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3393 utsv
->next
= *utsvp
;
3399 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3401 struct uploaded_tsv
*next_one
;
3405 next_one
= (*utsvp
)->next
;
3411 /* FIXME this function is heuristic and will miss the cases where the
3412 conditional is semantically identical but differs in whitespace,
3413 such as "x == 0" vs "x==0". */
3416 cond_string_is_same (char *str1
, char *str2
)
3418 if (str1
== NULL
|| str2
== NULL
)
3419 return (str1
== str2
);
3421 return (strcmp (str1
, str2
) == 0);
3424 /* Look for an existing tracepoint that seems similar enough to the
3425 uploaded one. Enablement isn't compared, because the user can
3426 toggle that freely, and may have done so in anticipation of the
3427 next trace run. Return the location of matched tracepoint. */
3429 static struct bp_location
*
3430 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3432 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3434 struct breakpoint
*b
;
3435 struct bp_location
*loc
;
3437 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3439 struct tracepoint
*t
= (struct tracepoint
*) b
;
3441 if (b
->type
== utp
->type
3442 && t
->step_count
== utp
->step
3443 && t
->pass_count
== utp
->pass
3444 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3445 /* FIXME also test actions. */
3448 /* Scan the locations for an address match. */
3449 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3451 if (loc
->address
== utp
->addr
)
3459 /* Given a list of tracepoints uploaded from a target, attempt to
3460 match them up with existing tracepoints, and create new ones if not
3464 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3466 struct uploaded_tp
*utp
;
3468 /* Look for GDB tracepoints that match up with our uploaded versions. */
3469 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3471 struct bp_location
*loc
;
3472 struct tracepoint
*t
;
3474 loc
= find_matching_tracepoint_location (utp
);
3477 /* Mark this location as already inserted. */
3479 t
= (struct tracepoint
*) loc
->owner
;
3480 printf_filtered (_("Assuming tracepoint %d is same "
3481 "as target's tracepoint %d at %s.\n"),
3482 loc
->owner
->number
, utp
->number
,
3483 paddress (loc
->gdbarch
, utp
->addr
));
3487 t
= create_tracepoint_from_upload (utp
);
3489 printf_filtered (_("Created tracepoint %d for "
3490 "target's tracepoint %d at %s.\n"),
3491 t
->base
.number
, utp
->number
,
3492 paddress (get_current_arch (), utp
->addr
));
3494 printf_filtered (_("Failed to create tracepoint for target's "
3495 "tracepoint %d at %s, skipping it.\n"),
3497 paddress (get_current_arch (), utp
->addr
));
3499 /* Whether found or created, record the number used by the
3500 target, to help with mapping target tracepoints back to their
3501 counterparts here. */
3503 t
->number_on_target
= utp
->number
;
3506 free_uploaded_tps (uploaded_tps
);
3509 /* Trace state variables don't have much to identify them beyond their
3510 name, so just use that to detect matches. */
3512 static struct trace_state_variable
*
3513 find_matching_tsv (struct uploaded_tsv
*utsv
)
3518 return find_trace_state_variable (utsv
->name
);
3521 static struct trace_state_variable
*
3522 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3524 const char *namebase
;
3527 struct trace_state_variable
*tsv
;
3528 struct cleanup
*old_chain
;
3532 namebase
= utsv
->name
;
3533 buf
= xstrprintf ("%s", namebase
);
3538 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3541 /* Fish for a name that is not in use. */
3542 /* (should check against all internal vars?) */
3543 while (find_trace_state_variable (buf
))
3546 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3549 old_chain
= make_cleanup (xfree
, buf
);
3551 /* We have an available name, create the variable. */
3552 tsv
= create_trace_state_variable (buf
);
3553 tsv
->initial_value
= utsv
->initial_value
;
3554 tsv
->builtin
= utsv
->builtin
;
3556 do_cleanups (old_chain
);
3561 /* Given a list of uploaded trace state variables, try to match them
3562 up with existing variables, or create additional ones. */
3565 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3568 struct uploaded_tsv
*utsv
;
3569 struct trace_state_variable
*tsv
;
3572 /* Most likely some numbers will have to be reassigned as part of
3573 the merge, so clear them all in anticipation. */
3574 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3577 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3579 tsv
= find_matching_tsv (utsv
);
3583 printf_filtered (_("Assuming trace state variable $%s "
3584 "is same as target's variable %d.\n"),
3585 tsv
->name
, utsv
->number
);
3589 tsv
= create_tsv_from_upload (utsv
);
3591 printf_filtered (_("Created trace state variable "
3592 "$%s for target's variable %d.\n"),
3593 tsv
->name
, utsv
->number
);
3595 /* Give precedence to numberings that come from the target. */
3597 tsv
->number
= utsv
->number
;
3600 /* Renumber everything that didn't get a target-assigned number. */
3602 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3603 if (tsv
->number
> highest
)
3604 highest
= tsv
->number
;
3607 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3608 if (tsv
->number
== 0)
3609 tsv
->number
= highest
++;
3611 free_uploaded_tsvs (uploaded_tsvs
);
3614 /* target tfile command */
3616 struct target_ops tfile_ops
;
3618 /* Fill in tfile_ops with its defined operations and properties. */
3620 #define TRACE_HEADER_SIZE 8
3622 char *trace_filename
;
3624 off_t trace_frames_offset
;
3626 int cur_traceframe_number
;
3628 int trace_regblock_size
;
3630 static void tfile_interp_line (char *line
,
3631 struct uploaded_tp
**utpp
,
3632 struct uploaded_tsv
**utsvp
);
3634 /* Read SIZE bytes into READBUF from the trace frame, starting at
3635 TRACE_FD's current position. Note that this call `read'
3636 underneath, hence it advances the file's seek position. Throws an
3637 error if the `read' syscall fails, or less than SIZE bytes are
3641 tfile_read (gdb_byte
*readbuf
, int size
)
3645 gotten
= read (trace_fd
, readbuf
, size
);
3647 perror_with_name (trace_filename
);
3648 else if (gotten
< size
)
3649 error (_("Premature end of file while reading trace file"));
3653 tfile_open (char *filename
, int from_tty
)
3655 volatile struct gdb_exception ex
;
3657 struct cleanup
*old_chain
;
3660 char header
[TRACE_HEADER_SIZE
];
3661 char linebuf
[1000]; /* Should be max remote packet size or so. */
3664 struct trace_status
*ts
;
3665 struct uploaded_tp
*uploaded_tps
= NULL
;
3666 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3668 target_preopen (from_tty
);
3670 error (_("No trace file specified."));
3672 filename
= tilde_expand (filename
);
3673 if (!IS_ABSOLUTE_PATH(filename
))
3675 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
3680 old_chain
= make_cleanup (xfree
, filename
);
3682 flags
= O_BINARY
| O_LARGEFILE
;
3684 scratch_chan
= open (filename
, flags
, 0);
3685 if (scratch_chan
< 0)
3686 perror_with_name (filename
);
3688 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3690 discard_cleanups (old_chain
); /* Don't free filename any more. */
3691 unpush_target (&tfile_ops
);
3693 trace_filename
= xstrdup (filename
);
3694 trace_fd
= scratch_chan
;
3697 /* Read the file header and test for validity. */
3698 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
3700 bytes
+= TRACE_HEADER_SIZE
;
3701 if (!(header
[0] == 0x7f
3702 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3703 error (_("File is not a valid trace file."));
3705 push_target (&tfile_ops
);
3707 trace_regblock_size
= 0;
3708 ts
= current_trace_status ();
3709 /* We know we're working with a file. */
3711 /* Set defaults in case there is no status line. */
3712 ts
->running_known
= 0;
3713 ts
->stop_reason
= trace_stop_reason_unknown
;
3714 ts
->traceframe_count
= -1;
3715 ts
->buffer_free
= 0;
3716 ts
->disconnected_tracing
= 0;
3717 ts
->circular_buffer
= 0;
3719 cur_traceframe_number
= -1;
3721 TRY_CATCH (ex
, RETURN_MASK_ALL
)
3723 /* Read through a section of newline-terminated lines that
3724 define things like tracepoints. */
3728 tfile_read (&byte
, 1);
3733 /* Empty line marks end of the definition section. */
3738 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3741 linebuf
[i
++] = byte
;
3743 error (_("Excessively long lines in trace file"));
3746 /* Record the starting offset of the binary trace data. */
3747 trace_frames_offset
= bytes
;
3749 /* If we don't have a blocksize, we can't interpret the
3751 if (trace_regblock_size
== 0)
3752 error (_("No register block size recorded in trace file"));
3756 /* Pop the partially set up target. */
3758 throw_exception (ex
);
3761 inferior_appeared (current_inferior (), TFILE_PID
);
3762 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3763 add_thread_silent (inferior_ptid
);
3765 if (ts
->traceframe_count
<= 0)
3766 warning (_("No traceframes present in this file."));
3768 /* Add the file's tracepoints and variables into the current mix. */
3770 /* Get trace state variables first, they may be checked when parsing
3771 uploaded commands. */
3772 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3774 merge_uploaded_tracepoints (&uploaded_tps
);
3776 post_create_inferior (&tfile_ops
, from_tty
);
3779 /* Interpret the given line from the definitions part of the trace
3783 tfile_interp_line (char *line
,
3784 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3788 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3791 trace_regblock_size
= strtol (p
, &p
, 16);
3793 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3795 p
+= strlen ("status ");
3796 parse_trace_status (p
, current_trace_status ());
3798 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3800 p
+= strlen ("tp ");
3801 parse_tracepoint_definition (p
, utpp
);
3803 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3805 p
+= strlen ("tsv ");
3806 parse_tsv_definition (p
, utsvp
);
3809 warning (_("Ignoring trace file definition \"%s\""), line
);
3812 /* Parse the part of trace status syntax that is shared between
3813 the remote protocol and the trace file reader. */
3816 parse_trace_status (char *line
, struct trace_status
*ts
)
3818 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
3822 ts
->running_known
= 1;
3823 ts
->running
= (*p
++ == '1');
3824 ts
->stop_reason
= trace_stop_reason_unknown
;
3825 xfree (ts
->stop_desc
);
3826 ts
->stop_desc
= NULL
;
3827 ts
->traceframe_count
= -1;
3828 ts
->traceframes_created
= -1;
3829 ts
->buffer_free
= -1;
3830 ts
->buffer_size
= -1;
3831 ts
->disconnected_tracing
= 0;
3832 ts
->circular_buffer
= 0;
3833 xfree (ts
->user_name
);
3834 ts
->user_name
= NULL
;
3837 ts
->start_time
= ts
->stop_time
= 0;
3841 p1
= strchr (p
, ':');
3843 error (_("Malformed trace status, at %s\n\
3844 Status line: '%s'\n"), p
, line
);
3845 p3
= strchr (p
, ';');
3847 p3
= p
+ strlen (p
);
3848 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3850 p
= unpack_varlen_hex (++p1
, &val
);
3851 ts
->stop_reason
= trace_buffer_full
;
3853 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3855 p
= unpack_varlen_hex (++p1
, &val
);
3856 ts
->stop_reason
= trace_never_run
;
3858 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3861 p
= unpack_varlen_hex (++p1
, &val
);
3862 ts
->stop_reason
= tracepoint_passcount
;
3863 ts
->stopping_tracepoint
= val
;
3865 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3867 p2
= strchr (++p1
, ':');
3875 ts
->stop_desc
= xmalloc (strlen (line
));
3876 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
3877 ts
->stop_desc
[end
] = '\0';
3880 ts
->stop_desc
= xstrdup ("");
3882 p
= unpack_varlen_hex (++p2
, &val
);
3883 ts
->stop_reason
= tstop_command
;
3885 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3887 p
= unpack_varlen_hex (++p1
, &val
);
3888 ts
->stop_reason
= trace_disconnected
;
3890 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3892 p2
= strchr (++p1
, ':');
3895 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3896 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
3897 ts
->stop_desc
[end
] = '\0';
3900 ts
->stop_desc
= xstrdup ("");
3902 p
= unpack_varlen_hex (++p2
, &val
);
3903 ts
->stopping_tracepoint
= val
;
3904 ts
->stop_reason
= tracepoint_error
;
3906 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3908 p
= unpack_varlen_hex (++p1
, &val
);
3909 ts
->traceframe_count
= val
;
3911 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3913 p
= unpack_varlen_hex (++p1
, &val
);
3914 ts
->traceframes_created
= val
;
3916 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3918 p
= unpack_varlen_hex (++p1
, &val
);
3919 ts
->buffer_free
= val
;
3921 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3923 p
= unpack_varlen_hex (++p1
, &val
);
3924 ts
->buffer_size
= val
;
3926 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3928 p
= unpack_varlen_hex (++p1
, &val
);
3929 ts
->disconnected_tracing
= val
;
3931 else if (strncmp (p
, "circular", p1
- p
) == 0)
3933 p
= unpack_varlen_hex (++p1
, &val
);
3934 ts
->circular_buffer
= val
;
3936 else if (strncmp (p
, "starttime", p1
- p
) == 0)
3938 p
= unpack_varlen_hex (++p1
, &val
);
3939 ts
->start_time
= val
;
3941 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
3943 p
= unpack_varlen_hex (++p1
, &val
);
3944 ts
->stop_time
= val
;
3946 else if (strncmp (p
, "username", p1
- p
) == 0)
3949 ts
->user_name
= xmalloc (strlen (p
) / 2);
3950 end
= hex2bin (p1
, ts
->user_name
, (p3
- p1
) / 2);
3951 ts
->user_name
[end
] = '\0';
3954 else if (strncmp (p
, "notes", p1
- p
) == 0)
3957 ts
->notes
= xmalloc (strlen (p
) / 2);
3958 end
= hex2bin (p1
, ts
->notes
, (p3
- p1
) / 2);
3959 ts
->notes
[end
] = '\0';
3964 /* Silently skip unknown optional info. */
3965 p_temp
= strchr (p1
+ 1, ';');
3969 /* Must be at the end. */
3976 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
3977 struct uploaded_tp
*utp
)
3980 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
3982 p
= unpack_varlen_hex (p
, &uval
);
3984 tp
->base
.hit_count
+= uval
;
3986 utp
->hit_count
+= uval
;
3987 p
= unpack_varlen_hex (p
+ 1, &uval
);
3989 tp
->traceframe_usage
+= uval
;
3991 utp
->traceframe_usage
+= uval
;
3992 /* Ignore any extra, allowing for future extensions. */
3995 /* Given a line of text defining a part of a tracepoint, parse it into
3996 an "uploaded tracepoint". */
3999 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
4003 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
4006 char *cond
, *srctype
, *buf
;
4007 struct uploaded_tp
*utp
= NULL
;
4010 /* Both tracepoint and action definitions start with the same number
4011 and address sequence. */
4013 p
= unpack_varlen_hex (p
, &num
);
4014 p
++; /* skip a colon */
4015 p
= unpack_varlen_hex (p
, &addr
);
4016 p
++; /* skip a colon */
4019 enabled
= (*p
++ == 'E');
4020 p
++; /* skip a colon */
4021 p
= unpack_varlen_hex (p
, &step
);
4022 p
++; /* skip a colon */
4023 p
= unpack_varlen_hex (p
, &pass
);
4024 type
= bp_tracepoint
;
4026 /* Thumb through optional fields. */
4029 p
++; /* skip a colon */
4032 type
= bp_fast_tracepoint
;
4034 p
= unpack_varlen_hex (p
, &orig_size
);
4038 type
= bp_static_tracepoint
;
4044 p
= unpack_varlen_hex (p
, &xlen
);
4045 p
++; /* skip a comma */
4046 cond
= (char *) xmalloc (2 * xlen
+ 1);
4047 strncpy (cond
, p
, 2 * xlen
);
4048 cond
[2 * xlen
] = '\0';
4052 warning (_("Unrecognized char '%c' in tracepoint "
4053 "definition, skipping rest"), *p
);
4055 utp
= get_uploaded_tp (num
, addr
, utpp
);
4057 utp
->enabled
= enabled
;
4062 else if (piece
== 'A')
4064 utp
= get_uploaded_tp (num
, addr
, utpp
);
4065 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
4067 else if (piece
== 'S')
4069 utp
= get_uploaded_tp (num
, addr
, utpp
);
4070 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
4072 else if (piece
== 'Z')
4074 /* Parse a chunk of source form definition. */
4075 utp
= get_uploaded_tp (num
, addr
, utpp
);
4077 p
= strchr (p
, ':');
4078 p
++; /* skip a colon */
4079 p
= unpack_varlen_hex (p
, &start
);
4080 p
++; /* skip a colon */
4081 p
= unpack_varlen_hex (p
, &xlen
);
4082 p
++; /* skip a colon */
4084 buf
= alloca (strlen (line
));
4086 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4089 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
4090 utp
->at_string
= xstrdup (buf
);
4091 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
4092 utp
->cond_string
= xstrdup (buf
);
4093 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
4094 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
4096 else if (piece
== 'V')
4098 utp
= get_uploaded_tp (num
, addr
, utpp
);
4100 parse_tracepoint_status (p
, NULL
, utp
);
4104 /* Don't error out, the target might be sending us optional
4105 info that we don't care about. */
4106 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
4110 /* Convert a textual description of a trace state variable into an
4114 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
4117 ULONGEST num
, initval
, builtin
;
4119 struct uploaded_tsv
*utsv
= NULL
;
4121 buf
= alloca (strlen (line
));
4124 p
= unpack_varlen_hex (p
, &num
);
4125 p
++; /* skip a colon */
4126 p
= unpack_varlen_hex (p
, &initval
);
4127 p
++; /* skip a colon */
4128 p
= unpack_varlen_hex (p
, &builtin
);
4129 p
++; /* skip a colon */
4130 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4133 utsv
= get_uploaded_tsv (num
, utsvp
);
4134 utsv
->initial_value
= initval
;
4135 utsv
->builtin
= builtin
;
4136 utsv
->name
= xstrdup (buf
);
4139 /* Close the trace file and generally clean up. */
4142 tfile_close (int quitting
)
4149 pid
= ptid_get_pid (inferior_ptid
);
4150 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff. */
4151 exit_inferior_silent (pid
);
4155 xfree (trace_filename
);
4156 trace_filename
= NULL
;
4160 tfile_files_info (struct target_ops
*t
)
4162 /* (it would be useful to mention the name of the file). */
4163 printf_filtered ("Looking at a trace file.\n");
4166 /* The trace status for a file is that tracing can never be run. */
4169 tfile_get_trace_status (struct trace_status
*ts
)
4171 /* Other bits of trace status were collected as part of opening the
4172 trace files, so nothing to do here. */
4178 tfile_get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
4180 /* Other bits of trace status were collected as part of opening the
4181 trace files, so nothing to do here. */
4184 /* Given the position of a traceframe in the file, figure out what
4185 address the frame was collected at. This would normally be the
4186 value of a collected PC register, but if not available, we
4190 tfile_get_traceframe_address (off_t tframe_offset
)
4194 struct tracepoint
*tp
;
4195 off_t saved_offset
= cur_offset
;
4197 /* FIXME dig pc out of collected registers. */
4199 /* Fall back to using tracepoint address. */
4200 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
4201 tfile_read ((gdb_byte
*) &tpnum
, 2);
4202 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4206 tp
= get_tracepoint_by_number_on_target (tpnum
);
4207 /* FIXME this is a poor heuristic if multiple locations. */
4208 if (tp
&& tp
->base
.loc
)
4209 addr
= tp
->base
.loc
->address
;
4211 /* Restore our seek position. */
4212 cur_offset
= saved_offset
;
4213 lseek (trace_fd
, cur_offset
, SEEK_SET
);
4217 /* Make tfile's selected traceframe match GDB's selected
4221 set_tfile_traceframe (void)
4225 if (cur_traceframe_number
== get_traceframe_number ())
4228 /* Avoid recursion, tfile_trace_find calls us again. */
4229 cur_traceframe_number
= get_traceframe_number ();
4231 newnum
= target_trace_find (tfind_number
,
4232 get_traceframe_number (), 0, 0, NULL
);
4234 /* Should not happen. If it does, all bets are off. */
4235 if (newnum
!= get_traceframe_number ())
4236 warning (_("could not set tfile's traceframe"));
4239 /* Given a type of search and some parameters, scan the collection of
4240 traceframes in the file looking for a match. When found, return
4241 both the traceframe and tracepoint number, otherwise -1 for
4245 tfile_trace_find (enum trace_find_type type
, int num
,
4246 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
4249 int tfnum
= 0, found
= 0;
4250 unsigned int data_size
;
4251 struct tracepoint
*tp
;
4252 off_t offset
, tframe_offset
;
4255 /* Lookups other than by absolute frame number depend on the current
4256 trace selected, so make sure it is correct on the tfile end
4258 if (type
!= tfind_number
)
4259 set_tfile_traceframe ();
4267 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
4268 offset
= trace_frames_offset
;
4271 tframe_offset
= offset
;
4272 tfile_read ((gdb_byte
*) &tpnum
, 2);
4273 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4279 tfile_read ((gdb_byte
*) &data_size
, 4);
4280 data_size
= (unsigned int) extract_unsigned_integer
4281 ((gdb_byte
*) &data_size
, 4,
4282 gdbarch_byte_order (target_gdbarch
));
4291 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4292 if (tfaddr
== addr1
)
4296 tp
= get_tracepoint (num
);
4297 if (tp
&& tpnum
== tp
->number_on_target
)
4301 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4302 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
4306 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4307 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
4311 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
4317 cur_offset
= offset
;
4318 cur_data_size
= data_size
;
4319 cur_traceframe_number
= tfnum
;
4322 /* Skip past the traceframe's data. */
4323 lseek (trace_fd
, data_size
, SEEK_CUR
);
4324 offset
+= data_size
;
4325 /* Update our own count of traceframes. */
4328 /* Did not find what we were looking for. */
4334 /* Prototype of the callback passed to tframe_walk_blocks. */
4335 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
4337 /* Callback for traceframe_walk_blocks, used to find a given block
4338 type in a traceframe. */
4341 match_blocktype (char blocktype
, void *data
)
4343 char *wantedp
= data
;
4345 if (*wantedp
== blocktype
)
4351 /* Walk over all traceframe block starting at POS offset from
4352 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4353 unmodified. If CALLBACK returns true, this returns the position in
4354 the traceframe where the block is found, relative to the start of
4355 the traceframe (cur_offset). Returns -1 if no callback call
4356 returned true, indicating that all blocks have been walked. */
4359 traceframe_walk_blocks (walk_blocks_callback_func callback
,
4360 int pos
, void *data
)
4362 /* Iterate through a traceframe's blocks, looking for a block of the
4365 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
4366 while (pos
< cur_data_size
)
4368 unsigned short mlen
;
4371 tfile_read (&block_type
, 1);
4375 if ((*callback
) (block_type
, data
))
4381 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4382 pos
+= trace_regblock_size
;
4385 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4386 tfile_read ((gdb_byte
*) &mlen
, 2);
4387 mlen
= (unsigned short)
4388 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4391 lseek (trace_fd
, mlen
, SEEK_CUR
);
4392 pos
+= (8 + 2 + mlen
);
4395 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
4399 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4400 block_type
, block_type
);
4408 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4409 position offset of a block of type TYPE_WANTED in the current trace
4410 frame, starting at POS. Returns -1 if no such block was found. */
4413 traceframe_find_block_type (char type_wanted
, int pos
)
4415 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
4418 /* Look for a block of saved registers in the traceframe, and get the
4419 requested register from it. */
4422 tfile_fetch_registers (struct target_ops
*ops
,
4423 struct regcache
*regcache
, int regno
)
4425 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4426 int offset
, regn
, regsize
, pc_regno
;
4429 /* An uninitialized reg size says we're not going to be
4430 successful at getting register blocks. */
4431 if (!trace_regblock_size
)
4434 set_tfile_traceframe ();
4436 regs
= alloca (trace_regblock_size
);
4438 if (traceframe_find_block_type ('R', 0) >= 0)
4440 tfile_read (regs
, trace_regblock_size
);
4442 /* Assume the block is laid out in GDB register number order,
4443 each register with the size that it has in GDB. */
4445 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4447 regsize
= register_size (gdbarch
, regn
);
4448 /* Make sure we stay within block bounds. */
4449 if (offset
+ regsize
>= trace_regblock_size
)
4451 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
4455 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
4458 else if (regno
== -1)
4460 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
4468 /* We get here if no register data has been found. Mark registers
4470 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4471 regcache_raw_supply (regcache
, regn
, NULL
);
4473 /* We can often usefully guess that the PC is going to be the same
4474 as the address of the tracepoint. */
4475 pc_regno
= gdbarch_pc_regnum (gdbarch
);
4476 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
4478 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
4480 if (tp
&& tp
->base
.loc
)
4482 /* But don't try to guess if tracepoint is multi-location... */
4483 if (tp
->base
.loc
->next
)
4485 warning (_("Tracepoint %d has multiple "
4486 "locations, cannot infer $pc"),
4490 /* ... or does while-stepping. */
4491 if (tp
->step_count
> 0)
4493 warning (_("Tracepoint %d does while-stepping, "
4494 "cannot infer $pc"),
4499 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
4500 gdbarch_byte_order (gdbarch
),
4501 tp
->base
.loc
->address
);
4502 regcache_raw_supply (regcache
, pc_regno
, regs
);
4508 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4509 const char *annex
, gdb_byte
*readbuf
,
4510 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
4512 /* We're only doing regular memory for now. */
4513 if (object
!= TARGET_OBJECT_MEMORY
)
4516 if (readbuf
== NULL
)
4517 error (_("tfile_xfer_partial: trace file is read-only"));
4519 set_tfile_traceframe ();
4521 if (traceframe_number
!= -1)
4525 /* Iterate through the traceframe's blocks, looking for
4527 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
4529 ULONGEST maddr
, amt
;
4530 unsigned short mlen
;
4531 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
4533 tfile_read ((gdb_byte
*) &maddr
, 8);
4534 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
4536 tfile_read ((gdb_byte
*) &mlen
, 2);
4537 mlen
= (unsigned short)
4538 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
4540 /* If the block includes the first part of the desired
4541 range, return as much it has; GDB will re-request the
4542 remainder, which might be in a different block of this
4544 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
4546 amt
= (maddr
+ mlen
) - offset
;
4550 if (maddr
!= offset
)
4551 lseek (trace_fd
, offset
- maddr
, SEEK_CUR
);
4552 tfile_read (readbuf
, amt
);
4556 /* Skip over this block. */
4557 pos
+= (8 + 2 + mlen
);
4561 /* It's unduly pedantic to refuse to look at the executable for
4562 read-only pieces; so do the equivalent of readonly regions aka
4564 /* FIXME account for relocation at some point. */
4571 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
4573 if ((s
->flags
& SEC_LOAD
) == 0
4574 || (s
->flags
& SEC_READONLY
) == 0)
4578 size
= bfd_get_section_size (s
);
4579 if (vma
<= offset
&& offset
< (vma
+ size
))
4583 amt
= (vma
+ size
) - offset
;
4587 amt
= bfd_get_section_contents (exec_bfd
, s
,
4588 readbuf
, offset
- vma
, amt
);
4594 /* Indicate failure to find the requested memory block. */
4598 /* Iterate through the blocks of a trace frame, looking for a 'V'
4599 block with a matching tsv number. */
4602 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
4606 set_tfile_traceframe ();
4609 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
4613 tfile_read ((gdb_byte
*) &vnum
, 4);
4614 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
4619 tfile_read ((gdb_byte
*) val
, 8);
4620 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
4628 /* Didn't find anything. */
4633 tfile_has_all_memory (struct target_ops
*ops
)
4639 tfile_has_memory (struct target_ops
*ops
)
4645 tfile_has_stack (struct target_ops
*ops
)
4647 return traceframe_number
!= -1;
4651 tfile_has_registers (struct target_ops
*ops
)
4653 return traceframe_number
!= -1;
4657 tfile_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
4662 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
4663 object for the tfile target's current traceframe. */
4666 build_traceframe_info (char blocktype
, void *data
)
4668 struct traceframe_info
*info
= data
;
4674 struct mem_range
*r
;
4676 unsigned short mlen
;
4678 tfile_read ((gdb_byte
*) &maddr
, 8);
4679 tfile_read ((gdb_byte
*) &mlen
, 2);
4681 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4694 warning (_("Unhandled trace block type (%d) '%c ' "
4695 "while building trace frame info."),
4696 blocktype
, blocktype
);
4703 static struct traceframe_info
*
4704 tfile_traceframe_info (void)
4706 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
4708 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
4713 init_tfile_ops (void)
4715 tfile_ops
.to_shortname
= "tfile";
4716 tfile_ops
.to_longname
= "Local trace dump file";
4718 = "Use a trace file as a target. Specify the filename of the trace file.";
4719 tfile_ops
.to_open
= tfile_open
;
4720 tfile_ops
.to_close
= tfile_close
;
4721 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
4722 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
4723 tfile_ops
.to_files_info
= tfile_files_info
;
4724 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
4725 tfile_ops
.to_get_tracepoint_status
= tfile_get_tracepoint_status
;
4726 tfile_ops
.to_trace_find
= tfile_trace_find
;
4727 tfile_ops
.to_get_trace_state_variable_value
4728 = tfile_get_trace_state_variable_value
;
4729 tfile_ops
.to_stratum
= process_stratum
;
4730 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
4731 tfile_ops
.to_has_memory
= tfile_has_memory
;
4732 tfile_ops
.to_has_stack
= tfile_has_stack
;
4733 tfile_ops
.to_has_registers
= tfile_has_registers
;
4734 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
4735 tfile_ops
.to_thread_alive
= tfile_thread_alive
;
4736 tfile_ops
.to_magic
= OPS_MAGIC
;
4740 free_current_marker (void *arg
)
4742 struct static_tracepoint_marker
**marker_p
= arg
;
4744 if (*marker_p
!= NULL
)
4746 release_static_tracepoint_marker (*marker_p
);
4753 /* Given a line of text defining a static tracepoint marker, parse it
4754 into a "static tracepoint marker" object. Throws an error is
4755 parsing fails. If PP is non-null, it points to one past the end of
4756 the parsed marker definition. */
4759 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
4760 struct static_tracepoint_marker
*marker
)
4767 p
= unpack_varlen_hex (p
, &addr
);
4768 p
++; /* skip a colon */
4770 marker
->gdbarch
= target_gdbarch
;
4771 marker
->address
= (CORE_ADDR
) addr
;
4773 endp
= strchr (p
, ':');
4775 error (_("bad marker definition: %s"), line
);
4777 marker
->str_id
= xmalloc (endp
- p
+ 1);
4778 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
4779 marker
->str_id
[end
] = '\0';
4782 p
++; /* skip a colon */
4784 marker
->extra
= xmalloc (strlen (p
) + 1);
4785 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
4786 marker
->extra
[end
] = '\0';
4792 /* Release a static tracepoint marker's contents. Note that the
4793 object itself isn't released here. There objects are usually on
4797 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
4799 xfree (marker
->str_id
);
4800 marker
->str_id
= NULL
;
4803 /* Print MARKER to gdb_stdout. */
4806 print_one_static_tracepoint_marker (int count
,
4807 struct static_tracepoint_marker
*marker
)
4809 struct command_line
*l
;
4812 char wrap_indent
[80];
4813 char extra_field_indent
[80];
4814 struct ui_out
*uiout
= current_uiout
;
4815 struct cleanup
*bkpt_chain
;
4816 VEC(breakpoint_p
) *tracepoints
;
4818 struct symtab_and_line sal
;
4822 sal
.pc
= marker
->address
;
4824 tracepoints
= static_tracepoints_here (marker
->address
);
4826 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
4828 /* A counter field to help readability. This is not a stable
4830 ui_out_field_int (uiout
, "count", count
);
4832 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
4834 ui_out_field_fmt (uiout
, "enabled", "%c",
4835 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
4836 ui_out_spaces (uiout
, 2);
4838 strcpy (wrap_indent
, " ");
4840 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
4841 strcat (wrap_indent
, " ");
4843 strcat (wrap_indent
, " ");
4845 strcpy (extra_field_indent
, " ");
4847 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
4849 sal
= find_pc_line (marker
->address
, 0);
4850 sym
= find_pc_sect_function (marker
->address
, NULL
);
4853 ui_out_text (uiout
, "in ");
4854 ui_out_field_string (uiout
, "func",
4855 SYMBOL_PRINT_NAME (sym
));
4856 ui_out_wrap_hint (uiout
, wrap_indent
);
4857 ui_out_text (uiout
, " at ");
4860 ui_out_field_skip (uiout
, "func");
4862 if (sal
.symtab
!= NULL
)
4864 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
4865 ui_out_text (uiout
, ":");
4867 if (ui_out_is_mi_like_p (uiout
))
4869 char *fullname
= symtab_to_fullname (sal
.symtab
);
4872 ui_out_field_string (uiout
, "fullname", fullname
);
4875 ui_out_field_skip (uiout
, "fullname");
4877 ui_out_field_int (uiout
, "line", sal
.line
);
4881 ui_out_field_skip (uiout
, "fullname");
4882 ui_out_field_skip (uiout
, "line");
4885 ui_out_text (uiout
, "\n");
4886 ui_out_text (uiout
, extra_field_indent
);
4887 ui_out_text (uiout
, _("Data: \""));
4888 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
4889 ui_out_text (uiout
, "\"\n");
4891 if (!VEC_empty (breakpoint_p
, tracepoints
))
4893 struct cleanup
*cleanup_chain
;
4895 struct breakpoint
*b
;
4897 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
4900 ui_out_text (uiout
, extra_field_indent
);
4901 ui_out_text (uiout
, _("Probed by static tracepoints: "));
4902 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
4905 ui_out_text (uiout
, ", ");
4906 ui_out_text (uiout
, "#");
4907 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
4910 do_cleanups (cleanup_chain
);
4912 if (ui_out_is_mi_like_p (uiout
))
4913 ui_out_field_int (uiout
, "number-of-tracepoints",
4914 VEC_length(breakpoint_p
, tracepoints
));
4916 ui_out_text (uiout
, "\n");
4918 VEC_free (breakpoint_p
, tracepoints
);
4920 do_cleanups (bkpt_chain
);
4924 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
4926 VEC(static_tracepoint_marker_p
) *markers
;
4927 struct cleanup
*old_chain
;
4928 struct static_tracepoint_marker
*marker
;
4929 struct ui_out
*uiout
= current_uiout
;
4932 /* We don't have to check target_can_use_agent and agent's capability on
4933 static tracepoint here, in order to be compatible with older GDBserver.
4934 We don't check USE_AGENT is true or not, because static tracepoints
4935 don't work without in-process agent, so we don't bother users to type
4936 `set agent on' when to use static tracepoint. */
4939 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
4940 "StaticTracepointMarkersTable");
4942 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
4944 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
4946 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
4947 if (gdbarch_addr_bit (target_gdbarch
) <= 32)
4948 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
4950 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
4951 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
4953 ui_out_table_body (uiout
);
4955 markers
= target_static_tracepoint_markers_by_strid (NULL
);
4956 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
4959 VEC_iterate (static_tracepoint_marker_p
,
4960 markers
, i
, marker
);
4963 print_one_static_tracepoint_marker (i
+ 1, marker
);
4964 release_static_tracepoint_marker (marker
);
4967 do_cleanups (old_chain
);
4970 /* The $_sdata convenience variable is a bit special. We don't know
4971 for sure type of the value until we actually have a chance to fetch
4972 the data --- the size of the object depends on what has been
4973 collected. We solve this by making $_sdata be an internalvar that
4974 creates a new value on access. */
4976 /* Return a new value with the correct type for the sdata object of
4977 the current trace frame. Return a void value if there's no object
4980 static struct value
*
4981 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
4987 /* We need to read the whole object before we know its size. */
4988 size
= target_read_alloc (¤t_target
,
4989 TARGET_OBJECT_STATIC_TRACE_DATA
,
4996 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
4998 v
= allocate_value (type
);
4999 memcpy (value_contents_raw (v
), buf
, size
);
5004 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
5007 #if !defined(HAVE_LIBEXPAT)
5009 struct traceframe_info
*
5010 parse_traceframe_info (const char *tframe_info
)
5012 static int have_warned
;
5017 warning (_("Can not parse XML trace frame info; XML support "
5018 "was disabled at compile time"));
5024 #else /* HAVE_LIBEXPAT */
5026 #include "xml-support.h"
5028 /* Handle the start of a <memory> element. */
5031 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
5032 const struct gdb_xml_element
*element
,
5033 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
5035 struct traceframe_info
*info
= user_data
;
5036 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5037 ULONGEST
*start_p
, *length_p
;
5039 start_p
= xml_find_attribute (attributes
, "start")->value
;
5040 length_p
= xml_find_attribute (attributes
, "length")->value
;
5042 r
->start
= *start_p
;
5043 r
->length
= *length_p
;
5046 /* Discard the constructed trace frame info (if an error occurs). */
5049 free_result (void *p
)
5051 struct traceframe_info
*result
= p
;
5053 free_traceframe_info (result
);
5056 /* The allowed elements and attributes for an XML memory map. */
5058 static const struct gdb_xml_attribute memory_attributes
[] = {
5059 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5060 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5061 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5064 static const struct gdb_xml_element traceframe_info_children
[] = {
5065 { "memory", memory_attributes
, NULL
,
5066 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5067 traceframe_info_start_memory
, NULL
},
5068 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5071 static const struct gdb_xml_element traceframe_info_elements
[] = {
5072 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
5074 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5077 /* Parse a traceframe-info XML document. */
5079 struct traceframe_info
*
5080 parse_traceframe_info (const char *tframe_info
)
5082 struct traceframe_info
*result
;
5083 struct cleanup
*back_to
;
5085 result
= XCNEW (struct traceframe_info
);
5086 back_to
= make_cleanup (free_result
, result
);
5088 if (gdb_xml_parse_quick (_("trace frame info"),
5089 "traceframe-info.dtd", traceframe_info_elements
,
5090 tframe_info
, result
) == 0)
5092 /* Parsed successfully, keep the result. */
5093 discard_cleanups (back_to
);
5098 do_cleanups (back_to
);
5102 #endif /* HAVE_LIBEXPAT */
5104 /* Returns the traceframe_info object for the current traceframe.
5105 This is where we avoid re-fetching the object from the target if we
5106 already have it cached. */
5108 static struct traceframe_info
*
5109 get_traceframe_info (void)
5111 if (traceframe_info
== NULL
)
5112 traceframe_info
= target_traceframe_info ();
5114 return traceframe_info
;
5117 /* If the target supports the query, return in RESULT the set of
5118 collected memory in the current traceframe, found within the LEN
5119 bytes range starting at MEMADDR. Returns true if the target
5120 supports the query, otherwise returns false, and RESULT is left
5124 traceframe_available_memory (VEC(mem_range_s
) **result
,
5125 CORE_ADDR memaddr
, ULONGEST len
)
5127 struct traceframe_info
*info
= get_traceframe_info ();
5131 struct mem_range
*r
;
5136 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
5137 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
5139 ULONGEST lo1
, hi1
, lo2
, hi2
;
5140 struct mem_range
*nr
;
5143 hi1
= memaddr
+ len
;
5146 hi2
= r
->start
+ r
->length
;
5148 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
5150 nr
->start
= max (lo1
, lo2
);
5151 nr
->length
= min (hi1
, hi2
) - nr
->start
;
5154 normalize_mem_ranges (*result
);
5161 /* Implementation of `sdata' variable. */
5163 static const struct internalvar_funcs sdata_funcs
=
5170 /* module initialization */
5172 _initialize_tracepoint (void)
5174 struct cmd_list_element
*c
;
5176 /* Explicitly create without lookup, since that tries to create a
5177 value with a void typed value, and when we get here, gdbarch
5178 isn't initialized yet. At this point, we're quite sure there
5179 isn't another convenience variable of the same name. */
5180 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
5182 traceframe_number
= -1;
5183 tracepoint_number
= -1;
5185 if (tracepoint_list
.list
== NULL
)
5187 tracepoint_list
.listsize
= 128;
5188 tracepoint_list
.list
= xmalloc
5189 (tracepoint_list
.listsize
* sizeof (struct memrange
));
5191 if (tracepoint_list
.aexpr_list
== NULL
)
5193 tracepoint_list
.aexpr_listsize
= 128;
5194 tracepoint_list
.aexpr_list
= xmalloc
5195 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5198 if (stepping_list
.list
== NULL
)
5200 stepping_list
.listsize
= 128;
5201 stepping_list
.list
= xmalloc
5202 (stepping_list
.listsize
* sizeof (struct memrange
));
5205 if (stepping_list
.aexpr_list
== NULL
)
5207 stepping_list
.aexpr_listsize
= 128;
5208 stepping_list
.aexpr_list
= xmalloc
5209 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5212 add_info ("scope", scope_info
,
5213 _("List the variables local to a scope"));
5215 add_cmd ("tracepoints", class_trace
, NULL
,
5216 _("Tracing of program execution without stopping the program."),
5219 add_com ("tdump", class_trace
, trace_dump_command
,
5220 _("Print everything collected at the current tracepoint."));
5222 add_com ("tsave", class_trace
, trace_save_command
, _("\
5223 Save the trace data to a file.\n\
5224 Use the '-r' option to direct the target to save directly to the file,\n\
5225 using its own filesystem."));
5227 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
5228 Define a trace state variable.\n\
5229 Argument is a $-prefixed name, optionally followed\n\
5230 by '=' and an expression that sets the initial value\n\
5231 at the start of tracing."));
5232 set_cmd_completer (c
, expression_completer
);
5234 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
5235 Delete one or more trace state variables.\n\
5236 Arguments are the names of the variables to delete.\n\
5237 If no arguments are supplied, delete all variables."), &deletelist
);
5238 /* FIXME add a trace variable completer. */
5240 add_info ("tvariables", tvariables_info
, _("\
5241 Status of trace state variables and their values.\n\
5244 add_info ("static-tracepoint-markers",
5245 info_static_tracepoint_markers_command
, _("\
5246 List target static tracepoints markers.\n\
5249 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
5250 Select a trace frame;\n\
5251 No argument means forward by one frame; '-' means backward by one frame."),
5252 &tfindlist
, "tfind ", 1, &cmdlist
);
5254 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
5255 Select a trace frame whose PC is outside the given range (exclusive).\n\
5256 Usage: tfind outside addr1, addr2"),
5259 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
5260 Select a trace frame whose PC is in the given range (inclusive).\n\
5261 Usage: tfind range addr1,addr2"),
5264 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
5265 Select a trace frame by source line.\n\
5266 Argument can be a line number (with optional source file),\n\
5267 a function name, or '*' followed by an address.\n\
5268 Default argument is 'the next source line that was traced'."),
5271 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
5272 Select a trace frame by tracepoint number.\n\
5273 Default is the tracepoint for the current trace frame."),
5276 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
5277 Select a trace frame by PC.\n\
5278 Default is the current PC, or the PC of the current trace frame."),
5281 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
5282 Synonym for 'none'.\n\
5283 De-select any trace frame and resume 'live' debugging."),
5286 add_cmd ("none", class_trace
, trace_find_none_command
,
5287 _("De-select any trace frame and resume 'live' debugging."),
5290 add_cmd ("start", class_trace
, trace_find_start_command
,
5291 _("Select the first trace frame in the trace buffer."),
5294 add_com ("tstatus", class_trace
, trace_status_command
,
5295 _("Display the status of the current trace data collection."));
5297 add_com ("tstop", class_trace
, trace_stop_command
, _("\
5298 Stop trace data collection.\n\
5299 Usage: tstop [ <notes> ... ]\n\
5300 Any arguments supplied are recorded with the trace as a stop reason and\n\
5301 reported by tstatus (if the target supports trace notes)."));
5303 add_com ("tstart", class_trace
, trace_start_command
, _("\
5304 Start trace data collection.\n\
5305 Usage: tstart [ <notes> ... ]\n\
5306 Any arguments supplied are recorded with the trace as a note and\n\
5307 reported by tstatus (if the target supports trace notes)."));
5309 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
5310 Ends a list of commands or actions.\n\
5311 Several GDB commands allow you to enter a list of commands or actions.\n\
5312 Entering \"end\" on a line by itself is the normal way to terminate\n\
5314 Note: the \"end\" command cannot be used at the gdb prompt."));
5316 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
5317 Specify single-stepping behavior at a tracepoint.\n\
5318 Argument is number of instructions to trace in single-step mode\n\
5319 following the tracepoint. This command is normally followed by\n\
5320 one or more \"collect\" commands, to specify what to collect\n\
5321 while single-stepping.\n\n\
5322 Note: this command can only be used in a tracepoint \"actions\" list."));
5324 add_com_alias ("ws", "while-stepping", class_alias
, 0);
5325 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
5327 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
5328 Specify one or more data items to be collected at a tracepoint.\n\
5329 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5330 collect all data (variables, registers) referenced by that expression.\n\
5331 Also accepts the following special arguments:\n\
5332 $regs -- all registers.\n\
5333 $args -- all function arguments.\n\
5334 $locals -- all variables local to the block/function scope.\n\
5335 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5336 Note: this command can only be used in a tracepoint \"actions\" list."));
5338 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
5339 Specify one or more expressions to be evaluated at a tracepoint.\n\
5340 Accepts a comma-separated list of (one or more) expressions.\n\
5341 The result of each evaluation will be discarded.\n\
5342 Note: this command can only be used in a tracepoint \"actions\" list."));
5344 add_com ("actions", class_trace
, trace_actions_command
, _("\
5345 Specify the actions to be taken at a tracepoint.\n\
5346 Tracepoint actions may include collecting of specified data,\n\
5347 single-stepping, or enabling/disabling other tracepoints,\n\
5348 depending on target's capabilities."));
5350 default_collect
= xstrdup ("");
5351 add_setshow_string_cmd ("default-collect", class_trace
,
5352 &default_collect
, _("\
5353 Set the list of expressions to collect by default"), _("\
5354 Show the list of expressions to collect by default"), NULL
,
5356 &setlist
, &showlist
);
5358 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
5359 &disconnected_tracing
, _("\
5360 Set whether tracing continues after GDB disconnects."), _("\
5361 Show whether tracing continues after GDB disconnects."), _("\
5362 Use this to continue a tracing run even if GDB disconnects\n\
5363 or detaches from the target. You can reconnect later and look at\n\
5364 trace data collected in the meantime."),
5365 set_disconnected_tracing
,
5370 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
5371 &circular_trace_buffer
, _("\
5372 Set target's use of circular trace buffer."), _("\
5373 Show target's use of circular trace buffer."), _("\
5374 Use this to make the trace buffer into a circular buffer,\n\
5375 which will discard traceframes (oldest first) instead of filling\n\
5376 up and stopping the trace run."),
5377 set_circular_trace_buffer
,
5382 add_setshow_string_cmd ("trace-user", class_trace
,
5384 Set the user name to use for current and future trace runs"), _("\
5385 Show the user name to use for current and future trace runs"), NULL
,
5386 set_trace_user
, NULL
,
5387 &setlist
, &showlist
);
5389 add_setshow_string_cmd ("trace-notes", class_trace
,
5391 Set notes string to use for current and future trace runs"), _("\
5392 Show the notes string to use for current and future trace runs"), NULL
,
5393 set_trace_notes
, NULL
,
5394 &setlist
, &showlist
);
5396 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
5397 &trace_stop_notes
, _("\
5398 Set notes string to use for future tstop commands"), _("\
5399 Show the notes string to use for future tstop commands"), NULL
,
5400 set_trace_stop_notes
, NULL
,
5401 &setlist
, &showlist
);
5405 add_target (&tfile_ops
);