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_tracepoint_num (-1);
2216 set_traceframe_context (NULL
);
2219 /* Worker function for the various flavors of the tfind command. */
2221 tfind_1 (enum trace_find_type type
, int num
,
2222 ULONGEST addr1
, ULONGEST addr2
,
2225 int target_frameno
= -1, target_tracept
= -1;
2226 struct frame_id old_frame_id
= null_frame_id
;
2227 struct tracepoint
*tp
;
2228 struct ui_out
*uiout
= current_uiout
;
2230 /* Only try to get the current stack frame if we have a chance of
2231 succeeding. In particular, if we're trying to get a first trace
2232 frame while all threads are running, it's not going to succeed,
2233 so leave it with a default value and let the frame comparison
2234 below (correctly) decide to print out the source location of the
2236 if (!(type
== tfind_number
&& num
== -1)
2237 && (has_stack_frames () || traceframe_number
>= 0))
2238 old_frame_id
= get_frame_id (get_current_frame ());
2240 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2243 if (type
== tfind_number
2245 && target_frameno
== -1)
2247 /* We told the target to get out of tfind mode, and it did. */
2249 else if (target_frameno
== -1)
2251 /* A request for a non-existent trace frame has failed.
2252 Our response will be different, depending on FROM_TTY:
2254 If FROM_TTY is true, meaning that this command was
2255 typed interactively by the user, then give an error
2256 and DO NOT change the state of traceframe_number etc.
2258 However if FROM_TTY is false, meaning that we're either
2259 in a script, a loop, or a user-defined command, then
2260 DON'T give an error, but DO change the state of
2261 traceframe_number etc. to invalid.
2263 The rationalle is that if you typed the command, you
2264 might just have committed a typo or something, and you'd
2265 like to NOT lose your current debugging state. However
2266 if you're in a user-defined command or especially in a
2267 loop, then you need a way to detect that the command
2268 failed WITHOUT aborting. This allows you to write
2269 scripts that search thru the trace buffer until the end,
2270 and then continue on to do something else. */
2273 error (_("Target failed to find requested trace frame."));
2277 printf_filtered ("End of trace buffer.\n");
2278 #if 0 /* dubious now? */
2279 /* The following will not recurse, since it's
2281 trace_find_command ("-1", from_tty
);
2286 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2288 reinit_frame_cache ();
2289 target_dcache_invalidate ();
2291 set_current_traceframe (target_frameno
);
2293 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2294 if (target_frameno
== -1)
2295 set_traceframe_context (NULL
);
2297 set_traceframe_context (get_current_frame ());
2299 if (traceframe_number
>= 0)
2301 /* Use different branches for MI and CLI to make CLI messages
2303 if (ui_out_is_mi_like_p (uiout
))
2305 ui_out_field_string (uiout
, "found", "1");
2306 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2307 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2311 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2312 traceframe_number
, tracepoint_number
);
2317 if (ui_out_is_mi_like_p (uiout
))
2318 ui_out_field_string (uiout
, "found", "0");
2319 else if (type
== tfind_number
&& num
== -1)
2320 printf_unfiltered (_("No longer looking at any trace frame\n"));
2321 else /* This case may never occur, check. */
2322 printf_unfiltered (_("No trace frame found\n"));
2325 /* If we're in nonstop mode and getting out of looking at trace
2326 frames, there won't be any current frame to go back to and
2329 && (has_stack_frames () || traceframe_number
>= 0))
2331 enum print_what print_what
;
2333 /* NOTE: in imitation of the step command, try to determine
2334 whether we have made a transition from one function to
2335 another. If so, we'll print the "stack frame" (ie. the new
2336 function and it's arguments) -- otherwise we'll just show the
2339 if (frame_id_eq (old_frame_id
,
2340 get_frame_id (get_current_frame ())))
2341 print_what
= SRC_LINE
;
2343 print_what
= SRC_AND_LOC
;
2345 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2350 /* trace_find_command takes a trace frame number n,
2351 sends "QTFrame:<n>" to the target,
2352 and accepts a reply that may contain several optional pieces
2353 of information: a frame number, a tracepoint number, and an
2354 indication of whether this is a trap frame or a stepping frame.
2356 The minimal response is just "OK" (which indicates that the
2357 target does not give us a frame number or a tracepoint number).
2358 Instead of that, the target may send us a string containing
2360 F<hexnum> (gives the selected frame number)
2361 T<hexnum> (gives the selected tracepoint number)
2366 trace_find_command (char *args
, int from_tty
)
2367 { /* This should only be called with a numeric argument. */
2370 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2371 error (_("May not look at trace frames while trace is running."));
2373 if (args
== 0 || *args
== 0)
2374 { /* TFIND with no args means find NEXT trace frame. */
2375 if (traceframe_number
== -1)
2376 frameno
= 0; /* "next" is first one. */
2378 frameno
= traceframe_number
+ 1;
2380 else if (0 == strcmp (args
, "-"))
2382 if (traceframe_number
== -1)
2383 error (_("not debugging trace buffer"));
2384 else if (from_tty
&& traceframe_number
== 0)
2385 error (_("already at start of trace buffer"));
2387 frameno
= traceframe_number
- 1;
2389 /* A hack to work around eval's need for fp to have been collected. */
2390 else if (0 == strcmp (args
, "-1"))
2393 frameno
= parse_and_eval_long (args
);
2396 error (_("invalid input (%d is less than zero)"), frameno
);
2398 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2403 trace_find_end_command (char *args
, int from_tty
)
2405 trace_find_command ("-1", from_tty
);
2410 trace_find_start_command (char *args
, int from_tty
)
2412 trace_find_command ("0", from_tty
);
2415 /* tfind pc command */
2417 trace_find_pc_command (char *args
, int from_tty
)
2421 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2422 error (_("May not look at trace frames while trace is running."));
2424 if (args
== 0 || *args
== 0)
2425 pc
= regcache_read_pc (get_current_regcache ());
2427 pc
= parse_and_eval_address (args
);
2429 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2432 /* tfind tracepoint command */
2434 trace_find_tracepoint_command (char *args
, int from_tty
)
2437 struct tracepoint
*tp
;
2439 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2440 error (_("May not look at trace frames while trace is running."));
2442 if (args
== 0 || *args
== 0)
2444 if (tracepoint_number
== -1)
2445 error (_("No current tracepoint -- please supply an argument."));
2447 tdp
= tracepoint_number
; /* Default is current TDP. */
2450 tdp
= parse_and_eval_long (args
);
2452 /* If we have the tracepoint on hand, use the number that the
2453 target knows about (which may be different if we disconnected
2454 and reconnected). */
2455 tp
= get_tracepoint (tdp
);
2457 tdp
= tp
->number_on_target
;
2459 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2462 /* TFIND LINE command:
2464 This command will take a sourceline for argument, just like BREAK
2465 or TRACE (ie. anything that "decode_line_1" can handle).
2467 With no argument, this command will find the next trace frame
2468 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2471 trace_find_line_command (char *args
, int from_tty
)
2473 static CORE_ADDR start_pc
, end_pc
;
2474 struct symtabs_and_lines sals
;
2475 struct symtab_and_line sal
;
2476 struct cleanup
*old_chain
;
2478 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2479 error (_("May not look at trace frames while trace is running."));
2481 if (args
== 0 || *args
== 0)
2483 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2485 sals
.sals
= (struct symtab_and_line
*)
2486 xmalloc (sizeof (struct symtab_and_line
));
2491 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2495 old_chain
= make_cleanup (xfree
, sals
.sals
);
2496 if (sal
.symtab
== 0)
2497 error (_("No line number information available."));
2499 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2501 if (start_pc
== end_pc
)
2503 printf_filtered ("Line %d of \"%s\"",
2504 sal
.line
, sal
.symtab
->filename
);
2506 printf_filtered (" is at address ");
2507 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2509 printf_filtered (" but contains no code.\n");
2510 sal
= find_pc_line (start_pc
, 0);
2512 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2513 && start_pc
!= end_pc
)
2514 printf_filtered ("Attempting to find line %d instead.\n",
2517 error (_("Cannot find a good line."));
2521 /* Is there any case in which we get here, and have an address
2522 which the user would want to see? If we have debugging
2523 symbols and no line numbers? */
2524 error (_("Line number %d is out of range for \"%s\"."),
2525 sal
.line
, sal
.symtab
->filename
);
2527 /* Find within range of stated line. */
2529 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2531 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2532 do_cleanups (old_chain
);
2535 /* tfind range command */
2537 trace_find_range_command (char *args
, int from_tty
)
2539 static CORE_ADDR start
, stop
;
2542 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2543 error (_("May not look at trace frames while trace is running."));
2545 if (args
== 0 || *args
== 0)
2546 { /* XXX FIXME: what should default behavior be? */
2547 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2551 if (0 != (tmp
= strchr (args
, ',')))
2553 *tmp
++ = '\0'; /* Terminate start address. */
2554 while (isspace ((int) *tmp
))
2556 start
= parse_and_eval_address (args
);
2557 stop
= parse_and_eval_address (tmp
);
2560 { /* No explicit end address? */
2561 start
= parse_and_eval_address (args
);
2562 stop
= start
+ 1; /* ??? */
2565 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2568 /* tfind outside command */
2570 trace_find_outside_command (char *args
, int from_tty
)
2572 CORE_ADDR start
, stop
;
2575 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2576 error (_("May not look at trace frames while trace is running."));
2578 if (args
== 0 || *args
== 0)
2579 { /* XXX FIXME: what should default behavior be? */
2580 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2584 if (0 != (tmp
= strchr (args
, ',')))
2586 *tmp
++ = '\0'; /* Terminate start address. */
2587 while (isspace ((int) *tmp
))
2589 start
= parse_and_eval_address (args
);
2590 stop
= parse_and_eval_address (tmp
);
2593 { /* No explicit end address? */
2594 start
= parse_and_eval_address (args
);
2595 stop
= start
+ 1; /* ??? */
2598 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2601 /* info scope command: list the locals for a scope. */
2603 scope_info (char *args
, int from_tty
)
2605 struct symtabs_and_lines sals
;
2607 struct minimal_symbol
*msym
;
2608 struct block
*block
;
2609 const char *symname
;
2610 char *save_args
= args
;
2611 struct block_iterator iter
;
2613 struct gdbarch
*gdbarch
;
2616 if (args
== 0 || *args
== 0)
2617 error (_("requires an argument (function, "
2618 "line or *addr) to define a scope"));
2620 sals
= decode_line_1 (&args
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2621 if (sals
.nelts
== 0)
2622 return; /* Presumably decode_line_1 has already warned. */
2624 /* Resolve line numbers to PC. */
2625 resolve_sal_pc (&sals
.sals
[0]);
2626 block
= block_for_pc (sals
.sals
[0].pc
);
2630 QUIT
; /* Allow user to bail out with ^C. */
2631 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2633 QUIT
; /* Allow user to bail out with ^C. */
2635 printf_filtered ("Scope for %s:\n", save_args
);
2638 symname
= SYMBOL_PRINT_NAME (sym
);
2639 if (symname
== NULL
|| *symname
== '\0')
2640 continue; /* Probably botched, certainly useless. */
2642 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2644 printf_filtered ("Symbol %s is ", symname
);
2645 switch (SYMBOL_CLASS (sym
))
2648 case LOC_UNDEF
: /* Messed up symbol? */
2649 printf_filtered ("a bogus symbol, class %d.\n",
2650 SYMBOL_CLASS (sym
));
2651 count
--; /* Don't count this one. */
2654 printf_filtered ("a constant with value %s (%s)",
2655 plongest (SYMBOL_VALUE (sym
)),
2656 hex_string (SYMBOL_VALUE (sym
)));
2658 case LOC_CONST_BYTES
:
2659 printf_filtered ("constant bytes: ");
2660 if (SYMBOL_TYPE (sym
))
2661 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2662 fprintf_filtered (gdb_stdout
, " %02x",
2663 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2666 printf_filtered ("in static storage at address ");
2667 printf_filtered ("%s", paddress (gdbarch
,
2668 SYMBOL_VALUE_ADDRESS (sym
)));
2671 /* GDBARCH is the architecture associated with the objfile
2672 the symbol is defined in; the target architecture may be
2673 different, and may provide additional registers. However,
2674 we do not know the target architecture at this point.
2675 We assume the objfile architecture will contain all the
2676 standard registers that occur in debug info in that
2678 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2681 if (SYMBOL_IS_ARGUMENT (sym
))
2682 printf_filtered ("an argument in register $%s",
2683 gdbarch_register_name (gdbarch
, regno
));
2685 printf_filtered ("a local variable in register $%s",
2686 gdbarch_register_name (gdbarch
, regno
));
2689 printf_filtered ("an argument at stack/frame offset %s",
2690 plongest (SYMBOL_VALUE (sym
)));
2693 printf_filtered ("a local variable at frame offset %s",
2694 plongest (SYMBOL_VALUE (sym
)));
2697 printf_filtered ("a reference argument at offset %s",
2698 plongest (SYMBOL_VALUE (sym
)));
2700 case LOC_REGPARM_ADDR
:
2701 /* Note comment at LOC_REGISTER. */
2702 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2704 printf_filtered ("the address of an argument, in register $%s",
2705 gdbarch_register_name (gdbarch
, regno
));
2708 printf_filtered ("a typedef.\n");
2711 printf_filtered ("a label at address ");
2712 printf_filtered ("%s", paddress (gdbarch
,
2713 SYMBOL_VALUE_ADDRESS (sym
)));
2716 printf_filtered ("a function at address ");
2717 printf_filtered ("%s",
2718 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2720 case LOC_UNRESOLVED
:
2721 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2724 printf_filtered ("Unresolved Static");
2727 printf_filtered ("static storage at address ");
2728 printf_filtered ("%s",
2729 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2732 case LOC_OPTIMIZED_OUT
:
2733 printf_filtered ("optimized out.\n");
2736 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2737 BLOCK_START (block
),
2741 if (SYMBOL_TYPE (sym
))
2742 printf_filtered (", length %d.\n",
2743 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2745 if (BLOCK_FUNCTION (block
))
2748 block
= BLOCK_SUPERBLOCK (block
);
2751 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2755 /* worker function (cleanup) */
2757 replace_comma (void *data
)
2764 /* Helper for trace_dump_command. Dump the action list starting at
2765 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2766 actions of the body of a while-stepping action. STEPPING_FRAME is
2767 set if the current traceframe was determined to be a while-stepping
2771 trace_dump_actions (struct command_line
*action
,
2772 int stepping_actions
, int stepping_frame
,
2775 char *action_exp
, *next_comma
;
2777 for (; action
!= NULL
; action
= action
->next
)
2779 struct cmd_list_element
*cmd
;
2781 QUIT
; /* Allow user to bail out with ^C. */
2782 action_exp
= action
->line
;
2783 while (isspace ((int) *action_exp
))
2786 /* The collection actions to be done while stepping are
2787 bracketed by the commands "while-stepping" and "end". */
2789 if (*action_exp
== '#') /* comment line */
2792 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2794 error (_("Bad action list item: %s"), action_exp
);
2796 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2800 for (i
= 0; i
< action
->body_count
; ++i
)
2801 trace_dump_actions (action
->body_list
[i
],
2802 1, stepping_frame
, from_tty
);
2804 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2806 /* Display the collected data.
2807 For the trap frame, display only what was collected at
2808 the trap. Likewise for stepping frames, display only
2809 what was collected while stepping. This means that the
2810 two boolean variables, STEPPING_FRAME and
2811 STEPPING_ACTIONS should be equal. */
2812 if (stepping_frame
== stepping_actions
)
2814 if (*action_exp
== '/')
2815 action_exp
= decode_agent_options (action_exp
);
2818 { /* Repeat over a comma-separated list. */
2819 QUIT
; /* Allow user to bail out with ^C. */
2820 if (*action_exp
== ',')
2822 while (isspace ((int) *action_exp
))
2825 next_comma
= strchr (action_exp
, ',');
2827 if (0 == strncasecmp (action_exp
, "$reg", 4))
2828 registers_info (NULL
, from_tty
);
2829 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2831 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2832 locals_info (NULL
, from_tty
);
2833 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2834 args_info (NULL
, from_tty
);
2839 make_cleanup (replace_comma
, next_comma
);
2842 printf_filtered ("%s = ", action_exp
);
2843 output_command (action_exp
, from_tty
);
2844 printf_filtered ("\n");
2848 action_exp
= next_comma
;
2850 while (action_exp
&& *action_exp
== ',');
2856 /* The tdump command. */
2859 trace_dump_command (char *args
, int from_tty
)
2861 struct regcache
*regcache
;
2862 struct tracepoint
*t
;
2863 int stepping_frame
= 0;
2864 struct bp_location
*loc
;
2865 char *line
, *default_collect_line
= NULL
;
2866 struct command_line
*actions
, *default_collect_action
= NULL
;
2867 struct cleanup
*old_chain
= NULL
;
2869 if (tracepoint_number
== -1)
2871 warning (_("No current trace frame."));
2875 t
= get_tracepoint (tracepoint_number
);
2878 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2881 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2882 tracepoint_number
, traceframe_number
);
2884 /* The current frame is a trap frame if the frame PC is equal
2885 to the tracepoint PC. If not, then the current frame was
2886 collected during single-stepping. */
2888 regcache
= get_current_regcache ();
2890 /* If the traceframe's address matches any of the tracepoint's
2891 locations, assume it is a direct hit rather than a while-stepping
2892 frame. (FIXME this is not reliable, should record each frame's
2895 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
2896 if (loc
->address
== regcache_read_pc (regcache
))
2899 actions
= breakpoint_commands (&t
->base
);
2901 /* If there is a default-collect list, make up a collect command,
2902 prepend to the tracepoint's commands, and pass the whole mess to
2903 the trace dump scanner. We need to validate because
2904 default-collect might have been junked since the trace run. */
2905 if (*default_collect
)
2907 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2908 old_chain
= make_cleanup (xfree
, default_collect_line
);
2909 line
= default_collect_line
;
2910 validate_actionline (&line
, &t
->base
);
2911 default_collect_action
= xmalloc (sizeof (struct command_line
));
2912 make_cleanup (xfree
, default_collect_action
);
2913 default_collect_action
->next
= actions
;
2914 default_collect_action
->line
= line
;
2915 actions
= default_collect_action
;
2918 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2920 if (*default_collect
)
2921 do_cleanups (old_chain
);
2924 /* Encode a piece of a tracepoint's source-level definition in a form
2925 that is suitable for both protocol and saving in files. */
2926 /* This version does not do multiple encodes for long strings; it should
2927 return an offset to the next piece to encode. FIXME */
2930 encode_source_string (int tpnum
, ULONGEST addr
,
2931 char *srctype
, char *src
, char *buf
, int buf_size
)
2933 if (80 + strlen (srctype
) > buf_size
)
2934 error (_("Buffer too small for source encoding"));
2935 sprintf (buf
, "%x:%s:%s:%x:%x:",
2936 tpnum
, phex_nz (addr
, sizeof (addr
)),
2937 srctype
, 0, (int) strlen (src
));
2938 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2939 error (_("Source string too long for buffer"));
2940 bin2hex (src
, buf
+ strlen (buf
), 0);
2944 extern int trace_regblock_size
;
2946 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2947 non-zero, the save is performed on the target, otherwise GDB obtains all
2948 trace data and saves it locally. */
2951 trace_save (const char *filename
, int target_does_save
)
2953 struct cleanup
*cleanup
;
2955 struct trace_status
*ts
= current_trace_status ();
2958 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2959 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2963 ULONGEST offset
= 0;
2964 #define MAX_TRACE_UPLOAD 2000
2965 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2968 /* If the target is to save the data to a file on its own, then just
2969 send the command and be done with it. */
2970 if (target_does_save
)
2972 err
= target_save_trace_data (filename
);
2974 error (_("Target failed to save trace data to '%s'."),
2979 /* Get the trace status first before opening the file, so if the
2980 target is losing, we can get out without touching files. */
2981 status
= target_get_trace_status (ts
);
2983 pathname
= tilde_expand (filename
);
2984 cleanup
= make_cleanup (xfree
, pathname
);
2986 fp
= fopen (pathname
, "wb");
2988 error (_("Unable to open file '%s' for saving trace data (%s)"),
2989 filename
, safe_strerror (errno
));
2990 make_cleanup_fclose (fp
);
2992 /* Write a file header, with a high-bit-set char to indicate a
2993 binary file, plus a hint as what this file is, and a version
2994 number in case of future needs. */
2995 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2997 perror_with_name (pathname
);
2999 /* Write descriptive info. */
3001 /* Write out the size of a register block. */
3002 fprintf (fp
, "R %x\n", trace_regblock_size
);
3004 /* Write out status of the tracing run (aka "tstatus" info). */
3005 fprintf (fp
, "status %c;%s",
3006 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
3007 if (ts
->stop_reason
== tracepoint_error
)
3009 char *buf
= (char *) alloca (strlen (ts
->stop_desc
) * 2 + 1);
3011 bin2hex ((gdb_byte
*) ts
->stop_desc
, buf
, 0);
3012 fprintf (fp
, ":%s", buf
);
3014 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
3015 if (ts
->traceframe_count
>= 0)
3016 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
3017 if (ts
->traceframes_created
>= 0)
3018 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
3019 if (ts
->buffer_free
>= 0)
3020 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
3021 if (ts
->buffer_size
>= 0)
3022 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
3023 if (ts
->disconnected_tracing
)
3024 fprintf (fp
, ";disconn:%x", ts
->disconnected_tracing
);
3025 if (ts
->circular_buffer
)
3026 fprintf (fp
, ";circular:%x", ts
->circular_buffer
);
3029 /* Note that we want to upload tracepoints and save those, rather
3030 than simply writing out the local ones, because the user may have
3031 changed tracepoints in GDB in preparation for a future tracing
3032 run, or maybe just mass-deleted all types of breakpoints as part
3033 of cleaning up. So as not to contaminate the session, leave the
3034 data in its uploaded form, don't make into real tracepoints. */
3036 /* Get trace state variables first, they may be checked when parsing
3037 uploaded commands. */
3039 target_upload_trace_state_variables (&uploaded_tsvs
);
3041 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3047 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
3048 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
3051 fprintf (fp
, "tsv %x:%s:%x:%s\n",
3052 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
3053 utsv
->builtin
, buf
);
3059 free_uploaded_tsvs (&uploaded_tsvs
);
3061 target_upload_tracepoints (&uploaded_tps
);
3063 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3064 target_get_tracepoint_status (NULL
, utp
);
3066 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3068 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
3069 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3070 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
3071 if (utp
->type
== bp_fast_tracepoint
)
3072 fprintf (fp
, ":F%x", utp
->orig_size
);
3074 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
3077 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
3078 fprintf (fp
, "tp A%x:%s:%s\n",
3079 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3080 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
3081 fprintf (fp
, "tp S%x:%s:%s\n",
3082 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3085 encode_source_string (utp
->number
, utp
->addr
,
3086 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
3087 fprintf (fp
, "tp Z%s\n", buf
);
3089 if (utp
->cond_string
)
3091 encode_source_string (utp
->number
, utp
->addr
,
3092 "cond", utp
->cond_string
,
3093 buf
, MAX_TRACE_UPLOAD
);
3094 fprintf (fp
, "tp Z%s\n", buf
);
3096 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
3098 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
3099 buf
, MAX_TRACE_UPLOAD
);
3100 fprintf (fp
, "tp Z%s\n", buf
);
3102 fprintf (fp
, "tp V%x:%s:%x:%s\n",
3103 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3105 phex_nz (utp
->traceframe_usage
,
3106 sizeof (utp
->traceframe_usage
)));
3109 free_uploaded_tps (&uploaded_tps
);
3111 /* Mark the end of the definition section. */
3114 /* Get and write the trace data proper. We ask for big blocks, in
3115 the hopes of efficiency, but will take less if the target has
3116 packet size limitations or some such. */
3119 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
3121 error (_("Failure to get requested trace buffer data"));
3122 /* No more data is forthcoming, we're done. */
3125 written
= fwrite (buf
, gotten
, 1, fp
);
3127 perror_with_name (pathname
);
3131 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
3132 written
= fwrite (&gotten
, 4, 1, fp
);
3134 perror_with_name (pathname
);
3136 do_cleanups (cleanup
);
3140 trace_save_command (char *args
, int from_tty
)
3142 int target_does_save
= 0;
3144 char *filename
= NULL
;
3145 struct cleanup
*back_to
;
3148 error_no_arg (_("file in which to save trace data"));
3150 argv
= gdb_buildargv (args
);
3151 back_to
= make_cleanup_freeargv (argv
);
3153 for (; *argv
; ++argv
)
3155 if (strcmp (*argv
, "-r") == 0)
3156 target_does_save
= 1;
3157 else if (**argv
== '-')
3158 error (_("unknown option `%s'"), *argv
);
3164 error_no_arg (_("file in which to save trace data"));
3166 trace_save (filename
, target_does_save
);
3169 printf_filtered (_("Trace data saved to file '%s'.\n"), filename
);
3171 do_cleanups (back_to
);
3174 /* Tell the target what to do with an ongoing tracing run if GDB
3175 disconnects for some reason. */
3178 set_disconnected_tracing (char *args
, int from_tty
,
3179 struct cmd_list_element
*c
)
3181 target_set_disconnected_tracing (disconnected_tracing
);
3185 set_circular_trace_buffer (char *args
, int from_tty
,
3186 struct cmd_list_element
*c
)
3188 target_set_circular_trace_buffer (circular_trace_buffer
);
3192 set_trace_user (char *args
, int from_tty
,
3193 struct cmd_list_element
*c
)
3197 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3200 warning (_("Target does not support trace notes, user ignored"));
3204 set_trace_notes (char *args
, int from_tty
,
3205 struct cmd_list_element
*c
)
3209 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3212 warning (_("Target does not support trace notes, note ignored"));
3216 set_trace_stop_notes (char *args
, int from_tty
,
3217 struct cmd_list_element
*c
)
3221 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3224 warning (_("Target does not support trace notes, stop note ignored"));
3227 /* Convert the memory pointed to by mem into hex, placing result in buf.
3228 * Return a pointer to the last char put in buf (null)
3229 * "stolen" from sparc-stub.c
3232 static const char hexchars
[] = "0123456789abcdef";
3235 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3243 *buf
++ = hexchars
[ch
>> 4];
3244 *buf
++ = hexchars
[ch
& 0xf];
3253 get_traceframe_number (void)
3255 return traceframe_number
;
3258 /* Make the traceframe NUM be the current trace frame. Does nothing
3259 if NUM is already current. */
3262 set_current_traceframe (int num
)
3266 if (traceframe_number
== num
)
3268 /* Nothing to do. */
3272 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3275 warning (_("could not change traceframe"));
3277 set_traceframe_num (newnum
);
3279 /* Changing the traceframe changes our view of registers and of the
3281 registers_changed ();
3283 clear_traceframe_info ();
3286 /* Make the traceframe NUM be the current trace frame, and do nothing
3290 set_traceframe_number (int num
)
3292 traceframe_number
= num
;
3295 /* A cleanup used when switching away and back from tfind mode. */
3297 struct current_traceframe_cleanup
3299 /* The traceframe we were inspecting. */
3300 int traceframe_number
;
3304 do_restore_current_traceframe_cleanup (void *arg
)
3306 struct current_traceframe_cleanup
*old
= arg
;
3308 set_current_traceframe (old
->traceframe_number
);
3312 restore_current_traceframe_cleanup_dtor (void *arg
)
3314 struct current_traceframe_cleanup
*old
= arg
;
3320 make_cleanup_restore_current_traceframe (void)
3322 struct current_traceframe_cleanup
*old
;
3324 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3325 old
->traceframe_number
= traceframe_number
;
3327 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3328 restore_current_traceframe_cleanup_dtor
);
3332 make_cleanup_restore_traceframe_number (void)
3334 return make_cleanup_restore_integer (&traceframe_number
);
3337 /* Given a number and address, return an uploaded tracepoint with that
3338 number, creating if necessary. */
3340 struct uploaded_tp
*
3341 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3343 struct uploaded_tp
*utp
;
3345 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3346 if (utp
->number
== num
&& utp
->addr
== addr
)
3348 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3349 memset (utp
, 0, sizeof (struct uploaded_tp
));
3352 utp
->actions
= NULL
;
3353 utp
->step_actions
= NULL
;
3354 utp
->cmd_strings
= NULL
;
3361 free_uploaded_tps (struct uploaded_tp
**utpp
)
3363 struct uploaded_tp
*next_one
;
3367 next_one
= (*utpp
)->next
;
3373 /* Given a number and address, return an uploaded tracepoint with that
3374 number, creating if necessary. */
3376 static struct uploaded_tsv
*
3377 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3379 struct uploaded_tsv
*utsv
;
3381 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3382 if (utsv
->number
== num
)
3384 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3385 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3387 utsv
->next
= *utsvp
;
3393 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3395 struct uploaded_tsv
*next_one
;
3399 next_one
= (*utsvp
)->next
;
3405 /* FIXME this function is heuristic and will miss the cases where the
3406 conditional is semantically identical but differs in whitespace,
3407 such as "x == 0" vs "x==0". */
3410 cond_string_is_same (char *str1
, char *str2
)
3412 if (str1
== NULL
|| str2
== NULL
)
3413 return (str1
== str2
);
3415 return (strcmp (str1
, str2
) == 0);
3418 /* Look for an existing tracepoint that seems similar enough to the
3419 uploaded one. Enablement isn't compared, because the user can
3420 toggle that freely, and may have done so in anticipation of the
3421 next trace run. Return the location of matched tracepoint. */
3423 static struct bp_location
*
3424 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3426 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3428 struct breakpoint
*b
;
3429 struct bp_location
*loc
;
3431 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3433 struct tracepoint
*t
= (struct tracepoint
*) b
;
3435 if (b
->type
== utp
->type
3436 && t
->step_count
== utp
->step
3437 && t
->pass_count
== utp
->pass
3438 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3439 /* FIXME also test actions. */
3442 /* Scan the locations for an address match. */
3443 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3445 if (loc
->address
== utp
->addr
)
3453 /* Given a list of tracepoints uploaded from a target, attempt to
3454 match them up with existing tracepoints, and create new ones if not
3458 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3460 struct uploaded_tp
*utp
;
3462 /* Look for GDB tracepoints that match up with our uploaded versions. */
3463 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3465 struct bp_location
*loc
;
3466 struct tracepoint
*t
;
3468 loc
= find_matching_tracepoint_location (utp
);
3471 /* Mark this location as already inserted. */
3473 t
= (struct tracepoint
*) loc
->owner
;
3474 printf_filtered (_("Assuming tracepoint %d is same "
3475 "as target's tracepoint %d at %s.\n"),
3476 loc
->owner
->number
, utp
->number
,
3477 paddress (loc
->gdbarch
, utp
->addr
));
3481 t
= create_tracepoint_from_upload (utp
);
3483 printf_filtered (_("Created tracepoint %d for "
3484 "target's tracepoint %d at %s.\n"),
3485 t
->base
.number
, utp
->number
,
3486 paddress (get_current_arch (), utp
->addr
));
3488 printf_filtered (_("Failed to create tracepoint for target's "
3489 "tracepoint %d at %s, skipping it.\n"),
3491 paddress (get_current_arch (), utp
->addr
));
3493 /* Whether found or created, record the number used by the
3494 target, to help with mapping target tracepoints back to their
3495 counterparts here. */
3497 t
->number_on_target
= utp
->number
;
3500 free_uploaded_tps (uploaded_tps
);
3503 /* Trace state variables don't have much to identify them beyond their
3504 name, so just use that to detect matches. */
3506 static struct trace_state_variable
*
3507 find_matching_tsv (struct uploaded_tsv
*utsv
)
3512 return find_trace_state_variable (utsv
->name
);
3515 static struct trace_state_variable
*
3516 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3518 const char *namebase
;
3521 struct trace_state_variable
*tsv
;
3522 struct cleanup
*old_chain
;
3526 namebase
= utsv
->name
;
3527 buf
= xstrprintf ("%s", namebase
);
3532 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3535 /* Fish for a name that is not in use. */
3536 /* (should check against all internal vars?) */
3537 while (find_trace_state_variable (buf
))
3540 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3543 old_chain
= make_cleanup (xfree
, buf
);
3545 /* We have an available name, create the variable. */
3546 tsv
= create_trace_state_variable (buf
);
3547 tsv
->initial_value
= utsv
->initial_value
;
3548 tsv
->builtin
= utsv
->builtin
;
3550 do_cleanups (old_chain
);
3555 /* Given a list of uploaded trace state variables, try to match them
3556 up with existing variables, or create additional ones. */
3559 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3562 struct uploaded_tsv
*utsv
;
3563 struct trace_state_variable
*tsv
;
3566 /* Most likely some numbers will have to be reassigned as part of
3567 the merge, so clear them all in anticipation. */
3568 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3571 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3573 tsv
= find_matching_tsv (utsv
);
3577 printf_filtered (_("Assuming trace state variable $%s "
3578 "is same as target's variable %d.\n"),
3579 tsv
->name
, utsv
->number
);
3583 tsv
= create_tsv_from_upload (utsv
);
3585 printf_filtered (_("Created trace state variable "
3586 "$%s for target's variable %d.\n"),
3587 tsv
->name
, utsv
->number
);
3589 /* Give precedence to numberings that come from the target. */
3591 tsv
->number
= utsv
->number
;
3594 /* Renumber everything that didn't get a target-assigned number. */
3596 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3597 if (tsv
->number
> highest
)
3598 highest
= tsv
->number
;
3601 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3602 if (tsv
->number
== 0)
3603 tsv
->number
= highest
++;
3605 free_uploaded_tsvs (uploaded_tsvs
);
3608 /* target tfile command */
3610 static struct target_ops tfile_ops
;
3612 /* Fill in tfile_ops with its defined operations and properties. */
3614 #define TRACE_HEADER_SIZE 8
3616 static char *trace_filename
;
3617 static int trace_fd
= -1;
3618 static off_t trace_frames_offset
;
3619 static off_t cur_offset
;
3620 static int cur_data_size
;
3621 int trace_regblock_size
;
3623 static void tfile_interp_line (char *line
,
3624 struct uploaded_tp
**utpp
,
3625 struct uploaded_tsv
**utsvp
);
3627 /* Read SIZE bytes into READBUF from the trace frame, starting at
3628 TRACE_FD's current position. Note that this call `read'
3629 underneath, hence it advances the file's seek position. Throws an
3630 error if the `read' syscall fails, or less than SIZE bytes are
3634 tfile_read (gdb_byte
*readbuf
, int size
)
3638 gotten
= read (trace_fd
, readbuf
, size
);
3640 perror_with_name (trace_filename
);
3641 else if (gotten
< size
)
3642 error (_("Premature end of file while reading trace file"));
3646 tfile_open (char *filename
, int from_tty
)
3648 volatile struct gdb_exception ex
;
3650 struct cleanup
*old_chain
;
3653 char header
[TRACE_HEADER_SIZE
];
3654 char linebuf
[1000]; /* Should be max remote packet size or so. */
3657 struct trace_status
*ts
;
3658 struct uploaded_tp
*uploaded_tps
= NULL
;
3659 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3661 target_preopen (from_tty
);
3663 error (_("No trace file specified."));
3665 filename
= tilde_expand (filename
);
3666 if (!IS_ABSOLUTE_PATH(filename
))
3668 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
3673 old_chain
= make_cleanup (xfree
, filename
);
3675 flags
= O_BINARY
| O_LARGEFILE
;
3677 scratch_chan
= open (filename
, flags
, 0);
3678 if (scratch_chan
< 0)
3679 perror_with_name (filename
);
3681 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3683 discard_cleanups (old_chain
); /* Don't free filename any more. */
3684 unpush_target (&tfile_ops
);
3686 trace_filename
= xstrdup (filename
);
3687 trace_fd
= scratch_chan
;
3690 /* Read the file header and test for validity. */
3691 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
3693 bytes
+= TRACE_HEADER_SIZE
;
3694 if (!(header
[0] == 0x7f
3695 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3696 error (_("File is not a valid trace file."));
3698 push_target (&tfile_ops
);
3700 trace_regblock_size
= 0;
3701 ts
= current_trace_status ();
3702 /* We know we're working with a file. */
3704 /* Set defaults in case there is no status line. */
3705 ts
->running_known
= 0;
3706 ts
->stop_reason
= trace_stop_reason_unknown
;
3707 ts
->traceframe_count
= -1;
3708 ts
->buffer_free
= 0;
3709 ts
->disconnected_tracing
= 0;
3710 ts
->circular_buffer
= 0;
3712 TRY_CATCH (ex
, RETURN_MASK_ALL
)
3714 /* Read through a section of newline-terminated lines that
3715 define things like tracepoints. */
3719 tfile_read (&byte
, 1);
3724 /* Empty line marks end of the definition section. */
3729 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3732 linebuf
[i
++] = byte
;
3734 error (_("Excessively long lines in trace file"));
3737 /* Record the starting offset of the binary trace data. */
3738 trace_frames_offset
= bytes
;
3740 /* If we don't have a blocksize, we can't interpret the
3742 if (trace_regblock_size
== 0)
3743 error (_("No register block size recorded in trace file"));
3747 /* Pop the partially set up target. */
3749 throw_exception (ex
);
3752 inferior_appeared (current_inferior (), TFILE_PID
);
3753 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3754 add_thread_silent (inferior_ptid
);
3756 if (ts
->traceframe_count
<= 0)
3757 warning (_("No traceframes present in this file."));
3759 /* Add the file's tracepoints and variables into the current mix. */
3761 /* Get trace state variables first, they may be checked when parsing
3762 uploaded commands. */
3763 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3765 merge_uploaded_tracepoints (&uploaded_tps
);
3767 post_create_inferior (&tfile_ops
, from_tty
);
3770 /* Interpret the given line from the definitions part of the trace
3774 tfile_interp_line (char *line
,
3775 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3779 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3782 trace_regblock_size
= strtol (p
, &p
, 16);
3784 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3786 p
+= strlen ("status ");
3787 parse_trace_status (p
, current_trace_status ());
3789 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3791 p
+= strlen ("tp ");
3792 parse_tracepoint_definition (p
, utpp
);
3794 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3796 p
+= strlen ("tsv ");
3797 parse_tsv_definition (p
, utsvp
);
3800 warning (_("Ignoring trace file definition \"%s\""), line
);
3803 /* Parse the part of trace status syntax that is shared between
3804 the remote protocol and the trace file reader. */
3807 parse_trace_status (char *line
, struct trace_status
*ts
)
3809 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
3813 ts
->running_known
= 1;
3814 ts
->running
= (*p
++ == '1');
3815 ts
->stop_reason
= trace_stop_reason_unknown
;
3816 xfree (ts
->stop_desc
);
3817 ts
->stop_desc
= NULL
;
3818 ts
->traceframe_count
= -1;
3819 ts
->traceframes_created
= -1;
3820 ts
->buffer_free
= -1;
3821 ts
->buffer_size
= -1;
3822 ts
->disconnected_tracing
= 0;
3823 ts
->circular_buffer
= 0;
3824 xfree (ts
->user_name
);
3825 ts
->user_name
= NULL
;
3828 ts
->start_time
= ts
->stop_time
= 0;
3832 p1
= strchr (p
, ':');
3834 error (_("Malformed trace status, at %s\n\
3835 Status line: '%s'\n"), p
, line
);
3836 p3
= strchr (p
, ';');
3838 p3
= p
+ strlen (p
);
3839 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3841 p
= unpack_varlen_hex (++p1
, &val
);
3842 ts
->stop_reason
= trace_buffer_full
;
3844 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3846 p
= unpack_varlen_hex (++p1
, &val
);
3847 ts
->stop_reason
= trace_never_run
;
3849 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3852 p
= unpack_varlen_hex (++p1
, &val
);
3853 ts
->stop_reason
= tracepoint_passcount
;
3854 ts
->stopping_tracepoint
= val
;
3856 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3858 p2
= strchr (++p1
, ':');
3866 ts
->stop_desc
= xmalloc (strlen (line
));
3867 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
3868 ts
->stop_desc
[end
] = '\0';
3871 ts
->stop_desc
= xstrdup ("");
3873 p
= unpack_varlen_hex (++p2
, &val
);
3874 ts
->stop_reason
= tstop_command
;
3876 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3878 p
= unpack_varlen_hex (++p1
, &val
);
3879 ts
->stop_reason
= trace_disconnected
;
3881 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3883 p2
= strchr (++p1
, ':');
3886 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3887 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
3888 ts
->stop_desc
[end
] = '\0';
3891 ts
->stop_desc
= xstrdup ("");
3893 p
= unpack_varlen_hex (++p2
, &val
);
3894 ts
->stopping_tracepoint
= val
;
3895 ts
->stop_reason
= tracepoint_error
;
3897 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3899 p
= unpack_varlen_hex (++p1
, &val
);
3900 ts
->traceframe_count
= val
;
3902 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3904 p
= unpack_varlen_hex (++p1
, &val
);
3905 ts
->traceframes_created
= val
;
3907 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3909 p
= unpack_varlen_hex (++p1
, &val
);
3910 ts
->buffer_free
= val
;
3912 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3914 p
= unpack_varlen_hex (++p1
, &val
);
3915 ts
->buffer_size
= val
;
3917 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3919 p
= unpack_varlen_hex (++p1
, &val
);
3920 ts
->disconnected_tracing
= val
;
3922 else if (strncmp (p
, "circular", p1
- p
) == 0)
3924 p
= unpack_varlen_hex (++p1
, &val
);
3925 ts
->circular_buffer
= val
;
3927 else if (strncmp (p
, "starttime", p1
- p
) == 0)
3929 p
= unpack_varlen_hex (++p1
, &val
);
3930 ts
->start_time
= val
;
3932 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
3934 p
= unpack_varlen_hex (++p1
, &val
);
3935 ts
->stop_time
= val
;
3937 else if (strncmp (p
, "username", p1
- p
) == 0)
3940 ts
->user_name
= xmalloc (strlen (p
) / 2);
3941 end
= hex2bin (p1
, ts
->user_name
, (p3
- p1
) / 2);
3942 ts
->user_name
[end
] = '\0';
3945 else if (strncmp (p
, "notes", p1
- p
) == 0)
3948 ts
->notes
= xmalloc (strlen (p
) / 2);
3949 end
= hex2bin (p1
, ts
->notes
, (p3
- p1
) / 2);
3950 ts
->notes
[end
] = '\0';
3955 /* Silently skip unknown optional info. */
3956 p_temp
= strchr (p1
+ 1, ';');
3960 /* Must be at the end. */
3967 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
3968 struct uploaded_tp
*utp
)
3971 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
3973 p
= unpack_varlen_hex (p
, &uval
);
3975 tp
->base
.hit_count
+= uval
;
3977 utp
->hit_count
+= uval
;
3978 p
= unpack_varlen_hex (p
+ 1, &uval
);
3980 tp
->traceframe_usage
+= uval
;
3982 utp
->traceframe_usage
+= uval
;
3983 /* Ignore any extra, allowing for future extensions. */
3986 /* Given a line of text defining a part of a tracepoint, parse it into
3987 an "uploaded tracepoint". */
3990 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3994 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3997 char *cond
, *srctype
, *buf
;
3998 struct uploaded_tp
*utp
= NULL
;
4001 /* Both tracepoint and action definitions start with the same number
4002 and address sequence. */
4004 p
= unpack_varlen_hex (p
, &num
);
4005 p
++; /* skip a colon */
4006 p
= unpack_varlen_hex (p
, &addr
);
4007 p
++; /* skip a colon */
4010 enabled
= (*p
++ == 'E');
4011 p
++; /* skip a colon */
4012 p
= unpack_varlen_hex (p
, &step
);
4013 p
++; /* skip a colon */
4014 p
= unpack_varlen_hex (p
, &pass
);
4015 type
= bp_tracepoint
;
4017 /* Thumb through optional fields. */
4020 p
++; /* skip a colon */
4023 type
= bp_fast_tracepoint
;
4025 p
= unpack_varlen_hex (p
, &orig_size
);
4029 type
= bp_static_tracepoint
;
4035 p
= unpack_varlen_hex (p
, &xlen
);
4036 p
++; /* skip a comma */
4037 cond
= (char *) xmalloc (2 * xlen
+ 1);
4038 strncpy (cond
, p
, 2 * xlen
);
4039 cond
[2 * xlen
] = '\0';
4043 warning (_("Unrecognized char '%c' in tracepoint "
4044 "definition, skipping rest"), *p
);
4046 utp
= get_uploaded_tp (num
, addr
, utpp
);
4048 utp
->enabled
= enabled
;
4053 else if (piece
== 'A')
4055 utp
= get_uploaded_tp (num
, addr
, utpp
);
4056 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
4058 else if (piece
== 'S')
4060 utp
= get_uploaded_tp (num
, addr
, utpp
);
4061 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
4063 else if (piece
== 'Z')
4065 /* Parse a chunk of source form definition. */
4066 utp
= get_uploaded_tp (num
, addr
, utpp
);
4068 p
= strchr (p
, ':');
4069 p
++; /* skip a colon */
4070 p
= unpack_varlen_hex (p
, &start
);
4071 p
++; /* skip a colon */
4072 p
= unpack_varlen_hex (p
, &xlen
);
4073 p
++; /* skip a colon */
4075 buf
= alloca (strlen (line
));
4077 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4080 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
4081 utp
->at_string
= xstrdup (buf
);
4082 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
4083 utp
->cond_string
= xstrdup (buf
);
4084 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
4085 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
4087 else if (piece
== 'V')
4089 utp
= get_uploaded_tp (num
, addr
, utpp
);
4091 parse_tracepoint_status (p
, NULL
, utp
);
4095 /* Don't error out, the target might be sending us optional
4096 info that we don't care about. */
4097 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
4101 /* Convert a textual description of a trace state variable into an
4105 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
4108 ULONGEST num
, initval
, builtin
;
4110 struct uploaded_tsv
*utsv
= NULL
;
4112 buf
= alloca (strlen (line
));
4115 p
= unpack_varlen_hex (p
, &num
);
4116 p
++; /* skip a colon */
4117 p
= unpack_varlen_hex (p
, &initval
);
4118 p
++; /* skip a colon */
4119 p
= unpack_varlen_hex (p
, &builtin
);
4120 p
++; /* skip a colon */
4121 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4124 utsv
= get_uploaded_tsv (num
, utsvp
);
4125 utsv
->initial_value
= initval
;
4126 utsv
->builtin
= builtin
;
4127 utsv
->name
= xstrdup (buf
);
4130 /* Close the trace file and generally clean up. */
4133 tfile_close (int quitting
)
4140 pid
= ptid_get_pid (inferior_ptid
);
4141 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff. */
4142 exit_inferior_silent (pid
);
4146 xfree (trace_filename
);
4147 trace_filename
= NULL
;
4151 tfile_files_info (struct target_ops
*t
)
4153 /* (it would be useful to mention the name of the file). */
4154 printf_filtered ("Looking at a trace file.\n");
4157 /* The trace status for a file is that tracing can never be run. */
4160 tfile_get_trace_status (struct trace_status
*ts
)
4162 /* Other bits of trace status were collected as part of opening the
4163 trace files, so nothing to do here. */
4169 tfile_get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
4171 /* Other bits of trace status were collected as part of opening the
4172 trace files, so nothing to do here. */
4175 /* Given the position of a traceframe in the file, figure out what
4176 address the frame was collected at. This would normally be the
4177 value of a collected PC register, but if not available, we
4181 tfile_get_traceframe_address (off_t tframe_offset
)
4185 struct tracepoint
*tp
;
4186 off_t saved_offset
= cur_offset
;
4188 /* FIXME dig pc out of collected registers. */
4190 /* Fall back to using tracepoint address. */
4191 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
4192 tfile_read ((gdb_byte
*) &tpnum
, 2);
4193 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4197 tp
= get_tracepoint_by_number_on_target (tpnum
);
4198 /* FIXME this is a poor heuristic if multiple locations. */
4199 if (tp
&& tp
->base
.loc
)
4200 addr
= tp
->base
.loc
->address
;
4202 /* Restore our seek position. */
4203 cur_offset
= saved_offset
;
4204 lseek (trace_fd
, cur_offset
, SEEK_SET
);
4208 /* Given a type of search and some parameters, scan the collection of
4209 traceframes in the file looking for a match. When found, return
4210 both the traceframe and tracepoint number, otherwise -1 for
4214 tfile_trace_find (enum trace_find_type type
, int num
,
4215 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
4218 int tfnum
= 0, found
= 0;
4219 unsigned int data_size
;
4220 struct tracepoint
*tp
;
4221 off_t offset
, tframe_offset
;
4231 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
4232 offset
= trace_frames_offset
;
4235 tframe_offset
= offset
;
4236 tfile_read ((gdb_byte
*) &tpnum
, 2);
4237 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4243 tfile_read ((gdb_byte
*) &data_size
, 4);
4244 data_size
= (unsigned int) extract_unsigned_integer
4245 ((gdb_byte
*) &data_size
, 4,
4246 gdbarch_byte_order (target_gdbarch
));
4255 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4256 if (tfaddr
== addr1
)
4260 tp
= get_tracepoint (num
);
4261 if (tp
&& tpnum
== tp
->number_on_target
)
4265 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4266 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
4270 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4271 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
4275 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
4281 cur_offset
= offset
;
4282 cur_data_size
= data_size
;
4286 /* Skip past the traceframe's data. */
4287 lseek (trace_fd
, data_size
, SEEK_CUR
);
4288 offset
+= data_size
;
4289 /* Update our own count of traceframes. */
4292 /* Did not find what we were looking for. */
4298 /* Prototype of the callback passed to tframe_walk_blocks. */
4299 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
4301 /* Callback for traceframe_walk_blocks, used to find a given block
4302 type in a traceframe. */
4305 match_blocktype (char blocktype
, void *data
)
4307 char *wantedp
= data
;
4309 if (*wantedp
== blocktype
)
4315 /* Walk over all traceframe block starting at POS offset from
4316 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4317 unmodified. If CALLBACK returns true, this returns the position in
4318 the traceframe where the block is found, relative to the start of
4319 the traceframe (cur_offset). Returns -1 if no callback call
4320 returned true, indicating that all blocks have been walked. */
4323 traceframe_walk_blocks (walk_blocks_callback_func callback
,
4324 int pos
, void *data
)
4326 /* Iterate through a traceframe's blocks, looking for a block of the
4329 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
4330 while (pos
< cur_data_size
)
4332 unsigned short mlen
;
4335 tfile_read (&block_type
, 1);
4339 if ((*callback
) (block_type
, data
))
4345 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4346 pos
+= trace_regblock_size
;
4349 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4350 tfile_read ((gdb_byte
*) &mlen
, 2);
4351 mlen
= (unsigned short)
4352 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4355 lseek (trace_fd
, mlen
, SEEK_CUR
);
4356 pos
+= (8 + 2 + mlen
);
4359 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
4363 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4364 block_type
, block_type
);
4372 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4373 position offset of a block of type TYPE_WANTED in the current trace
4374 frame, starting at POS. Returns -1 if no such block was found. */
4377 traceframe_find_block_type (char type_wanted
, int pos
)
4379 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
4382 /* Look for a block of saved registers in the traceframe, and get the
4383 requested register from it. */
4386 tfile_fetch_registers (struct target_ops
*ops
,
4387 struct regcache
*regcache
, int regno
)
4389 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4390 int offset
, regn
, regsize
, pc_regno
;
4393 /* An uninitialized reg size says we're not going to be
4394 successful at getting register blocks. */
4395 if (!trace_regblock_size
)
4398 regs
= alloca (trace_regblock_size
);
4400 if (traceframe_find_block_type ('R', 0) >= 0)
4402 tfile_read (regs
, trace_regblock_size
);
4404 /* Assume the block is laid out in GDB register number order,
4405 each register with the size that it has in GDB. */
4407 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4409 regsize
= register_size (gdbarch
, regn
);
4410 /* Make sure we stay within block bounds. */
4411 if (offset
+ regsize
>= trace_regblock_size
)
4413 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
4417 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
4420 else if (regno
== -1)
4422 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
4430 /* We get here if no register data has been found. Mark registers
4432 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4433 regcache_raw_supply (regcache
, regn
, NULL
);
4435 /* We can often usefully guess that the PC is going to be the same
4436 as the address of the tracepoint. */
4437 pc_regno
= gdbarch_pc_regnum (gdbarch
);
4438 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
4440 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
4442 if (tp
&& tp
->base
.loc
)
4444 /* But don't try to guess if tracepoint is multi-location... */
4445 if (tp
->base
.loc
->next
)
4447 warning (_("Tracepoint %d has multiple "
4448 "locations, cannot infer $pc"),
4452 /* ... or does while-stepping. */
4453 if (tp
->step_count
> 0)
4455 warning (_("Tracepoint %d does while-stepping, "
4456 "cannot infer $pc"),
4461 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
4462 gdbarch_byte_order (gdbarch
),
4463 tp
->base
.loc
->address
);
4464 regcache_raw_supply (regcache
, pc_regno
, regs
);
4470 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4471 const char *annex
, gdb_byte
*readbuf
,
4472 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
4474 /* We're only doing regular memory for now. */
4475 if (object
!= TARGET_OBJECT_MEMORY
)
4478 if (readbuf
== NULL
)
4479 error (_("tfile_xfer_partial: trace file is read-only"));
4481 if (traceframe_number
!= -1)
4485 /* Iterate through the traceframe's blocks, looking for
4487 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
4489 ULONGEST maddr
, amt
;
4490 unsigned short mlen
;
4491 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
4493 tfile_read ((gdb_byte
*) &maddr
, 8);
4494 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
4496 tfile_read ((gdb_byte
*) &mlen
, 2);
4497 mlen
= (unsigned short)
4498 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
4500 /* If the block includes the first part of the desired
4501 range, return as much it has; GDB will re-request the
4502 remainder, which might be in a different block of this
4504 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
4506 amt
= (maddr
+ mlen
) - offset
;
4510 if (maddr
!= offset
)
4511 lseek (trace_fd
, offset
- maddr
, SEEK_CUR
);
4512 tfile_read (readbuf
, amt
);
4516 /* Skip over this block. */
4517 pos
+= (8 + 2 + mlen
);
4521 /* It's unduly pedantic to refuse to look at the executable for
4522 read-only pieces; so do the equivalent of readonly regions aka
4524 /* FIXME account for relocation at some point. */
4531 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
4533 if ((s
->flags
& SEC_LOAD
) == 0
4534 || (s
->flags
& SEC_READONLY
) == 0)
4538 size
= bfd_get_section_size (s
);
4539 if (vma
<= offset
&& offset
< (vma
+ size
))
4543 amt
= (vma
+ size
) - offset
;
4547 amt
= bfd_get_section_contents (exec_bfd
, s
,
4548 readbuf
, offset
- vma
, amt
);
4554 /* Indicate failure to find the requested memory block. */
4558 /* Iterate through the blocks of a trace frame, looking for a 'V'
4559 block with a matching tsv number. */
4562 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
4567 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
4571 tfile_read ((gdb_byte
*) &vnum
, 4);
4572 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
4577 tfile_read ((gdb_byte
*) val
, 8);
4578 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
4586 /* Didn't find anything. */
4591 tfile_has_all_memory (struct target_ops
*ops
)
4597 tfile_has_memory (struct target_ops
*ops
)
4603 tfile_has_stack (struct target_ops
*ops
)
4605 return traceframe_number
!= -1;
4609 tfile_has_registers (struct target_ops
*ops
)
4611 return traceframe_number
!= -1;
4615 tfile_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
4620 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
4621 object for the tfile target's current traceframe. */
4624 build_traceframe_info (char blocktype
, void *data
)
4626 struct traceframe_info
*info
= data
;
4632 struct mem_range
*r
;
4634 unsigned short mlen
;
4636 tfile_read ((gdb_byte
*) &maddr
, 8);
4637 tfile_read ((gdb_byte
*) &mlen
, 2);
4639 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4652 warning (_("Unhandled trace block type (%d) '%c ' "
4653 "while building trace frame info."),
4654 blocktype
, blocktype
);
4661 static struct traceframe_info
*
4662 tfile_traceframe_info (void)
4664 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
4666 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
4671 init_tfile_ops (void)
4673 tfile_ops
.to_shortname
= "tfile";
4674 tfile_ops
.to_longname
= "Local trace dump file";
4676 = "Use a trace file as a target. Specify the filename of the trace file.";
4677 tfile_ops
.to_open
= tfile_open
;
4678 tfile_ops
.to_close
= tfile_close
;
4679 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
4680 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
4681 tfile_ops
.to_files_info
= tfile_files_info
;
4682 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
4683 tfile_ops
.to_get_tracepoint_status
= tfile_get_tracepoint_status
;
4684 tfile_ops
.to_trace_find
= tfile_trace_find
;
4685 tfile_ops
.to_get_trace_state_variable_value
4686 = tfile_get_trace_state_variable_value
;
4687 tfile_ops
.to_stratum
= process_stratum
;
4688 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
4689 tfile_ops
.to_has_memory
= tfile_has_memory
;
4690 tfile_ops
.to_has_stack
= tfile_has_stack
;
4691 tfile_ops
.to_has_registers
= tfile_has_registers
;
4692 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
4693 tfile_ops
.to_thread_alive
= tfile_thread_alive
;
4694 tfile_ops
.to_magic
= OPS_MAGIC
;
4698 free_current_marker (void *arg
)
4700 struct static_tracepoint_marker
**marker_p
= arg
;
4702 if (*marker_p
!= NULL
)
4704 release_static_tracepoint_marker (*marker_p
);
4711 /* Given a line of text defining a static tracepoint marker, parse it
4712 into a "static tracepoint marker" object. Throws an error is
4713 parsing fails. If PP is non-null, it points to one past the end of
4714 the parsed marker definition. */
4717 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
4718 struct static_tracepoint_marker
*marker
)
4725 p
= unpack_varlen_hex (p
, &addr
);
4726 p
++; /* skip a colon */
4728 marker
->gdbarch
= target_gdbarch
;
4729 marker
->address
= (CORE_ADDR
) addr
;
4731 endp
= strchr (p
, ':');
4733 error (_("bad marker definition: %s"), line
);
4735 marker
->str_id
= xmalloc (endp
- p
+ 1);
4736 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
4737 marker
->str_id
[end
] = '\0';
4740 p
++; /* skip a colon */
4742 marker
->extra
= xmalloc (strlen (p
) + 1);
4743 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
4744 marker
->extra
[end
] = '\0';
4750 /* Release a static tracepoint marker's contents. Note that the
4751 object itself isn't released here. There objects are usually on
4755 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
4757 xfree (marker
->str_id
);
4758 marker
->str_id
= NULL
;
4761 /* Print MARKER to gdb_stdout. */
4764 print_one_static_tracepoint_marker (int count
,
4765 struct static_tracepoint_marker
*marker
)
4767 struct command_line
*l
;
4770 char wrap_indent
[80];
4771 char extra_field_indent
[80];
4772 struct ui_out
*uiout
= current_uiout
;
4773 struct cleanup
*bkpt_chain
;
4774 VEC(breakpoint_p
) *tracepoints
;
4776 struct symtab_and_line sal
;
4780 sal
.pc
= marker
->address
;
4782 tracepoints
= static_tracepoints_here (marker
->address
);
4784 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
4786 /* A counter field to help readability. This is not a stable
4788 ui_out_field_int (uiout
, "count", count
);
4790 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
4792 ui_out_field_fmt (uiout
, "enabled", "%c",
4793 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
4794 ui_out_spaces (uiout
, 2);
4796 strcpy (wrap_indent
, " ");
4798 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
4799 strcat (wrap_indent
, " ");
4801 strcat (wrap_indent
, " ");
4803 strcpy (extra_field_indent
, " ");
4805 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
4807 sal
= find_pc_line (marker
->address
, 0);
4808 sym
= find_pc_sect_function (marker
->address
, NULL
);
4811 ui_out_text (uiout
, "in ");
4812 ui_out_field_string (uiout
, "func",
4813 SYMBOL_PRINT_NAME (sym
));
4814 ui_out_wrap_hint (uiout
, wrap_indent
);
4815 ui_out_text (uiout
, " at ");
4818 ui_out_field_skip (uiout
, "func");
4820 if (sal
.symtab
!= NULL
)
4822 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
4823 ui_out_text (uiout
, ":");
4825 if (ui_out_is_mi_like_p (uiout
))
4827 char *fullname
= symtab_to_fullname (sal
.symtab
);
4830 ui_out_field_string (uiout
, "fullname", fullname
);
4833 ui_out_field_skip (uiout
, "fullname");
4835 ui_out_field_int (uiout
, "line", sal
.line
);
4839 ui_out_field_skip (uiout
, "fullname");
4840 ui_out_field_skip (uiout
, "line");
4843 ui_out_text (uiout
, "\n");
4844 ui_out_text (uiout
, extra_field_indent
);
4845 ui_out_text (uiout
, _("Data: \""));
4846 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
4847 ui_out_text (uiout
, "\"\n");
4849 if (!VEC_empty (breakpoint_p
, tracepoints
))
4851 struct cleanup
*cleanup_chain
;
4853 struct breakpoint
*b
;
4855 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
4858 ui_out_text (uiout
, extra_field_indent
);
4859 ui_out_text (uiout
, _("Probed by static tracepoints: "));
4860 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
4863 ui_out_text (uiout
, ", ");
4864 ui_out_text (uiout
, "#");
4865 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
4868 do_cleanups (cleanup_chain
);
4870 if (ui_out_is_mi_like_p (uiout
))
4871 ui_out_field_int (uiout
, "number-of-tracepoints",
4872 VEC_length(breakpoint_p
, tracepoints
));
4874 ui_out_text (uiout
, "\n");
4876 VEC_free (breakpoint_p
, tracepoints
);
4878 do_cleanups (bkpt_chain
);
4882 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
4884 VEC(static_tracepoint_marker_p
) *markers
;
4885 struct cleanup
*old_chain
;
4886 struct static_tracepoint_marker
*marker
;
4887 struct ui_out
*uiout
= current_uiout
;
4890 /* We don't have to check target_can_use_agent and agent's capability on
4891 static tracepoint here, in order to be compatible with older GDBserver.
4892 We don't check USE_AGENT is true or not, because static tracepoints
4893 don't work without in-process agent, so we don't bother users to type
4894 `set agent on' when to use static tracepoint. */
4897 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
4898 "StaticTracepointMarkersTable");
4900 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
4902 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
4904 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
4905 if (gdbarch_addr_bit (target_gdbarch
) <= 32)
4906 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
4908 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
4909 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
4911 ui_out_table_body (uiout
);
4913 markers
= target_static_tracepoint_markers_by_strid (NULL
);
4914 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
4917 VEC_iterate (static_tracepoint_marker_p
,
4918 markers
, i
, marker
);
4921 print_one_static_tracepoint_marker (i
+ 1, marker
);
4922 release_static_tracepoint_marker (marker
);
4925 do_cleanups (old_chain
);
4928 /* The $_sdata convenience variable is a bit special. We don't know
4929 for sure type of the value until we actually have a chance to fetch
4930 the data --- the size of the object depends on what has been
4931 collected. We solve this by making $_sdata be an internalvar that
4932 creates a new value on access. */
4934 /* Return a new value with the correct type for the sdata object of
4935 the current trace frame. Return a void value if there's no object
4938 static struct value
*
4939 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
4945 /* We need to read the whole object before we know its size. */
4946 size
= target_read_alloc (¤t_target
,
4947 TARGET_OBJECT_STATIC_TRACE_DATA
,
4954 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
4956 v
= allocate_value (type
);
4957 memcpy (value_contents_raw (v
), buf
, size
);
4962 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
4965 #if !defined(HAVE_LIBEXPAT)
4967 struct traceframe_info
*
4968 parse_traceframe_info (const char *tframe_info
)
4970 static int have_warned
;
4975 warning (_("Can not parse XML trace frame info; XML support "
4976 "was disabled at compile time"));
4982 #else /* HAVE_LIBEXPAT */
4984 #include "xml-support.h"
4986 /* Handle the start of a <memory> element. */
4989 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
4990 const struct gdb_xml_element
*element
,
4991 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
4993 struct traceframe_info
*info
= user_data
;
4994 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4995 ULONGEST
*start_p
, *length_p
;
4997 start_p
= xml_find_attribute (attributes
, "start")->value
;
4998 length_p
= xml_find_attribute (attributes
, "length")->value
;
5000 r
->start
= *start_p
;
5001 r
->length
= *length_p
;
5004 /* Discard the constructed trace frame info (if an error occurs). */
5007 free_result (void *p
)
5009 struct traceframe_info
*result
= p
;
5011 free_traceframe_info (result
);
5014 /* The allowed elements and attributes for an XML memory map. */
5016 static const struct gdb_xml_attribute memory_attributes
[] = {
5017 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5018 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5019 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5022 static const struct gdb_xml_element traceframe_info_children
[] = {
5023 { "memory", memory_attributes
, NULL
,
5024 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5025 traceframe_info_start_memory
, NULL
},
5026 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5029 static const struct gdb_xml_element traceframe_info_elements
[] = {
5030 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
5032 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5035 /* Parse a traceframe-info XML document. */
5037 struct traceframe_info
*
5038 parse_traceframe_info (const char *tframe_info
)
5040 struct traceframe_info
*result
;
5041 struct cleanup
*back_to
;
5043 result
= XCNEW (struct traceframe_info
);
5044 back_to
= make_cleanup (free_result
, result
);
5046 if (gdb_xml_parse_quick (_("trace frame info"),
5047 "traceframe-info.dtd", traceframe_info_elements
,
5048 tframe_info
, result
) == 0)
5050 /* Parsed successfully, keep the result. */
5051 discard_cleanups (back_to
);
5056 do_cleanups (back_to
);
5060 #endif /* HAVE_LIBEXPAT */
5062 /* Returns the traceframe_info object for the current traceframe.
5063 This is where we avoid re-fetching the object from the target if we
5064 already have it cached. */
5066 static struct traceframe_info
*
5067 get_traceframe_info (void)
5069 if (traceframe_info
== NULL
)
5070 traceframe_info
= target_traceframe_info ();
5072 return traceframe_info
;
5075 /* If the target supports the query, return in RESULT the set of
5076 collected memory in the current traceframe, found within the LEN
5077 bytes range starting at MEMADDR. Returns true if the target
5078 supports the query, otherwise returns false, and RESULT is left
5082 traceframe_available_memory (VEC(mem_range_s
) **result
,
5083 CORE_ADDR memaddr
, ULONGEST len
)
5085 struct traceframe_info
*info
= get_traceframe_info ();
5089 struct mem_range
*r
;
5094 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
5095 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
5097 ULONGEST lo1
, hi1
, lo2
, hi2
;
5098 struct mem_range
*nr
;
5101 hi1
= memaddr
+ len
;
5104 hi2
= r
->start
+ r
->length
;
5106 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
5108 nr
->start
= max (lo1
, lo2
);
5109 nr
->length
= min (hi1
, hi2
) - nr
->start
;
5112 normalize_mem_ranges (*result
);
5119 /* Implementation of `sdata' variable. */
5121 static const struct internalvar_funcs sdata_funcs
=
5128 /* module initialization */
5130 _initialize_tracepoint (void)
5132 struct cmd_list_element
*c
;
5134 /* Explicitly create without lookup, since that tries to create a
5135 value with a void typed value, and when we get here, gdbarch
5136 isn't initialized yet. At this point, we're quite sure there
5137 isn't another convenience variable of the same name. */
5138 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
5140 traceframe_number
= -1;
5141 tracepoint_number
= -1;
5143 if (tracepoint_list
.list
== NULL
)
5145 tracepoint_list
.listsize
= 128;
5146 tracepoint_list
.list
= xmalloc
5147 (tracepoint_list
.listsize
* sizeof (struct memrange
));
5149 if (tracepoint_list
.aexpr_list
== NULL
)
5151 tracepoint_list
.aexpr_listsize
= 128;
5152 tracepoint_list
.aexpr_list
= xmalloc
5153 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5156 if (stepping_list
.list
== NULL
)
5158 stepping_list
.listsize
= 128;
5159 stepping_list
.list
= xmalloc
5160 (stepping_list
.listsize
* sizeof (struct memrange
));
5163 if (stepping_list
.aexpr_list
== NULL
)
5165 stepping_list
.aexpr_listsize
= 128;
5166 stepping_list
.aexpr_list
= xmalloc
5167 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5170 add_info ("scope", scope_info
,
5171 _("List the variables local to a scope"));
5173 add_cmd ("tracepoints", class_trace
, NULL
,
5174 _("Tracing of program execution without stopping the program."),
5177 add_com ("tdump", class_trace
, trace_dump_command
,
5178 _("Print everything collected at the current tracepoint."));
5180 add_com ("tsave", class_trace
, trace_save_command
, _("\
5181 Save the trace data to a file.\n\
5182 Use the '-r' option to direct the target to save directly to the file,\n\
5183 using its own filesystem."));
5185 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
5186 Define a trace state variable.\n\
5187 Argument is a $-prefixed name, optionally followed\n\
5188 by '=' and an expression that sets the initial value\n\
5189 at the start of tracing."));
5190 set_cmd_completer (c
, expression_completer
);
5192 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
5193 Delete one or more trace state variables.\n\
5194 Arguments are the names of the variables to delete.\n\
5195 If no arguments are supplied, delete all variables."), &deletelist
);
5196 /* FIXME add a trace variable completer. */
5198 add_info ("tvariables", tvariables_info
, _("\
5199 Status of trace state variables and their values.\n\
5202 add_info ("static-tracepoint-markers",
5203 info_static_tracepoint_markers_command
, _("\
5204 List target static tracepoints markers.\n\
5207 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
5208 Select a trace frame;\n\
5209 No argument means forward by one frame; '-' means backward by one frame."),
5210 &tfindlist
, "tfind ", 1, &cmdlist
);
5212 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
5213 Select a trace frame whose PC is outside the given range (exclusive).\n\
5214 Usage: tfind outside addr1, addr2"),
5217 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
5218 Select a trace frame whose PC is in the given range (inclusive).\n\
5219 Usage: tfind range addr1,addr2"),
5222 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
5223 Select a trace frame by source line.\n\
5224 Argument can be a line number (with optional source file),\n\
5225 a function name, or '*' followed by an address.\n\
5226 Default argument is 'the next source line that was traced'."),
5229 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
5230 Select a trace frame by tracepoint number.\n\
5231 Default is the tracepoint for the current trace frame."),
5234 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
5235 Select a trace frame by PC.\n\
5236 Default is the current PC, or the PC of the current trace frame."),
5239 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
5240 De-select any trace frame and resume 'live' debugging."),
5243 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
5245 add_cmd ("start", class_trace
, trace_find_start_command
,
5246 _("Select the first trace frame in the trace buffer."),
5249 add_com ("tstatus", class_trace
, trace_status_command
,
5250 _("Display the status of the current trace data collection."));
5252 add_com ("tstop", class_trace
, trace_stop_command
, _("\
5253 Stop trace data collection.\n\
5254 Usage: tstop [ <notes> ... ]\n\
5255 Any arguments supplied are recorded with the trace as a stop reason and\n\
5256 reported by tstatus (if the target supports trace notes)."));
5258 add_com ("tstart", class_trace
, trace_start_command
, _("\
5259 Start trace data collection.\n\
5260 Usage: tstart [ <notes> ... ]\n\
5261 Any arguments supplied are recorded with the trace as a note and\n\
5262 reported by tstatus (if the target supports trace notes)."));
5264 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
5265 Ends a list of commands or actions.\n\
5266 Several GDB commands allow you to enter a list of commands or actions.\n\
5267 Entering \"end\" on a line by itself is the normal way to terminate\n\
5269 Note: the \"end\" command cannot be used at the gdb prompt."));
5271 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
5272 Specify single-stepping behavior at a tracepoint.\n\
5273 Argument is number of instructions to trace in single-step mode\n\
5274 following the tracepoint. This command is normally followed by\n\
5275 one or more \"collect\" commands, to specify what to collect\n\
5276 while single-stepping.\n\n\
5277 Note: this command can only be used in a tracepoint \"actions\" list."));
5279 add_com_alias ("ws", "while-stepping", class_alias
, 0);
5280 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
5282 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
5283 Specify one or more data items to be collected at a tracepoint.\n\
5284 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5285 collect all data (variables, registers) referenced by that expression.\n\
5286 Also accepts the following special arguments:\n\
5287 $regs -- all registers.\n\
5288 $args -- all function arguments.\n\
5289 $locals -- all variables local to the block/function scope.\n\
5290 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5291 Note: this command can only be used in a tracepoint \"actions\" list."));
5293 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
5294 Specify one or more expressions to be evaluated at a tracepoint.\n\
5295 Accepts a comma-separated list of (one or more) expressions.\n\
5296 The result of each evaluation will be discarded.\n\
5297 Note: this command can only be used in a tracepoint \"actions\" list."));
5299 add_com ("actions", class_trace
, trace_actions_command
, _("\
5300 Specify the actions to be taken at a tracepoint.\n\
5301 Tracepoint actions may include collecting of specified data,\n\
5302 single-stepping, or enabling/disabling other tracepoints,\n\
5303 depending on target's capabilities."));
5305 default_collect
= xstrdup ("");
5306 add_setshow_string_cmd ("default-collect", class_trace
,
5307 &default_collect
, _("\
5308 Set the list of expressions to collect by default"), _("\
5309 Show the list of expressions to collect by default"), NULL
,
5311 &setlist
, &showlist
);
5313 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
5314 &disconnected_tracing
, _("\
5315 Set whether tracing continues after GDB disconnects."), _("\
5316 Show whether tracing continues after GDB disconnects."), _("\
5317 Use this to continue a tracing run even if GDB disconnects\n\
5318 or detaches from the target. You can reconnect later and look at\n\
5319 trace data collected in the meantime."),
5320 set_disconnected_tracing
,
5325 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
5326 &circular_trace_buffer
, _("\
5327 Set target's use of circular trace buffer."), _("\
5328 Show target's use of circular trace buffer."), _("\
5329 Use this to make the trace buffer into a circular buffer,\n\
5330 which will discard traceframes (oldest first) instead of filling\n\
5331 up and stopping the trace run."),
5332 set_circular_trace_buffer
,
5337 add_setshow_string_cmd ("trace-user", class_trace
,
5339 Set the user name to use for current and future trace runs"), _("\
5340 Show the user name to use for current and future trace runs"), NULL
,
5341 set_trace_user
, NULL
,
5342 &setlist
, &showlist
);
5344 add_setshow_string_cmd ("trace-notes", class_trace
,
5346 Set notes string to use for current and future trace runs"), _("\
5347 Show the notes string to use for current and future trace runs"), NULL
,
5348 set_trace_notes
, NULL
,
5349 &setlist
, &showlist
);
5351 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
5352 &trace_stop_notes
, _("\
5353 Set notes string to use for future tstop commands"), _("\
5354 Show the notes string to use for future tstop commands"), NULL
,
5355 set_trace_stop_notes
, NULL
,
5356 &setlist
, &showlist
);
5360 add_target (&tfile_ops
);