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"
56 /* readline include files */
57 #include "readline/readline.h"
58 #include "readline/history.h"
60 /* readline defines this. */
71 extern int hex2bin (const char *hex
, gdb_byte
*bin
, int count
);
72 extern int bin2hex (const gdb_byte
*bin
, char *hex
, int count
);
74 /* Maximum length of an agent aexpression.
75 This accounts for the fact that packets are limited to 400 bytes
76 (which includes everything -- including the checksum), and assumes
77 the worst case of maximum length for each of the pieces of a
80 NOTE: expressions get mem2hex'ed otherwise this would be twice as
81 large. (400 - 31)/2 == 184 */
82 #define MAX_AGENT_EXPR_LEN 184
86 /* A hook used to notify the UI of tracepoint operations. */
88 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
89 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
91 extern void (*deprecated_readline_begin_hook
) (char *, ...);
92 extern char *(*deprecated_readline_hook
) (char *);
93 extern void (*deprecated_readline_end_hook
) (void);
95 /* GDB commands implemented in other modules:
98 extern void output_command (char *, int);
103 This module defines the following debugger commands:
104 trace : set a tracepoint on a function, line, or address.
105 info trace : list all debugger-defined tracepoints.
106 delete trace : delete one or more tracepoints.
107 enable trace : enable one or more tracepoints.
108 disable trace : disable one or more tracepoints.
109 actions : specify actions to be taken at a tracepoint.
110 passcount : specify a pass count for a tracepoint.
111 tstart : start a trace experiment.
112 tstop : stop a trace experiment.
113 tstatus : query the status of a trace experiment.
114 tfind : find a trace frame in the trace buffer.
115 tdump : print everything collected at the current tracepoint.
116 save-tracepoints : write tracepoint setup into a file.
118 This module defines the following user-visible debugger variables:
119 $trace_frame : sequence number of trace frame currently being debugged.
120 $trace_line : source line of trace frame currently being debugged.
121 $trace_file : source file of trace frame currently being debugged.
122 $tracepoint : tracepoint number of trace frame currently being debugged.
126 /* ======= Important global variables: ======= */
128 /* The list of all trace state variables. We don't retain pointers to
129 any of these for any reason - API is by name or number only - so it
130 works to have a vector of objects. */
132 typedef struct trace_state_variable tsv_s
;
135 /* An object describing the contents of a traceframe. */
137 struct traceframe_info
139 /* Collected memory. */
140 VEC(mem_range_s
) *memory
;
143 static VEC(tsv_s
) *tvariables
;
145 /* The next integer to assign to a variable. */
147 static int next_tsv_number
= 1;
149 /* Number of last traceframe collected. */
150 static int traceframe_number
;
152 /* Tracepoint for last traceframe collected. */
153 static int tracepoint_number
;
155 /* Symbol for function for last traceframe collected. */
156 static struct symbol
*traceframe_fun
;
158 /* Symtab and line for last traceframe collected. */
159 static struct symtab_and_line traceframe_sal
;
161 /* The traceframe info of the current traceframe. NULL if we haven't
162 yet attempted to fetch it, or if the target does not support
163 fetching this object, or if we're not inspecting a traceframe
165 static struct traceframe_info
*traceframe_info
;
167 /* Tracing command lists. */
168 static struct cmd_list_element
*tfindlist
;
170 /* List of expressions to collect by default at each tracepoint hit. */
171 char *default_collect
= "";
173 static int disconnected_tracing
;
175 /* This variable controls whether we ask the target for a linear or
176 circular trace buffer. */
178 static int circular_trace_buffer
;
180 /* Textual notes applying to the current and/or future trace runs. */
182 char *trace_user
= NULL
;
184 /* Textual notes applying to the current and/or future trace runs. */
186 char *trace_notes
= NULL
;
188 /* Textual notes applying to the stopping of a trace. */
190 char *trace_stop_notes
= NULL
;
192 /* ======= Important command functions: ======= */
193 static void trace_actions_command (char *, int);
194 static void trace_start_command (char *, int);
195 static void trace_stop_command (char *, int);
196 static void trace_status_command (char *, int);
197 static void trace_find_command (char *, int);
198 static void trace_find_pc_command (char *, int);
199 static void trace_find_tracepoint_command (char *, int);
200 static void trace_find_line_command (char *, int);
201 static void trace_find_range_command (char *, int);
202 static void trace_find_outside_command (char *, int);
203 static void trace_dump_command (char *, int);
205 /* support routines */
207 struct collection_list
;
208 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
209 static char *mem2hex (gdb_byte
*, char *, int);
210 static void add_register (struct collection_list
*collection
,
213 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
214 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
217 extern void _initialize_tracepoint (void);
219 static struct trace_status trace_status
;
221 char *stop_reason_names
[] = {
231 struct trace_status
*
232 current_trace_status (void)
234 return &trace_status
;
240 free_traceframe_info (struct traceframe_info
*info
)
244 VEC_free (mem_range_s
, info
->memory
);
250 /* Free and clear the traceframe info cache of the current
254 clear_traceframe_info (void)
256 free_traceframe_info (traceframe_info
);
257 traceframe_info
= NULL
;
260 /* Set traceframe number to NUM. */
262 set_traceframe_num (int num
)
264 traceframe_number
= num
;
265 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
268 /* Set tracepoint number to NUM. */
270 set_tracepoint_num (int num
)
272 tracepoint_number
= num
;
273 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
276 /* Set externally visible debug variables for querying/printing
277 the traceframe context (line, function, file). */
280 set_traceframe_context (struct frame_info
*trace_frame
)
284 /* Save as globals for internal use. */
285 if (trace_frame
!= NULL
286 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
288 traceframe_sal
= find_pc_line (trace_pc
, 0);
289 traceframe_fun
= find_pc_function (trace_pc
);
291 /* Save linenumber as "$trace_line", a debugger variable visible to
293 set_internalvar_integer (lookup_internalvar ("trace_line"),
294 traceframe_sal
.line
);
298 init_sal (&traceframe_sal
);
299 traceframe_fun
= NULL
;
300 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
303 /* Save func name as "$trace_func", a debugger variable visible to
305 if (traceframe_fun
== NULL
306 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
307 clear_internalvar (lookup_internalvar ("trace_func"));
309 set_internalvar_string (lookup_internalvar ("trace_func"),
310 SYMBOL_LINKAGE_NAME (traceframe_fun
));
312 /* Save file name as "$trace_file", a debugger variable visible to
314 if (traceframe_sal
.symtab
== NULL
315 || traceframe_sal
.symtab
->filename
== NULL
)
316 clear_internalvar (lookup_internalvar ("trace_file"));
318 set_internalvar_string (lookup_internalvar ("trace_file"),
319 traceframe_sal
.symtab
->filename
);
322 /* Create a new trace state variable with the given name. */
324 struct trace_state_variable
*
325 create_trace_state_variable (const char *name
)
327 struct trace_state_variable tsv
;
329 memset (&tsv
, 0, sizeof (tsv
));
330 tsv
.name
= xstrdup (name
);
331 tsv
.number
= next_tsv_number
++;
332 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
335 /* Look for a trace state variable of the given name. */
337 struct trace_state_variable
*
338 find_trace_state_variable (const char *name
)
340 struct trace_state_variable
*tsv
;
343 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
344 if (strcmp (name
, tsv
->name
) == 0)
351 delete_trace_state_variable (const char *name
)
353 struct trace_state_variable
*tsv
;
356 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
357 if (strcmp (name
, tsv
->name
) == 0)
359 xfree ((void *)tsv
->name
);
360 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
364 warning (_("No trace variable named \"$%s\", not deleting"), name
);
367 /* The 'tvariable' command collects a name and optional expression to
368 evaluate into an initial value. */
371 trace_variable_command (char *args
, int from_tty
)
373 struct expression
*expr
;
374 struct cleanup
*old_chain
;
375 struct internalvar
*intvar
= NULL
;
377 struct trace_state_variable
*tsv
;
380 error_no_arg (_("trace state variable name"));
382 /* All the possible valid arguments are expressions. */
383 expr
= parse_expression (args
);
384 old_chain
= make_cleanup (free_current_contents
, &expr
);
386 if (expr
->nelts
== 0)
387 error (_("No expression?"));
389 /* Only allow two syntaxes; "$name" and "$name=value". */
390 if (expr
->elts
[0].opcode
== OP_INTERNALVAR
)
392 intvar
= expr
->elts
[1].internalvar
;
394 else if (expr
->elts
[0].opcode
== BINOP_ASSIGN
395 && expr
->elts
[1].opcode
== OP_INTERNALVAR
)
397 intvar
= expr
->elts
[2].internalvar
;
398 initval
= value_as_long (evaluate_subexpression_type (expr
, 4));
401 error (_("Syntax must be $NAME [ = EXPR ]"));
404 error (_("No name given"));
406 if (strlen (internalvar_name (intvar
)) <= 0)
407 error (_("Must supply a non-empty variable name"));
409 /* If the variable already exists, just change its initial value. */
410 tsv
= find_trace_state_variable (internalvar_name (intvar
));
413 tsv
->initial_value
= initval
;
414 printf_filtered (_("Trace state variable $%s "
415 "now has initial value %s.\n"),
416 tsv
->name
, plongest (tsv
->initial_value
));
417 do_cleanups (old_chain
);
421 /* Create a new variable. */
422 tsv
= create_trace_state_variable (internalvar_name (intvar
));
423 tsv
->initial_value
= initval
;
425 printf_filtered (_("Trace state variable $%s "
426 "created, with initial value %s.\n"),
427 tsv
->name
, plongest (tsv
->initial_value
));
429 do_cleanups (old_chain
);
433 delete_trace_variable_command (char *args
, int from_tty
)
437 struct cleanup
*back_to
;
441 if (query (_("Delete all trace state variables? ")))
442 VEC_free (tsv_s
, tvariables
);
447 argv
= gdb_buildargv (args
);
448 back_to
= make_cleanup_freeargv (argv
);
450 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
452 if (*argv
[ix
] == '$')
453 delete_trace_state_variable (argv
[ix
] + 1);
455 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
458 do_cleanups (back_to
);
464 tvariables_info_1 (void)
466 struct trace_state_variable
*tsv
;
469 struct cleanup
*back_to
;
470 struct ui_out
*uiout
= current_uiout
;
472 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
474 printf_filtered (_("No trace state variables.\n"));
478 /* Try to acquire values from the target. */
479 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
480 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
483 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
484 count
, "trace-variables");
485 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
486 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
487 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
489 ui_out_table_body (uiout
);
491 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
493 struct cleanup
*back_to2
;
497 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
499 name
= concat ("$", tsv
->name
, (char *) NULL
);
500 make_cleanup (xfree
, name
);
501 ui_out_field_string (uiout
, "name", name
);
502 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
504 if (tsv
->value_known
)
505 c
= plongest (tsv
->value
);
506 else if (ui_out_is_mi_like_p (uiout
))
507 /* For MI, we prefer not to use magic string constants, but rather
508 omit the field completely. The difference between unknown and
509 undefined does not seem important enough to represent. */
511 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
512 /* The value is/was defined, but we don't have it. */
515 /* It is not meaningful to ask about the value. */
518 ui_out_field_string (uiout
, "current", c
);
519 ui_out_text (uiout
, "\n");
521 do_cleanups (back_to2
);
524 do_cleanups (back_to
);
527 /* List all the trace state variables. */
530 tvariables_info (char *args
, int from_tty
)
532 tvariables_info_1 ();
535 /* Stash definitions of tsvs into the given file. */
538 save_trace_state_variables (struct ui_file
*fp
)
540 struct trace_state_variable
*tsv
;
543 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
545 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
546 if (tsv
->initial_value
)
547 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
548 fprintf_unfiltered (fp
, "\n");
552 /* ACTIONS functions: */
554 /* The three functions:
555 collect_pseudocommand,
556 while_stepping_pseudocommand, and
557 end_actions_pseudocommand
558 are placeholders for "commands" that are actually ONLY to be used
559 within a tracepoint action list. If the actual function is ever called,
560 it means that somebody issued the "command" at the top level,
561 which is always an error. */
564 end_actions_pseudocommand (char *args
, int from_tty
)
566 error (_("This command cannot be used at the top level."));
570 while_stepping_pseudocommand (char *args
, int from_tty
)
572 error (_("This command can only be used in a tracepoint actions list."));
576 collect_pseudocommand (char *args
, int from_tty
)
578 error (_("This command can only be used in a tracepoint actions list."));
582 teval_pseudocommand (char *args
, int from_tty
)
584 error (_("This command can only be used in a tracepoint actions list."));
587 /* Parse any collection options, such as /s for strings. */
590 decode_agent_options (char *exp
)
592 struct value_print_options opts
;
597 /* Call this to borrow the print elements default for collection
599 get_user_print_options (&opts
);
604 if (target_supports_string_tracing ())
606 /* Allow an optional decimal number giving an explicit maximum
607 string length, defaulting it to the "print elements" value;
608 so "collect/s80 mystr" gets at most 80 bytes of string. */
609 trace_string_kludge
= opts
.print_max
;
611 if (*exp
>= '0' && *exp
<= '9')
612 trace_string_kludge
= atoi (exp
);
613 while (*exp
>= '0' && *exp
<= '9')
617 error (_("Target does not support \"/s\" option for string tracing."));
620 error (_("Undefined collection format \"%c\"."), *exp
);
622 exp
= skip_spaces (exp
);
627 /* Enter a list of actions for a tracepoint. */
629 trace_actions_command (char *args
, int from_tty
)
631 struct tracepoint
*t
;
632 struct command_line
*l
;
634 t
= get_tracepoint_by_number (&args
, NULL
, 1);
638 xstrprintf ("Enter actions for tracepoint %d, one per line.",
640 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
642 l
= read_command_lines (tmpbuf
, from_tty
, 1,
643 check_tracepoint_command
, t
);
644 do_cleanups (cleanups
);
645 breakpoint_set_commands (&t
->base
, l
);
647 /* else just return */
650 /* Report the results of checking the agent expression, as errors or
654 report_agent_reqs_errors (struct agent_expr
*aexpr
)
656 /* All of the "flaws" are serious bytecode generation issues that
657 should never occur. */
658 if (aexpr
->flaw
!= agent_flaw_none
)
659 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
661 /* If analysis shows a stack underflow, GDB must have done something
662 badly wrong in its bytecode generation. */
663 if (aexpr
->min_height
< 0)
664 internal_error (__FILE__
, __LINE__
,
665 _("expression has min height < 0"));
667 /* Issue this error if the stack is predicted to get too deep. The
668 limit is rather arbitrary; a better scheme might be for the
669 target to report how much stack it will have available. The
670 depth roughly corresponds to parenthesization, so a limit of 20
671 amounts to 20 levels of expression nesting, which is actually
672 a pretty big hairy expression. */
673 if (aexpr
->max_height
> 20)
674 error (_("Expression is too complicated."));
677 /* worker function */
679 validate_actionline (char **line
, struct breakpoint
*b
)
681 struct cmd_list_element
*c
;
682 struct expression
*exp
= NULL
;
683 struct cleanup
*old_chain
= NULL
;
685 struct bp_location
*loc
;
686 struct agent_expr
*aexpr
;
687 struct tracepoint
*t
= (struct tracepoint
*) b
;
689 /* If EOF is typed, *line is NULL. */
693 for (p
= *line
; isspace ((int) *p
);)
696 /* Symbol lookup etc. */
697 if (*p
== '\0') /* empty line: just prompt for another line. */
700 if (*p
== '#') /* comment line */
703 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
705 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
707 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
709 trace_string_kludge
= 0;
711 p
= decode_agent_options (p
);
714 { /* Repeat over a comma-separated list. */
715 QUIT
; /* Allow user to bail out with ^C. */
716 while (isspace ((int) *p
))
719 if (*p
== '$') /* Look for special pseudo-symbols. */
721 if (0 == strncasecmp ("reg", p
+ 1, 3)
722 || 0 == strncasecmp ("arg", p
+ 1, 3)
723 || 0 == strncasecmp ("loc", p
+ 1, 3)
724 || 0 == strncasecmp ("_ret", p
+ 1, 4)
725 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
730 /* else fall thru, treat p as an expression and parse it! */
733 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
736 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
737 old_chain
= make_cleanup (free_current_contents
, &exp
);
739 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
741 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
743 error (_("constant `%s' (value %s) "
744 "will not be collected."),
745 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
746 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
748 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
749 == LOC_OPTIMIZED_OUT
)
751 error (_("`%s' is optimized away "
752 "and cannot be collected."),
753 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
757 /* We have something to collect, make sure that the expr to
758 bytecode translator can handle it and that it's not too
760 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
761 make_cleanup_free_agent_expr (aexpr
);
763 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
764 error (_("Expression is too complicated."));
768 report_agent_reqs_errors (aexpr
);
770 do_cleanups (old_chain
);
773 while (p
&& *p
++ == ',');
776 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
779 { /* Repeat over a comma-separated list. */
780 QUIT
; /* Allow user to bail out with ^C. */
781 while (isspace ((int) *p
))
785 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
788 /* Only expressions are allowed for this action. */
789 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
790 old_chain
= make_cleanup (free_current_contents
, &exp
);
792 /* We have something to evaluate, make sure that the expr to
793 bytecode translator can handle it and that it's not too
795 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
796 make_cleanup_free_agent_expr (aexpr
);
798 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
799 error (_("Expression is too complicated."));
802 report_agent_reqs_errors (aexpr
);
804 do_cleanups (old_chain
);
807 while (p
&& *p
++ == ',');
810 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
812 char *steparg
; /* In case warning is necessary. */
814 while (isspace ((int) *p
))
818 if (*p
== '\0' || (t
->step_count
= strtol (p
, &p
, 0)) == 0)
819 error (_("while-stepping step count `%s' is malformed."), *line
);
822 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
826 error (_("`%s' is not a supported tracepoint action."), *line
);
830 memrange_absolute
= -1
835 int type
; /* memrange_absolute for absolute memory range,
836 else basereg number. */
837 bfd_signed_vma start
;
841 struct collection_list
843 unsigned char regs_mask
[32]; /* room for up to 256 regs */
846 struct memrange
*list
;
847 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
849 struct agent_expr
**aexpr_list
;
851 /* True is the user requested a collection of "$_sdata", "static
855 tracepoint_list
, stepping_list
;
857 /* MEMRANGE functions: */
859 static int memrange_cmp (const void *, const void *);
861 /* Compare memranges for qsort. */
863 memrange_cmp (const void *va
, const void *vb
)
865 const struct memrange
*a
= va
, *b
= vb
;
867 if (a
->type
< b
->type
)
869 if (a
->type
> b
->type
)
871 if (a
->type
== memrange_absolute
)
873 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
875 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
880 if (a
->start
< b
->start
)
882 if (a
->start
> b
->start
)
888 /* Sort the memrange list using qsort, and merge adjacent memranges. */
890 memrange_sortmerge (struct collection_list
*memranges
)
894 qsort (memranges
->list
, memranges
->next_memrange
,
895 sizeof (struct memrange
), memrange_cmp
);
896 if (memranges
->next_memrange
> 0)
898 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
900 /* If memrange b overlaps or is adjacent to memrange a,
902 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
903 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
905 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
906 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
907 continue; /* next b, same a */
911 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
912 sizeof (struct memrange
));
914 memranges
->next_memrange
= a
+ 1;
918 /* Add a register to a collection list. */
920 add_register (struct collection_list
*collection
, unsigned int regno
)
923 printf_filtered ("collect register %d\n", regno
);
924 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
925 error (_("Internal: register number %d too large for tracepoint"),
927 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
930 /* Add a memrange to a collection list. */
932 add_memrange (struct collection_list
*memranges
,
933 int type
, bfd_signed_vma base
,
938 printf_filtered ("(%d,", type
);
940 printf_filtered (",%ld)\n", len
);
943 /* type: memrange_absolute == memory, other n == basereg */
944 memranges
->list
[memranges
->next_memrange
].type
= type
;
945 /* base: addr if memory, offset if reg relative. */
946 memranges
->list
[memranges
->next_memrange
].start
= base
;
947 /* len: we actually save end (base + len) for convenience */
948 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
949 memranges
->next_memrange
++;
950 if (memranges
->next_memrange
>= memranges
->listsize
)
952 memranges
->listsize
*= 2;
953 memranges
->list
= xrealloc (memranges
->list
,
954 memranges
->listsize
);
957 if (type
!= memrange_absolute
) /* Better collect the base register! */
958 add_register (memranges
, type
);
961 /* Add a symbol to a collection list. */
963 collect_symbol (struct collection_list
*collect
,
965 struct gdbarch
*gdbarch
,
966 long frame_regno
, long frame_offset
,
971 bfd_signed_vma offset
;
972 int treat_as_expr
= 0;
974 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
975 switch (SYMBOL_CLASS (sym
))
978 printf_filtered ("%s: don't know symbol class %d\n",
979 SYMBOL_PRINT_NAME (sym
),
983 printf_filtered ("constant %s (value %s) will not be collected.\n",
984 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
987 offset
= SYMBOL_VALUE_ADDRESS (sym
);
992 sprintf_vma (tmp
, offset
);
993 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
994 SYMBOL_PRINT_NAME (sym
), len
,
997 /* A struct may be a C++ class with static fields, go to general
998 expression handling. */
999 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
1002 add_memrange (collect
, memrange_absolute
, offset
, len
);
1005 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1007 printf_filtered ("LOC_REG[parm] %s: ",
1008 SYMBOL_PRINT_NAME (sym
));
1009 add_register (collect
, reg
);
1010 /* Check for doubles stored in two registers. */
1011 /* FIXME: how about larger types stored in 3 or more regs? */
1012 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1013 len
> register_size (gdbarch
, reg
))
1014 add_register (collect
, reg
+ 1);
1017 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1018 printf_filtered (" (will not collect %s)\n",
1019 SYMBOL_PRINT_NAME (sym
));
1023 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1026 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1027 SYMBOL_PRINT_NAME (sym
), len
);
1028 printf_vma (offset
);
1029 printf_filtered (" from frame ptr reg %d\n", reg
);
1031 add_memrange (collect
, reg
, offset
, len
);
1033 case LOC_REGPARM_ADDR
:
1034 reg
= SYMBOL_VALUE (sym
);
1038 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1039 SYMBOL_PRINT_NAME (sym
), len
);
1040 printf_vma (offset
);
1041 printf_filtered (" from reg %d\n", reg
);
1043 add_memrange (collect
, reg
, offset
, len
);
1047 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1050 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1051 SYMBOL_PRINT_NAME (sym
), len
);
1052 printf_vma (offset
);
1053 printf_filtered (" from frame ptr reg %d\n", reg
);
1055 add_memrange (collect
, reg
, offset
, len
);
1058 case LOC_UNRESOLVED
:
1062 case LOC_OPTIMIZED_OUT
:
1063 printf_filtered ("%s has been optimized out of existence.\n",
1064 SYMBOL_PRINT_NAME (sym
));
1072 /* Expressions are the most general case. */
1075 struct agent_expr
*aexpr
;
1076 struct cleanup
*old_chain1
= NULL
;
1078 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
1080 /* It can happen that the symbol is recorded as a computed
1081 location, but it's been optimized away and doesn't actually
1082 have a location expression. */
1085 printf_filtered ("%s has been optimized out of existence.\n",
1086 SYMBOL_PRINT_NAME (sym
));
1090 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1094 report_agent_reqs_errors (aexpr
);
1096 discard_cleanups (old_chain1
);
1097 add_aexpr (collect
, aexpr
);
1099 /* Take care of the registers. */
1100 if (aexpr
->reg_mask_len
> 0)
1104 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1106 QUIT
; /* Allow user to bail out with ^C. */
1107 if (aexpr
->reg_mask
[ndx1
] != 0)
1109 /* Assume chars have 8 bits. */
1110 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1111 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1112 /* It's used -- record it. */
1113 add_register (collect
, ndx1
* 8 + ndx2
);
1120 /* Data to be passed around in the calls to the locals and args
1123 struct add_local_symbols_data
1125 struct collection_list
*collect
;
1126 struct gdbarch
*gdbarch
;
1133 /* The callback for the locals and args iterators. */
1136 do_collect_symbol (const char *print_name
,
1140 struct add_local_symbols_data
*p
= cb_data
;
1142 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1143 p
->frame_offset
, p
->pc
);
1147 /* Add all locals (or args) symbols to collection list. */
1149 add_local_symbols (struct collection_list
*collect
,
1150 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1151 long frame_regno
, long frame_offset
, int type
)
1153 struct block
*block
;
1154 struct add_local_symbols_data cb_data
;
1156 cb_data
.collect
= collect
;
1157 cb_data
.gdbarch
= gdbarch
;
1159 cb_data
.frame_regno
= frame_regno
;
1160 cb_data
.frame_offset
= frame_offset
;
1165 block
= block_for_pc (pc
);
1168 warning (_("Can't collect locals; "
1169 "no symbol table info available.\n"));
1173 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1174 if (cb_data
.count
== 0)
1175 warning (_("No locals found in scope."));
1179 pc
= get_pc_function_start (pc
);
1180 block
= block_for_pc (pc
);
1183 warning (_("Can't collect args; no symbol table info available."));
1187 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1188 if (cb_data
.count
== 0)
1189 warning (_("No args found in scope."));
1194 add_static_trace_data (struct collection_list
*collection
)
1197 printf_filtered ("collect static trace data\n");
1198 collection
->strace_data
= 1;
1201 /* worker function */
1203 clear_collection_list (struct collection_list
*list
)
1207 list
->next_memrange
= 0;
1208 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1210 free_agent_expr (list
->aexpr_list
[ndx
]);
1211 list
->aexpr_list
[ndx
] = NULL
;
1213 list
->next_aexpr_elt
= 0;
1214 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1215 list
->strace_data
= 0;
1218 /* Reduce a collection list to string form (for gdb protocol). */
1220 stringify_collection_list (struct collection_list
*list
, char *string
)
1222 char temp_buf
[2048];
1226 char *(*str_list
)[];
1230 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1231 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1233 if (list
->strace_data
)
1236 printf_filtered ("\nCollecting static trace data\n");
1239 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1243 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1244 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1246 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1249 printf_filtered ("\nCollecting registers (mask): 0x");
1254 QUIT
; /* Allow user to bail out with ^C. */
1256 printf_filtered ("%02X", list
->regs_mask
[i
]);
1257 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1260 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1264 printf_filtered ("\n");
1265 if (list
->next_memrange
> 0 && info_verbose
)
1266 printf_filtered ("Collecting memranges: \n");
1267 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1269 QUIT
; /* Allow user to bail out with ^C. */
1270 sprintf_vma (tmp2
, list
->list
[i
].start
);
1273 printf_filtered ("(%d, %s, %ld)\n",
1276 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1278 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1280 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1287 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1289 /* The "%X" conversion specifier expects an unsigned argument,
1290 so passing -1 (memrange_absolute) to it directly gives you
1291 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1293 if (list
->list
[i
].type
== memrange_absolute
)
1294 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1296 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1299 count
+= strlen (end
);
1300 end
= temp_buf
+ count
;
1303 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1305 QUIT
; /* Allow user to bail out with ^C. */
1306 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1308 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1313 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1314 end
+= 10; /* 'X' + 8 hex digits + ',' */
1317 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1318 end
, list
->aexpr_list
[i
]->len
);
1319 count
+= 2 * list
->aexpr_list
[i
]->len
;
1324 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1329 (*str_list
)[ndx
] = NULL
;
1342 encode_actions_1 (struct command_line
*action
,
1343 struct breakpoint
*t
,
1344 struct bp_location
*tloc
,
1346 LONGEST frame_offset
,
1347 struct collection_list
*collect
,
1348 struct collection_list
*stepping_list
)
1351 struct expression
*exp
= NULL
;
1353 struct value
*tempval
;
1354 struct cmd_list_element
*cmd
;
1355 struct agent_expr
*aexpr
;
1357 for (; action
; action
= action
->next
)
1359 QUIT
; /* Allow user to bail out with ^C. */
1360 action_exp
= action
->line
;
1361 while (isspace ((int) *action_exp
))
1364 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1366 error (_("Bad action list item: %s"), action_exp
);
1368 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1370 trace_string_kludge
= 0;
1371 if (*action_exp
== '/')
1372 action_exp
= decode_agent_options (action_exp
);
1375 { /* Repeat over a comma-separated list. */
1376 QUIT
; /* Allow user to bail out with ^C. */
1377 while (isspace ((int) *action_exp
))
1380 if (0 == strncasecmp ("$reg", action_exp
, 4))
1382 for (i
= 0; i
< gdbarch_num_regs (tloc
->gdbarch
); i
++)
1383 add_register (collect
, i
);
1384 action_exp
= strchr (action_exp
, ','); /* more? */
1386 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1388 add_local_symbols (collect
,
1394 action_exp
= strchr (action_exp
, ','); /* more? */
1396 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1398 add_local_symbols (collect
,
1404 action_exp
= strchr (action_exp
, ','); /* more? */
1406 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1408 struct cleanup
*old_chain1
= NULL
;
1410 aexpr
= gen_trace_for_return_address (tloc
->address
,
1413 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1416 report_agent_reqs_errors (aexpr
);
1418 discard_cleanups (old_chain1
);
1419 add_aexpr (collect
, aexpr
);
1421 /* take care of the registers */
1422 if (aexpr
->reg_mask_len
> 0)
1426 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1428 QUIT
; /* allow user to bail out with ^C */
1429 if (aexpr
->reg_mask
[ndx1
] != 0)
1431 /* assume chars have 8 bits */
1432 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1433 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1434 /* it's used -- record it */
1435 add_register (collect
,
1441 action_exp
= strchr (action_exp
, ','); /* more? */
1443 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1445 add_static_trace_data (collect
);
1446 action_exp
= strchr (action_exp
, ','); /* more? */
1450 unsigned long addr
, len
;
1451 struct cleanup
*old_chain
= NULL
;
1452 struct cleanup
*old_chain1
= NULL
;
1454 exp
= parse_exp_1 (&action_exp
,
1455 block_for_pc (tloc
->address
), 1);
1456 old_chain
= make_cleanup (free_current_contents
, &exp
);
1458 switch (exp
->elts
[0].opcode
)
1462 const char *name
= &exp
->elts
[2].string
;
1464 i
= user_reg_map_name_to_regnum (tloc
->gdbarch
,
1465 name
, strlen (name
));
1467 internal_error (__FILE__
, __LINE__
,
1468 _("Register $%s not available"),
1471 printf_filtered ("OP_REGISTER: ");
1472 add_register (collect
, i
);
1477 /* Safe because we know it's a simple expression. */
1478 tempval
= evaluate_expression (exp
);
1479 addr
= value_address (tempval
);
1480 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1481 add_memrange (collect
, memrange_absolute
, addr
, len
);
1485 collect_symbol (collect
,
1486 exp
->elts
[2].symbol
,
1493 default: /* Full-fledged expression. */
1494 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1496 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1500 report_agent_reqs_errors (aexpr
);
1502 discard_cleanups (old_chain1
);
1503 add_aexpr (collect
, aexpr
);
1505 /* Take care of the registers. */
1506 if (aexpr
->reg_mask_len
> 0)
1511 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1513 QUIT
; /* Allow user to bail out with ^C. */
1514 if (aexpr
->reg_mask
[ndx1
] != 0)
1516 /* Assume chars have 8 bits. */
1517 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1518 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1519 /* It's used -- record it. */
1520 add_register (collect
,
1527 do_cleanups (old_chain
);
1530 while (action_exp
&& *action_exp
++ == ',');
1532 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1535 { /* Repeat over a comma-separated list. */
1536 QUIT
; /* Allow user to bail out with ^C. */
1537 while (isspace ((int) *action_exp
))
1541 struct cleanup
*old_chain
= NULL
;
1542 struct cleanup
*old_chain1
= NULL
;
1544 exp
= parse_exp_1 (&action_exp
,
1545 block_for_pc (tloc
->address
), 1);
1546 old_chain
= make_cleanup (free_current_contents
, &exp
);
1548 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1549 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1552 report_agent_reqs_errors (aexpr
);
1554 discard_cleanups (old_chain1
);
1555 /* Even though we're not officially collecting, add
1556 to the collect list anyway. */
1557 add_aexpr (collect
, aexpr
);
1559 do_cleanups (old_chain
);
1562 while (action_exp
&& *action_exp
++ == ',');
1564 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1566 /* We check against nested while-stepping when setting
1567 breakpoint action, so no way to run into nested
1569 gdb_assert (stepping_list
);
1571 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
,
1572 frame_offset
, stepping_list
, NULL
);
1575 error (_("Invalid tracepoint command '%s'"), action
->line
);
1579 /* Render all actions into gdb protocol. */
1582 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1583 char ***tdp_actions
, char ***stepping_actions
)
1585 static char tdp_buff
[2048], step_buff
[2048];
1586 char *default_collect_line
= NULL
;
1587 struct command_line
*actions
;
1588 struct command_line
*default_collect_action
= NULL
;
1590 LONGEST frame_offset
;
1591 struct cleanup
*back_to
;
1593 back_to
= make_cleanup (null_cleanup
, NULL
);
1595 clear_collection_list (&tracepoint_list
);
1596 clear_collection_list (&stepping_list
);
1598 *tdp_actions
= NULL
;
1599 *stepping_actions
= NULL
;
1601 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1602 tloc
->address
, &frame_reg
, &frame_offset
);
1604 actions
= breakpoint_commands (t
);
1606 /* If there are default expressions to collect, make up a collect
1607 action and prepend to the action list to encode. Note that since
1608 validation is per-tracepoint (local var "xyz" might be valid for
1609 one tracepoint and not another, etc), we make up the action on
1610 the fly, and don't cache it. */
1611 if (*default_collect
)
1615 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1616 make_cleanup (xfree
, default_collect_line
);
1618 line
= default_collect_line
;
1619 validate_actionline (&line
, t
);
1621 default_collect_action
= xmalloc (sizeof (struct command_line
));
1622 make_cleanup (xfree
, default_collect_action
);
1623 default_collect_action
->next
= actions
;
1624 default_collect_action
->line
= line
;
1625 actions
= default_collect_action
;
1627 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1628 &tracepoint_list
, &stepping_list
);
1630 memrange_sortmerge (&tracepoint_list
);
1631 memrange_sortmerge (&stepping_list
);
1633 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1635 *stepping_actions
= stringify_collection_list (&stepping_list
,
1638 do_cleanups (back_to
);
1642 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1644 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1646 collect
->aexpr_list
=
1647 xrealloc (collect
->aexpr_list
,
1648 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1649 collect
->aexpr_listsize
*= 2;
1651 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1652 collect
->next_aexpr_elt
++;
1656 process_tracepoint_on_disconnect (void)
1658 VEC(breakpoint_p
) *tp_vec
= NULL
;
1660 struct breakpoint
*b
;
1661 int has_pending_p
= 0;
1663 /* Check whether we still have pending tracepoint. If we have, warn the
1664 user that pending tracepoint will no longer work. */
1665 tp_vec
= all_tracepoints ();
1666 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1675 struct bp_location
*loc1
;
1677 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1679 if (loc1
->shlib_disabled
)
1690 VEC_free (breakpoint_p
, tp_vec
);
1693 warning (_("Pending tracepoints will not be resolved while"
1694 " GDB is disconnected\n"));
1699 start_tracing (char *notes
)
1701 VEC(breakpoint_p
) *tp_vec
= NULL
;
1703 struct breakpoint
*b
;
1704 struct trace_state_variable
*tsv
;
1705 int any_enabled
= 0, num_to_download
= 0;
1708 tp_vec
= all_tracepoints ();
1710 /* No point in tracing without any tracepoints... */
1711 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1713 VEC_free (breakpoint_p
, tp_vec
);
1714 error (_("No tracepoints defined, not starting trace"));
1717 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1719 struct tracepoint
*t
= (struct tracepoint
*) b
;
1721 if (b
->enable_state
== bp_enabled
)
1724 if ((b
->type
== bp_fast_tracepoint
1725 ? may_insert_fast_tracepoints
1726 : may_insert_tracepoints
))
1729 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1730 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1735 if (target_supports_enable_disable_tracepoint ())
1736 warning (_("No tracepoints enabled"));
1739 /* No point in tracing with only disabled tracepoints that
1740 cannot be re-enabled. */
1741 VEC_free (breakpoint_p
, tp_vec
);
1742 error (_("No tracepoints enabled, not starting trace"));
1746 if (num_to_download
<= 0)
1748 VEC_free (breakpoint_p
, tp_vec
);
1749 error (_("No tracepoints that may be downloaded, not starting trace"));
1752 target_trace_init ();
1754 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1756 struct tracepoint
*t
= (struct tracepoint
*) b
;
1757 struct bp_location
*loc
;
1759 /* Clear `inserted' flag. */
1760 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1763 if ((b
->type
== bp_fast_tracepoint
1764 ? !may_insert_fast_tracepoints
1765 : !may_insert_tracepoints
))
1768 t
->number_on_target
= 0;
1770 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1772 /* Since tracepoint locations are never duplicated, `inserted'
1773 flag should be zero. */
1774 gdb_assert (!loc
->inserted
);
1776 target_download_tracepoint (loc
);
1781 t
->number_on_target
= b
->number
;
1783 VEC_free (breakpoint_p
, tp_vec
);
1785 /* Send down all the trace state variables too. */
1786 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1788 target_download_trace_state_variable (tsv
);
1791 /* Tell target to treat text-like sections as transparent. */
1792 target_trace_set_readonly_regions ();
1793 /* Set some mode flags. */
1794 target_set_disconnected_tracing (disconnected_tracing
);
1795 target_set_circular_trace_buffer (circular_trace_buffer
);
1798 notes
= trace_notes
;
1799 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1801 if (!ret
&& (trace_user
|| notes
))
1802 warning ("Target does not support trace user/notes, info ignored");
1804 /* Now insert traps and begin collecting data. */
1805 target_trace_start ();
1807 /* Reset our local state. */
1808 set_traceframe_num (-1);
1809 set_tracepoint_num (-1);
1810 set_traceframe_context (NULL
);
1811 current_trace_status()->running
= 1;
1812 clear_traceframe_info ();
1815 /* The tstart command requests the target to start a new trace run.
1816 The command passes any arguments it has to the target verbatim, as
1817 an optional "trace note". This is useful as for instance a warning
1818 to other users if the trace runs disconnected, and you don't want
1819 anybody else messing with the target. */
1822 trace_start_command (char *args
, int from_tty
)
1824 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1826 if (current_trace_status ()->running
)
1829 && !query (_("A trace is running already. Start a new run? ")))
1830 error (_("New trace run not started."));
1833 start_tracing (args
);
1836 /* The tstop command stops the tracing run. The command passes any
1837 supplied arguments to the target verbatim as a "stop note"; if the
1838 target supports trace notes, then it will be reported back as part
1839 of the trace run's status. */
1842 trace_stop_command (char *args
, int from_tty
)
1844 if (!current_trace_status ()->running
)
1845 error (_("Trace is not running."));
1847 stop_tracing (args
);
1851 stop_tracing (char *note
)
1855 target_trace_stop ();
1858 note
= trace_stop_notes
;
1859 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1862 warning ("Target does not support trace notes, note ignored");
1864 /* Should change in response to reply? */
1865 current_trace_status ()->running
= 0;
1868 /* tstatus command */
1870 trace_status_command (char *args
, int from_tty
)
1872 struct trace_status
*ts
= current_trace_status ();
1874 VEC(breakpoint_p
) *tp_vec
= NULL
;
1875 struct breakpoint
*t
;
1877 status
= target_get_trace_status (ts
);
1882 printf_filtered (_("Using a trace file.\n"));
1885 printf_filtered (_("Trace can not be run on this target.\n"));
1890 if (!ts
->running_known
)
1892 printf_filtered (_("Run/stop status is unknown.\n"));
1894 else if (ts
->running
)
1896 printf_filtered (_("Trace is running on the target.\n"));
1900 switch (ts
->stop_reason
)
1902 case trace_never_run
:
1903 printf_filtered (_("No trace has been run on the target.\n"));
1907 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1910 printf_filtered (_("Trace stopped by a tstop command.\n"));
1912 case trace_buffer_full
:
1913 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1915 case trace_disconnected
:
1916 printf_filtered (_("Trace stopped because of disconnection.\n"));
1918 case tracepoint_passcount
:
1919 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1920 ts
->stopping_tracepoint
);
1922 case tracepoint_error
:
1923 if (ts
->stopping_tracepoint
)
1924 printf_filtered (_("Trace stopped by an "
1925 "error (%s, tracepoint %d).\n"),
1926 ts
->stop_desc
, ts
->stopping_tracepoint
);
1928 printf_filtered (_("Trace stopped by an error (%s).\n"),
1931 case trace_stop_reason_unknown
:
1932 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1935 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1941 if (ts
->traceframes_created
>= 0
1942 && ts
->traceframe_count
!= ts
->traceframes_created
)
1944 printf_filtered (_("Buffer contains %d trace "
1945 "frames (of %d created total).\n"),
1946 ts
->traceframe_count
, ts
->traceframes_created
);
1948 else if (ts
->traceframe_count
>= 0)
1950 printf_filtered (_("Collected %d trace frames.\n"),
1951 ts
->traceframe_count
);
1954 if (ts
->buffer_free
>= 0)
1956 if (ts
->buffer_size
>= 0)
1958 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1959 ts
->buffer_free
, ts
->buffer_size
);
1960 if (ts
->buffer_size
> 0)
1961 printf_filtered (_(" (%d%% full)"),
1962 ((int) ((((long long) (ts
->buffer_size
1963 - ts
->buffer_free
)) * 100)
1964 / ts
->buffer_size
)));
1965 printf_filtered (_(".\n"));
1968 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1972 if (ts
->disconnected_tracing
)
1973 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1975 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1977 if (ts
->circular_buffer
)
1978 printf_filtered (_("Trace buffer is circular.\n"));
1980 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
1981 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
1983 if (ts
->notes
&& strlen (ts
->notes
) > 0)
1984 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
1986 /* Now report on what we're doing with tfind. */
1987 if (traceframe_number
>= 0)
1988 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1989 traceframe_number
, tracepoint_number
);
1991 printf_filtered (_("Not looking at any trace frame.\n"));
1993 /* Report start/stop times if supplied. */
1998 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
2000 /* Reporting a run time is more readable than two long numbers. */
2001 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2002 (long int) ts
->start_time
/ 1000000,
2003 (long int) ts
->start_time
% 1000000,
2004 (long int) run_time
/ 1000000,
2005 (long int) run_time
% 1000000);
2008 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2009 (long int) ts
->start_time
/ 1000000,
2010 (long int) ts
->start_time
% 1000000);
2012 else if (ts
->stop_time
)
2013 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2014 (long int) ts
->stop_time
/ 1000000,
2015 (long int) ts
->stop_time
% 1000000);
2017 /* Now report any per-tracepoint status available. */
2018 tp_vec
= all_tracepoints ();
2020 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2021 target_get_tracepoint_status (t
, NULL
);
2023 VEC_free (breakpoint_p
, tp_vec
);
2026 /* Report the trace status to uiout, in a way suitable for MI, and not
2027 suitable for CLI. If ON_STOP is true, suppress a few fields that
2028 are not meaningful in the -trace-stop response.
2030 The implementation is essentially parallel to trace_status_command, but
2031 merging them will result in unreadable code. */
2033 trace_status_mi (int on_stop
)
2035 struct ui_out
*uiout
= current_uiout
;
2036 struct trace_status
*ts
= current_trace_status ();
2039 status
= target_get_trace_status (ts
);
2041 if (status
== -1 && !ts
->from_file
)
2043 ui_out_field_string (uiout
, "supported", "0");
2048 ui_out_field_string (uiout
, "supported", "file");
2050 ui_out_field_string (uiout
, "supported", "1");
2052 gdb_assert (ts
->running_known
);
2056 ui_out_field_string (uiout
, "running", "1");
2058 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2059 Given that the frontend gets the status either on -trace-stop, or from
2060 -trace-status after re-connection, it does not seem like this
2061 information is necessary for anything. It is not necessary for either
2062 figuring the vital state of the target nor for navigation of trace
2063 frames. If the frontend wants to show the current state is some
2064 configure dialog, it can request the value when such dialog is
2065 invoked by the user. */
2069 char *stop_reason
= NULL
;
2070 int stopping_tracepoint
= -1;
2073 ui_out_field_string (uiout
, "running", "0");
2075 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2077 switch (ts
->stop_reason
)
2080 stop_reason
= "request";
2082 case trace_buffer_full
:
2083 stop_reason
= "overflow";
2085 case trace_disconnected
:
2086 stop_reason
= "disconnection";
2088 case tracepoint_passcount
:
2089 stop_reason
= "passcount";
2090 stopping_tracepoint
= ts
->stopping_tracepoint
;
2092 case tracepoint_error
:
2093 stop_reason
= "error";
2094 stopping_tracepoint
= ts
->stopping_tracepoint
;
2100 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2101 if (stopping_tracepoint
!= -1)
2102 ui_out_field_int (uiout
, "stopping-tracepoint",
2103 stopping_tracepoint
);
2104 if (ts
->stop_reason
== tracepoint_error
)
2105 ui_out_field_string (uiout
, "error-description",
2111 if (ts
->traceframe_count
!= -1)
2112 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2113 if (ts
->traceframes_created
!= -1)
2114 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2115 if (ts
->buffer_size
!= -1)
2116 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2117 if (ts
->buffer_free
!= -1)
2118 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2120 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2121 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2123 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2124 ui_out_field_string (uiout
, "notes", ts
->notes
);
2129 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2130 (long int) ts
->start_time
/ 1000000,
2131 (long int) ts
->start_time
% 1000000);
2132 ui_out_field_string (uiout
, "start-time", buf
);
2133 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2134 (long int) ts
->stop_time
/ 1000000,
2135 (long int) ts
->stop_time
% 1000000);
2136 ui_out_field_string (uiout
, "stop-time", buf
);
2140 /* This function handles the details of what to do about an ongoing
2141 tracing run if the user has asked to detach or otherwise disconnect
2144 disconnect_tracing (int from_tty
)
2146 /* It can happen that the target that was tracing went away on its
2147 own, and we didn't notice. Get a status update, and if the
2148 current target doesn't even do tracing, then assume it's not
2150 if (target_get_trace_status (current_trace_status ()) < 0)
2151 current_trace_status ()->running
= 0;
2153 /* If running interactively, give the user the option to cancel and
2154 then decide what to do differently with the run. Scripts are
2155 just going to disconnect and let the target deal with it,
2156 according to how it's been instructed previously via
2157 disconnected-tracing. */
2158 if (current_trace_status ()->running
&& from_tty
)
2160 process_tracepoint_on_disconnect ();
2162 if (current_trace_status ()->disconnected_tracing
)
2164 if (!query (_("Trace is running and will "
2165 "continue after detach; detach anyway? ")))
2166 error (_("Not confirmed."));
2170 if (!query (_("Trace is running but will "
2171 "stop on detach; detach anyway? ")))
2172 error (_("Not confirmed."));
2176 /* Also we want to be out of tfind mode, otherwise things can get
2177 confusing upon reconnection. Just use these calls instead of
2178 full tfind_1 behavior because we're in the middle of detaching,
2179 and there's no point to updating current stack frame etc. */
2180 set_current_traceframe (-1);
2181 set_traceframe_context (NULL
);
2184 /* Worker function for the various flavors of the tfind command. */
2186 tfind_1 (enum trace_find_type type
, int num
,
2187 ULONGEST addr1
, ULONGEST addr2
,
2190 int target_frameno
= -1, target_tracept
= -1;
2191 struct frame_id old_frame_id
= null_frame_id
;
2192 struct tracepoint
*tp
;
2193 struct ui_out
*uiout
= current_uiout
;
2195 /* Only try to get the current stack frame if we have a chance of
2196 succeeding. In particular, if we're trying to get a first trace
2197 frame while all threads are running, it's not going to succeed,
2198 so leave it with a default value and let the frame comparison
2199 below (correctly) decide to print out the source location of the
2201 if (!(type
== tfind_number
&& num
== -1)
2202 && (has_stack_frames () || traceframe_number
>= 0))
2203 old_frame_id
= get_frame_id (get_current_frame ());
2205 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2208 if (type
== tfind_number
2210 && target_frameno
== -1)
2212 /* We told the target to get out of tfind mode, and it did. */
2214 else if (target_frameno
== -1)
2216 /* A request for a non-existent trace frame has failed.
2217 Our response will be different, depending on FROM_TTY:
2219 If FROM_TTY is true, meaning that this command was
2220 typed interactively by the user, then give an error
2221 and DO NOT change the state of traceframe_number etc.
2223 However if FROM_TTY is false, meaning that we're either
2224 in a script, a loop, or a user-defined command, then
2225 DON'T give an error, but DO change the state of
2226 traceframe_number etc. to invalid.
2228 The rationalle is that if you typed the command, you
2229 might just have committed a typo or something, and you'd
2230 like to NOT lose your current debugging state. However
2231 if you're in a user-defined command or especially in a
2232 loop, then you need a way to detect that the command
2233 failed WITHOUT aborting. This allows you to write
2234 scripts that search thru the trace buffer until the end,
2235 and then continue on to do something else. */
2238 error (_("Target failed to find requested trace frame."));
2242 printf_filtered ("End of trace buffer.\n");
2243 #if 0 /* dubious now? */
2244 /* The following will not recurse, since it's
2246 trace_find_command ("-1", from_tty
);
2251 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2253 reinit_frame_cache ();
2254 registers_changed ();
2255 target_dcache_invalidate ();
2256 set_traceframe_num (target_frameno
);
2257 clear_traceframe_info ();
2258 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2259 if (target_frameno
== -1)
2260 set_traceframe_context (NULL
);
2262 set_traceframe_context (get_current_frame ());
2264 if (traceframe_number
>= 0)
2266 /* Use different branches for MI and CLI to make CLI messages
2268 if (ui_out_is_mi_like_p (uiout
))
2270 ui_out_field_string (uiout
, "found", "1");
2271 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2272 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2276 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2277 traceframe_number
, tracepoint_number
);
2282 if (ui_out_is_mi_like_p (uiout
))
2283 ui_out_field_string (uiout
, "found", "0");
2284 else if (type
== tfind_number
&& num
== -1)
2285 printf_unfiltered (_("No longer looking at any trace frame\n"));
2286 else /* This case may never occur, check. */
2287 printf_unfiltered (_("No trace frame found\n"));
2290 /* If we're in nonstop mode and getting out of looking at trace
2291 frames, there won't be any current frame to go back to and
2294 && (has_stack_frames () || traceframe_number
>= 0))
2296 enum print_what print_what
;
2298 /* NOTE: in imitation of the step command, try to determine
2299 whether we have made a transition from one function to
2300 another. If so, we'll print the "stack frame" (ie. the new
2301 function and it's arguments) -- otherwise we'll just show the
2304 if (frame_id_eq (old_frame_id
,
2305 get_frame_id (get_current_frame ())))
2306 print_what
= SRC_LINE
;
2308 print_what
= SRC_AND_LOC
;
2310 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2315 /* trace_find_command takes a trace frame number n,
2316 sends "QTFrame:<n>" to the target,
2317 and accepts a reply that may contain several optional pieces
2318 of information: a frame number, a tracepoint number, and an
2319 indication of whether this is a trap frame or a stepping frame.
2321 The minimal response is just "OK" (which indicates that the
2322 target does not give us a frame number or a tracepoint number).
2323 Instead of that, the target may send us a string containing
2325 F<hexnum> (gives the selected frame number)
2326 T<hexnum> (gives the selected tracepoint number)
2331 trace_find_command (char *args
, int from_tty
)
2332 { /* This should only be called with a numeric argument. */
2335 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2336 error (_("May not look at trace frames while trace is running."));
2338 if (args
== 0 || *args
== 0)
2339 { /* TFIND with no args means find NEXT trace frame. */
2340 if (traceframe_number
== -1)
2341 frameno
= 0; /* "next" is first one. */
2343 frameno
= traceframe_number
+ 1;
2345 else if (0 == strcmp (args
, "-"))
2347 if (traceframe_number
== -1)
2348 error (_("not debugging trace buffer"));
2349 else if (from_tty
&& traceframe_number
== 0)
2350 error (_("already at start of trace buffer"));
2352 frameno
= traceframe_number
- 1;
2354 /* A hack to work around eval's need for fp to have been collected. */
2355 else if (0 == strcmp (args
, "-1"))
2358 frameno
= parse_and_eval_long (args
);
2361 error (_("invalid input (%d is less than zero)"), frameno
);
2363 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2368 trace_find_end_command (char *args
, int from_tty
)
2370 trace_find_command ("-1", from_tty
);
2375 trace_find_none_command (char *args
, int from_tty
)
2377 trace_find_command ("-1", from_tty
);
2382 trace_find_start_command (char *args
, int from_tty
)
2384 trace_find_command ("0", from_tty
);
2387 /* tfind pc command */
2389 trace_find_pc_command (char *args
, int from_tty
)
2393 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2394 error (_("May not look at trace frames while trace is running."));
2396 if (args
== 0 || *args
== 0)
2397 pc
= regcache_read_pc (get_current_regcache ());
2399 pc
= parse_and_eval_address (args
);
2401 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2404 /* tfind tracepoint command */
2406 trace_find_tracepoint_command (char *args
, int from_tty
)
2409 struct tracepoint
*tp
;
2411 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2412 error (_("May not look at trace frames while trace is running."));
2414 if (args
== 0 || *args
== 0)
2416 if (tracepoint_number
== -1)
2417 error (_("No current tracepoint -- please supply an argument."));
2419 tdp
= tracepoint_number
; /* Default is current TDP. */
2422 tdp
= parse_and_eval_long (args
);
2424 /* If we have the tracepoint on hand, use the number that the
2425 target knows about (which may be different if we disconnected
2426 and reconnected). */
2427 tp
= get_tracepoint (tdp
);
2429 tdp
= tp
->number_on_target
;
2431 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2434 /* TFIND LINE command:
2436 This command will take a sourceline for argument, just like BREAK
2437 or TRACE (ie. anything that "decode_line_1" can handle).
2439 With no argument, this command will find the next trace frame
2440 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2443 trace_find_line_command (char *args
, int from_tty
)
2445 static CORE_ADDR start_pc
, end_pc
;
2446 struct symtabs_and_lines sals
;
2447 struct symtab_and_line sal
;
2448 struct cleanup
*old_chain
;
2450 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2451 error (_("May not look at trace frames while trace is running."));
2453 if (args
== 0 || *args
== 0)
2455 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2457 sals
.sals
= (struct symtab_and_line
*)
2458 xmalloc (sizeof (struct symtab_and_line
));
2463 sals
= decode_line_spec (args
, DECODE_LINE_FUNFIRSTLINE
);
2467 old_chain
= make_cleanup (xfree
, sals
.sals
);
2468 if (sal
.symtab
== 0)
2469 error (_("No line number information available."));
2471 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2473 if (start_pc
== end_pc
)
2475 printf_filtered ("Line %d of \"%s\"",
2476 sal
.line
, sal
.symtab
->filename
);
2478 printf_filtered (" is at address ");
2479 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2481 printf_filtered (" but contains no code.\n");
2482 sal
= find_pc_line (start_pc
, 0);
2484 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2485 && start_pc
!= end_pc
)
2486 printf_filtered ("Attempting to find line %d instead.\n",
2489 error (_("Cannot find a good line."));
2493 /* Is there any case in which we get here, and have an address
2494 which the user would want to see? If we have debugging
2495 symbols and no line numbers? */
2496 error (_("Line number %d is out of range for \"%s\"."),
2497 sal
.line
, sal
.symtab
->filename
);
2499 /* Find within range of stated line. */
2501 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2503 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2504 do_cleanups (old_chain
);
2507 /* tfind range command */
2509 trace_find_range_command (char *args
, int from_tty
)
2511 static CORE_ADDR start
, stop
;
2514 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2515 error (_("May not look at trace frames while trace is running."));
2517 if (args
== 0 || *args
== 0)
2518 { /* XXX FIXME: what should default behavior be? */
2519 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2523 if (0 != (tmp
= strchr (args
, ',')))
2525 *tmp
++ = '\0'; /* Terminate start address. */
2526 while (isspace ((int) *tmp
))
2528 start
= parse_and_eval_address (args
);
2529 stop
= parse_and_eval_address (tmp
);
2532 { /* No explicit end address? */
2533 start
= parse_and_eval_address (args
);
2534 stop
= start
+ 1; /* ??? */
2537 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2540 /* tfind outside command */
2542 trace_find_outside_command (char *args
, int from_tty
)
2544 CORE_ADDR start
, stop
;
2547 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2548 error (_("May not look at trace frames while trace is running."));
2550 if (args
== 0 || *args
== 0)
2551 { /* XXX FIXME: what should default behavior be? */
2552 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2556 if (0 != (tmp
= strchr (args
, ',')))
2558 *tmp
++ = '\0'; /* Terminate start address. */
2559 while (isspace ((int) *tmp
))
2561 start
= parse_and_eval_address (args
);
2562 stop
= parse_and_eval_address (tmp
);
2565 { /* No explicit end address? */
2566 start
= parse_and_eval_address (args
);
2567 stop
= start
+ 1; /* ??? */
2570 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2573 /* info scope command: list the locals for a scope. */
2575 scope_info (char *args
, int from_tty
)
2577 struct symtabs_and_lines sals
;
2579 struct minimal_symbol
*msym
;
2580 struct block
*block
;
2581 const char *symname
;
2582 char *save_args
= args
;
2583 struct dict_iterator iter
;
2585 struct gdbarch
*gdbarch
;
2588 if (args
== 0 || *args
== 0)
2589 error (_("requires an argument (function, "
2590 "line or *addr) to define a scope"));
2592 sals
= decode_line_1 (&args
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2593 if (sals
.nelts
== 0)
2594 return; /* Presumably decode_line_1 has already warned. */
2596 /* Resolve line numbers to PC. */
2597 resolve_sal_pc (&sals
.sals
[0]);
2598 block
= block_for_pc (sals
.sals
[0].pc
);
2602 QUIT
; /* Allow user to bail out with ^C. */
2603 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2605 QUIT
; /* Allow user to bail out with ^C. */
2607 printf_filtered ("Scope for %s:\n", save_args
);
2610 symname
= SYMBOL_PRINT_NAME (sym
);
2611 if (symname
== NULL
|| *symname
== '\0')
2612 continue; /* Probably botched, certainly useless. */
2614 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2616 printf_filtered ("Symbol %s is ", symname
);
2617 switch (SYMBOL_CLASS (sym
))
2620 case LOC_UNDEF
: /* Messed up symbol? */
2621 printf_filtered ("a bogus symbol, class %d.\n",
2622 SYMBOL_CLASS (sym
));
2623 count
--; /* Don't count this one. */
2626 printf_filtered ("a constant with value %s (%s)",
2627 plongest (SYMBOL_VALUE (sym
)),
2628 hex_string (SYMBOL_VALUE (sym
)));
2630 case LOC_CONST_BYTES
:
2631 printf_filtered ("constant bytes: ");
2632 if (SYMBOL_TYPE (sym
))
2633 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2634 fprintf_filtered (gdb_stdout
, " %02x",
2635 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2638 printf_filtered ("in static storage at address ");
2639 printf_filtered ("%s", paddress (gdbarch
,
2640 SYMBOL_VALUE_ADDRESS (sym
)));
2643 /* GDBARCH is the architecture associated with the objfile
2644 the symbol is defined in; the target architecture may be
2645 different, and may provide additional registers. However,
2646 we do not know the target architecture at this point.
2647 We assume the objfile architecture will contain all the
2648 standard registers that occur in debug info in that
2650 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2653 if (SYMBOL_IS_ARGUMENT (sym
))
2654 printf_filtered ("an argument in register $%s",
2655 gdbarch_register_name (gdbarch
, regno
));
2657 printf_filtered ("a local variable in register $%s",
2658 gdbarch_register_name (gdbarch
, regno
));
2661 printf_filtered ("an argument at stack/frame offset %s",
2662 plongest (SYMBOL_VALUE (sym
)));
2665 printf_filtered ("a local variable at frame offset %s",
2666 plongest (SYMBOL_VALUE (sym
)));
2669 printf_filtered ("a reference argument at offset %s",
2670 plongest (SYMBOL_VALUE (sym
)));
2672 case LOC_REGPARM_ADDR
:
2673 /* Note comment at LOC_REGISTER. */
2674 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2676 printf_filtered ("the address of an argument, in register $%s",
2677 gdbarch_register_name (gdbarch
, regno
));
2680 printf_filtered ("a typedef.\n");
2683 printf_filtered ("a label at address ");
2684 printf_filtered ("%s", paddress (gdbarch
,
2685 SYMBOL_VALUE_ADDRESS (sym
)));
2688 printf_filtered ("a function at address ");
2689 printf_filtered ("%s",
2690 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2692 case LOC_UNRESOLVED
:
2693 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2696 printf_filtered ("Unresolved Static");
2699 printf_filtered ("static storage at address ");
2700 printf_filtered ("%s",
2701 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2704 case LOC_OPTIMIZED_OUT
:
2705 printf_filtered ("optimized out.\n");
2708 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2709 BLOCK_START (block
),
2713 if (SYMBOL_TYPE (sym
))
2714 printf_filtered (", length %d.\n",
2715 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2717 if (BLOCK_FUNCTION (block
))
2720 block
= BLOCK_SUPERBLOCK (block
);
2723 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2727 /* worker function (cleanup) */
2729 replace_comma (void *data
)
2736 /* Helper for trace_dump_command. Dump the action list starting at
2737 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2738 actions of the body of a while-stepping action. STEPPING_FRAME is
2739 set if the current traceframe was determined to be a while-stepping
2743 trace_dump_actions (struct command_line
*action
,
2744 int stepping_actions
, int stepping_frame
,
2747 char *action_exp
, *next_comma
;
2749 for (; action
!= NULL
; action
= action
->next
)
2751 struct cmd_list_element
*cmd
;
2753 QUIT
; /* Allow user to bail out with ^C. */
2754 action_exp
= action
->line
;
2755 while (isspace ((int) *action_exp
))
2758 /* The collection actions to be done while stepping are
2759 bracketed by the commands "while-stepping" and "end". */
2761 if (*action_exp
== '#') /* comment line */
2764 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2766 error (_("Bad action list item: %s"), action_exp
);
2768 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2772 for (i
= 0; i
< action
->body_count
; ++i
)
2773 trace_dump_actions (action
->body_list
[i
],
2774 1, stepping_frame
, from_tty
);
2776 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2778 /* Display the collected data.
2779 For the trap frame, display only what was collected at
2780 the trap. Likewise for stepping frames, display only
2781 what was collected while stepping. This means that the
2782 two boolean variables, STEPPING_FRAME and
2783 STEPPING_ACTIONS should be equal. */
2784 if (stepping_frame
== stepping_actions
)
2786 if (*action_exp
== '/')
2787 action_exp
= decode_agent_options (action_exp
);
2790 { /* Repeat over a comma-separated list. */
2791 QUIT
; /* Allow user to bail out with ^C. */
2792 if (*action_exp
== ',')
2794 while (isspace ((int) *action_exp
))
2797 next_comma
= strchr (action_exp
, ',');
2799 if (0 == strncasecmp (action_exp
, "$reg", 4))
2800 registers_info (NULL
, from_tty
);
2801 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2803 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2804 locals_info (NULL
, from_tty
);
2805 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2806 args_info (NULL
, from_tty
);
2811 make_cleanup (replace_comma
, next_comma
);
2814 printf_filtered ("%s = ", action_exp
);
2815 output_command (action_exp
, from_tty
);
2816 printf_filtered ("\n");
2820 action_exp
= next_comma
;
2822 while (action_exp
&& *action_exp
== ',');
2828 /* The tdump command. */
2831 trace_dump_command (char *args
, int from_tty
)
2833 struct regcache
*regcache
;
2834 struct tracepoint
*t
;
2835 int stepping_frame
= 0;
2836 struct bp_location
*loc
;
2837 char *line
, *default_collect_line
= NULL
;
2838 struct command_line
*actions
, *default_collect_action
= NULL
;
2839 struct cleanup
*old_chain
= NULL
;
2841 if (tracepoint_number
== -1)
2843 warning (_("No current trace frame."));
2847 t
= get_tracepoint (tracepoint_number
);
2850 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2853 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2854 tracepoint_number
, traceframe_number
);
2856 /* The current frame is a trap frame if the frame PC is equal
2857 to the tracepoint PC. If not, then the current frame was
2858 collected during single-stepping. */
2860 regcache
= get_current_regcache ();
2862 /* If the traceframe's address matches any of the tracepoint's
2863 locations, assume it is a direct hit rather than a while-stepping
2864 frame. (FIXME this is not reliable, should record each frame's
2867 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
2868 if (loc
->address
== regcache_read_pc (regcache
))
2871 actions
= breakpoint_commands (&t
->base
);
2873 /* If there is a default-collect list, make up a collect command,
2874 prepend to the tracepoint's commands, and pass the whole mess to
2875 the trace dump scanner. We need to validate because
2876 default-collect might have been junked since the trace run. */
2877 if (*default_collect
)
2879 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2880 old_chain
= make_cleanup (xfree
, default_collect_line
);
2881 line
= default_collect_line
;
2882 validate_actionline (&line
, &t
->base
);
2883 default_collect_action
= xmalloc (sizeof (struct command_line
));
2884 make_cleanup (xfree
, default_collect_action
);
2885 default_collect_action
->next
= actions
;
2886 default_collect_action
->line
= line
;
2887 actions
= default_collect_action
;
2890 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2892 if (*default_collect
)
2893 do_cleanups (old_chain
);
2896 /* Encode a piece of a tracepoint's source-level definition in a form
2897 that is suitable for both protocol and saving in files. */
2898 /* This version does not do multiple encodes for long strings; it should
2899 return an offset to the next piece to encode. FIXME */
2902 encode_source_string (int tpnum
, ULONGEST addr
,
2903 char *srctype
, char *src
, char *buf
, int buf_size
)
2905 if (80 + strlen (srctype
) > buf_size
)
2906 error (_("Buffer too small for source encoding"));
2907 sprintf (buf
, "%x:%s:%s:%x:%x:",
2908 tpnum
, phex_nz (addr
, sizeof (addr
)),
2909 srctype
, 0, (int) strlen (src
));
2910 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2911 error (_("Source string too long for buffer"));
2912 bin2hex (src
, buf
+ strlen (buf
), 0);
2916 extern int trace_regblock_size
;
2918 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2919 non-zero, the save is performed on the target, otherwise GDB obtains all
2920 trace data and saves it locally. */
2923 trace_save (const char *filename
, int target_does_save
)
2925 struct cleanup
*cleanup
;
2927 struct trace_status
*ts
= current_trace_status ();
2930 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2931 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2935 ULONGEST offset
= 0;
2936 #define MAX_TRACE_UPLOAD 2000
2937 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2940 /* If the target is to save the data to a file on its own, then just
2941 send the command and be done with it. */
2942 if (target_does_save
)
2944 err
= target_save_trace_data (filename
);
2946 error (_("Target failed to save trace data to '%s'."),
2951 /* Get the trace status first before opening the file, so if the
2952 target is losing, we can get out without touching files. */
2953 status
= target_get_trace_status (ts
);
2955 pathname
= tilde_expand (filename
);
2956 cleanup
= make_cleanup (xfree
, pathname
);
2958 fp
= fopen (pathname
, "wb");
2960 error (_("Unable to open file '%s' for saving trace data (%s)"),
2961 filename
, safe_strerror (errno
));
2962 make_cleanup_fclose (fp
);
2964 /* Write a file header, with a high-bit-set char to indicate a
2965 binary file, plus a hint as what this file is, and a version
2966 number in case of future needs. */
2967 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2969 perror_with_name (pathname
);
2971 /* Write descriptive info. */
2973 /* Write out the size of a register block. */
2974 fprintf (fp
, "R %x\n", trace_regblock_size
);
2976 /* Write out status of the tracing run (aka "tstatus" info). */
2977 fprintf (fp
, "status %c;%s",
2978 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
2979 if (ts
->stop_reason
== tracepoint_error
)
2981 char *buf
= (char *) alloca (strlen (ts
->stop_desc
) * 2 + 1);
2983 bin2hex ((gdb_byte
*) ts
->stop_desc
, buf
, 0);
2984 fprintf (fp
, ":%s", buf
);
2986 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
2987 if (ts
->traceframe_count
>= 0)
2988 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
2989 if (ts
->traceframes_created
>= 0)
2990 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
2991 if (ts
->buffer_free
>= 0)
2992 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
2993 if (ts
->buffer_size
>= 0)
2994 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
2995 if (ts
->disconnected_tracing
)
2996 fprintf (fp
, ";disconn:%x", ts
->disconnected_tracing
);
2997 if (ts
->circular_buffer
)
2998 fprintf (fp
, ";circular:%x", ts
->circular_buffer
);
3001 /* Note that we want to upload tracepoints and save those, rather
3002 than simply writing out the local ones, because the user may have
3003 changed tracepoints in GDB in preparation for a future tracing
3004 run, or maybe just mass-deleted all types of breakpoints as part
3005 of cleaning up. So as not to contaminate the session, leave the
3006 data in its uploaded form, don't make into real tracepoints. */
3008 /* Get trace state variables first, they may be checked when parsing
3009 uploaded commands. */
3011 target_upload_trace_state_variables (&uploaded_tsvs
);
3013 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3019 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
3020 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
3023 fprintf (fp
, "tsv %x:%s:%x:%s\n",
3024 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
3025 utsv
->builtin
, buf
);
3031 free_uploaded_tsvs (&uploaded_tsvs
);
3033 target_upload_tracepoints (&uploaded_tps
);
3035 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3036 target_get_tracepoint_status (NULL
, utp
);
3038 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3040 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
3041 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3042 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
3043 if (utp
->type
== bp_fast_tracepoint
)
3044 fprintf (fp
, ":F%x", utp
->orig_size
);
3046 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
3049 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
3050 fprintf (fp
, "tp A%x:%s:%s\n",
3051 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3052 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
3053 fprintf (fp
, "tp S%x:%s:%s\n",
3054 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3057 encode_source_string (utp
->number
, utp
->addr
,
3058 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
3059 fprintf (fp
, "tp Z%s\n", buf
);
3061 if (utp
->cond_string
)
3063 encode_source_string (utp
->number
, utp
->addr
,
3064 "cond", utp
->cond_string
,
3065 buf
, MAX_TRACE_UPLOAD
);
3066 fprintf (fp
, "tp Z%s\n", buf
);
3068 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
3070 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
3071 buf
, MAX_TRACE_UPLOAD
);
3072 fprintf (fp
, "tp Z%s\n", buf
);
3074 fprintf (fp
, "tp V%x:%s:%x:%s\n",
3075 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3077 phex_nz (utp
->traceframe_usage
,
3078 sizeof (utp
->traceframe_usage
)));
3081 free_uploaded_tps (&uploaded_tps
);
3083 /* Mark the end of the definition section. */
3086 /* Get and write the trace data proper. We ask for big blocks, in
3087 the hopes of efficiency, but will take less if the target has
3088 packet size limitations or some such. */
3091 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
3093 error (_("Failure to get requested trace buffer data"));
3094 /* No more data is forthcoming, we're done. */
3097 written
= fwrite (buf
, gotten
, 1, fp
);
3099 perror_with_name (pathname
);
3103 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
3104 written
= fwrite (&gotten
, 4, 1, fp
);
3106 perror_with_name (pathname
);
3108 do_cleanups (cleanup
);
3112 trace_save_command (char *args
, int from_tty
)
3114 int target_does_save
= 0;
3116 char *filename
= NULL
;
3117 struct cleanup
*back_to
;
3120 error_no_arg (_("file in which to save trace data"));
3122 argv
= gdb_buildargv (args
);
3123 back_to
= make_cleanup_freeargv (argv
);
3125 for (; *argv
; ++argv
)
3127 if (strcmp (*argv
, "-r") == 0)
3128 target_does_save
= 1;
3129 else if (**argv
== '-')
3130 error (_("unknown option `%s'"), *argv
);
3136 error_no_arg (_("file in which to save trace data"));
3138 trace_save (filename
, target_does_save
);
3141 printf_filtered (_("Trace data saved to file '%s'.\n"), filename
);
3143 do_cleanups (back_to
);
3146 /* Tell the target what to do with an ongoing tracing run if GDB
3147 disconnects for some reason. */
3150 set_disconnected_tracing (char *args
, int from_tty
,
3151 struct cmd_list_element
*c
)
3153 target_set_disconnected_tracing (disconnected_tracing
);
3157 set_circular_trace_buffer (char *args
, int from_tty
,
3158 struct cmd_list_element
*c
)
3160 target_set_circular_trace_buffer (circular_trace_buffer
);
3164 set_trace_user (char *args
, int from_tty
,
3165 struct cmd_list_element
*c
)
3169 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3172 warning ("Target does not support trace notes, user ignored");
3176 set_trace_notes (char *args
, int from_tty
,
3177 struct cmd_list_element
*c
)
3181 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3184 warning ("Target does not support trace notes, note ignored");
3188 set_trace_stop_notes (char *args
, int from_tty
,
3189 struct cmd_list_element
*c
)
3193 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3196 warning ("Target does not support trace notes, stop note ignored");
3199 /* Convert the memory pointed to by mem into hex, placing result in buf.
3200 * Return a pointer to the last char put in buf (null)
3201 * "stolen" from sparc-stub.c
3204 static const char hexchars
[] = "0123456789abcdef";
3207 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3215 *buf
++ = hexchars
[ch
>> 4];
3216 *buf
++ = hexchars
[ch
& 0xf];
3225 get_traceframe_number (void)
3227 return traceframe_number
;
3230 /* Make the traceframe NUM be the current trace frame. Does nothing
3231 if NUM is already current. */
3234 set_current_traceframe (int num
)
3238 if (traceframe_number
== num
)
3240 /* Nothing to do. */
3244 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3247 warning (_("could not change traceframe"));
3249 traceframe_number
= newnum
;
3251 /* Changing the traceframe changes our view of registers and of the
3253 registers_changed ();
3255 clear_traceframe_info ();
3258 /* Make the traceframe NUM be the current trace frame, and do nothing
3262 set_traceframe_number (int num
)
3264 traceframe_number
= num
;
3267 /* A cleanup used when switching away and back from tfind mode. */
3269 struct current_traceframe_cleanup
3271 /* The traceframe we were inspecting. */
3272 int traceframe_number
;
3276 do_restore_current_traceframe_cleanup (void *arg
)
3278 struct current_traceframe_cleanup
*old
= arg
;
3280 set_current_traceframe (old
->traceframe_number
);
3284 restore_current_traceframe_cleanup_dtor (void *arg
)
3286 struct current_traceframe_cleanup
*old
= arg
;
3292 make_cleanup_restore_current_traceframe (void)
3294 struct current_traceframe_cleanup
*old
;
3296 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3297 old
->traceframe_number
= traceframe_number
;
3299 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3300 restore_current_traceframe_cleanup_dtor
);
3304 make_cleanup_restore_traceframe_number (void)
3306 return make_cleanup_restore_integer (&traceframe_number
);
3309 /* Given a number and address, return an uploaded tracepoint with that
3310 number, creating if necessary. */
3312 struct uploaded_tp
*
3313 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3315 struct uploaded_tp
*utp
;
3317 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3318 if (utp
->number
== num
&& utp
->addr
== addr
)
3320 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3321 memset (utp
, 0, sizeof (struct uploaded_tp
));
3324 utp
->actions
= NULL
;
3325 utp
->step_actions
= NULL
;
3326 utp
->cmd_strings
= NULL
;
3333 free_uploaded_tps (struct uploaded_tp
**utpp
)
3335 struct uploaded_tp
*next_one
;
3339 next_one
= (*utpp
)->next
;
3345 /* Given a number and address, return an uploaded tracepoint with that
3346 number, creating if necessary. */
3348 static struct uploaded_tsv
*
3349 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3351 struct uploaded_tsv
*utsv
;
3353 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3354 if (utsv
->number
== num
)
3356 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3357 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3359 utsv
->next
= *utsvp
;
3365 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3367 struct uploaded_tsv
*next_one
;
3371 next_one
= (*utsvp
)->next
;
3377 /* FIXME this function is heuristic and will miss the cases where the
3378 conditional is semantically identical but differs in whitespace,
3379 such as "x == 0" vs "x==0". */
3382 cond_string_is_same (char *str1
, char *str2
)
3384 if (str1
== NULL
|| str2
== NULL
)
3385 return (str1
== str2
);
3387 return (strcmp (str1
, str2
) == 0);
3390 /* Look for an existing tracepoint that seems similar enough to the
3391 uploaded one. Enablement isn't compared, because the user can
3392 toggle that freely, and may have done so in anticipation of the
3393 next trace run. Return the location of matched tracepoint. */
3395 static struct bp_location
*
3396 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3398 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3400 struct breakpoint
*b
;
3401 struct bp_location
*loc
;
3403 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3405 struct tracepoint
*t
= (struct tracepoint
*) b
;
3407 if (b
->type
== utp
->type
3408 && t
->step_count
== utp
->step
3409 && t
->pass_count
== utp
->pass
3410 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3411 /* FIXME also test actions. */
3414 /* Scan the locations for an address match. */
3415 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3417 if (loc
->address
== utp
->addr
)
3425 /* Given a list of tracepoints uploaded from a target, attempt to
3426 match them up with existing tracepoints, and create new ones if not
3430 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3432 struct uploaded_tp
*utp
;
3434 /* Look for GDB tracepoints that match up with our uploaded versions. */
3435 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3437 struct bp_location
*loc
;
3438 struct tracepoint
*t
;
3440 loc
= find_matching_tracepoint_location (utp
);
3443 /* Mark this location as already inserted. */
3445 t
= (struct tracepoint
*) loc
->owner
;
3446 printf_filtered (_("Assuming tracepoint %d is same "
3447 "as target's tracepoint %d at %s.\n"),
3448 loc
->owner
->number
, utp
->number
,
3449 paddress (loc
->gdbarch
, utp
->addr
));
3453 t
= create_tracepoint_from_upload (utp
);
3455 printf_filtered (_("Created tracepoint %d for "
3456 "target's tracepoint %d at %s.\n"),
3457 t
->base
.number
, utp
->number
,
3458 paddress (get_current_arch (), utp
->addr
));
3460 printf_filtered (_("Failed to create tracepoint for target's "
3461 "tracepoint %d at %s, skipping it.\n"),
3463 paddress (get_current_arch (), utp
->addr
));
3465 /* Whether found or created, record the number used by the
3466 target, to help with mapping target tracepoints back to their
3467 counterparts here. */
3469 t
->number_on_target
= utp
->number
;
3472 free_uploaded_tps (uploaded_tps
);
3475 /* Trace state variables don't have much to identify them beyond their
3476 name, so just use that to detect matches. */
3478 static struct trace_state_variable
*
3479 find_matching_tsv (struct uploaded_tsv
*utsv
)
3484 return find_trace_state_variable (utsv
->name
);
3487 static struct trace_state_variable
*
3488 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3490 const char *namebase
;
3493 struct trace_state_variable
*tsv
;
3494 struct cleanup
*old_chain
;
3498 namebase
= utsv
->name
;
3499 buf
= xstrprintf ("%s", namebase
);
3504 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3507 /* Fish for a name that is not in use. */
3508 /* (should check against all internal vars?) */
3509 while (find_trace_state_variable (buf
))
3512 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3515 old_chain
= make_cleanup (xfree
, buf
);
3517 /* We have an available name, create the variable. */
3518 tsv
= create_trace_state_variable (buf
);
3519 tsv
->initial_value
= utsv
->initial_value
;
3520 tsv
->builtin
= utsv
->builtin
;
3522 do_cleanups (old_chain
);
3527 /* Given a list of uploaded trace state variables, try to match them
3528 up with existing variables, or create additional ones. */
3531 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3534 struct uploaded_tsv
*utsv
;
3535 struct trace_state_variable
*tsv
;
3538 /* Most likely some numbers will have to be reassigned as part of
3539 the merge, so clear them all in anticipation. */
3540 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3543 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3545 tsv
= find_matching_tsv (utsv
);
3549 printf_filtered (_("Assuming trace state variable $%s "
3550 "is same as target's variable %d.\n"),
3551 tsv
->name
, utsv
->number
);
3555 tsv
= create_tsv_from_upload (utsv
);
3557 printf_filtered (_("Created trace state variable "
3558 "$%s for target's variable %d.\n"),
3559 tsv
->name
, utsv
->number
);
3561 /* Give precedence to numberings that come from the target. */
3563 tsv
->number
= utsv
->number
;
3566 /* Renumber everything that didn't get a target-assigned number. */
3568 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3569 if (tsv
->number
> highest
)
3570 highest
= tsv
->number
;
3573 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3574 if (tsv
->number
== 0)
3575 tsv
->number
= highest
++;
3577 free_uploaded_tsvs (uploaded_tsvs
);
3580 /* target tfile command */
3582 struct target_ops tfile_ops
;
3584 /* Fill in tfile_ops with its defined operations and properties. */
3586 #define TRACE_HEADER_SIZE 8
3588 char *trace_filename
;
3590 off_t trace_frames_offset
;
3592 int cur_traceframe_number
;
3594 int trace_regblock_size
;
3596 static void tfile_interp_line (char *line
,
3597 struct uploaded_tp
**utpp
,
3598 struct uploaded_tsv
**utsvp
);
3600 /* Read SIZE bytes into READBUF from the trace frame, starting at
3601 TRACE_FD's current position. Note that this call `read'
3602 underneath, hence it advances the file's seek position. Throws an
3603 error if the `read' syscall fails, or less than SIZE bytes are
3607 tfile_read (gdb_byte
*readbuf
, int size
)
3611 gotten
= read (trace_fd
, readbuf
, size
);
3613 perror_with_name (trace_filename
);
3614 else if (gotten
< size
)
3615 error (_("Premature end of file while reading trace file"));
3619 tfile_open (char *filename
, int from_tty
)
3621 volatile struct gdb_exception ex
;
3623 struct cleanup
*old_chain
;
3626 char header
[TRACE_HEADER_SIZE
];
3627 char linebuf
[1000]; /* Should be max remote packet size or so. */
3630 struct trace_status
*ts
;
3631 struct uploaded_tp
*uploaded_tps
= NULL
;
3632 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3634 target_preopen (from_tty
);
3636 error (_("No trace file specified."));
3638 filename
= tilde_expand (filename
);
3639 if (!IS_ABSOLUTE_PATH(filename
))
3641 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
3646 old_chain
= make_cleanup (xfree
, filename
);
3648 flags
= O_BINARY
| O_LARGEFILE
;
3650 scratch_chan
= open (filename
, flags
, 0);
3651 if (scratch_chan
< 0)
3652 perror_with_name (filename
);
3654 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3656 discard_cleanups (old_chain
); /* Don't free filename any more. */
3657 unpush_target (&tfile_ops
);
3659 trace_filename
= xstrdup (filename
);
3660 trace_fd
= scratch_chan
;
3663 /* Read the file header and test for validity. */
3664 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
3666 bytes
+= TRACE_HEADER_SIZE
;
3667 if (!(header
[0] == 0x7f
3668 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3669 error (_("File is not a valid trace file."));
3671 push_target (&tfile_ops
);
3673 trace_regblock_size
= 0;
3674 ts
= current_trace_status ();
3675 /* We know we're working with a file. */
3677 /* Set defaults in case there is no status line. */
3678 ts
->running_known
= 0;
3679 ts
->stop_reason
= trace_stop_reason_unknown
;
3680 ts
->traceframe_count
= -1;
3681 ts
->buffer_free
= 0;
3682 ts
->disconnected_tracing
= 0;
3683 ts
->circular_buffer
= 0;
3685 cur_traceframe_number
= -1;
3687 TRY_CATCH (ex
, RETURN_MASK_ALL
)
3689 /* Read through a section of newline-terminated lines that
3690 define things like tracepoints. */
3694 tfile_read (&byte
, 1);
3699 /* Empty line marks end of the definition section. */
3704 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3707 linebuf
[i
++] = byte
;
3709 error (_("Excessively long lines in trace file"));
3712 /* Record the starting offset of the binary trace data. */
3713 trace_frames_offset
= bytes
;
3715 /* If we don't have a blocksize, we can't interpret the
3717 if (trace_regblock_size
== 0)
3718 error (_("No register block size recorded in trace file"));
3722 /* Pop the partially set up target. */
3724 throw_exception (ex
);
3727 inferior_appeared (current_inferior (), TFILE_PID
);
3728 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3729 add_thread_silent (inferior_ptid
);
3731 if (ts
->traceframe_count
<= 0)
3732 warning (_("No traceframes present in this file."));
3734 /* Add the file's tracepoints and variables into the current mix. */
3736 /* Get trace state variables first, they may be checked when parsing
3737 uploaded commands. */
3738 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3740 merge_uploaded_tracepoints (&uploaded_tps
);
3742 post_create_inferior (&tfile_ops
, from_tty
);
3745 /* Interpret the given line from the definitions part of the trace
3749 tfile_interp_line (char *line
,
3750 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3754 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3757 trace_regblock_size
= strtol (p
, &p
, 16);
3759 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3761 p
+= strlen ("status ");
3762 parse_trace_status (p
, current_trace_status ());
3764 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3766 p
+= strlen ("tp ");
3767 parse_tracepoint_definition (p
, utpp
);
3769 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3771 p
+= strlen ("tsv ");
3772 parse_tsv_definition (p
, utsvp
);
3775 warning (_("Ignoring trace file definition \"%s\""), line
);
3778 /* Parse the part of trace status syntax that is shared between
3779 the remote protocol and the trace file reader. */
3782 parse_trace_status (char *line
, struct trace_status
*ts
)
3784 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
3788 ts
->running_known
= 1;
3789 ts
->running
= (*p
++ == '1');
3790 ts
->stop_reason
= trace_stop_reason_unknown
;
3791 xfree (ts
->stop_desc
);
3792 ts
->stop_desc
= NULL
;
3793 ts
->traceframe_count
= -1;
3794 ts
->traceframes_created
= -1;
3795 ts
->buffer_free
= -1;
3796 ts
->buffer_size
= -1;
3797 ts
->disconnected_tracing
= 0;
3798 ts
->circular_buffer
= 0;
3799 xfree (ts
->user_name
);
3800 ts
->user_name
= NULL
;
3803 ts
->start_time
= ts
->stop_time
= 0;
3807 p1
= strchr (p
, ':');
3809 error (_("Malformed trace status, at %s\n\
3810 Status line: '%s'\n"), p
, line
);
3811 p3
= strchr (p
, ';');
3813 p3
= p
+ strlen (p
);
3814 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3816 p
= unpack_varlen_hex (++p1
, &val
);
3817 ts
->stop_reason
= trace_buffer_full
;
3819 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3821 p
= unpack_varlen_hex (++p1
, &val
);
3822 ts
->stop_reason
= trace_never_run
;
3824 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3827 p
= unpack_varlen_hex (++p1
, &val
);
3828 ts
->stop_reason
= tracepoint_passcount
;
3829 ts
->stopping_tracepoint
= val
;
3831 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3833 p2
= strchr (++p1
, ':');
3841 ts
->stop_desc
= xmalloc (strlen (line
));
3842 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
3843 ts
->stop_desc
[end
] = '\0';
3846 ts
->stop_desc
= xstrdup ("");
3848 p
= unpack_varlen_hex (++p2
, &val
);
3849 ts
->stop_reason
= tstop_command
;
3851 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3853 p
= unpack_varlen_hex (++p1
, &val
);
3854 ts
->stop_reason
= trace_disconnected
;
3856 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3858 p2
= strchr (++p1
, ':');
3861 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3862 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
3863 ts
->stop_desc
[end
] = '\0';
3866 ts
->stop_desc
= xstrdup ("");
3868 p
= unpack_varlen_hex (++p2
, &val
);
3869 ts
->stopping_tracepoint
= val
;
3870 ts
->stop_reason
= tracepoint_error
;
3872 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3874 p
= unpack_varlen_hex (++p1
, &val
);
3875 ts
->traceframe_count
= val
;
3877 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3879 p
= unpack_varlen_hex (++p1
, &val
);
3880 ts
->traceframes_created
= val
;
3882 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3884 p
= unpack_varlen_hex (++p1
, &val
);
3885 ts
->buffer_free
= val
;
3887 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3889 p
= unpack_varlen_hex (++p1
, &val
);
3890 ts
->buffer_size
= val
;
3892 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3894 p
= unpack_varlen_hex (++p1
, &val
);
3895 ts
->disconnected_tracing
= val
;
3897 else if (strncmp (p
, "circular", p1
- p
) == 0)
3899 p
= unpack_varlen_hex (++p1
, &val
);
3900 ts
->circular_buffer
= val
;
3902 else if (strncmp (p
, "starttime", p1
- p
) == 0)
3904 p
= unpack_varlen_hex (++p1
, &val
);
3905 ts
->start_time
= val
;
3907 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
3909 p
= unpack_varlen_hex (++p1
, &val
);
3910 ts
->stop_time
= val
;
3912 else if (strncmp (p
, "username", p1
- p
) == 0)
3915 ts
->user_name
= xmalloc (strlen (p
) / 2);
3916 end
= hex2bin (p1
, ts
->user_name
, (p3
- p1
) / 2);
3917 ts
->user_name
[end
] = '\0';
3920 else if (strncmp (p
, "notes", p1
- p
) == 0)
3923 ts
->notes
= xmalloc (strlen (p
) / 2);
3924 end
= hex2bin (p1
, ts
->notes
, (p3
- p1
) / 2);
3925 ts
->notes
[end
] = '\0';
3930 /* Silently skip unknown optional info. */
3931 p_temp
= strchr (p1
+ 1, ';');
3935 /* Must be at the end. */
3942 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
3943 struct uploaded_tp
*utp
)
3946 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
3948 p
= unpack_varlen_hex (p
, &uval
);
3950 tp
->base
.hit_count
+= uval
;
3952 utp
->hit_count
+= uval
;
3953 p
= unpack_varlen_hex (p
+ 1, &uval
);
3955 tp
->traceframe_usage
+= uval
;
3957 utp
->traceframe_usage
+= uval
;
3958 /* Ignore any extra, allowing for future extensions. */
3961 /* Given a line of text defining a part of a tracepoint, parse it into
3962 an "uploaded tracepoint". */
3965 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3969 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3972 char *cond
, *srctype
, *buf
;
3973 struct uploaded_tp
*utp
= NULL
;
3976 /* Both tracepoint and action definitions start with the same number
3977 and address sequence. */
3979 p
= unpack_varlen_hex (p
, &num
);
3980 p
++; /* skip a colon */
3981 p
= unpack_varlen_hex (p
, &addr
);
3982 p
++; /* skip a colon */
3985 enabled
= (*p
++ == 'E');
3986 p
++; /* skip a colon */
3987 p
= unpack_varlen_hex (p
, &step
);
3988 p
++; /* skip a colon */
3989 p
= unpack_varlen_hex (p
, &pass
);
3990 type
= bp_tracepoint
;
3992 /* Thumb through optional fields. */
3995 p
++; /* skip a colon */
3998 type
= bp_fast_tracepoint
;
4000 p
= unpack_varlen_hex (p
, &orig_size
);
4004 type
= bp_static_tracepoint
;
4010 p
= unpack_varlen_hex (p
, &xlen
);
4011 p
++; /* skip a comma */
4012 cond
= (char *) xmalloc (2 * xlen
+ 1);
4013 strncpy (cond
, p
, 2 * xlen
);
4014 cond
[2 * xlen
] = '\0';
4018 warning (_("Unrecognized char '%c' in tracepoint "
4019 "definition, skipping rest"), *p
);
4021 utp
= get_uploaded_tp (num
, addr
, utpp
);
4023 utp
->enabled
= enabled
;
4028 else if (piece
== 'A')
4030 utp
= get_uploaded_tp (num
, addr
, utpp
);
4031 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
4033 else if (piece
== 'S')
4035 utp
= get_uploaded_tp (num
, addr
, utpp
);
4036 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
4038 else if (piece
== 'Z')
4040 /* Parse a chunk of source form definition. */
4041 utp
= get_uploaded_tp (num
, addr
, utpp
);
4043 p
= strchr (p
, ':');
4044 p
++; /* skip a colon */
4045 p
= unpack_varlen_hex (p
, &start
);
4046 p
++; /* skip a colon */
4047 p
= unpack_varlen_hex (p
, &xlen
);
4048 p
++; /* skip a colon */
4050 buf
= alloca (strlen (line
));
4052 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4055 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
4056 utp
->at_string
= xstrdup (buf
);
4057 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
4058 utp
->cond_string
= xstrdup (buf
);
4059 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
4060 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
4062 else if (piece
== 'V')
4064 utp
= get_uploaded_tp (num
, addr
, utpp
);
4066 parse_tracepoint_status (p
, NULL
, utp
);
4070 /* Don't error out, the target might be sending us optional
4071 info that we don't care about. */
4072 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
4076 /* Convert a textual description of a trace state variable into an
4080 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
4083 ULONGEST num
, initval
, builtin
;
4085 struct uploaded_tsv
*utsv
= NULL
;
4087 buf
= alloca (strlen (line
));
4090 p
= unpack_varlen_hex (p
, &num
);
4091 p
++; /* skip a colon */
4092 p
= unpack_varlen_hex (p
, &initval
);
4093 p
++; /* skip a colon */
4094 p
= unpack_varlen_hex (p
, &builtin
);
4095 p
++; /* skip a colon */
4096 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4099 utsv
= get_uploaded_tsv (num
, utsvp
);
4100 utsv
->initial_value
= initval
;
4101 utsv
->builtin
= builtin
;
4102 utsv
->name
= xstrdup (buf
);
4105 /* Close the trace file and generally clean up. */
4108 tfile_close (int quitting
)
4115 pid
= ptid_get_pid (inferior_ptid
);
4116 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff. */
4117 exit_inferior_silent (pid
);
4121 xfree (trace_filename
);
4122 trace_filename
= NULL
;
4126 tfile_files_info (struct target_ops
*t
)
4128 /* (it would be useful to mention the name of the file). */
4129 printf_filtered ("Looking at a trace file.\n");
4132 /* The trace status for a file is that tracing can never be run. */
4135 tfile_get_trace_status (struct trace_status
*ts
)
4137 /* Other bits of trace status were collected as part of opening the
4138 trace files, so nothing to do here. */
4144 tfile_get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
4146 /* Other bits of trace status were collected as part of opening the
4147 trace files, so nothing to do here. */
4150 /* Given the position of a traceframe in the file, figure out what
4151 address the frame was collected at. This would normally be the
4152 value of a collected PC register, but if not available, we
4156 tfile_get_traceframe_address (off_t tframe_offset
)
4160 struct tracepoint
*tp
;
4161 off_t saved_offset
= cur_offset
;
4163 /* FIXME dig pc out of collected registers. */
4165 /* Fall back to using tracepoint address. */
4166 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
4167 tfile_read ((gdb_byte
*) &tpnum
, 2);
4168 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4172 tp
= get_tracepoint_by_number_on_target (tpnum
);
4173 /* FIXME this is a poor heuristic if multiple locations. */
4174 if (tp
&& tp
->base
.loc
)
4175 addr
= tp
->base
.loc
->address
;
4177 /* Restore our seek position. */
4178 cur_offset
= saved_offset
;
4179 lseek (trace_fd
, cur_offset
, SEEK_SET
);
4183 /* Make tfile's selected traceframe match GDB's selected
4187 set_tfile_traceframe (void)
4191 if (cur_traceframe_number
== get_traceframe_number ())
4194 /* Avoid recursion, tfile_trace_find calls us again. */
4195 cur_traceframe_number
= get_traceframe_number ();
4197 newnum
= target_trace_find (tfind_number
,
4198 get_traceframe_number (), 0, 0, NULL
);
4200 /* Should not happen. If it does, all bets are off. */
4201 if (newnum
!= get_traceframe_number ())
4202 warning (_("could not set tfile's traceframe"));
4205 /* Given a type of search and some parameters, scan the collection of
4206 traceframes in the file looking for a match. When found, return
4207 both the traceframe and tracepoint number, otherwise -1 for
4211 tfile_trace_find (enum trace_find_type type
, int num
,
4212 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
4215 int tfnum
= 0, found
= 0;
4216 unsigned int data_size
;
4217 struct tracepoint
*tp
;
4218 off_t offset
, tframe_offset
;
4221 /* Lookups other than by absolute frame number depend on the current
4222 trace selected, so make sure it is correct on the tfile end
4224 if (type
!= tfind_number
)
4225 set_tfile_traceframe ();
4233 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
4234 offset
= trace_frames_offset
;
4237 tframe_offset
= offset
;
4238 tfile_read ((gdb_byte
*) &tpnum
, 2);
4239 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4245 tfile_read ((gdb_byte
*) &data_size
, 4);
4246 data_size
= (unsigned int) extract_unsigned_integer
4247 ((gdb_byte
*) &data_size
, 4,
4248 gdbarch_byte_order (target_gdbarch
));
4257 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4258 if (tfaddr
== addr1
)
4262 tp
= get_tracepoint (num
);
4263 if (tp
&& tpnum
== tp
->number_on_target
)
4267 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4268 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
4272 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4273 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
4277 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
4283 cur_offset
= offset
;
4284 cur_data_size
= data_size
;
4285 cur_traceframe_number
= tfnum
;
4288 /* Skip past the traceframe's data. */
4289 lseek (trace_fd
, data_size
, SEEK_CUR
);
4290 offset
+= data_size
;
4291 /* Update our own count of traceframes. */
4294 /* Did not find what we were looking for. */
4300 /* Prototype of the callback passed to tframe_walk_blocks. */
4301 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
4303 /* Callback for traceframe_walk_blocks, used to find a given block
4304 type in a traceframe. */
4307 match_blocktype (char blocktype
, void *data
)
4309 char *wantedp
= data
;
4311 if (*wantedp
== blocktype
)
4317 /* Walk over all traceframe block starting at POS offset from
4318 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4319 unmodified. If CALLBACK returns true, this returns the position in
4320 the traceframe where the block is found, relative to the start of
4321 the traceframe (cur_offset). Returns -1 if no callback call
4322 returned true, indicating that all blocks have been walked. */
4325 traceframe_walk_blocks (walk_blocks_callback_func callback
,
4326 int pos
, void *data
)
4328 /* Iterate through a traceframe's blocks, looking for a block of the
4331 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
4332 while (pos
< cur_data_size
)
4334 unsigned short mlen
;
4337 tfile_read (&block_type
, 1);
4341 if ((*callback
) (block_type
, data
))
4347 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4348 pos
+= trace_regblock_size
;
4351 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4352 tfile_read ((gdb_byte
*) &mlen
, 2);
4353 mlen
= (unsigned short)
4354 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4357 lseek (trace_fd
, mlen
, SEEK_CUR
);
4358 pos
+= (8 + 2 + mlen
);
4361 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
4365 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4366 block_type
, block_type
);
4374 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4375 position offset of a block of type TYPE_WANTED in the current trace
4376 frame, starting at POS. Returns -1 if no such block was found. */
4379 traceframe_find_block_type (char type_wanted
, int pos
)
4381 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
4384 /* Look for a block of saved registers in the traceframe, and get the
4385 requested register from it. */
4388 tfile_fetch_registers (struct target_ops
*ops
,
4389 struct regcache
*regcache
, int regno
)
4391 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4393 int pos
, offset
, regn
, regsize
, pc_regno
;
4394 unsigned short mlen
;
4397 /* An uninitialized reg size says we're not going to be
4398 successful at getting register blocks. */
4399 if (!trace_regblock_size
)
4402 set_tfile_traceframe ();
4404 regs
= alloca (trace_regblock_size
);
4406 if (traceframe_find_block_type ('R', 0) >= 0)
4408 tfile_read (regs
, trace_regblock_size
);
4410 /* Assume the block is laid out in GDB register number order,
4411 each register with the size that it has in GDB. */
4413 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4415 regsize
= register_size (gdbarch
, regn
);
4416 /* Make sure we stay within block bounds. */
4417 if (offset
+ regsize
>= trace_regblock_size
)
4419 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
4423 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
4426 else if (regno
== -1)
4428 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
4436 /* We get here if no register data has been found. Mark registers
4438 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4439 regcache_raw_supply (regcache
, regn
, NULL
);
4441 /* We can often usefully guess that the PC is going to be the same
4442 as the address of the tracepoint. */
4443 pc_regno
= gdbarch_pc_regnum (gdbarch
);
4444 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
4446 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
4448 if (tp
&& tp
->base
.loc
)
4450 /* But don't try to guess if tracepoint is multi-location... */
4451 if (tp
->base
.loc
->next
)
4453 warning (_("Tracepoint %d has multiple "
4454 "locations, cannot infer $pc"),
4458 /* ... or does while-stepping. */
4459 if (tp
->step_count
> 0)
4461 warning (_("Tracepoint %d does while-stepping, "
4462 "cannot infer $pc"),
4467 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
4468 gdbarch_byte_order (gdbarch
),
4469 tp
->base
.loc
->address
);
4470 regcache_raw_supply (regcache
, pc_regno
, regs
);
4476 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4477 const char *annex
, gdb_byte
*readbuf
,
4478 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
4480 /* We're only doing regular memory for now. */
4481 if (object
!= TARGET_OBJECT_MEMORY
)
4484 if (readbuf
== NULL
)
4485 error (_("tfile_xfer_partial: trace file is read-only"));
4487 set_tfile_traceframe ();
4489 if (traceframe_number
!= -1)
4493 /* Iterate through the traceframe's blocks, looking for
4495 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
4497 ULONGEST maddr
, amt
;
4498 unsigned short mlen
;
4499 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
4501 tfile_read ((gdb_byte
*) &maddr
, 8);
4502 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
4504 tfile_read ((gdb_byte
*) &mlen
, 2);
4505 mlen
= (unsigned short)
4506 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
4508 /* If the block includes the first part of the desired
4509 range, return as much it has; GDB will re-request the
4510 remainder, which might be in a different block of this
4512 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
4514 amt
= (maddr
+ mlen
) - offset
;
4518 tfile_read (readbuf
, amt
);
4522 /* Skip over this block. */
4523 pos
+= (8 + 2 + mlen
);
4527 /* It's unduly pedantic to refuse to look at the executable for
4528 read-only pieces; so do the equivalent of readonly regions aka
4530 /* FIXME account for relocation at some point. */
4537 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
4539 if ((s
->flags
& SEC_LOAD
) == 0
4540 || (s
->flags
& SEC_READONLY
) == 0)
4544 size
= bfd_get_section_size (s
);
4545 if (vma
<= offset
&& offset
< (vma
+ size
))
4549 amt
= (vma
+ size
) - offset
;
4553 amt
= bfd_get_section_contents (exec_bfd
, s
,
4554 readbuf
, offset
- vma
, amt
);
4560 /* Indicate failure to find the requested memory block. */
4564 /* Iterate through the blocks of a trace frame, looking for a 'V'
4565 block with a matching tsv number. */
4568 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
4572 set_tfile_traceframe ();
4575 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
4579 tfile_read ((gdb_byte
*) &vnum
, 4);
4580 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
4585 tfile_read ((gdb_byte
*) val
, 8);
4586 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
4594 /* Didn't find anything. */
4599 tfile_has_all_memory (struct target_ops
*ops
)
4605 tfile_has_memory (struct target_ops
*ops
)
4611 tfile_has_stack (struct target_ops
*ops
)
4613 return traceframe_number
!= -1;
4617 tfile_has_registers (struct target_ops
*ops
)
4619 return traceframe_number
!= -1;
4623 tfile_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
4628 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
4629 object for the tfile target's current traceframe. */
4632 build_traceframe_info (char blocktype
, void *data
)
4634 struct traceframe_info
*info
= data
;
4640 struct mem_range
*r
;
4642 unsigned short mlen
;
4644 tfile_read ((gdb_byte
*) &maddr
, 8);
4645 tfile_read ((gdb_byte
*) &mlen
, 2);
4647 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4660 warning (_("Unhandled trace block type (%d) '%c ' "
4661 "while building trace frame info."),
4662 blocktype
, blocktype
);
4669 static struct traceframe_info
*
4670 tfile_traceframe_info (void)
4672 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
4674 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
4679 init_tfile_ops (void)
4681 tfile_ops
.to_shortname
= "tfile";
4682 tfile_ops
.to_longname
= "Local trace dump file";
4684 = "Use a trace file as a target. Specify the filename of the trace file.";
4685 tfile_ops
.to_open
= tfile_open
;
4686 tfile_ops
.to_close
= tfile_close
;
4687 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
4688 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
4689 tfile_ops
.to_files_info
= tfile_files_info
;
4690 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
4691 tfile_ops
.to_get_tracepoint_status
= tfile_get_tracepoint_status
;
4692 tfile_ops
.to_trace_find
= tfile_trace_find
;
4693 tfile_ops
.to_get_trace_state_variable_value
4694 = tfile_get_trace_state_variable_value
;
4695 tfile_ops
.to_stratum
= process_stratum
;
4696 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
4697 tfile_ops
.to_has_memory
= tfile_has_memory
;
4698 tfile_ops
.to_has_stack
= tfile_has_stack
;
4699 tfile_ops
.to_has_registers
= tfile_has_registers
;
4700 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
4701 tfile_ops
.to_thread_alive
= tfile_thread_alive
;
4702 tfile_ops
.to_magic
= OPS_MAGIC
;
4706 free_current_marker (void *arg
)
4708 struct static_tracepoint_marker
**marker_p
= arg
;
4710 if (*marker_p
!= NULL
)
4712 release_static_tracepoint_marker (*marker_p
);
4719 /* Given a line of text defining a static tracepoint marker, parse it
4720 into a "static tracepoint marker" object. Throws an error is
4721 parsing fails. If PP is non-null, it points to one past the end of
4722 the parsed marker definition. */
4725 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
4726 struct static_tracepoint_marker
*marker
)
4733 p
= unpack_varlen_hex (p
, &addr
);
4734 p
++; /* skip a colon */
4736 marker
->gdbarch
= target_gdbarch
;
4737 marker
->address
= (CORE_ADDR
) addr
;
4739 endp
= strchr (p
, ':');
4741 error (_("bad marker definition: %s"), line
);
4743 marker
->str_id
= xmalloc (endp
- p
+ 1);
4744 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
4745 marker
->str_id
[end
] = '\0';
4748 p
++; /* skip a colon */
4750 marker
->extra
= xmalloc (strlen (p
) + 1);
4751 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
4752 marker
->extra
[end
] = '\0';
4758 /* Release a static tracepoint marker's contents. Note that the
4759 object itself isn't released here. There objects are usually on
4763 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
4765 xfree (marker
->str_id
);
4766 marker
->str_id
= NULL
;
4769 /* Print MARKER to gdb_stdout. */
4772 print_one_static_tracepoint_marker (int count
,
4773 struct static_tracepoint_marker
*marker
)
4775 struct command_line
*l
;
4778 char wrap_indent
[80];
4779 char extra_field_indent
[80];
4780 struct ui_out
*uiout
= current_uiout
;
4781 struct cleanup
*bkpt_chain
;
4782 VEC(breakpoint_p
) *tracepoints
;
4784 struct symtab_and_line sal
;
4788 sal
.pc
= marker
->address
;
4790 tracepoints
= static_tracepoints_here (marker
->address
);
4792 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
4794 /* A counter field to help readability. This is not a stable
4796 ui_out_field_int (uiout
, "count", count
);
4798 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
4800 ui_out_field_fmt (uiout
, "enabled", "%c",
4801 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
4802 ui_out_spaces (uiout
, 2);
4804 strcpy (wrap_indent
, " ");
4806 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
4807 strcat (wrap_indent
, " ");
4809 strcat (wrap_indent
, " ");
4811 strcpy (extra_field_indent
, " ");
4813 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
4815 sal
= find_pc_line (marker
->address
, 0);
4816 sym
= find_pc_sect_function (marker
->address
, NULL
);
4819 ui_out_text (uiout
, "in ");
4820 ui_out_field_string (uiout
, "func",
4821 SYMBOL_PRINT_NAME (sym
));
4822 ui_out_wrap_hint (uiout
, wrap_indent
);
4823 ui_out_text (uiout
, " at ");
4826 ui_out_field_skip (uiout
, "func");
4828 if (sal
.symtab
!= NULL
)
4830 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
4831 ui_out_text (uiout
, ":");
4833 if (ui_out_is_mi_like_p (uiout
))
4835 char *fullname
= symtab_to_fullname (sal
.symtab
);
4838 ui_out_field_string (uiout
, "fullname", fullname
);
4841 ui_out_field_skip (uiout
, "fullname");
4843 ui_out_field_int (uiout
, "line", sal
.line
);
4847 ui_out_field_skip (uiout
, "fullname");
4848 ui_out_field_skip (uiout
, "line");
4851 ui_out_text (uiout
, "\n");
4852 ui_out_text (uiout
, extra_field_indent
);
4853 ui_out_text (uiout
, _("Data: \""));
4854 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
4855 ui_out_text (uiout
, "\"\n");
4857 if (!VEC_empty (breakpoint_p
, tracepoints
))
4859 struct cleanup
*cleanup_chain
;
4861 struct breakpoint
*b
;
4863 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
4866 ui_out_text (uiout
, extra_field_indent
);
4867 ui_out_text (uiout
, _("Probed by static tracepoints: "));
4868 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
4871 ui_out_text (uiout
, ", ");
4872 ui_out_text (uiout
, "#");
4873 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
4876 do_cleanups (cleanup_chain
);
4878 if (ui_out_is_mi_like_p (uiout
))
4879 ui_out_field_int (uiout
, "number-of-tracepoints",
4880 VEC_length(breakpoint_p
, tracepoints
));
4882 ui_out_text (uiout
, "\n");
4884 VEC_free (breakpoint_p
, tracepoints
);
4886 do_cleanups (bkpt_chain
);
4890 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
4892 VEC(static_tracepoint_marker_p
) *markers
;
4893 struct cleanup
*old_chain
;
4894 struct static_tracepoint_marker
*marker
;
4895 struct ui_out
*uiout
= current_uiout
;
4898 /* We don't have to check target_can_use_agent and agent's capability on
4899 static tracepoint here, in order to be compatible with older GDBserver.
4900 We don't check USE_AGENT is true or not, because static tracepoints
4901 don't work without in-process agent, so we don't bother users to type
4902 `set agent on' when to use static tracepoint. */
4905 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
4906 "StaticTracepointMarkersTable");
4908 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
4910 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
4912 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
4913 if (gdbarch_addr_bit (target_gdbarch
) <= 32)
4914 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
4916 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
4917 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
4919 ui_out_table_body (uiout
);
4921 markers
= target_static_tracepoint_markers_by_strid (NULL
);
4922 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
4925 VEC_iterate (static_tracepoint_marker_p
,
4926 markers
, i
, marker
);
4929 print_one_static_tracepoint_marker (i
+ 1, marker
);
4930 release_static_tracepoint_marker (marker
);
4933 do_cleanups (old_chain
);
4936 /* The $_sdata convenience variable is a bit special. We don't know
4937 for sure type of the value until we actually have a chance to fetch
4938 the data --- the size of the object depends on what has been
4939 collected. We solve this by making $_sdata be an internalvar that
4940 creates a new value on access. */
4942 /* Return a new value with the correct type for the sdata object of
4943 the current trace frame. Return a void value if there's no object
4946 static struct value
*
4947 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
)
4952 /* We need to read the whole object before we know its size. */
4953 size
= target_read_alloc (¤t_target
,
4954 TARGET_OBJECT_STATIC_TRACE_DATA
,
4961 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
4963 v
= allocate_value (type
);
4964 memcpy (value_contents_raw (v
), buf
, size
);
4969 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
4972 #if !defined(HAVE_LIBEXPAT)
4974 struct traceframe_info
*
4975 parse_traceframe_info (const char *tframe_info
)
4977 static int have_warned
;
4982 warning (_("Can not parse XML trace frame info; XML support "
4983 "was disabled at compile time"));
4989 #else /* HAVE_LIBEXPAT */
4991 #include "xml-support.h"
4993 /* Handle the start of a <memory> element. */
4996 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
4997 const struct gdb_xml_element
*element
,
4998 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
5000 struct traceframe_info
*info
= user_data
;
5001 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5002 ULONGEST
*start_p
, *length_p
;
5004 start_p
= xml_find_attribute (attributes
, "start")->value
;
5005 length_p
= xml_find_attribute (attributes
, "length")->value
;
5007 r
->start
= *start_p
;
5008 r
->length
= *length_p
;
5011 /* Discard the constructed trace frame info (if an error occurs). */
5014 free_result (void *p
)
5016 struct traceframe_info
*result
= p
;
5018 free_traceframe_info (result
);
5021 /* The allowed elements and attributes for an XML memory map. */
5023 static const struct gdb_xml_attribute memory_attributes
[] = {
5024 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5025 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5026 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5029 static const struct gdb_xml_element traceframe_info_children
[] = {
5030 { "memory", memory_attributes
, NULL
,
5031 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5032 traceframe_info_start_memory
, NULL
},
5033 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5036 static const struct gdb_xml_element traceframe_info_elements
[] = {
5037 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
5039 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5042 /* Parse a traceframe-info XML document. */
5044 struct traceframe_info
*
5045 parse_traceframe_info (const char *tframe_info
)
5047 struct traceframe_info
*result
;
5048 struct cleanup
*back_to
;
5050 result
= XCNEW (struct traceframe_info
);
5051 back_to
= make_cleanup (free_result
, result
);
5053 if (gdb_xml_parse_quick (_("trace frame info"),
5054 "traceframe-info.dtd", traceframe_info_elements
,
5055 tframe_info
, result
) == 0)
5057 /* Parsed successfully, keep the result. */
5058 discard_cleanups (back_to
);
5063 do_cleanups (back_to
);
5067 #endif /* HAVE_LIBEXPAT */
5069 /* Returns the traceframe_info object for the current traceframe.
5070 This is where we avoid re-fetching the object from the target if we
5071 already have it cached. */
5073 static struct traceframe_info
*
5074 get_traceframe_info (void)
5076 if (traceframe_info
== NULL
)
5077 traceframe_info
= target_traceframe_info ();
5079 return traceframe_info
;
5082 /* If the target supports the query, return in RESULT the set of
5083 collected memory in the current traceframe, found within the LEN
5084 bytes range starting at MEMADDR. Returns true if the target
5085 supports the query, otherwise returns false, and RESULT is left
5089 traceframe_available_memory (VEC(mem_range_s
) **result
,
5090 CORE_ADDR memaddr
, ULONGEST len
)
5092 struct traceframe_info
*info
= get_traceframe_info ();
5096 struct mem_range
*r
;
5101 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
5102 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
5104 ULONGEST lo1
, hi1
, lo2
, hi2
;
5105 struct mem_range
*nr
;
5108 hi1
= memaddr
+ len
;
5111 hi2
= r
->start
+ r
->length
;
5113 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
5115 nr
->start
= max (lo1
, lo2
);
5116 nr
->length
= min (hi1
, hi2
) - nr
->start
;
5119 normalize_mem_ranges (*result
);
5126 /* module initialization */
5128 _initialize_tracepoint (void)
5130 struct cmd_list_element
*c
;
5132 /* Explicitly create without lookup, since that tries to create a
5133 value with a void typed value, and when we get here, gdbarch
5134 isn't initialized yet. At this point, we're quite sure there
5135 isn't another convenience variable of the same name. */
5136 create_internalvar_type_lazy ("_sdata", sdata_make_value
);
5138 traceframe_number
= -1;
5139 tracepoint_number
= -1;
5141 if (tracepoint_list
.list
== NULL
)
5143 tracepoint_list
.listsize
= 128;
5144 tracepoint_list
.list
= xmalloc
5145 (tracepoint_list
.listsize
* sizeof (struct memrange
));
5147 if (tracepoint_list
.aexpr_list
== NULL
)
5149 tracepoint_list
.aexpr_listsize
= 128;
5150 tracepoint_list
.aexpr_list
= xmalloc
5151 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5154 if (stepping_list
.list
== NULL
)
5156 stepping_list
.listsize
= 128;
5157 stepping_list
.list
= xmalloc
5158 (stepping_list
.listsize
* sizeof (struct memrange
));
5161 if (stepping_list
.aexpr_list
== NULL
)
5163 stepping_list
.aexpr_listsize
= 128;
5164 stepping_list
.aexpr_list
= xmalloc
5165 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5168 add_info ("scope", scope_info
,
5169 _("List the variables local to a scope"));
5171 add_cmd ("tracepoints", class_trace
, NULL
,
5172 _("Tracing of program execution without stopping the program."),
5175 add_com ("tdump", class_trace
, trace_dump_command
,
5176 _("Print everything collected at the current tracepoint."));
5178 add_com ("tsave", class_trace
, trace_save_command
, _("\
5179 Save the trace data to a file.\n\
5180 Use the '-r' option to direct the target to save directly to the file,\n\
5181 using its own filesystem."));
5183 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
5184 Define a trace state variable.\n\
5185 Argument is a $-prefixed name, optionally followed\n\
5186 by '=' and an expression that sets the initial value\n\
5187 at the start of tracing."));
5188 set_cmd_completer (c
, expression_completer
);
5190 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
5191 Delete one or more trace state variables.\n\
5192 Arguments are the names of the variables to delete.\n\
5193 If no arguments are supplied, delete all variables."), &deletelist
);
5194 /* FIXME add a trace variable completer. */
5196 add_info ("tvariables", tvariables_info
, _("\
5197 Status of trace state variables and their values.\n\
5200 add_info ("static-tracepoint-markers",
5201 info_static_tracepoint_markers_command
, _("\
5202 List target static tracepoints markers.\n\
5205 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
5206 Select a trace frame;\n\
5207 No argument means forward by one frame; '-' means backward by one frame."),
5208 &tfindlist
, "tfind ", 1, &cmdlist
);
5210 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
5211 Select a trace frame whose PC is outside the given range (exclusive).\n\
5212 Usage: tfind outside addr1, addr2"),
5215 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
5216 Select a trace frame whose PC is in the given range (inclusive).\n\
5217 Usage: tfind range addr1,addr2"),
5220 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
5221 Select a trace frame by source line.\n\
5222 Argument can be a line number (with optional source file),\n\
5223 a function name, or '*' followed by an address.\n\
5224 Default argument is 'the next source line that was traced'."),
5227 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
5228 Select a trace frame by tracepoint number.\n\
5229 Default is the tracepoint for the current trace frame."),
5232 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
5233 Select a trace frame by PC.\n\
5234 Default is the current PC, or the PC of the current trace frame."),
5237 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
5238 Synonym for 'none'.\n\
5239 De-select any trace frame and resume 'live' debugging."),
5242 add_cmd ("none", class_trace
, trace_find_none_command
,
5243 _("De-select any trace frame and resume 'live' debugging."),
5246 add_cmd ("start", class_trace
, trace_find_start_command
,
5247 _("Select the first trace frame in the trace buffer."),
5250 add_com ("tstatus", class_trace
, trace_status_command
,
5251 _("Display the status of the current trace data collection."));
5253 add_com ("tstop", class_trace
, trace_stop_command
, _("\
5254 Stop trace data collection.\n\
5255 Usage: tstop [ <notes> ... ]\n\
5256 Any arguments supplied are recorded with the trace as a stop reason and\n\
5257 reported by tstatus (if the target supports trace notes)."));
5259 add_com ("tstart", class_trace
, trace_start_command
, _("\
5260 Start trace data collection.\n\
5261 Usage: tstart [ <notes> ... ]\n\
5262 Any arguments supplied are recorded with the trace as a note and\n\
5263 reported by tstatus (if the target supports trace notes)."));
5265 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
5266 Ends a list of commands or actions.\n\
5267 Several GDB commands allow you to enter a list of commands or actions.\n\
5268 Entering \"end\" on a line by itself is the normal way to terminate\n\
5270 Note: the \"end\" command cannot be used at the gdb prompt."));
5272 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
5273 Specify single-stepping behavior at a tracepoint.\n\
5274 Argument is number of instructions to trace in single-step mode\n\
5275 following the tracepoint. This command is normally followed by\n\
5276 one or more \"collect\" commands, to specify what to collect\n\
5277 while single-stepping.\n\n\
5278 Note: this command can only be used in a tracepoint \"actions\" list."));
5280 add_com_alias ("ws", "while-stepping", class_alias
, 0);
5281 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
5283 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
5284 Specify one or more data items to be collected at a tracepoint.\n\
5285 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5286 collect all data (variables, registers) referenced by that expression.\n\
5287 Also accepts the following special arguments:\n\
5288 $regs -- all registers.\n\
5289 $args -- all function arguments.\n\
5290 $locals -- all variables local to the block/function scope.\n\
5291 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5292 Note: this command can only be used in a tracepoint \"actions\" list."));
5294 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
5295 Specify one or more expressions to be evaluated at a tracepoint.\n\
5296 Accepts a comma-separated list of (one or more) expressions.\n\
5297 The result of each evaluation will be discarded.\n\
5298 Note: this command can only be used in a tracepoint \"actions\" list."));
5300 add_com ("actions", class_trace
, trace_actions_command
, _("\
5301 Specify the actions to be taken at a tracepoint.\n\
5302 Tracepoint actions may include collecting of specified data,\n\
5303 single-stepping, or enabling/disabling other tracepoints,\n\
5304 depending on target's capabilities."));
5306 default_collect
= xstrdup ("");
5307 add_setshow_string_cmd ("default-collect", class_trace
,
5308 &default_collect
, _("\
5309 Set the list of expressions to collect by default"), _("\
5310 Show the list of expressions to collect by default"), NULL
,
5312 &setlist
, &showlist
);
5314 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
5315 &disconnected_tracing
, _("\
5316 Set whether tracing continues after GDB disconnects."), _("\
5317 Show whether tracing continues after GDB disconnects."), _("\
5318 Use this to continue a tracing run even if GDB disconnects\n\
5319 or detaches from the target. You can reconnect later and look at\n\
5320 trace data collected in the meantime."),
5321 set_disconnected_tracing
,
5326 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
5327 &circular_trace_buffer
, _("\
5328 Set target's use of circular trace buffer."), _("\
5329 Show target's use of circular trace buffer."), _("\
5330 Use this to make the trace buffer into a circular buffer,\n\
5331 which will discard traceframes (oldest first) instead of filling\n\
5332 up and stopping the trace run."),
5333 set_circular_trace_buffer
,
5338 add_setshow_string_cmd ("trace-user", class_trace
,
5340 Set the user name to use for current and future trace runs"), _("\
5341 Show the user name to use for current and future trace runs"), NULL
,
5342 set_trace_user
, NULL
,
5343 &setlist
, &showlist
);
5345 add_setshow_string_cmd ("trace-notes", class_trace
,
5347 Set notes string to use for current and future trace runs"), _("\
5348 Show the notes string to use for current and future trace runs"), NULL
,
5349 set_trace_notes
, NULL
,
5350 &setlist
, &showlist
);
5352 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
5353 &trace_stop_notes
, _("\
5354 Set notes string to use for future tstop commands"), _("\
5355 Show the notes string to use for future tstop commands"), NULL
,
5356 set_trace_stop_notes
, NULL
,
5357 &setlist
, &showlist
);
5361 add_target (&tfile_ops
);