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 %ld) "
744 "will not be collected."),
745 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
746 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 %ld) will not be collected.\n",
984 SYMBOL_PRINT_NAME (sym
), 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. */
1581 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1582 char ***tdp_actions
, char ***stepping_actions
)
1584 static char tdp_buff
[2048], step_buff
[2048];
1585 char *default_collect_line
= NULL
;
1586 struct command_line
*actions
;
1587 struct command_line
*default_collect_action
= NULL
;
1589 LONGEST frame_offset
;
1590 struct cleanup
*back_to
;
1592 back_to
= make_cleanup (null_cleanup
, NULL
);
1594 clear_collection_list (&tracepoint_list
);
1595 clear_collection_list (&stepping_list
);
1597 *tdp_actions
= NULL
;
1598 *stepping_actions
= NULL
;
1600 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1601 tloc
->address
, &frame_reg
, &frame_offset
);
1603 actions
= breakpoint_commands (t
);
1605 /* If there are default expressions to collect, make up a collect
1606 action and prepend to the action list to encode. Note that since
1607 validation is per-tracepoint (local var "xyz" might be valid for
1608 one tracepoint and not another, etc), we make up the action on
1609 the fly, and don't cache it. */
1610 if (*default_collect
)
1614 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1615 make_cleanup (xfree
, default_collect_line
);
1617 line
= default_collect_line
;
1618 validate_actionline (&line
, t
);
1620 default_collect_action
= xmalloc (sizeof (struct command_line
));
1621 make_cleanup (xfree
, default_collect_action
);
1622 default_collect_action
->next
= actions
;
1623 default_collect_action
->line
= line
;
1624 actions
= default_collect_action
;
1626 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1627 &tracepoint_list
, &stepping_list
);
1629 memrange_sortmerge (&tracepoint_list
);
1630 memrange_sortmerge (&stepping_list
);
1632 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1634 *stepping_actions
= stringify_collection_list (&stepping_list
,
1637 do_cleanups (back_to
);
1641 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1643 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1645 collect
->aexpr_list
=
1646 xrealloc (collect
->aexpr_list
,
1647 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1648 collect
->aexpr_listsize
*= 2;
1650 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1651 collect
->next_aexpr_elt
++;
1655 process_tracepoint_on_disconnect (void)
1657 VEC(breakpoint_p
) *tp_vec
= NULL
;
1659 struct breakpoint
*b
;
1660 int has_pending_p
= 0;
1662 /* Check whether we still have pending tracepoint. If we have, warn the
1663 user that pending tracepoint will no longer work. */
1664 tp_vec
= all_tracepoints ();
1665 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1674 struct bp_location
*loc1
;
1676 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1678 if (loc1
->shlib_disabled
)
1689 VEC_free (breakpoint_p
, tp_vec
);
1692 warning (_("Pending tracepoints will not be resolved while"
1693 " GDB is disconnected\n"));
1698 start_tracing (char *notes
)
1700 VEC(breakpoint_p
) *tp_vec
= NULL
;
1702 struct breakpoint
*b
;
1703 struct trace_state_variable
*tsv
;
1704 int any_enabled
= 0, num_to_download
= 0;
1707 tp_vec
= all_tracepoints ();
1709 /* No point in tracing without any tracepoints... */
1710 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1712 VEC_free (breakpoint_p
, tp_vec
);
1713 error (_("No tracepoints defined, not starting trace"));
1716 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1718 struct tracepoint
*t
= (struct tracepoint
*) b
;
1720 if (b
->enable_state
== bp_enabled
)
1723 if ((b
->type
== bp_fast_tracepoint
1724 ? may_insert_fast_tracepoints
1725 : may_insert_tracepoints
))
1728 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1729 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1734 if (target_supports_enable_disable_tracepoint ())
1735 warning (_("No tracepoints enabled"));
1738 /* No point in tracing with only disabled tracepoints that
1739 cannot be re-enabled. */
1740 VEC_free (breakpoint_p
, tp_vec
);
1741 error (_("No tracepoints enabled, not starting trace"));
1745 if (num_to_download
<= 0)
1747 VEC_free (breakpoint_p
, tp_vec
);
1748 error (_("No tracepoints that may be downloaded, not starting trace"));
1751 target_trace_init ();
1753 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1755 struct tracepoint
*t
= (struct tracepoint
*) b
;
1756 struct bp_location
*loc
;
1758 /* Clear `inserted' flag. */
1759 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1762 if ((b
->type
== bp_fast_tracepoint
1763 ? !may_insert_fast_tracepoints
1764 : !may_insert_tracepoints
))
1767 t
->number_on_target
= 0;
1769 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1771 /* Since tracepoint locations are never duplicated, `inserted'
1772 flag should be zero. */
1773 gdb_assert (!loc
->inserted
);
1775 target_download_tracepoint (loc
);
1780 t
->number_on_target
= b
->number
;
1782 VEC_free (breakpoint_p
, tp_vec
);
1784 /* Send down all the trace state variables too. */
1785 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1787 target_download_trace_state_variable (tsv
);
1790 /* Tell target to treat text-like sections as transparent. */
1791 target_trace_set_readonly_regions ();
1792 /* Set some mode flags. */
1793 target_set_disconnected_tracing (disconnected_tracing
);
1794 target_set_circular_trace_buffer (circular_trace_buffer
);
1797 notes
= trace_notes
;
1798 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1800 if (!ret
&& (trace_user
|| notes
))
1801 warning ("Target does not support trace user/notes, info ignored");
1803 /* Now insert traps and begin collecting data. */
1804 target_trace_start ();
1806 /* Reset our local state. */
1807 set_traceframe_num (-1);
1808 set_tracepoint_num (-1);
1809 set_traceframe_context (NULL
);
1810 current_trace_status()->running
= 1;
1811 clear_traceframe_info ();
1814 /* The tstart command requests the target to start a new trace run.
1815 The command passes any arguments it has to the target verbatim, as
1816 an optional "trace note". This is useful as for instance a warning
1817 to other users if the trace runs disconnected, and you don't want
1818 anybody else messing with the target. */
1821 trace_start_command (char *args
, int from_tty
)
1823 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1825 if (current_trace_status ()->running
)
1828 && !query (_("A trace is running already. Start a new run? ")))
1829 error (_("New trace run not started."));
1832 start_tracing (args
);
1835 /* The tstop command stops the tracing run. The command passes any
1836 supplied arguments to the target verbatim as a "stop note"; if the
1837 target supports trace notes, then it will be reported back as part
1838 of the trace run's status. */
1841 trace_stop_command (char *args
, int from_tty
)
1843 if (!current_trace_status ()->running
)
1844 error (_("Trace is not running."));
1846 stop_tracing (args
);
1850 stop_tracing (char *note
)
1854 target_trace_stop ();
1857 note
= trace_stop_notes
;
1858 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1861 warning ("Target does not support trace notes, note ignored");
1863 /* Should change in response to reply? */
1864 current_trace_status ()->running
= 0;
1867 /* tstatus command */
1869 trace_status_command (char *args
, int from_tty
)
1871 struct trace_status
*ts
= current_trace_status ();
1873 VEC(breakpoint_p
) *tp_vec
= NULL
;
1874 struct breakpoint
*t
;
1876 status
= target_get_trace_status (ts
);
1881 printf_filtered (_("Using a trace file.\n"));
1884 printf_filtered (_("Trace can not be run on this target.\n"));
1889 if (!ts
->running_known
)
1891 printf_filtered (_("Run/stop status is unknown.\n"));
1893 else if (ts
->running
)
1895 printf_filtered (_("Trace is running on the target.\n"));
1899 switch (ts
->stop_reason
)
1901 case trace_never_run
:
1902 printf_filtered (_("No trace has been run on the target.\n"));
1906 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1909 printf_filtered (_("Trace stopped by a tstop command.\n"));
1911 case trace_buffer_full
:
1912 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1914 case trace_disconnected
:
1915 printf_filtered (_("Trace stopped because of disconnection.\n"));
1917 case tracepoint_passcount
:
1918 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1919 ts
->stopping_tracepoint
);
1921 case tracepoint_error
:
1922 if (ts
->stopping_tracepoint
)
1923 printf_filtered (_("Trace stopped by an "
1924 "error (%s, tracepoint %d).\n"),
1925 ts
->stop_desc
, ts
->stopping_tracepoint
);
1927 printf_filtered (_("Trace stopped by an error (%s).\n"),
1930 case trace_stop_reason_unknown
:
1931 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1934 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1940 if (ts
->traceframes_created
>= 0
1941 && ts
->traceframe_count
!= ts
->traceframes_created
)
1943 printf_filtered (_("Buffer contains %d trace "
1944 "frames (of %d created total).\n"),
1945 ts
->traceframe_count
, ts
->traceframes_created
);
1947 else if (ts
->traceframe_count
>= 0)
1949 printf_filtered (_("Collected %d trace frames.\n"),
1950 ts
->traceframe_count
);
1953 if (ts
->buffer_free
>= 0)
1955 if (ts
->buffer_size
>= 0)
1957 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1958 ts
->buffer_free
, ts
->buffer_size
);
1959 if (ts
->buffer_size
> 0)
1960 printf_filtered (_(" (%d%% full)"),
1961 ((int) ((((long long) (ts
->buffer_size
1962 - ts
->buffer_free
)) * 100)
1963 / ts
->buffer_size
)));
1964 printf_filtered (_(".\n"));
1967 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1971 if (ts
->disconnected_tracing
)
1972 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1974 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1976 if (ts
->circular_buffer
)
1977 printf_filtered (_("Trace buffer is circular.\n"));
1979 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
1980 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
1982 if (ts
->notes
&& strlen (ts
->notes
) > 0)
1983 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
1985 /* Now report on what we're doing with tfind. */
1986 if (traceframe_number
>= 0)
1987 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1988 traceframe_number
, tracepoint_number
);
1990 printf_filtered (_("Not looking at any trace frame.\n"));
1992 /* Report start/stop times if supplied. */
1997 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
1999 /* Reporting a run time is more readable than two long numbers. */
2000 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2001 (long int) ts
->start_time
/ 1000000,
2002 (long int) ts
->start_time
% 1000000,
2003 (long int) run_time
/ 1000000,
2004 (long int) run_time
% 1000000);
2007 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2008 (long int) ts
->start_time
/ 1000000,
2009 (long int) ts
->start_time
% 1000000);
2011 else if (ts
->stop_time
)
2012 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2013 (long int) ts
->stop_time
/ 1000000,
2014 (long int) ts
->stop_time
% 1000000);
2016 /* Now report any per-tracepoint status available. */
2017 tp_vec
= all_tracepoints ();
2019 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2020 target_get_tracepoint_status (t
, NULL
);
2022 VEC_free (breakpoint_p
, tp_vec
);
2025 /* Report the trace status to uiout, in a way suitable for MI, and not
2026 suitable for CLI. If ON_STOP is true, suppress a few fields that
2027 are not meaningful in the -trace-stop response.
2029 The implementation is essentially parallel to trace_status_command, but
2030 merging them will result in unreadable code. */
2032 trace_status_mi (int on_stop
)
2034 struct ui_out
*uiout
= current_uiout
;
2035 struct trace_status
*ts
= current_trace_status ();
2038 status
= target_get_trace_status (ts
);
2040 if (status
== -1 && !ts
->from_file
)
2042 ui_out_field_string (uiout
, "supported", "0");
2047 ui_out_field_string (uiout
, "supported", "file");
2049 ui_out_field_string (uiout
, "supported", "1");
2051 gdb_assert (ts
->running_known
);
2055 ui_out_field_string (uiout
, "running", "1");
2057 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2058 Given that the frontend gets the status either on -trace-stop, or from
2059 -trace-status after re-connection, it does not seem like this
2060 information is necessary for anything. It is not necessary for either
2061 figuring the vital state of the target nor for navigation of trace
2062 frames. If the frontend wants to show the current state is some
2063 configure dialog, it can request the value when such dialog is
2064 invoked by the user. */
2068 char *stop_reason
= NULL
;
2069 int stopping_tracepoint
= -1;
2072 ui_out_field_string (uiout
, "running", "0");
2074 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2076 switch (ts
->stop_reason
)
2079 stop_reason
= "request";
2081 case trace_buffer_full
:
2082 stop_reason
= "overflow";
2084 case trace_disconnected
:
2085 stop_reason
= "disconnection";
2087 case tracepoint_passcount
:
2088 stop_reason
= "passcount";
2089 stopping_tracepoint
= ts
->stopping_tracepoint
;
2091 case tracepoint_error
:
2092 stop_reason
= "error";
2093 stopping_tracepoint
= ts
->stopping_tracepoint
;
2099 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2100 if (stopping_tracepoint
!= -1)
2101 ui_out_field_int (uiout
, "stopping-tracepoint",
2102 stopping_tracepoint
);
2103 if (ts
->stop_reason
== tracepoint_error
)
2104 ui_out_field_string (uiout
, "error-description",
2110 if (ts
->traceframe_count
!= -1)
2111 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2112 if (ts
->traceframes_created
!= -1)
2113 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2114 if (ts
->buffer_size
!= -1)
2115 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2116 if (ts
->buffer_free
!= -1)
2117 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2119 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2120 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2122 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2123 ui_out_field_string (uiout
, "notes", ts
->notes
);
2128 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2129 (long int) ts
->start_time
/ 1000000,
2130 (long int) ts
->start_time
% 1000000);
2131 ui_out_field_string (uiout
, "start-time", buf
);
2132 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2133 (long int) ts
->stop_time
/ 1000000,
2134 (long int) ts
->stop_time
% 1000000);
2135 ui_out_field_string (uiout
, "stop-time", buf
);
2139 /* This function handles the details of what to do about an ongoing
2140 tracing run if the user has asked to detach or otherwise disconnect
2143 disconnect_tracing (int from_tty
)
2145 /* It can happen that the target that was tracing went away on its
2146 own, and we didn't notice. Get a status update, and if the
2147 current target doesn't even do tracing, then assume it's not
2149 if (target_get_trace_status (current_trace_status ()) < 0)
2150 current_trace_status ()->running
= 0;
2152 /* If running interactively, give the user the option to cancel and
2153 then decide what to do differently with the run. Scripts are
2154 just going to disconnect and let the target deal with it,
2155 according to how it's been instructed previously via
2156 disconnected-tracing. */
2157 if (current_trace_status ()->running
&& from_tty
)
2159 process_tracepoint_on_disconnect ();
2161 if (current_trace_status ()->disconnected_tracing
)
2163 if (!query (_("Trace is running and will "
2164 "continue after detach; detach anyway? ")))
2165 error (_("Not confirmed."));
2169 if (!query (_("Trace is running but will "
2170 "stop on detach; detach anyway? ")))
2171 error (_("Not confirmed."));
2175 /* Also we want to be out of tfind mode, otherwise things can get
2176 confusing upon reconnection. Just use these calls instead of
2177 full tfind_1 behavior because we're in the middle of detaching,
2178 and there's no point to updating current stack frame etc. */
2179 set_current_traceframe (-1);
2180 set_traceframe_context (NULL
);
2183 /* Worker function for the various flavors of the tfind command. */
2185 tfind_1 (enum trace_find_type type
, int num
,
2186 ULONGEST addr1
, ULONGEST addr2
,
2189 int target_frameno
= -1, target_tracept
= -1;
2190 struct frame_id old_frame_id
= null_frame_id
;
2191 struct tracepoint
*tp
;
2192 struct ui_out
*uiout
= current_uiout
;
2194 /* Only try to get the current stack frame if we have a chance of
2195 succeeding. In particular, if we're trying to get a first trace
2196 frame while all threads are running, it's not going to succeed,
2197 so leave it with a default value and let the frame comparison
2198 below (correctly) decide to print out the source location of the
2200 if (!(type
== tfind_number
&& num
== -1)
2201 && (has_stack_frames () || traceframe_number
>= 0))
2202 old_frame_id
= get_frame_id (get_current_frame ());
2204 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2207 if (type
== tfind_number
2209 && target_frameno
== -1)
2211 /* We told the target to get out of tfind mode, and it did. */
2213 else if (target_frameno
== -1)
2215 /* A request for a non-existent trace frame has failed.
2216 Our response will be different, depending on FROM_TTY:
2218 If FROM_TTY is true, meaning that this command was
2219 typed interactively by the user, then give an error
2220 and DO NOT change the state of traceframe_number etc.
2222 However if FROM_TTY is false, meaning that we're either
2223 in a script, a loop, or a user-defined command, then
2224 DON'T give an error, but DO change the state of
2225 traceframe_number etc. to invalid.
2227 The rationalle is that if you typed the command, you
2228 might just have committed a typo or something, and you'd
2229 like to NOT lose your current debugging state. However
2230 if you're in a user-defined command or especially in a
2231 loop, then you need a way to detect that the command
2232 failed WITHOUT aborting. This allows you to write
2233 scripts that search thru the trace buffer until the end,
2234 and then continue on to do something else. */
2237 error (_("Target failed to find requested trace frame."));
2241 printf_filtered ("End of trace buffer.\n");
2242 #if 0 /* dubious now? */
2243 /* The following will not recurse, since it's
2245 trace_find_command ("-1", from_tty
);
2250 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2252 reinit_frame_cache ();
2253 registers_changed ();
2254 target_dcache_invalidate ();
2255 set_traceframe_num (target_frameno
);
2256 clear_traceframe_info ();
2257 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2258 if (target_frameno
== -1)
2259 set_traceframe_context (NULL
);
2261 set_traceframe_context (get_current_frame ());
2263 if (traceframe_number
>= 0)
2265 /* Use different branches for MI and CLI to make CLI messages
2267 if (ui_out_is_mi_like_p (uiout
))
2269 ui_out_field_string (uiout
, "found", "1");
2270 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2271 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2275 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2276 traceframe_number
, tracepoint_number
);
2281 if (ui_out_is_mi_like_p (uiout
))
2282 ui_out_field_string (uiout
, "found", "0");
2283 else if (type
== tfind_number
&& num
== -1)
2284 printf_unfiltered (_("No longer looking at any trace frame\n"));
2285 else /* This case may never occur, check. */
2286 printf_unfiltered (_("No trace frame found\n"));
2289 /* If we're in nonstop mode and getting out of looking at trace
2290 frames, there won't be any current frame to go back to and
2293 && (has_stack_frames () || traceframe_number
>= 0))
2295 enum print_what print_what
;
2297 /* NOTE: in imitation of the step command, try to determine
2298 whether we have made a transition from one function to
2299 another. If so, we'll print the "stack frame" (ie. the new
2300 function and it's arguments) -- otherwise we'll just show the
2303 if (frame_id_eq (old_frame_id
,
2304 get_frame_id (get_current_frame ())))
2305 print_what
= SRC_LINE
;
2307 print_what
= SRC_AND_LOC
;
2309 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2314 /* trace_find_command takes a trace frame number n,
2315 sends "QTFrame:<n>" to the target,
2316 and accepts a reply that may contain several optional pieces
2317 of information: a frame number, a tracepoint number, and an
2318 indication of whether this is a trap frame or a stepping frame.
2320 The minimal response is just "OK" (which indicates that the
2321 target does not give us a frame number or a tracepoint number).
2322 Instead of that, the target may send us a string containing
2324 F<hexnum> (gives the selected frame number)
2325 T<hexnum> (gives the selected tracepoint number)
2330 trace_find_command (char *args
, int from_tty
)
2331 { /* This should only be called with a numeric argument. */
2334 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2335 error (_("May not look at trace frames while trace is running."));
2337 if (args
== 0 || *args
== 0)
2338 { /* TFIND with no args means find NEXT trace frame. */
2339 if (traceframe_number
== -1)
2340 frameno
= 0; /* "next" is first one. */
2342 frameno
= traceframe_number
+ 1;
2344 else if (0 == strcmp (args
, "-"))
2346 if (traceframe_number
== -1)
2347 error (_("not debugging trace buffer"));
2348 else if (from_tty
&& traceframe_number
== 0)
2349 error (_("already at start of trace buffer"));
2351 frameno
= traceframe_number
- 1;
2353 /* A hack to work around eval's need for fp to have been collected. */
2354 else if (0 == strcmp (args
, "-1"))
2357 frameno
= parse_and_eval_long (args
);
2360 error (_("invalid input (%d is less than zero)"), frameno
);
2362 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2367 trace_find_end_command (char *args
, int from_tty
)
2369 trace_find_command ("-1", from_tty
);
2374 trace_find_none_command (char *args
, int from_tty
)
2376 trace_find_command ("-1", from_tty
);
2381 trace_find_start_command (char *args
, int from_tty
)
2383 trace_find_command ("0", from_tty
);
2386 /* tfind pc command */
2388 trace_find_pc_command (char *args
, int from_tty
)
2392 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2393 error (_("May not look at trace frames while trace is running."));
2395 if (args
== 0 || *args
== 0)
2396 pc
= regcache_read_pc (get_current_regcache ());
2398 pc
= parse_and_eval_address (args
);
2400 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2403 /* tfind tracepoint command */
2405 trace_find_tracepoint_command (char *args
, int from_tty
)
2408 struct tracepoint
*tp
;
2410 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2411 error (_("May not look at trace frames while trace is running."));
2413 if (args
== 0 || *args
== 0)
2415 if (tracepoint_number
== -1)
2416 error (_("No current tracepoint -- please supply an argument."));
2418 tdp
= tracepoint_number
; /* Default is current TDP. */
2421 tdp
= parse_and_eval_long (args
);
2423 /* If we have the tracepoint on hand, use the number that the
2424 target knows about (which may be different if we disconnected
2425 and reconnected). */
2426 tp
= get_tracepoint (tdp
);
2428 tdp
= tp
->number_on_target
;
2430 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2433 /* TFIND LINE command:
2435 This command will take a sourceline for argument, just like BREAK
2436 or TRACE (ie. anything that "decode_line_1" can handle).
2438 With no argument, this command will find the next trace frame
2439 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2442 trace_find_line_command (char *args
, int from_tty
)
2444 static CORE_ADDR start_pc
, end_pc
;
2445 struct symtabs_and_lines sals
;
2446 struct symtab_and_line sal
;
2447 struct cleanup
*old_chain
;
2449 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2450 error (_("May not look at trace frames while trace is running."));
2452 if (args
== 0 || *args
== 0)
2454 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2456 sals
.sals
= (struct symtab_and_line
*)
2457 xmalloc (sizeof (struct symtab_and_line
));
2462 sals
= decode_line_spec (args
, DECODE_LINE_FUNFIRSTLINE
);
2466 old_chain
= make_cleanup (xfree
, sals
.sals
);
2467 if (sal
.symtab
== 0)
2468 error (_("No line number information available."));
2470 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2472 if (start_pc
== end_pc
)
2474 printf_filtered ("Line %d of \"%s\"",
2475 sal
.line
, sal
.symtab
->filename
);
2477 printf_filtered (" is at address ");
2478 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2480 printf_filtered (" but contains no code.\n");
2481 sal
= find_pc_line (start_pc
, 0);
2483 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2484 && start_pc
!= end_pc
)
2485 printf_filtered ("Attempting to find line %d instead.\n",
2488 error (_("Cannot find a good line."));
2492 /* Is there any case in which we get here, and have an address
2493 which the user would want to see? If we have debugging
2494 symbols and no line numbers? */
2495 error (_("Line number %d is out of range for \"%s\"."),
2496 sal
.line
, sal
.symtab
->filename
);
2498 /* Find within range of stated line. */
2500 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2502 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2503 do_cleanups (old_chain
);
2506 /* tfind range command */
2508 trace_find_range_command (char *args
, int from_tty
)
2510 static CORE_ADDR start
, stop
;
2513 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2514 error (_("May not look at trace frames while trace is running."));
2516 if (args
== 0 || *args
== 0)
2517 { /* XXX FIXME: what should default behavior be? */
2518 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2522 if (0 != (tmp
= strchr (args
, ',')))
2524 *tmp
++ = '\0'; /* Terminate start address. */
2525 while (isspace ((int) *tmp
))
2527 start
= parse_and_eval_address (args
);
2528 stop
= parse_and_eval_address (tmp
);
2531 { /* No explicit end address? */
2532 start
= parse_and_eval_address (args
);
2533 stop
= start
+ 1; /* ??? */
2536 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2539 /* tfind outside command */
2541 trace_find_outside_command (char *args
, int from_tty
)
2543 CORE_ADDR start
, stop
;
2546 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2547 error (_("May not look at trace frames while trace is running."));
2549 if (args
== 0 || *args
== 0)
2550 { /* XXX FIXME: what should default behavior be? */
2551 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2555 if (0 != (tmp
= strchr (args
, ',')))
2557 *tmp
++ = '\0'; /* Terminate start address. */
2558 while (isspace ((int) *tmp
))
2560 start
= parse_and_eval_address (args
);
2561 stop
= parse_and_eval_address (tmp
);
2564 { /* No explicit end address? */
2565 start
= parse_and_eval_address (args
);
2566 stop
= start
+ 1; /* ??? */
2569 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2572 /* info scope command: list the locals for a scope. */
2574 scope_info (char *args
, int from_tty
)
2576 struct symtabs_and_lines sals
;
2578 struct minimal_symbol
*msym
;
2579 struct block
*block
;
2580 char *symname
, *save_args
= args
;
2581 struct dict_iterator iter
;
2583 struct gdbarch
*gdbarch
;
2586 if (args
== 0 || *args
== 0)
2587 error (_("requires an argument (function, "
2588 "line or *addr) to define a scope"));
2590 sals
= decode_line_1 (&args
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2591 if (sals
.nelts
== 0)
2592 return; /* Presumably decode_line_1 has already warned. */
2594 /* Resolve line numbers to PC. */
2595 resolve_sal_pc (&sals
.sals
[0]);
2596 block
= block_for_pc (sals
.sals
[0].pc
);
2600 QUIT
; /* Allow user to bail out with ^C. */
2601 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2603 QUIT
; /* Allow user to bail out with ^C. */
2605 printf_filtered ("Scope for %s:\n", save_args
);
2608 symname
= SYMBOL_PRINT_NAME (sym
);
2609 if (symname
== NULL
|| *symname
== '\0')
2610 continue; /* Probably botched, certainly useless. */
2612 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2614 printf_filtered ("Symbol %s is ", symname
);
2615 switch (SYMBOL_CLASS (sym
))
2618 case LOC_UNDEF
: /* Messed up symbol? */
2619 printf_filtered ("a bogus symbol, class %d.\n",
2620 SYMBOL_CLASS (sym
));
2621 count
--; /* Don't count this one. */
2624 printf_filtered ("a constant with value %ld (0x%lx)",
2625 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2627 case LOC_CONST_BYTES
:
2628 printf_filtered ("constant bytes: ");
2629 if (SYMBOL_TYPE (sym
))
2630 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2631 fprintf_filtered (gdb_stdout
, " %02x",
2632 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2635 printf_filtered ("in static storage at address ");
2636 printf_filtered ("%s", paddress (gdbarch
,
2637 SYMBOL_VALUE_ADDRESS (sym
)));
2640 /* GDBARCH is the architecture associated with the objfile
2641 the symbol is defined in; the target architecture may be
2642 different, and may provide additional registers. However,
2643 we do not know the target architecture at this point.
2644 We assume the objfile architecture will contain all the
2645 standard registers that occur in debug info in that
2647 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2650 if (SYMBOL_IS_ARGUMENT (sym
))
2651 printf_filtered ("an argument in register $%s",
2652 gdbarch_register_name (gdbarch
, regno
));
2654 printf_filtered ("a local variable in register $%s",
2655 gdbarch_register_name (gdbarch
, regno
));
2658 printf_filtered ("an argument at stack/frame offset %ld",
2659 SYMBOL_VALUE (sym
));
2662 printf_filtered ("a local variable at frame offset %ld",
2663 SYMBOL_VALUE (sym
));
2666 printf_filtered ("a reference argument at offset %ld",
2667 SYMBOL_VALUE (sym
));
2669 case LOC_REGPARM_ADDR
:
2670 /* Note comment at LOC_REGISTER. */
2671 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2673 printf_filtered ("the address of an argument, in register $%s",
2674 gdbarch_register_name (gdbarch
, regno
));
2677 printf_filtered ("a typedef.\n");
2680 printf_filtered ("a label at address ");
2681 printf_filtered ("%s", paddress (gdbarch
,
2682 SYMBOL_VALUE_ADDRESS (sym
)));
2685 printf_filtered ("a function at address ");
2686 printf_filtered ("%s",
2687 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2689 case LOC_UNRESOLVED
:
2690 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2693 printf_filtered ("Unresolved Static");
2696 printf_filtered ("static storage at address ");
2697 printf_filtered ("%s",
2698 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2701 case LOC_OPTIMIZED_OUT
:
2702 printf_filtered ("optimized out.\n");
2705 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2706 BLOCK_START (block
),
2710 if (SYMBOL_TYPE (sym
))
2711 printf_filtered (", length %d.\n",
2712 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2714 if (BLOCK_FUNCTION (block
))
2717 block
= BLOCK_SUPERBLOCK (block
);
2720 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2724 /* worker function (cleanup) */
2726 replace_comma (void *data
)
2733 /* Helper for trace_dump_command. Dump the action list starting at
2734 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2735 actions of the body of a while-stepping action. STEPPING_FRAME is
2736 set if the current traceframe was determined to be a while-stepping
2740 trace_dump_actions (struct command_line
*action
,
2741 int stepping_actions
, int stepping_frame
,
2744 char *action_exp
, *next_comma
;
2746 for (; action
!= NULL
; action
= action
->next
)
2748 struct cmd_list_element
*cmd
;
2750 QUIT
; /* Allow user to bail out with ^C. */
2751 action_exp
= action
->line
;
2752 while (isspace ((int) *action_exp
))
2755 /* The collection actions to be done while stepping are
2756 bracketed by the commands "while-stepping" and "end". */
2758 if (*action_exp
== '#') /* comment line */
2761 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2763 error (_("Bad action list item: %s"), action_exp
);
2765 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2769 for (i
= 0; i
< action
->body_count
; ++i
)
2770 trace_dump_actions (action
->body_list
[i
],
2771 1, stepping_frame
, from_tty
);
2773 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2775 /* Display the collected data.
2776 For the trap frame, display only what was collected at
2777 the trap. Likewise for stepping frames, display only
2778 what was collected while stepping. This means that the
2779 two boolean variables, STEPPING_FRAME and
2780 STEPPING_ACTIONS should be equal. */
2781 if (stepping_frame
== stepping_actions
)
2783 if (*action_exp
== '/')
2784 action_exp
= decode_agent_options (action_exp
);
2787 { /* Repeat over a comma-separated list. */
2788 QUIT
; /* Allow user to bail out with ^C. */
2789 if (*action_exp
== ',')
2791 while (isspace ((int) *action_exp
))
2794 next_comma
= strchr (action_exp
, ',');
2796 if (0 == strncasecmp (action_exp
, "$reg", 4))
2797 registers_info (NULL
, from_tty
);
2798 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2800 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2801 locals_info (NULL
, from_tty
);
2802 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2803 args_info (NULL
, from_tty
);
2808 make_cleanup (replace_comma
, next_comma
);
2811 printf_filtered ("%s = ", action_exp
);
2812 output_command (action_exp
, from_tty
);
2813 printf_filtered ("\n");
2817 action_exp
= next_comma
;
2819 while (action_exp
&& *action_exp
== ',');
2825 /* The tdump command. */
2828 trace_dump_command (char *args
, int from_tty
)
2830 struct regcache
*regcache
;
2831 struct tracepoint
*t
;
2832 int stepping_frame
= 0;
2833 struct bp_location
*loc
;
2834 char *line
, *default_collect_line
= NULL
;
2835 struct command_line
*actions
, *default_collect_action
= NULL
;
2836 struct cleanup
*old_chain
= NULL
;
2838 if (tracepoint_number
== -1)
2840 warning (_("No current trace frame."));
2844 t
= get_tracepoint (tracepoint_number
);
2847 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2850 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2851 tracepoint_number
, traceframe_number
);
2853 /* The current frame is a trap frame if the frame PC is equal
2854 to the tracepoint PC. If not, then the current frame was
2855 collected during single-stepping. */
2857 regcache
= get_current_regcache ();
2859 /* If the traceframe's address matches any of the tracepoint's
2860 locations, assume it is a direct hit rather than a while-stepping
2861 frame. (FIXME this is not reliable, should record each frame's
2864 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
2865 if (loc
->address
== regcache_read_pc (regcache
))
2868 actions
= breakpoint_commands (&t
->base
);
2870 /* If there is a default-collect list, make up a collect command,
2871 prepend to the tracepoint's commands, and pass the whole mess to
2872 the trace dump scanner. We need to validate because
2873 default-collect might have been junked since the trace run. */
2874 if (*default_collect
)
2876 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2877 old_chain
= make_cleanup (xfree
, default_collect_line
);
2878 line
= default_collect_line
;
2879 validate_actionline (&line
, &t
->base
);
2880 default_collect_action
= xmalloc (sizeof (struct command_line
));
2881 make_cleanup (xfree
, default_collect_action
);
2882 default_collect_action
->next
= actions
;
2883 default_collect_action
->line
= line
;
2884 actions
= default_collect_action
;
2887 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2889 if (*default_collect
)
2890 do_cleanups (old_chain
);
2893 /* Encode a piece of a tracepoint's source-level definition in a form
2894 that is suitable for both protocol and saving in files. */
2895 /* This version does not do multiple encodes for long strings; it should
2896 return an offset to the next piece to encode. FIXME */
2899 encode_source_string (int tpnum
, ULONGEST addr
,
2900 char *srctype
, char *src
, char *buf
, int buf_size
)
2902 if (80 + strlen (srctype
) > buf_size
)
2903 error (_("Buffer too small for source encoding"));
2904 sprintf (buf
, "%x:%s:%s:%x:%x:",
2905 tpnum
, phex_nz (addr
, sizeof (addr
)),
2906 srctype
, 0, (int) strlen (src
));
2907 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2908 error (_("Source string too long for buffer"));
2909 bin2hex (src
, buf
+ strlen (buf
), 0);
2913 extern int trace_regblock_size
;
2915 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2916 non-zero, the save is performed on the target, otherwise GDB obtains all
2917 trace data and saves it locally. */
2920 trace_save (const char *filename
, int target_does_save
)
2922 struct cleanup
*cleanup
;
2924 struct trace_status
*ts
= current_trace_status ();
2927 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2928 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2932 ULONGEST offset
= 0;
2933 #define MAX_TRACE_UPLOAD 2000
2934 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2937 /* If the target is to save the data to a file on its own, then just
2938 send the command and be done with it. */
2939 if (target_does_save
)
2941 err
= target_save_trace_data (filename
);
2943 error (_("Target failed to save trace data to '%s'."),
2948 /* Get the trace status first before opening the file, so if the
2949 target is losing, we can get out without touching files. */
2950 status
= target_get_trace_status (ts
);
2952 pathname
= tilde_expand (filename
);
2953 cleanup
= make_cleanup (xfree
, pathname
);
2955 fp
= fopen (pathname
, "wb");
2957 error (_("Unable to open file '%s' for saving trace data (%s)"),
2958 filename
, safe_strerror (errno
));
2959 make_cleanup_fclose (fp
);
2961 /* Write a file header, with a high-bit-set char to indicate a
2962 binary file, plus a hint as what this file is, and a version
2963 number in case of future needs. */
2964 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2966 perror_with_name (pathname
);
2968 /* Write descriptive info. */
2970 /* Write out the size of a register block. */
2971 fprintf (fp
, "R %x\n", trace_regblock_size
);
2973 /* Write out status of the tracing run (aka "tstatus" info). */
2974 fprintf (fp
, "status %c;%s",
2975 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
2976 if (ts
->stop_reason
== tracepoint_error
)
2978 char *buf
= (char *) alloca (strlen (ts
->stop_desc
) * 2 + 1);
2980 bin2hex ((gdb_byte
*) ts
->stop_desc
, buf
, 0);
2981 fprintf (fp
, ":%s", buf
);
2983 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
2984 if (ts
->traceframe_count
>= 0)
2985 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
2986 if (ts
->traceframes_created
>= 0)
2987 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
2988 if (ts
->buffer_free
>= 0)
2989 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
2990 if (ts
->buffer_size
>= 0)
2991 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
2992 if (ts
->disconnected_tracing
)
2993 fprintf (fp
, ";disconn:%x", ts
->disconnected_tracing
);
2994 if (ts
->circular_buffer
)
2995 fprintf (fp
, ";circular:%x", ts
->circular_buffer
);
2998 /* Note that we want to upload tracepoints and save those, rather
2999 than simply writing out the local ones, because the user may have
3000 changed tracepoints in GDB in preparation for a future tracing
3001 run, or maybe just mass-deleted all types of breakpoints as part
3002 of cleaning up. So as not to contaminate the session, leave the
3003 data in its uploaded form, don't make into real tracepoints. */
3005 /* Get trace state variables first, they may be checked when parsing
3006 uploaded commands. */
3008 target_upload_trace_state_variables (&uploaded_tsvs
);
3010 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3016 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
3017 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
3020 fprintf (fp
, "tsv %x:%s:%x:%s\n",
3021 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
3022 utsv
->builtin
, buf
);
3028 free_uploaded_tsvs (&uploaded_tsvs
);
3030 target_upload_tracepoints (&uploaded_tps
);
3032 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3033 target_get_tracepoint_status (NULL
, utp
);
3035 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3037 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
3038 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3039 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
3040 if (utp
->type
== bp_fast_tracepoint
)
3041 fprintf (fp
, ":F%x", utp
->orig_size
);
3043 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
3046 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
3047 fprintf (fp
, "tp A%x:%s:%s\n",
3048 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3049 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
3050 fprintf (fp
, "tp S%x:%s:%s\n",
3051 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3054 encode_source_string (utp
->number
, utp
->addr
,
3055 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
3056 fprintf (fp
, "tp Z%s\n", buf
);
3058 if (utp
->cond_string
)
3060 encode_source_string (utp
->number
, utp
->addr
,
3061 "cond", utp
->cond_string
,
3062 buf
, MAX_TRACE_UPLOAD
);
3063 fprintf (fp
, "tp Z%s\n", buf
);
3065 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
3067 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
3068 buf
, MAX_TRACE_UPLOAD
);
3069 fprintf (fp
, "tp Z%s\n", buf
);
3071 fprintf (fp
, "tp V%x:%s:%x:%s\n",
3072 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3074 phex_nz (utp
->traceframe_usage
,
3075 sizeof (utp
->traceframe_usage
)));
3078 free_uploaded_tps (&uploaded_tps
);
3080 /* Mark the end of the definition section. */
3083 /* Get and write the trace data proper. We ask for big blocks, in
3084 the hopes of efficiency, but will take less if the target has
3085 packet size limitations or some such. */
3088 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
3090 error (_("Failure to get requested trace buffer data"));
3091 /* No more data is forthcoming, we're done. */
3094 written
= fwrite (buf
, gotten
, 1, fp
);
3096 perror_with_name (pathname
);
3100 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
3101 written
= fwrite (&gotten
, 4, 1, fp
);
3103 perror_with_name (pathname
);
3105 do_cleanups (cleanup
);
3109 trace_save_command (char *args
, int from_tty
)
3111 int target_does_save
= 0;
3113 char *filename
= NULL
;
3114 struct cleanup
*back_to
;
3117 error_no_arg (_("file in which to save trace data"));
3119 argv
= gdb_buildargv (args
);
3120 back_to
= make_cleanup_freeargv (argv
);
3122 for (; *argv
; ++argv
)
3124 if (strcmp (*argv
, "-r") == 0)
3125 target_does_save
= 1;
3126 else if (**argv
== '-')
3127 error (_("unknown option `%s'"), *argv
);
3133 error_no_arg (_("file in which to save trace data"));
3135 trace_save (filename
, target_does_save
);
3138 printf_filtered (_("Trace data saved to file '%s'.\n"), filename
);
3140 do_cleanups (back_to
);
3143 /* Tell the target what to do with an ongoing tracing run if GDB
3144 disconnects for some reason. */
3147 set_disconnected_tracing (char *args
, int from_tty
,
3148 struct cmd_list_element
*c
)
3150 target_set_disconnected_tracing (disconnected_tracing
);
3154 set_circular_trace_buffer (char *args
, int from_tty
,
3155 struct cmd_list_element
*c
)
3157 target_set_circular_trace_buffer (circular_trace_buffer
);
3161 set_trace_user (char *args
, int from_tty
,
3162 struct cmd_list_element
*c
)
3166 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3169 warning ("Target does not support trace notes, user ignored");
3173 set_trace_notes (char *args
, int from_tty
,
3174 struct cmd_list_element
*c
)
3178 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3181 warning ("Target does not support trace notes, note ignored");
3185 set_trace_stop_notes (char *args
, int from_tty
,
3186 struct cmd_list_element
*c
)
3190 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3193 warning ("Target does not support trace notes, stop note ignored");
3196 /* Convert the memory pointed to by mem into hex, placing result in buf.
3197 * Return a pointer to the last char put in buf (null)
3198 * "stolen" from sparc-stub.c
3201 static const char hexchars
[] = "0123456789abcdef";
3204 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3212 *buf
++ = hexchars
[ch
>> 4];
3213 *buf
++ = hexchars
[ch
& 0xf];
3222 get_traceframe_number (void)
3224 return traceframe_number
;
3227 /* Make the traceframe NUM be the current trace frame. Does nothing
3228 if NUM is already current. */
3231 set_current_traceframe (int num
)
3235 if (traceframe_number
== num
)
3237 /* Nothing to do. */
3241 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3244 warning (_("could not change traceframe"));
3246 traceframe_number
= newnum
;
3248 /* Changing the traceframe changes our view of registers and of the
3250 registers_changed ();
3252 clear_traceframe_info ();
3255 /* Make the traceframe NUM be the current trace frame, and do nothing
3259 set_traceframe_number (int num
)
3261 traceframe_number
= num
;
3264 /* A cleanup used when switching away and back from tfind mode. */
3266 struct current_traceframe_cleanup
3268 /* The traceframe we were inspecting. */
3269 int traceframe_number
;
3273 do_restore_current_traceframe_cleanup (void *arg
)
3275 struct current_traceframe_cleanup
*old
= arg
;
3277 set_current_traceframe (old
->traceframe_number
);
3281 restore_current_traceframe_cleanup_dtor (void *arg
)
3283 struct current_traceframe_cleanup
*old
= arg
;
3289 make_cleanup_restore_current_traceframe (void)
3291 struct current_traceframe_cleanup
*old
;
3293 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3294 old
->traceframe_number
= traceframe_number
;
3296 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3297 restore_current_traceframe_cleanup_dtor
);
3301 make_cleanup_restore_traceframe_number (void)
3303 return make_cleanup_restore_integer (&traceframe_number
);
3306 /* Given a number and address, return an uploaded tracepoint with that
3307 number, creating if necessary. */
3309 struct uploaded_tp
*
3310 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3312 struct uploaded_tp
*utp
;
3314 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3315 if (utp
->number
== num
&& utp
->addr
== addr
)
3317 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3318 memset (utp
, 0, sizeof (struct uploaded_tp
));
3321 utp
->actions
= NULL
;
3322 utp
->step_actions
= NULL
;
3323 utp
->cmd_strings
= NULL
;
3330 free_uploaded_tps (struct uploaded_tp
**utpp
)
3332 struct uploaded_tp
*next_one
;
3336 next_one
= (*utpp
)->next
;
3342 /* Given a number and address, return an uploaded tracepoint with that
3343 number, creating if necessary. */
3345 struct uploaded_tsv
*
3346 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3348 struct uploaded_tsv
*utsv
;
3350 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3351 if (utsv
->number
== num
)
3353 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3354 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3356 utsv
->next
= *utsvp
;
3362 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3364 struct uploaded_tsv
*next_one
;
3368 next_one
= (*utsvp
)->next
;
3374 /* FIXME this function is heuristic and will miss the cases where the
3375 conditional is semantically identical but differs in whitespace,
3376 such as "x == 0" vs "x==0". */
3379 cond_string_is_same (char *str1
, char *str2
)
3381 if (str1
== NULL
|| str2
== NULL
)
3382 return (str1
== str2
);
3384 return (strcmp (str1
, str2
) == 0);
3387 /* Look for an existing tracepoint that seems similar enough to the
3388 uploaded one. Enablement isn't compared, because the user can
3389 toggle that freely, and may have done so in anticipation of the
3390 next trace run. Return the location of matched tracepoint. */
3392 struct bp_location
*
3393 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3395 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3397 struct breakpoint
*b
;
3398 struct bp_location
*loc
;
3400 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3402 struct tracepoint
*t
= (struct tracepoint
*) b
;
3404 if (b
->type
== utp
->type
3405 && t
->step_count
== utp
->step
3406 && t
->pass_count
== utp
->pass
3407 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3408 /* FIXME also test actions. */
3411 /* Scan the locations for an address match. */
3412 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3414 if (loc
->address
== utp
->addr
)
3422 /* Given a list of tracepoints uploaded from a target, attempt to
3423 match them up with existing tracepoints, and create new ones if not
3427 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3429 struct uploaded_tp
*utp
;
3431 /* Look for GDB tracepoints that match up with our uploaded versions. */
3432 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3434 struct bp_location
*loc
;
3435 struct tracepoint
*t
;
3437 loc
= find_matching_tracepoint_location (utp
);
3440 /* Mark this location as already inserted. */
3442 t
= (struct tracepoint
*) loc
->owner
;
3443 printf_filtered (_("Assuming tracepoint %d is same "
3444 "as target's tracepoint %d at %s.\n"),
3445 loc
->owner
->number
, utp
->number
,
3446 paddress (loc
->gdbarch
, utp
->addr
));
3450 t
= create_tracepoint_from_upload (utp
);
3452 printf_filtered (_("Created tracepoint %d for "
3453 "target's tracepoint %d at %s.\n"),
3454 t
->base
.number
, utp
->number
,
3455 paddress (get_current_arch (), utp
->addr
));
3457 printf_filtered (_("Failed to create tracepoint for target's "
3458 "tracepoint %d at %s, skipping it.\n"),
3460 paddress (get_current_arch (), utp
->addr
));
3462 /* Whether found or created, record the number used by the
3463 target, to help with mapping target tracepoints back to their
3464 counterparts here. */
3466 t
->number_on_target
= utp
->number
;
3469 free_uploaded_tps (uploaded_tps
);
3472 /* Trace state variables don't have much to identify them beyond their
3473 name, so just use that to detect matches. */
3475 struct trace_state_variable
*
3476 find_matching_tsv (struct uploaded_tsv
*utsv
)
3481 return find_trace_state_variable (utsv
->name
);
3484 struct trace_state_variable
*
3485 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3487 const char *namebase
;
3490 struct trace_state_variable
*tsv
;
3491 struct cleanup
*old_chain
;
3495 namebase
= utsv
->name
;
3496 buf
= xstrprintf ("%s", namebase
);
3501 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3504 /* Fish for a name that is not in use. */
3505 /* (should check against all internal vars?) */
3506 while (find_trace_state_variable (buf
))
3509 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3512 old_chain
= make_cleanup (xfree
, buf
);
3514 /* We have an available name, create the variable. */
3515 tsv
= create_trace_state_variable (buf
);
3516 tsv
->initial_value
= utsv
->initial_value
;
3517 tsv
->builtin
= utsv
->builtin
;
3519 do_cleanups (old_chain
);
3524 /* Given a list of uploaded trace state variables, try to match them
3525 up with existing variables, or create additional ones. */
3528 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3531 struct uploaded_tsv
*utsv
;
3532 struct trace_state_variable
*tsv
;
3535 /* Most likely some numbers will have to be reassigned as part of
3536 the merge, so clear them all in anticipation. */
3537 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3540 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3542 tsv
= find_matching_tsv (utsv
);
3546 printf_filtered (_("Assuming trace state variable $%s "
3547 "is same as target's variable %d.\n"),
3548 tsv
->name
, utsv
->number
);
3552 tsv
= create_tsv_from_upload (utsv
);
3554 printf_filtered (_("Created trace state variable "
3555 "$%s for target's variable %d.\n"),
3556 tsv
->name
, utsv
->number
);
3558 /* Give precedence to numberings that come from the target. */
3560 tsv
->number
= utsv
->number
;
3563 /* Renumber everything that didn't get a target-assigned number. */
3565 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3566 if (tsv
->number
> highest
)
3567 highest
= tsv
->number
;
3570 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3571 if (tsv
->number
== 0)
3572 tsv
->number
= highest
++;
3574 free_uploaded_tsvs (uploaded_tsvs
);
3577 /* target tfile command */
3579 struct target_ops tfile_ops
;
3581 /* Fill in tfile_ops with its defined operations and properties. */
3583 #define TRACE_HEADER_SIZE 8
3585 char *trace_filename
;
3587 off_t trace_frames_offset
;
3589 int cur_traceframe_number
;
3591 int trace_regblock_size
;
3593 static void tfile_interp_line (char *line
,
3594 struct uploaded_tp
**utpp
,
3595 struct uploaded_tsv
**utsvp
);
3597 /* Read SIZE bytes into READBUF from the trace frame, starting at
3598 TRACE_FD's current position. Note that this call `read'
3599 underneath, hence it advances the file's seek position. Throws an
3600 error if the `read' syscall fails, or less than SIZE bytes are
3604 tfile_read (gdb_byte
*readbuf
, int size
)
3608 gotten
= read (trace_fd
, readbuf
, size
);
3610 perror_with_name (trace_filename
);
3611 else if (gotten
< size
)
3612 error (_("Premature end of file while reading trace file"));
3616 tfile_open (char *filename
, int from_tty
)
3618 volatile struct gdb_exception ex
;
3620 struct cleanup
*old_chain
;
3623 char header
[TRACE_HEADER_SIZE
];
3624 char linebuf
[1000]; /* Should be max remote packet size or so. */
3627 struct trace_status
*ts
;
3628 struct uploaded_tp
*uploaded_tps
= NULL
;
3629 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3631 target_preopen (from_tty
);
3633 error (_("No trace file specified."));
3635 filename
= tilde_expand (filename
);
3636 if (!IS_ABSOLUTE_PATH(filename
))
3638 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
3643 old_chain
= make_cleanup (xfree
, filename
);
3645 flags
= O_BINARY
| O_LARGEFILE
;
3647 scratch_chan
= open (filename
, flags
, 0);
3648 if (scratch_chan
< 0)
3649 perror_with_name (filename
);
3651 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3653 discard_cleanups (old_chain
); /* Don't free filename any more. */
3654 unpush_target (&tfile_ops
);
3656 trace_filename
= xstrdup (filename
);
3657 trace_fd
= scratch_chan
;
3660 /* Read the file header and test for validity. */
3661 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
3663 bytes
+= TRACE_HEADER_SIZE
;
3664 if (!(header
[0] == 0x7f
3665 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3666 error (_("File is not a valid trace file."));
3668 push_target (&tfile_ops
);
3670 trace_regblock_size
= 0;
3671 ts
= current_trace_status ();
3672 /* We know we're working with a file. */
3674 /* Set defaults in case there is no status line. */
3675 ts
->running_known
= 0;
3676 ts
->stop_reason
= trace_stop_reason_unknown
;
3677 ts
->traceframe_count
= -1;
3678 ts
->buffer_free
= 0;
3679 ts
->disconnected_tracing
= 0;
3680 ts
->circular_buffer
= 0;
3682 cur_traceframe_number
= -1;
3684 TRY_CATCH (ex
, RETURN_MASK_ALL
)
3686 /* Read through a section of newline-terminated lines that
3687 define things like tracepoints. */
3691 tfile_read (&byte
, 1);
3696 /* Empty line marks end of the definition section. */
3701 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3704 linebuf
[i
++] = byte
;
3706 error (_("Excessively long lines in trace file"));
3709 /* Record the starting offset of the binary trace data. */
3710 trace_frames_offset
= bytes
;
3712 /* If we don't have a blocksize, we can't interpret the
3714 if (trace_regblock_size
== 0)
3715 error (_("No register block size recorded in trace file"));
3719 /* Pop the partially set up target. */
3721 throw_exception (ex
);
3724 inferior_appeared (current_inferior (), TFILE_PID
);
3725 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3726 add_thread_silent (inferior_ptid
);
3728 if (ts
->traceframe_count
<= 0)
3729 warning (_("No traceframes present in this file."));
3731 /* Add the file's tracepoints and variables into the current mix. */
3733 /* Get trace state variables first, they may be checked when parsing
3734 uploaded commands. */
3735 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3737 merge_uploaded_tracepoints (&uploaded_tps
);
3739 post_create_inferior (&tfile_ops
, from_tty
);
3742 /* Interpret the given line from the definitions part of the trace
3746 tfile_interp_line (char *line
,
3747 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3751 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3754 trace_regblock_size
= strtol (p
, &p
, 16);
3756 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3758 p
+= strlen ("status ");
3759 parse_trace_status (p
, current_trace_status ());
3761 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3763 p
+= strlen ("tp ");
3764 parse_tracepoint_definition (p
, utpp
);
3766 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3768 p
+= strlen ("tsv ");
3769 parse_tsv_definition (p
, utsvp
);
3772 warning (_("Ignoring trace file definition \"%s\""), line
);
3775 /* Parse the part of trace status syntax that is shared between
3776 the remote protocol and the trace file reader. */
3779 parse_trace_status (char *line
, struct trace_status
*ts
)
3781 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
3785 ts
->running_known
= 1;
3786 ts
->running
= (*p
++ == '1');
3787 ts
->stop_reason
= trace_stop_reason_unknown
;
3788 xfree (ts
->stop_desc
);
3789 ts
->stop_desc
= NULL
;
3790 ts
->traceframe_count
= -1;
3791 ts
->traceframes_created
= -1;
3792 ts
->buffer_free
= -1;
3793 ts
->buffer_size
= -1;
3794 ts
->disconnected_tracing
= 0;
3795 ts
->circular_buffer
= 0;
3796 xfree (ts
->user_name
);
3797 ts
->user_name
= NULL
;
3800 ts
->start_time
= ts
->stop_time
= 0;
3804 p1
= strchr (p
, ':');
3806 error (_("Malformed trace status, at %s\n\
3807 Status line: '%s'\n"), p
, line
);
3808 p3
= strchr (p
, ';');
3810 p3
= p
+ strlen (p
);
3811 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3813 p
= unpack_varlen_hex (++p1
, &val
);
3814 ts
->stop_reason
= trace_buffer_full
;
3816 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3818 p
= unpack_varlen_hex (++p1
, &val
);
3819 ts
->stop_reason
= trace_never_run
;
3821 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3824 p
= unpack_varlen_hex (++p1
, &val
);
3825 ts
->stop_reason
= tracepoint_passcount
;
3826 ts
->stopping_tracepoint
= val
;
3828 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3830 p2
= strchr (++p1
, ':');
3838 ts
->stop_desc
= xmalloc (strlen (line
));
3839 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
3840 ts
->stop_desc
[end
] = '\0';
3843 ts
->stop_desc
= xstrdup ("");
3845 p
= unpack_varlen_hex (++p2
, &val
);
3846 ts
->stop_reason
= tstop_command
;
3848 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3850 p
= unpack_varlen_hex (++p1
, &val
);
3851 ts
->stop_reason
= trace_disconnected
;
3853 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3855 p2
= strchr (++p1
, ':');
3858 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3859 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
3860 ts
->stop_desc
[end
] = '\0';
3863 ts
->stop_desc
= xstrdup ("");
3865 p
= unpack_varlen_hex (++p2
, &val
);
3866 ts
->stopping_tracepoint
= val
;
3867 ts
->stop_reason
= tracepoint_error
;
3869 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3871 p
= unpack_varlen_hex (++p1
, &val
);
3872 ts
->traceframe_count
= val
;
3874 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3876 p
= unpack_varlen_hex (++p1
, &val
);
3877 ts
->traceframes_created
= val
;
3879 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3881 p
= unpack_varlen_hex (++p1
, &val
);
3882 ts
->buffer_free
= val
;
3884 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3886 p
= unpack_varlen_hex (++p1
, &val
);
3887 ts
->buffer_size
= val
;
3889 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3891 p
= unpack_varlen_hex (++p1
, &val
);
3892 ts
->disconnected_tracing
= val
;
3894 else if (strncmp (p
, "circular", p1
- p
) == 0)
3896 p
= unpack_varlen_hex (++p1
, &val
);
3897 ts
->circular_buffer
= val
;
3899 else if (strncmp (p
, "starttime", p1
- p
) == 0)
3901 p
= unpack_varlen_hex (++p1
, &val
);
3902 ts
->start_time
= val
;
3904 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
3906 p
= unpack_varlen_hex (++p1
, &val
);
3907 ts
->stop_time
= val
;
3909 else if (strncmp (p
, "username", p1
- p
) == 0)
3912 ts
->user_name
= xmalloc (strlen (p
) / 2);
3913 end
= hex2bin (p1
, ts
->user_name
, (p3
- p1
) / 2);
3914 ts
->user_name
[end
] = '\0';
3917 else if (strncmp (p
, "notes", p1
- p
) == 0)
3920 ts
->notes
= xmalloc (strlen (p
) / 2);
3921 end
= hex2bin (p1
, ts
->notes
, (p3
- p1
) / 2);
3922 ts
->notes
[end
] = '\0';
3927 /* Silently skip unknown optional info. */
3928 p_temp
= strchr (p1
+ 1, ';');
3932 /* Must be at the end. */
3939 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
3940 struct uploaded_tp
*utp
)
3943 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
3945 p
= unpack_varlen_hex (p
, &uval
);
3947 tp
->base
.hit_count
+= uval
;
3949 utp
->hit_count
+= uval
;
3950 p
= unpack_varlen_hex (p
+ 1, &uval
);
3952 tp
->traceframe_usage
+= uval
;
3954 utp
->traceframe_usage
+= uval
;
3955 /* Ignore any extra, allowing for future extensions. */
3958 /* Given a line of text defining a part of a tracepoint, parse it into
3959 an "uploaded tracepoint". */
3962 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3966 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3969 char *cond
, *srctype
, *buf
;
3970 struct uploaded_tp
*utp
= NULL
;
3973 /* Both tracepoint and action definitions start with the same number
3974 and address sequence. */
3976 p
= unpack_varlen_hex (p
, &num
);
3977 p
++; /* skip a colon */
3978 p
= unpack_varlen_hex (p
, &addr
);
3979 p
++; /* skip a colon */
3982 enabled
= (*p
++ == 'E');
3983 p
++; /* skip a colon */
3984 p
= unpack_varlen_hex (p
, &step
);
3985 p
++; /* skip a colon */
3986 p
= unpack_varlen_hex (p
, &pass
);
3987 type
= bp_tracepoint
;
3989 /* Thumb through optional fields. */
3992 p
++; /* skip a colon */
3995 type
= bp_fast_tracepoint
;
3997 p
= unpack_varlen_hex (p
, &orig_size
);
4001 type
= bp_static_tracepoint
;
4007 p
= unpack_varlen_hex (p
, &xlen
);
4008 p
++; /* skip a comma */
4009 cond
= (char *) xmalloc (2 * xlen
+ 1);
4010 strncpy (cond
, p
, 2 * xlen
);
4011 cond
[2 * xlen
] = '\0';
4015 warning (_("Unrecognized char '%c' in tracepoint "
4016 "definition, skipping rest"), *p
);
4018 utp
= get_uploaded_tp (num
, addr
, utpp
);
4020 utp
->enabled
= enabled
;
4025 else if (piece
== 'A')
4027 utp
= get_uploaded_tp (num
, addr
, utpp
);
4028 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
4030 else if (piece
== 'S')
4032 utp
= get_uploaded_tp (num
, addr
, utpp
);
4033 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
4035 else if (piece
== 'Z')
4037 /* Parse a chunk of source form definition. */
4038 utp
= get_uploaded_tp (num
, addr
, utpp
);
4040 p
= strchr (p
, ':');
4041 p
++; /* skip a colon */
4042 p
= unpack_varlen_hex (p
, &start
);
4043 p
++; /* skip a colon */
4044 p
= unpack_varlen_hex (p
, &xlen
);
4045 p
++; /* skip a colon */
4047 buf
= alloca (strlen (line
));
4049 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4052 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
4053 utp
->at_string
= xstrdup (buf
);
4054 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
4055 utp
->cond_string
= xstrdup (buf
);
4056 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
4057 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
4059 else if (piece
== 'V')
4061 utp
= get_uploaded_tp (num
, addr
, utpp
);
4063 parse_tracepoint_status (p
, NULL
, utp
);
4067 /* Don't error out, the target might be sending us optional
4068 info that we don't care about. */
4069 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
4073 /* Convert a textual description of a trace state variable into an
4077 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
4080 ULONGEST num
, initval
, builtin
;
4082 struct uploaded_tsv
*utsv
= NULL
;
4084 buf
= alloca (strlen (line
));
4087 p
= unpack_varlen_hex (p
, &num
);
4088 p
++; /* skip a colon */
4089 p
= unpack_varlen_hex (p
, &initval
);
4090 p
++; /* skip a colon */
4091 p
= unpack_varlen_hex (p
, &builtin
);
4092 p
++; /* skip a colon */
4093 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4096 utsv
= get_uploaded_tsv (num
, utsvp
);
4097 utsv
->initial_value
= initval
;
4098 utsv
->builtin
= builtin
;
4099 utsv
->name
= xstrdup (buf
);
4102 /* Close the trace file and generally clean up. */
4105 tfile_close (int quitting
)
4112 pid
= ptid_get_pid (inferior_ptid
);
4113 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff. */
4114 exit_inferior_silent (pid
);
4118 xfree (trace_filename
);
4119 trace_filename
= NULL
;
4123 tfile_files_info (struct target_ops
*t
)
4125 /* (it would be useful to mention the name of the file). */
4126 printf_filtered ("Looking at a trace file.\n");
4129 /* The trace status for a file is that tracing can never be run. */
4132 tfile_get_trace_status (struct trace_status
*ts
)
4134 /* Other bits of trace status were collected as part of opening the
4135 trace files, so nothing to do here. */
4141 tfile_get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
4143 /* Other bits of trace status were collected as part of opening the
4144 trace files, so nothing to do here. */
4147 /* Given the position of a traceframe in the file, figure out what
4148 address the frame was collected at. This would normally be the
4149 value of a collected PC register, but if not available, we
4153 tfile_get_traceframe_address (off_t tframe_offset
)
4157 struct tracepoint
*tp
;
4158 off_t saved_offset
= cur_offset
;
4160 /* FIXME dig pc out of collected registers. */
4162 /* Fall back to using tracepoint address. */
4163 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
4164 tfile_read ((gdb_byte
*) &tpnum
, 2);
4165 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4169 tp
= get_tracepoint_by_number_on_target (tpnum
);
4170 /* FIXME this is a poor heuristic if multiple locations. */
4171 if (tp
&& tp
->base
.loc
)
4172 addr
= tp
->base
.loc
->address
;
4174 /* Restore our seek position. */
4175 cur_offset
= saved_offset
;
4176 lseek (trace_fd
, cur_offset
, SEEK_SET
);
4180 /* Make tfile's selected traceframe match GDB's selected
4184 set_tfile_traceframe (void)
4188 if (cur_traceframe_number
== get_traceframe_number ())
4191 /* Avoid recursion, tfile_trace_find calls us again. */
4192 cur_traceframe_number
= get_traceframe_number ();
4194 newnum
= target_trace_find (tfind_number
,
4195 get_traceframe_number (), 0, 0, NULL
);
4197 /* Should not happen. If it does, all bets are off. */
4198 if (newnum
!= get_traceframe_number ())
4199 warning (_("could not set tfile's traceframe"));
4202 /* Given a type of search and some parameters, scan the collection of
4203 traceframes in the file looking for a match. When found, return
4204 both the traceframe and tracepoint number, otherwise -1 for
4208 tfile_trace_find (enum trace_find_type type
, int num
,
4209 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
4212 int tfnum
= 0, found
= 0;
4213 unsigned int data_size
;
4214 struct tracepoint
*tp
;
4215 off_t offset
, tframe_offset
;
4218 /* Lookups other than by absolute frame number depend on the current
4219 trace selected, so make sure it is correct on the tfile end
4221 if (type
!= tfind_number
)
4222 set_tfile_traceframe ();
4230 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
4231 offset
= trace_frames_offset
;
4234 tframe_offset
= offset
;
4235 tfile_read ((gdb_byte
*) &tpnum
, 2);
4236 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4242 tfile_read ((gdb_byte
*) &data_size
, 4);
4243 data_size
= (unsigned int) extract_unsigned_integer
4244 ((gdb_byte
*) &data_size
, 4,
4245 gdbarch_byte_order (target_gdbarch
));
4254 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4255 if (tfaddr
== addr1
)
4259 tp
= get_tracepoint (num
);
4260 if (tp
&& tpnum
== tp
->number_on_target
)
4264 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4265 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
4269 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4270 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
4274 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
4280 cur_offset
= offset
;
4281 cur_data_size
= data_size
;
4282 cur_traceframe_number
= tfnum
;
4285 /* Skip past the traceframe's data. */
4286 lseek (trace_fd
, data_size
, SEEK_CUR
);
4287 offset
+= data_size
;
4288 /* Update our own count of traceframes. */
4291 /* Did not find what we were looking for. */
4297 /* Prototype of the callback passed to tframe_walk_blocks. */
4298 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
4300 /* Callback for traceframe_walk_blocks, used to find a given block
4301 type in a traceframe. */
4304 match_blocktype (char blocktype
, void *data
)
4306 char *wantedp
= data
;
4308 if (*wantedp
== blocktype
)
4314 /* Walk over all traceframe block starting at POS offset from
4315 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4316 unmodified. If CALLBACK returns true, this returns the position in
4317 the traceframe where the block is found, relative to the start of
4318 the traceframe (cur_offset). Returns -1 if no callback call
4319 returned true, indicating that all blocks have been walked. */
4322 traceframe_walk_blocks (walk_blocks_callback_func callback
,
4323 int pos
, void *data
)
4325 /* Iterate through a traceframe's blocks, looking for a block of the
4328 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
4329 while (pos
< cur_data_size
)
4331 unsigned short mlen
;
4334 tfile_read (&block_type
, 1);
4338 if ((*callback
) (block_type
, data
))
4344 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4345 pos
+= trace_regblock_size
;
4348 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4349 tfile_read ((gdb_byte
*) &mlen
, 2);
4350 mlen
= (unsigned short)
4351 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4354 lseek (trace_fd
, mlen
, SEEK_CUR
);
4355 pos
+= (8 + 2 + mlen
);
4358 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
4362 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4363 block_type
, block_type
);
4371 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4372 position offset of a block of type TYPE_WANTED in the current trace
4373 frame, starting at POS. Returns -1 if no such block was found. */
4376 traceframe_find_block_type (char type_wanted
, int pos
)
4378 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
4381 /* Look for a block of saved registers in the traceframe, and get the
4382 requested register from it. */
4385 tfile_fetch_registers (struct target_ops
*ops
,
4386 struct regcache
*regcache
, int regno
)
4388 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4390 int pos
, offset
, regn
, regsize
, pc_regno
;
4391 unsigned short mlen
;
4394 /* An uninitialized reg size says we're not going to be
4395 successful at getting register blocks. */
4396 if (!trace_regblock_size
)
4399 set_tfile_traceframe ();
4401 regs
= alloca (trace_regblock_size
);
4403 if (traceframe_find_block_type ('R', 0) >= 0)
4405 tfile_read (regs
, trace_regblock_size
);
4407 /* Assume the block is laid out in GDB register number order,
4408 each register with the size that it has in GDB. */
4410 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4412 regsize
= register_size (gdbarch
, regn
);
4413 /* Make sure we stay within block bounds. */
4414 if (offset
+ regsize
>= trace_regblock_size
)
4416 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
4420 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
4423 else if (regno
== -1)
4425 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
4433 /* We get here if no register data has been found. Mark registers
4435 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4436 regcache_raw_supply (regcache
, regn
, NULL
);
4438 /* We can often usefully guess that the PC is going to be the same
4439 as the address of the tracepoint. */
4440 pc_regno
= gdbarch_pc_regnum (gdbarch
);
4441 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
4443 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
4445 if (tp
&& tp
->base
.loc
)
4447 /* But don't try to guess if tracepoint is multi-location... */
4448 if (tp
->base
.loc
->next
)
4450 warning (_("Tracepoint %d has multiple "
4451 "locations, cannot infer $pc"),
4455 /* ... or does while-stepping. */
4456 if (tp
->step_count
> 0)
4458 warning (_("Tracepoint %d does while-stepping, "
4459 "cannot infer $pc"),
4464 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
4465 gdbarch_byte_order (gdbarch
),
4466 tp
->base
.loc
->address
);
4467 regcache_raw_supply (regcache
, pc_regno
, regs
);
4473 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4474 const char *annex
, gdb_byte
*readbuf
,
4475 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
4477 /* We're only doing regular memory for now. */
4478 if (object
!= TARGET_OBJECT_MEMORY
)
4481 if (readbuf
== NULL
)
4482 error (_("tfile_xfer_partial: trace file is read-only"));
4484 set_tfile_traceframe ();
4486 if (traceframe_number
!= -1)
4490 /* Iterate through the traceframe's blocks, looking for
4492 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
4494 ULONGEST maddr
, amt
;
4495 unsigned short mlen
;
4496 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
4498 tfile_read ((gdb_byte
*) &maddr
, 8);
4499 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
4501 tfile_read ((gdb_byte
*) &mlen
, 2);
4502 mlen
= (unsigned short)
4503 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
4505 /* If the block includes the first part of the desired
4506 range, return as much it has; GDB will re-request the
4507 remainder, which might be in a different block of this
4509 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
4511 amt
= (maddr
+ mlen
) - offset
;
4515 tfile_read (readbuf
, amt
);
4519 /* Skip over this block. */
4520 pos
+= (8 + 2 + mlen
);
4524 /* It's unduly pedantic to refuse to look at the executable for
4525 read-only pieces; so do the equivalent of readonly regions aka
4527 /* FIXME account for relocation at some point. */
4534 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
4536 if ((s
->flags
& SEC_LOAD
) == 0
4537 || (s
->flags
& SEC_READONLY
) == 0)
4541 size
= bfd_get_section_size (s
);
4542 if (vma
<= offset
&& offset
< (vma
+ size
))
4546 amt
= (vma
+ size
) - offset
;
4550 amt
= bfd_get_section_contents (exec_bfd
, s
,
4551 readbuf
, offset
- vma
, amt
);
4557 /* Indicate failure to find the requested memory block. */
4561 /* Iterate through the blocks of a trace frame, looking for a 'V'
4562 block with a matching tsv number. */
4565 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
4569 set_tfile_traceframe ();
4572 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
4576 tfile_read ((gdb_byte
*) &vnum
, 4);
4577 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
4582 tfile_read ((gdb_byte
*) val
, 8);
4583 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
4591 /* Didn't find anything. */
4596 tfile_has_all_memory (struct target_ops
*ops
)
4602 tfile_has_memory (struct target_ops
*ops
)
4608 tfile_has_stack (struct target_ops
*ops
)
4610 return traceframe_number
!= -1;
4614 tfile_has_registers (struct target_ops
*ops
)
4616 return traceframe_number
!= -1;
4620 tfile_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
4625 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
4626 object for the tfile target's current traceframe. */
4629 build_traceframe_info (char blocktype
, void *data
)
4631 struct traceframe_info
*info
= data
;
4637 struct mem_range
*r
;
4639 unsigned short mlen
;
4641 tfile_read ((gdb_byte
*) &maddr
, 8);
4642 tfile_read ((gdb_byte
*) &mlen
, 2);
4644 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4657 warning (_("Unhandled trace block type (%d) '%c ' "
4658 "while building trace frame info."),
4659 blocktype
, blocktype
);
4666 static struct traceframe_info
*
4667 tfile_traceframe_info (void)
4669 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
4671 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
4676 init_tfile_ops (void)
4678 tfile_ops
.to_shortname
= "tfile";
4679 tfile_ops
.to_longname
= "Local trace dump file";
4681 = "Use a trace file as a target. Specify the filename of the trace file.";
4682 tfile_ops
.to_open
= tfile_open
;
4683 tfile_ops
.to_close
= tfile_close
;
4684 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
4685 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
4686 tfile_ops
.to_files_info
= tfile_files_info
;
4687 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
4688 tfile_ops
.to_get_tracepoint_status
= tfile_get_tracepoint_status
;
4689 tfile_ops
.to_trace_find
= tfile_trace_find
;
4690 tfile_ops
.to_get_trace_state_variable_value
4691 = tfile_get_trace_state_variable_value
;
4692 tfile_ops
.to_stratum
= process_stratum
;
4693 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
4694 tfile_ops
.to_has_memory
= tfile_has_memory
;
4695 tfile_ops
.to_has_stack
= tfile_has_stack
;
4696 tfile_ops
.to_has_registers
= tfile_has_registers
;
4697 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
4698 tfile_ops
.to_thread_alive
= tfile_thread_alive
;
4699 tfile_ops
.to_magic
= OPS_MAGIC
;
4702 /* Given a line of text defining a static tracepoint marker, parse it
4703 into a "static tracepoint marker" object. Throws an error is
4704 parsing fails. If PP is non-null, it points to one past the end of
4705 the parsed marker definition. */
4708 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
4709 struct static_tracepoint_marker
*marker
)
4716 p
= unpack_varlen_hex (p
, &addr
);
4717 p
++; /* skip a colon */
4719 marker
->gdbarch
= target_gdbarch
;
4720 marker
->address
= (CORE_ADDR
) addr
;
4722 endp
= strchr (p
, ':');
4724 error (_("bad marker definition: %s"), line
);
4726 marker
->str_id
= xmalloc (endp
- p
+ 1);
4727 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
4728 marker
->str_id
[end
] = '\0';
4731 p
++; /* skip a colon */
4733 marker
->extra
= xmalloc (strlen (p
) + 1);
4734 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
4735 marker
->extra
[end
] = '\0';
4741 /* Release a static tracepoint marker's contents. Note that the
4742 object itself isn't released here. There objects are usually on
4746 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
4748 xfree (marker
->str_id
);
4749 marker
->str_id
= NULL
;
4752 /* Print MARKER to gdb_stdout. */
4755 print_one_static_tracepoint_marker (int count
,
4756 struct static_tracepoint_marker
*marker
)
4758 struct command_line
*l
;
4761 char wrap_indent
[80];
4762 char extra_field_indent
[80];
4763 struct ui_out
*uiout
= current_uiout
;
4764 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
4765 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4766 struct cleanup
*bkpt_chain
;
4767 VEC(breakpoint_p
) *tracepoints
;
4769 struct symtab_and_line sal
;
4773 sal
.pc
= marker
->address
;
4775 tracepoints
= static_tracepoints_here (marker
->address
);
4777 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
4779 /* A counter field to help readability. This is not a stable
4781 ui_out_field_int (uiout
, "count", count
);
4783 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
4785 ui_out_field_fmt (uiout
, "enabled", "%c",
4786 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
4787 ui_out_spaces (uiout
, 2);
4789 strcpy (wrap_indent
, " ");
4791 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
4792 strcat (wrap_indent
, " ");
4794 strcat (wrap_indent
, " ");
4796 strcpy (extra_field_indent
, " ");
4798 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
4800 sal
= find_pc_line (marker
->address
, 0);
4801 sym
= find_pc_sect_function (marker
->address
, NULL
);
4804 ui_out_text (uiout
, "in ");
4805 ui_out_field_string (uiout
, "func",
4806 SYMBOL_PRINT_NAME (sym
));
4807 ui_out_wrap_hint (uiout
, wrap_indent
);
4808 ui_out_text (uiout
, " at ");
4811 ui_out_field_skip (uiout
, "func");
4813 if (sal
.symtab
!= NULL
)
4815 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
4816 ui_out_text (uiout
, ":");
4818 if (ui_out_is_mi_like_p (uiout
))
4820 char *fullname
= symtab_to_fullname (sal
.symtab
);
4823 ui_out_field_string (uiout
, "fullname", fullname
);
4826 ui_out_field_skip (uiout
, "fullname");
4828 ui_out_field_int (uiout
, "line", sal
.line
);
4832 ui_out_field_skip (uiout
, "fullname");
4833 ui_out_field_skip (uiout
, "line");
4836 ui_out_text (uiout
, "\n");
4837 ui_out_text (uiout
, extra_field_indent
);
4838 ui_out_text (uiout
, _("Data: \""));
4839 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
4840 ui_out_text (uiout
, "\"\n");
4842 if (!VEC_empty (breakpoint_p
, tracepoints
))
4844 struct cleanup
*cleanup_chain
;
4846 struct breakpoint
*b
;
4848 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
4851 ui_out_text (uiout
, extra_field_indent
);
4852 ui_out_text (uiout
, _("Probed by static tracepoints: "));
4853 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
4856 ui_out_text (uiout
, ", ");
4857 ui_out_text (uiout
, "#");
4858 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
4861 do_cleanups (cleanup_chain
);
4863 if (ui_out_is_mi_like_p (uiout
))
4864 ui_out_field_int (uiout
, "number-of-tracepoints",
4865 VEC_length(breakpoint_p
, tracepoints
));
4867 ui_out_text (uiout
, "\n");
4869 VEC_free (breakpoint_p
, tracepoints
);
4871 do_cleanups (bkpt_chain
);
4872 do_cleanups (old_chain
);
4876 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
4878 VEC(static_tracepoint_marker_p
) *markers
;
4879 struct cleanup
*old_chain
;
4880 struct static_tracepoint_marker
*marker
;
4881 struct ui_out
*uiout
= current_uiout
;
4885 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
4886 "StaticTracepointMarkersTable");
4888 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
4890 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
4892 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
4893 if (gdbarch_addr_bit (target_gdbarch
) <= 32)
4894 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
4896 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
4897 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
4899 ui_out_table_body (uiout
);
4901 markers
= target_static_tracepoint_markers_by_strid (NULL
);
4902 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
4905 VEC_iterate (static_tracepoint_marker_p
,
4906 markers
, i
, marker
);
4909 print_one_static_tracepoint_marker (i
+ 1, marker
);
4910 release_static_tracepoint_marker (marker
);
4913 do_cleanups (old_chain
);
4916 /* The $_sdata convenience variable is a bit special. We don't know
4917 for sure type of the value until we actually have a chance to fetch
4918 the data --- the size of the object depends on what has been
4919 collected. We solve this by making $_sdata be an internalvar that
4920 creates a new value on access. */
4922 /* Return a new value with the correct type for the sdata object of
4923 the current trace frame. Return a void value if there's no object
4926 static struct value
*
4927 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
)
4932 /* We need to read the whole object before we know its size. */
4933 size
= target_read_alloc (¤t_target
,
4934 TARGET_OBJECT_STATIC_TRACE_DATA
,
4941 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
4943 v
= allocate_value (type
);
4944 memcpy (value_contents_raw (v
), buf
, size
);
4949 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
4952 #if !defined(HAVE_LIBEXPAT)
4954 struct traceframe_info
*
4955 parse_traceframe_info (const char *tframe_info
)
4957 static int have_warned
;
4962 warning (_("Can not parse XML trace frame info; XML support "
4963 "was disabled at compile time"));
4969 #else /* HAVE_LIBEXPAT */
4971 #include "xml-support.h"
4973 /* Handle the start of a <memory> element. */
4976 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
4977 const struct gdb_xml_element
*element
,
4978 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
4980 struct traceframe_info
*info
= user_data
;
4981 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4982 ULONGEST
*start_p
, *length_p
;
4984 start_p
= xml_find_attribute (attributes
, "start")->value
;
4985 length_p
= xml_find_attribute (attributes
, "length")->value
;
4987 r
->start
= *start_p
;
4988 r
->length
= *length_p
;
4991 /* Discard the constructed trace frame info (if an error occurs). */
4994 free_result (void *p
)
4996 struct traceframe_info
*result
= p
;
4998 free_traceframe_info (result
);
5001 /* The allowed elements and attributes for an XML memory map. */
5003 static const struct gdb_xml_attribute memory_attributes
[] = {
5004 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5005 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5006 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5009 static const struct gdb_xml_element traceframe_info_children
[] = {
5010 { "memory", memory_attributes
, NULL
,
5011 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5012 traceframe_info_start_memory
, NULL
},
5013 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5016 static const struct gdb_xml_element traceframe_info_elements
[] = {
5017 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
5019 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5022 /* Parse a traceframe-info XML document. */
5024 struct traceframe_info
*
5025 parse_traceframe_info (const char *tframe_info
)
5027 struct traceframe_info
*result
;
5028 struct cleanup
*back_to
;
5030 result
= XCNEW (struct traceframe_info
);
5031 back_to
= make_cleanup (free_result
, result
);
5033 if (gdb_xml_parse_quick (_("trace frame info"),
5034 "traceframe-info.dtd", traceframe_info_elements
,
5035 tframe_info
, result
) == 0)
5037 /* Parsed successfully, keep the result. */
5038 discard_cleanups (back_to
);
5043 do_cleanups (back_to
);
5047 #endif /* HAVE_LIBEXPAT */
5049 /* Returns the traceframe_info object for the current traceframe.
5050 This is where we avoid re-fetching the object from the target if we
5051 already have it cached. */
5053 struct traceframe_info
*
5054 get_traceframe_info (void)
5056 if (traceframe_info
== NULL
)
5057 traceframe_info
= target_traceframe_info ();
5059 return traceframe_info
;
5062 /* If the target supports the query, return in RESULT the set of
5063 collected memory in the current traceframe, found within the LEN
5064 bytes range starting at MEMADDR. Returns true if the target
5065 supports the query, otherwise returns false, and RESULT is left
5069 traceframe_available_memory (VEC(mem_range_s
) **result
,
5070 CORE_ADDR memaddr
, ULONGEST len
)
5072 struct traceframe_info
*info
= get_traceframe_info ();
5076 struct mem_range
*r
;
5081 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
5082 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
5084 ULONGEST lo1
, hi1
, lo2
, hi2
;
5085 struct mem_range
*nr
;
5088 hi1
= memaddr
+ len
;
5091 hi2
= r
->start
+ r
->length
;
5093 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
5095 nr
->start
= max (lo1
, lo2
);
5096 nr
->length
= min (hi1
, hi2
) - nr
->start
;
5099 normalize_mem_ranges (*result
);
5106 /* module initialization */
5108 _initialize_tracepoint (void)
5110 struct cmd_list_element
*c
;
5112 /* Explicitly create without lookup, since that tries to create a
5113 value with a void typed value, and when we get here, gdbarch
5114 isn't initialized yet. At this point, we're quite sure there
5115 isn't another convenience variable of the same name. */
5116 create_internalvar_type_lazy ("_sdata", sdata_make_value
);
5118 traceframe_number
= -1;
5119 tracepoint_number
= -1;
5121 if (tracepoint_list
.list
== NULL
)
5123 tracepoint_list
.listsize
= 128;
5124 tracepoint_list
.list
= xmalloc
5125 (tracepoint_list
.listsize
* sizeof (struct memrange
));
5127 if (tracepoint_list
.aexpr_list
== NULL
)
5129 tracepoint_list
.aexpr_listsize
= 128;
5130 tracepoint_list
.aexpr_list
= xmalloc
5131 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5134 if (stepping_list
.list
== NULL
)
5136 stepping_list
.listsize
= 128;
5137 stepping_list
.list
= xmalloc
5138 (stepping_list
.listsize
* sizeof (struct memrange
));
5141 if (stepping_list
.aexpr_list
== NULL
)
5143 stepping_list
.aexpr_listsize
= 128;
5144 stepping_list
.aexpr_list
= xmalloc
5145 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5148 add_info ("scope", scope_info
,
5149 _("List the variables local to a scope"));
5151 add_cmd ("tracepoints", class_trace
, NULL
,
5152 _("Tracing of program execution without stopping the program."),
5155 add_com ("tdump", class_trace
, trace_dump_command
,
5156 _("Print everything collected at the current tracepoint."));
5158 add_com ("tsave", class_trace
, trace_save_command
, _("\
5159 Save the trace data to a file.\n\
5160 Use the '-r' option to direct the target to save directly to the file,\n\
5161 using its own filesystem."));
5163 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
5164 Define a trace state variable.\n\
5165 Argument is a $-prefixed name, optionally followed\n\
5166 by '=' and an expression that sets the initial value\n\
5167 at the start of tracing."));
5168 set_cmd_completer (c
, expression_completer
);
5170 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
5171 Delete one or more trace state variables.\n\
5172 Arguments are the names of the variables to delete.\n\
5173 If no arguments are supplied, delete all variables."), &deletelist
);
5174 /* FIXME add a trace variable completer. */
5176 add_info ("tvariables", tvariables_info
, _("\
5177 Status of trace state variables and their values.\n\
5180 add_info ("static-tracepoint-markers",
5181 info_static_tracepoint_markers_command
, _("\
5182 List target static tracepoints markers.\n\
5185 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
5186 Select a trace frame;\n\
5187 No argument means forward by one frame; '-' means backward by one frame."),
5188 &tfindlist
, "tfind ", 1, &cmdlist
);
5190 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
5191 Select a trace frame whose PC is outside the given range (exclusive).\n\
5192 Usage: tfind outside addr1, addr2"),
5195 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
5196 Select a trace frame whose PC is in the given range (inclusive).\n\
5197 Usage: tfind range addr1,addr2"),
5200 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
5201 Select a trace frame by source line.\n\
5202 Argument can be a line number (with optional source file),\n\
5203 a function name, or '*' followed by an address.\n\
5204 Default argument is 'the next source line that was traced'."),
5207 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
5208 Select a trace frame by tracepoint number.\n\
5209 Default is the tracepoint for the current trace frame."),
5212 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
5213 Select a trace frame by PC.\n\
5214 Default is the current PC, or the PC of the current trace frame."),
5217 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
5218 Synonym for 'none'.\n\
5219 De-select any trace frame and resume 'live' debugging."),
5222 add_cmd ("none", class_trace
, trace_find_none_command
,
5223 _("De-select any trace frame and resume 'live' debugging."),
5226 add_cmd ("start", class_trace
, trace_find_start_command
,
5227 _("Select the first trace frame in the trace buffer."),
5230 add_com ("tstatus", class_trace
, trace_status_command
,
5231 _("Display the status of the current trace data collection."));
5233 add_com ("tstop", class_trace
, trace_stop_command
, _("\
5234 Stop trace data collection.\n\
5235 Usage: tstop [ <notes> ... ]\n\
5236 Any arguments supplied are recorded with the trace as a stop reason and\n\
5237 reported by tstatus (if the target supports trace notes)."));
5239 add_com ("tstart", class_trace
, trace_start_command
, _("\
5240 Start trace data collection.\n\
5241 Usage: tstart [ <notes> ... ]\n\
5242 Any arguments supplied are recorded with the trace as a note and\n\
5243 reported by tstatus (if the target supports trace notes)."));
5245 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
5246 Ends a list of commands or actions.\n\
5247 Several GDB commands allow you to enter a list of commands or actions.\n\
5248 Entering \"end\" on a line by itself is the normal way to terminate\n\
5250 Note: the \"end\" command cannot be used at the gdb prompt."));
5252 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
5253 Specify single-stepping behavior at a tracepoint.\n\
5254 Argument is number of instructions to trace in single-step mode\n\
5255 following the tracepoint. This command is normally followed by\n\
5256 one or more \"collect\" commands, to specify what to collect\n\
5257 while single-stepping.\n\n\
5258 Note: this command can only be used in a tracepoint \"actions\" list."));
5260 add_com_alias ("ws", "while-stepping", class_alias
, 0);
5261 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
5263 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
5264 Specify one or more data items to be collected at a tracepoint.\n\
5265 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5266 collect all data (variables, registers) referenced by that expression.\n\
5267 Also accepts the following special arguments:\n\
5268 $regs -- all registers.\n\
5269 $args -- all function arguments.\n\
5270 $locals -- all variables local to the block/function scope.\n\
5271 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5272 Note: this command can only be used in a tracepoint \"actions\" list."));
5274 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
5275 Specify one or more expressions to be evaluated at a tracepoint.\n\
5276 Accepts a comma-separated list of (one or more) expressions.\n\
5277 The result of each evaluation will be discarded.\n\
5278 Note: this command can only be used in a tracepoint \"actions\" list."));
5280 add_com ("actions", class_trace
, trace_actions_command
, _("\
5281 Specify the actions to be taken at a tracepoint.\n\
5282 Tracepoint actions may include collecting of specified data,\n\
5283 single-stepping, or enabling/disabling other tracepoints,\n\
5284 depending on target's capabilities."));
5286 default_collect
= xstrdup ("");
5287 add_setshow_string_cmd ("default-collect", class_trace
,
5288 &default_collect
, _("\
5289 Set the list of expressions to collect by default"), _("\
5290 Show the list of expressions to collect by default"), NULL
,
5292 &setlist
, &showlist
);
5294 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
5295 &disconnected_tracing
, _("\
5296 Set whether tracing continues after GDB disconnects."), _("\
5297 Show whether tracing continues after GDB disconnects."), _("\
5298 Use this to continue a tracing run even if GDB disconnects\n\
5299 or detaches from the target. You can reconnect later and look at\n\
5300 trace data collected in the meantime."),
5301 set_disconnected_tracing
,
5306 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
5307 &circular_trace_buffer
, _("\
5308 Set target's use of circular trace buffer."), _("\
5309 Show target's use of circular trace buffer."), _("\
5310 Use this to make the trace buffer into a circular buffer,\n\
5311 which will discard traceframes (oldest first) instead of filling\n\
5312 up and stopping the trace run."),
5313 set_circular_trace_buffer
,
5318 add_setshow_string_cmd ("trace-user", class_trace
,
5320 Set the user name to use for current and future trace runs"), _("\
5321 Show the user name to use for current and future trace runs"), NULL
,
5322 set_trace_user
, NULL
,
5323 &setlist
, &showlist
);
5325 add_setshow_string_cmd ("trace-notes", class_trace
,
5327 Set notes string to use for current and future trace runs"), _("\
5328 Show the notes string to use for current and future trace runs"), NULL
,
5329 set_trace_notes
, NULL
,
5330 &setlist
, &showlist
);
5332 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
5333 &trace_stop_notes
, _("\
5334 Set notes string to use for future tstop commands"), _("\
5335 Show the notes string to use for future tstop commands"), NULL
,
5336 set_trace_stop_notes
, NULL
,
5337 &setlist
, &showlist
);
5341 add_target (&tfile_ops
);