1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
25 #include "expression.h"
30 #include "gdb_string.h"
32 #include "breakpoint.h"
33 #include "tracepoint.h"
36 #include "completer.h"
38 #include "dictionary.h"
40 #include "user-regs.h"
44 #include "filenames.h"
45 #include "gdbthread.h"
53 #include "exceptions.h"
54 #include "cli/cli-utils.h"
57 /* readline include files */
58 #include "readline/readline.h"
59 #include "readline/history.h"
61 /* readline defines this. */
72 /* Maximum length of an agent aexpression.
73 This accounts for the fact that packets are limited to 400 bytes
74 (which includes everything -- including the checksum), and assumes
75 the worst case of maximum length for each of the pieces of a
78 NOTE: expressions get mem2hex'ed otherwise this would be twice as
79 large. (400 - 31)/2 == 184 */
80 #define MAX_AGENT_EXPR_LEN 184
84 /* A hook used to notify the UI of tracepoint operations. */
86 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
87 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
89 extern void (*deprecated_readline_begin_hook
) (char *, ...);
90 extern char *(*deprecated_readline_hook
) (char *);
91 extern void (*deprecated_readline_end_hook
) (void);
96 This module defines the following debugger commands:
97 trace : set a tracepoint on a function, line, or address.
98 info trace : list all debugger-defined tracepoints.
99 delete trace : delete one or more tracepoints.
100 enable trace : enable one or more tracepoints.
101 disable trace : disable one or more tracepoints.
102 actions : specify actions to be taken at a tracepoint.
103 passcount : specify a pass count for a tracepoint.
104 tstart : start a trace experiment.
105 tstop : stop a trace experiment.
106 tstatus : query the status of a trace experiment.
107 tfind : find a trace frame in the trace buffer.
108 tdump : print everything collected at the current tracepoint.
109 save-tracepoints : write tracepoint setup into a file.
111 This module defines the following user-visible debugger variables:
112 $trace_frame : sequence number of trace frame currently being debugged.
113 $trace_line : source line of trace frame currently being debugged.
114 $trace_file : source file of trace frame currently being debugged.
115 $tracepoint : tracepoint number of trace frame currently being debugged.
119 /* ======= Important global variables: ======= */
121 /* The list of all trace state variables. We don't retain pointers to
122 any of these for any reason - API is by name or number only - so it
123 works to have a vector of objects. */
125 typedef struct trace_state_variable tsv_s
;
128 /* An object describing the contents of a traceframe. */
130 struct traceframe_info
132 /* Collected memory. */
133 VEC(mem_range_s
) *memory
;
136 static VEC(tsv_s
) *tvariables
;
138 /* The next integer to assign to a variable. */
140 static int next_tsv_number
= 1;
142 /* Number of last traceframe collected. */
143 static int traceframe_number
;
145 /* Tracepoint for last traceframe collected. */
146 static int tracepoint_number
;
148 /* Symbol for function for last traceframe collected. */
149 static struct symbol
*traceframe_fun
;
151 /* Symtab and line for last traceframe collected. */
152 static struct symtab_and_line traceframe_sal
;
154 /* The traceframe info of the current traceframe. NULL if we haven't
155 yet attempted to fetch it, or if the target does not support
156 fetching this object, or if we're not inspecting a traceframe
158 static struct traceframe_info
*traceframe_info
;
160 /* Tracing command lists. */
161 static struct cmd_list_element
*tfindlist
;
163 /* List of expressions to collect by default at each tracepoint hit. */
164 char *default_collect
= "";
166 static int disconnected_tracing
;
168 /* This variable controls whether we ask the target for a linear or
169 circular trace buffer. */
171 static int circular_trace_buffer
;
173 /* Textual notes applying to the current and/or future trace runs. */
175 char *trace_user
= NULL
;
177 /* Textual notes applying to the current and/or future trace runs. */
179 char *trace_notes
= NULL
;
181 /* Textual notes applying to the stopping of a trace. */
183 char *trace_stop_notes
= NULL
;
185 /* ======= Important command functions: ======= */
186 static void trace_actions_command (char *, int);
187 static void trace_start_command (char *, int);
188 static void trace_stop_command (char *, int);
189 static void trace_status_command (char *, int);
190 static void trace_find_command (char *, int);
191 static void trace_find_pc_command (char *, int);
192 static void trace_find_tracepoint_command (char *, int);
193 static void trace_find_line_command (char *, int);
194 static void trace_find_range_command (char *, int);
195 static void trace_find_outside_command (char *, int);
196 static void trace_dump_command (char *, int);
198 /* support routines */
200 struct collection_list
;
201 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
202 static char *mem2hex (gdb_byte
*, char *, int);
203 static void add_register (struct collection_list
*collection
,
206 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
207 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
210 extern void _initialize_tracepoint (void);
212 static struct trace_status trace_status
;
214 char *stop_reason_names
[] = {
224 struct trace_status
*
225 current_trace_status (void)
227 return &trace_status
;
233 free_traceframe_info (struct traceframe_info
*info
)
237 VEC_free (mem_range_s
, info
->memory
);
243 /* Free and clear the traceframe info cache of the current
247 clear_traceframe_info (void)
249 free_traceframe_info (traceframe_info
);
250 traceframe_info
= NULL
;
253 /* Set traceframe number to NUM. */
255 set_traceframe_num (int num
)
257 traceframe_number
= num
;
258 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
261 /* Set tracepoint number to NUM. */
263 set_tracepoint_num (int num
)
265 tracepoint_number
= num
;
266 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
269 /* Set externally visible debug variables for querying/printing
270 the traceframe context (line, function, file). */
273 set_traceframe_context (struct frame_info
*trace_frame
)
277 /* Save as globals for internal use. */
278 if (trace_frame
!= NULL
279 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
281 traceframe_sal
= find_pc_line (trace_pc
, 0);
282 traceframe_fun
= find_pc_function (trace_pc
);
284 /* Save linenumber as "$trace_line", a debugger variable visible to
286 set_internalvar_integer (lookup_internalvar ("trace_line"),
287 traceframe_sal
.line
);
291 init_sal (&traceframe_sal
);
292 traceframe_fun
= NULL
;
293 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
296 /* Save func name as "$trace_func", a debugger variable visible to
298 if (traceframe_fun
== NULL
299 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
300 clear_internalvar (lookup_internalvar ("trace_func"));
302 set_internalvar_string (lookup_internalvar ("trace_func"),
303 SYMBOL_LINKAGE_NAME (traceframe_fun
));
305 /* Save file name as "$trace_file", a debugger variable visible to
307 if (traceframe_sal
.symtab
== NULL
)
308 clear_internalvar (lookup_internalvar ("trace_file"));
310 set_internalvar_string (lookup_internalvar ("trace_file"),
311 symtab_to_filename_for_display (traceframe_sal
.symtab
));
314 /* Create a new trace state variable with the given name. */
316 struct trace_state_variable
*
317 create_trace_state_variable (const char *name
)
319 struct trace_state_variable tsv
;
321 memset (&tsv
, 0, sizeof (tsv
));
322 tsv
.name
= xstrdup (name
);
323 tsv
.number
= next_tsv_number
++;
324 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
327 /* Look for a trace state variable of the given name. */
329 struct trace_state_variable
*
330 find_trace_state_variable (const char *name
)
332 struct trace_state_variable
*tsv
;
335 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
336 if (strcmp (name
, tsv
->name
) == 0)
343 delete_trace_state_variable (const char *name
)
345 struct trace_state_variable
*tsv
;
348 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
349 if (strcmp (name
, tsv
->name
) == 0)
351 observer_notify_tsv_deleted (tsv
);
353 xfree ((void *)tsv
->name
);
354 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
359 warning (_("No trace variable named \"$%s\", not deleting"), name
);
362 /* Throws an error if NAME is not valid syntax for a trace state
366 validate_trace_state_variable_name (const char *name
)
371 error (_("Must supply a non-empty variable name"));
373 /* All digits in the name is reserved for value history
375 for (p
= name
; isdigit (*p
); p
++)
378 error (_("$%s is not a valid trace state variable name"), name
);
380 for (p
= name
; isalnum (*p
) || *p
== '_'; p
++)
383 error (_("$%s is not a valid trace state variable name"), name
);
386 /* The 'tvariable' command collects a name and optional expression to
387 evaluate into an initial value. */
390 trace_variable_command (char *args
, int from_tty
)
392 struct cleanup
*old_chain
;
394 struct trace_state_variable
*tsv
;
398 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
400 /* Only allow two syntaxes; "$name" and "$name=value". */
401 p
= skip_spaces (args
);
404 error (_("Name of trace variable should start with '$'"));
407 while (isalnum (*p
) || *p
== '_')
409 name
= savestring (name
, p
- name
);
410 old_chain
= make_cleanup (xfree
, name
);
413 if (*p
!= '=' && *p
!= '\0')
414 error (_("Syntax must be $NAME [ = EXPR ]"));
416 validate_trace_state_variable_name (name
);
419 initval
= value_as_long (parse_and_eval (++p
));
421 /* If the variable already exists, just change its initial value. */
422 tsv
= find_trace_state_variable (name
);
425 if (tsv
->initial_value
!= initval
)
427 tsv
->initial_value
= initval
;
428 observer_notify_tsv_modified (tsv
);
430 printf_filtered (_("Trace state variable $%s "
431 "now has initial value %s.\n"),
432 tsv
->name
, plongest (tsv
->initial_value
));
433 do_cleanups (old_chain
);
437 /* Create a new variable. */
438 tsv
= create_trace_state_variable (name
);
439 tsv
->initial_value
= initval
;
441 observer_notify_tsv_created (tsv
);
443 printf_filtered (_("Trace state variable $%s "
444 "created, with initial value %s.\n"),
445 tsv
->name
, plongest (tsv
->initial_value
));
447 do_cleanups (old_chain
);
451 delete_trace_variable_command (char *args
, int from_tty
)
455 struct cleanup
*back_to
;
459 if (query (_("Delete all trace state variables? ")))
460 VEC_free (tsv_s
, tvariables
);
462 observer_notify_tsv_deleted (NULL
);
466 argv
= gdb_buildargv (args
);
467 back_to
= make_cleanup_freeargv (argv
);
469 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
471 if (*argv
[ix
] == '$')
472 delete_trace_state_variable (argv
[ix
] + 1);
474 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
477 do_cleanups (back_to
);
483 tvariables_info_1 (void)
485 struct trace_state_variable
*tsv
;
488 struct cleanup
*back_to
;
489 struct ui_out
*uiout
= current_uiout
;
491 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
493 printf_filtered (_("No trace state variables.\n"));
497 /* Try to acquire values from the target. */
498 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
499 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
502 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
503 count
, "trace-variables");
504 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
505 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
506 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
508 ui_out_table_body (uiout
);
510 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
512 struct cleanup
*back_to2
;
516 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
518 name
= concat ("$", tsv
->name
, (char *) NULL
);
519 make_cleanup (xfree
, name
);
520 ui_out_field_string (uiout
, "name", name
);
521 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
523 if (tsv
->value_known
)
524 c
= plongest (tsv
->value
);
525 else if (ui_out_is_mi_like_p (uiout
))
526 /* For MI, we prefer not to use magic string constants, but rather
527 omit the field completely. The difference between unknown and
528 undefined does not seem important enough to represent. */
530 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
531 /* The value is/was defined, but we don't have it. */
534 /* It is not meaningful to ask about the value. */
537 ui_out_field_string (uiout
, "current", c
);
538 ui_out_text (uiout
, "\n");
540 do_cleanups (back_to2
);
543 do_cleanups (back_to
);
546 /* List all the trace state variables. */
549 tvariables_info (char *args
, int from_tty
)
551 tvariables_info_1 ();
554 /* Stash definitions of tsvs into the given file. */
557 save_trace_state_variables (struct ui_file
*fp
)
559 struct trace_state_variable
*tsv
;
562 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
564 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
565 if (tsv
->initial_value
)
566 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
567 fprintf_unfiltered (fp
, "\n");
571 /* ACTIONS functions: */
573 /* The three functions:
574 collect_pseudocommand,
575 while_stepping_pseudocommand, and
576 end_actions_pseudocommand
577 are placeholders for "commands" that are actually ONLY to be used
578 within a tracepoint action list. If the actual function is ever called,
579 it means that somebody issued the "command" at the top level,
580 which is always an error. */
583 end_actions_pseudocommand (char *args
, int from_tty
)
585 error (_("This command cannot be used at the top level."));
589 while_stepping_pseudocommand (char *args
, int from_tty
)
591 error (_("This command can only be used in a tracepoint actions list."));
595 collect_pseudocommand (char *args
, int from_tty
)
597 error (_("This command can only be used in a tracepoint actions list."));
601 teval_pseudocommand (char *args
, int from_tty
)
603 error (_("This command can only be used in a tracepoint actions list."));
606 /* Parse any collection options, such as /s for strings. */
609 decode_agent_options (char *exp
)
611 struct value_print_options opts
;
616 /* Call this to borrow the print elements default for collection
618 get_user_print_options (&opts
);
623 if (target_supports_string_tracing ())
625 /* Allow an optional decimal number giving an explicit maximum
626 string length, defaulting it to the "print elements" value;
627 so "collect/s80 mystr" gets at most 80 bytes of string. */
628 trace_string_kludge
= opts
.print_max
;
630 if (*exp
>= '0' && *exp
<= '9')
631 trace_string_kludge
= atoi (exp
);
632 while (*exp
>= '0' && *exp
<= '9')
636 error (_("Target does not support \"/s\" option for string tracing."));
639 error (_("Undefined collection format \"%c\"."), *exp
);
641 exp
= skip_spaces (exp
);
646 /* Enter a list of actions for a tracepoint. */
648 trace_actions_command (char *args
, int from_tty
)
650 struct tracepoint
*t
;
651 struct command_line
*l
;
653 t
= get_tracepoint_by_number (&args
, NULL
, 1);
657 xstrprintf ("Enter actions for tracepoint %d, one per line.",
659 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
661 l
= read_command_lines (tmpbuf
, from_tty
, 1,
662 check_tracepoint_command
, t
);
663 do_cleanups (cleanups
);
664 breakpoint_set_commands (&t
->base
, l
);
666 /* else just return */
669 /* Report the results of checking the agent expression, as errors or
673 report_agent_reqs_errors (struct agent_expr
*aexpr
)
675 /* All of the "flaws" are serious bytecode generation issues that
676 should never occur. */
677 if (aexpr
->flaw
!= agent_flaw_none
)
678 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
680 /* If analysis shows a stack underflow, GDB must have done something
681 badly wrong in its bytecode generation. */
682 if (aexpr
->min_height
< 0)
683 internal_error (__FILE__
, __LINE__
,
684 _("expression has min height < 0"));
686 /* Issue this error if the stack is predicted to get too deep. The
687 limit is rather arbitrary; a better scheme might be for the
688 target to report how much stack it will have available. The
689 depth roughly corresponds to parenthesization, so a limit of 20
690 amounts to 20 levels of expression nesting, which is actually
691 a pretty big hairy expression. */
692 if (aexpr
->max_height
> 20)
693 error (_("Expression is too complicated."));
696 /* worker function */
698 validate_actionline (char **line
, struct breakpoint
*b
)
700 struct cmd_list_element
*c
;
701 struct expression
*exp
= NULL
;
702 struct cleanup
*old_chain
= NULL
;
704 struct bp_location
*loc
;
705 struct agent_expr
*aexpr
;
706 struct tracepoint
*t
= (struct tracepoint
*) b
;
708 /* If EOF is typed, *line is NULL. */
712 p
= skip_spaces (*line
);
714 /* Symbol lookup etc. */
715 if (*p
== '\0') /* empty line: just prompt for another line. */
718 if (*p
== '#') /* comment line */
721 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
723 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
725 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
727 trace_string_kludge
= 0;
729 p
= decode_agent_options (p
);
732 { /* Repeat over a comma-separated list. */
733 QUIT
; /* Allow user to bail out with ^C. */
736 if (*p
== '$') /* Look for special pseudo-symbols. */
738 if (0 == strncasecmp ("reg", p
+ 1, 3)
739 || 0 == strncasecmp ("arg", p
+ 1, 3)
740 || 0 == strncasecmp ("loc", p
+ 1, 3)
741 || 0 == strncasecmp ("_ret", p
+ 1, 4)
742 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
747 /* else fall thru, treat p as an expression and parse it! */
750 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
753 exp
= parse_exp_1 (&p
, loc
->address
,
754 block_for_pc (loc
->address
), 1);
755 old_chain
= make_cleanup (free_current_contents
, &exp
);
757 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
759 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
761 error (_("constant `%s' (value %s) "
762 "will not be collected."),
763 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
764 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
766 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
767 == LOC_OPTIMIZED_OUT
)
769 error (_("`%s' is optimized away "
770 "and cannot be collected."),
771 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
775 /* We have something to collect, make sure that the expr to
776 bytecode translator can handle it and that it's not too
778 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
779 make_cleanup_free_agent_expr (aexpr
);
781 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
782 error (_("Expression is too complicated."));
786 report_agent_reqs_errors (aexpr
);
788 do_cleanups (old_chain
);
791 while (p
&& *p
++ == ',');
794 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
797 { /* Repeat over a comma-separated list. */
798 QUIT
; /* Allow user to bail out with ^C. */
802 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
805 /* Only expressions are allowed for this action. */
806 exp
= parse_exp_1 (&p
, loc
->address
,
807 block_for_pc (loc
->address
), 1);
808 old_chain
= make_cleanup (free_current_contents
, &exp
);
810 /* We have something to evaluate, make sure that the expr to
811 bytecode translator can handle it and that it's not too
813 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
814 make_cleanup_free_agent_expr (aexpr
);
816 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
817 error (_("Expression is too complicated."));
820 report_agent_reqs_errors (aexpr
);
822 do_cleanups (old_chain
);
825 while (p
&& *p
++ == ',');
828 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
830 char *steparg
; /* In case warning is necessary. */
835 if (*p
== '\0' || (t
->step_count
= strtol (p
, &p
, 0)) == 0)
836 error (_("while-stepping step count `%s' is malformed."), *line
);
839 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
843 error (_("`%s' is not a supported tracepoint action."), *line
);
847 memrange_absolute
= -1
852 int type
; /* memrange_absolute for absolute memory range,
853 else basereg number. */
854 bfd_signed_vma start
;
858 struct collection_list
860 unsigned char regs_mask
[32]; /* room for up to 256 regs */
863 struct memrange
*list
;
864 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
866 struct agent_expr
**aexpr_list
;
868 /* True is the user requested a collection of "$_sdata", "static
872 tracepoint_list
, stepping_list
;
874 /* MEMRANGE functions: */
876 static int memrange_cmp (const void *, const void *);
878 /* Compare memranges for qsort. */
880 memrange_cmp (const void *va
, const void *vb
)
882 const struct memrange
*a
= va
, *b
= vb
;
884 if (a
->type
< b
->type
)
886 if (a
->type
> b
->type
)
888 if (a
->type
== memrange_absolute
)
890 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
892 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
897 if (a
->start
< b
->start
)
899 if (a
->start
> b
->start
)
905 /* Sort the memrange list using qsort, and merge adjacent memranges. */
907 memrange_sortmerge (struct collection_list
*memranges
)
911 qsort (memranges
->list
, memranges
->next_memrange
,
912 sizeof (struct memrange
), memrange_cmp
);
913 if (memranges
->next_memrange
> 0)
915 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
917 /* If memrange b overlaps or is adjacent to memrange a,
919 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
920 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
922 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
923 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
924 continue; /* next b, same a */
928 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
929 sizeof (struct memrange
));
931 memranges
->next_memrange
= a
+ 1;
935 /* Add a register to a collection list. */
937 add_register (struct collection_list
*collection
, unsigned int regno
)
940 printf_filtered ("collect register %d\n", regno
);
941 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
942 error (_("Internal: register number %d too large for tracepoint"),
944 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
947 /* Add a memrange to a collection list. */
949 add_memrange (struct collection_list
*memranges
,
950 int type
, bfd_signed_vma base
,
955 printf_filtered ("(%d,", type
);
957 printf_filtered (",%ld)\n", len
);
960 /* type: memrange_absolute == memory, other n == basereg */
961 memranges
->list
[memranges
->next_memrange
].type
= type
;
962 /* base: addr if memory, offset if reg relative. */
963 memranges
->list
[memranges
->next_memrange
].start
= base
;
964 /* len: we actually save end (base + len) for convenience */
965 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
966 memranges
->next_memrange
++;
967 if (memranges
->next_memrange
>= memranges
->listsize
)
969 memranges
->listsize
*= 2;
970 memranges
->list
= xrealloc (memranges
->list
,
971 memranges
->listsize
);
974 if (type
!= memrange_absolute
) /* Better collect the base register! */
975 add_register (memranges
, type
);
978 /* Add a symbol to a collection list. */
980 collect_symbol (struct collection_list
*collect
,
982 struct gdbarch
*gdbarch
,
983 long frame_regno
, long frame_offset
,
988 bfd_signed_vma offset
;
989 int treat_as_expr
= 0;
991 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
992 switch (SYMBOL_CLASS (sym
))
995 printf_filtered ("%s: don't know symbol class %d\n",
996 SYMBOL_PRINT_NAME (sym
),
1000 printf_filtered ("constant %s (value %s) will not be collected.\n",
1001 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
1004 offset
= SYMBOL_VALUE_ADDRESS (sym
);
1009 sprintf_vma (tmp
, offset
);
1010 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1011 SYMBOL_PRINT_NAME (sym
), len
,
1014 /* A struct may be a C++ class with static fields, go to general
1015 expression handling. */
1016 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
1019 add_memrange (collect
, memrange_absolute
, offset
, len
);
1022 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1024 printf_filtered ("LOC_REG[parm] %s: ",
1025 SYMBOL_PRINT_NAME (sym
));
1026 add_register (collect
, reg
);
1027 /* Check for doubles stored in two registers. */
1028 /* FIXME: how about larger types stored in 3 or more regs? */
1029 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1030 len
> register_size (gdbarch
, reg
))
1031 add_register (collect
, reg
+ 1);
1034 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1035 printf_filtered (" (will not collect %s)\n",
1036 SYMBOL_PRINT_NAME (sym
));
1040 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1043 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1044 SYMBOL_PRINT_NAME (sym
), len
);
1045 printf_vma (offset
);
1046 printf_filtered (" from frame ptr reg %d\n", reg
);
1048 add_memrange (collect
, reg
, offset
, len
);
1050 case LOC_REGPARM_ADDR
:
1051 reg
= SYMBOL_VALUE (sym
);
1055 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1056 SYMBOL_PRINT_NAME (sym
), len
);
1057 printf_vma (offset
);
1058 printf_filtered (" from reg %d\n", reg
);
1060 add_memrange (collect
, reg
, offset
, len
);
1064 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1067 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1068 SYMBOL_PRINT_NAME (sym
), len
);
1069 printf_vma (offset
);
1070 printf_filtered (" from frame ptr reg %d\n", reg
);
1072 add_memrange (collect
, reg
, offset
, len
);
1075 case LOC_UNRESOLVED
:
1079 case LOC_OPTIMIZED_OUT
:
1080 printf_filtered ("%s has been optimized out of existence.\n",
1081 SYMBOL_PRINT_NAME (sym
));
1089 /* Expressions are the most general case. */
1092 struct agent_expr
*aexpr
;
1093 struct cleanup
*old_chain1
= NULL
;
1095 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
1097 /* It can happen that the symbol is recorded as a computed
1098 location, but it's been optimized away and doesn't actually
1099 have a location expression. */
1102 printf_filtered ("%s has been optimized out of existence.\n",
1103 SYMBOL_PRINT_NAME (sym
));
1107 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1111 report_agent_reqs_errors (aexpr
);
1113 discard_cleanups (old_chain1
);
1114 add_aexpr (collect
, aexpr
);
1116 /* Take care of the registers. */
1117 if (aexpr
->reg_mask_len
> 0)
1121 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1123 QUIT
; /* Allow user to bail out with ^C. */
1124 if (aexpr
->reg_mask
[ndx1
] != 0)
1126 /* Assume chars have 8 bits. */
1127 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1128 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1129 /* It's used -- record it. */
1130 add_register (collect
, ndx1
* 8 + ndx2
);
1137 /* Data to be passed around in the calls to the locals and args
1140 struct add_local_symbols_data
1142 struct collection_list
*collect
;
1143 struct gdbarch
*gdbarch
;
1150 /* The callback for the locals and args iterators. */
1153 do_collect_symbol (const char *print_name
,
1157 struct add_local_symbols_data
*p
= cb_data
;
1159 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1160 p
->frame_offset
, p
->pc
);
1164 /* Add all locals (or args) symbols to collection list. */
1166 add_local_symbols (struct collection_list
*collect
,
1167 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1168 long frame_regno
, long frame_offset
, int type
)
1170 struct block
*block
;
1171 struct add_local_symbols_data cb_data
;
1173 cb_data
.collect
= collect
;
1174 cb_data
.gdbarch
= gdbarch
;
1176 cb_data
.frame_regno
= frame_regno
;
1177 cb_data
.frame_offset
= frame_offset
;
1182 block
= block_for_pc (pc
);
1185 warning (_("Can't collect locals; "
1186 "no symbol table info available.\n"));
1190 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1191 if (cb_data
.count
== 0)
1192 warning (_("No locals found in scope."));
1196 pc
= get_pc_function_start (pc
);
1197 block
= block_for_pc (pc
);
1200 warning (_("Can't collect args; no symbol table info available."));
1204 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1205 if (cb_data
.count
== 0)
1206 warning (_("No args found in scope."));
1211 add_static_trace_data (struct collection_list
*collection
)
1214 printf_filtered ("collect static trace data\n");
1215 collection
->strace_data
= 1;
1218 /* worker function */
1220 clear_collection_list (struct collection_list
*list
)
1224 list
->next_memrange
= 0;
1225 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1227 free_agent_expr (list
->aexpr_list
[ndx
]);
1228 list
->aexpr_list
[ndx
] = NULL
;
1230 list
->next_aexpr_elt
= 0;
1231 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1232 list
->strace_data
= 0;
1235 /* Reduce a collection list to string form (for gdb protocol). */
1237 stringify_collection_list (struct collection_list
*list
, char *string
)
1239 char temp_buf
[2048];
1243 char *(*str_list
)[];
1247 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1248 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1250 if (list
->strace_data
)
1253 printf_filtered ("\nCollecting static trace data\n");
1256 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1260 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1261 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1263 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1266 printf_filtered ("\nCollecting registers (mask): 0x");
1271 QUIT
; /* Allow user to bail out with ^C. */
1273 printf_filtered ("%02X", list
->regs_mask
[i
]);
1274 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1277 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1281 printf_filtered ("\n");
1282 if (list
->next_memrange
> 0 && info_verbose
)
1283 printf_filtered ("Collecting memranges: \n");
1284 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1286 QUIT
; /* Allow user to bail out with ^C. */
1287 sprintf_vma (tmp2
, list
->list
[i
].start
);
1290 printf_filtered ("(%d, %s, %ld)\n",
1293 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1295 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1297 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1304 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1306 /* The "%X" conversion specifier expects an unsigned argument,
1307 so passing -1 (memrange_absolute) to it directly gives you
1308 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1310 if (list
->list
[i
].type
== memrange_absolute
)
1311 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1313 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1316 count
+= strlen (end
);
1317 end
= temp_buf
+ count
;
1320 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1322 QUIT
; /* Allow user to bail out with ^C. */
1323 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1325 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1330 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1331 end
+= 10; /* 'X' + 8 hex digits + ',' */
1334 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1335 end
, list
->aexpr_list
[i
]->len
);
1336 count
+= 2 * list
->aexpr_list
[i
]->len
;
1341 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1346 (*str_list
)[ndx
] = NULL
;
1359 encode_actions_1 (struct command_line
*action
,
1360 struct breakpoint
*t
,
1361 struct bp_location
*tloc
,
1363 LONGEST frame_offset
,
1364 struct collection_list
*collect
,
1365 struct collection_list
*stepping_list
)
1368 struct expression
*exp
= NULL
;
1370 struct value
*tempval
;
1371 struct cmd_list_element
*cmd
;
1372 struct agent_expr
*aexpr
;
1374 for (; action
; action
= action
->next
)
1376 QUIT
; /* Allow user to bail out with ^C. */
1377 action_exp
= action
->line
;
1378 action_exp
= skip_spaces (action_exp
);
1380 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1382 error (_("Bad action list item: %s"), action_exp
);
1384 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1386 trace_string_kludge
= 0;
1387 if (*action_exp
== '/')
1388 action_exp
= decode_agent_options (action_exp
);
1391 { /* Repeat over a comma-separated list. */
1392 QUIT
; /* Allow user to bail out with ^C. */
1393 action_exp
= skip_spaces (action_exp
);
1395 if (0 == strncasecmp ("$reg", action_exp
, 4))
1397 for (i
= 0; i
< gdbarch_num_regs (tloc
->gdbarch
); i
++)
1398 add_register (collect
, i
);
1399 action_exp
= strchr (action_exp
, ','); /* more? */
1401 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1403 add_local_symbols (collect
,
1409 action_exp
= strchr (action_exp
, ','); /* more? */
1411 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1413 add_local_symbols (collect
,
1419 action_exp
= strchr (action_exp
, ','); /* more? */
1421 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1423 struct cleanup
*old_chain1
= NULL
;
1425 aexpr
= gen_trace_for_return_address (tloc
->address
,
1428 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1431 report_agent_reqs_errors (aexpr
);
1433 discard_cleanups (old_chain1
);
1434 add_aexpr (collect
, aexpr
);
1436 /* take care of the registers */
1437 if (aexpr
->reg_mask_len
> 0)
1441 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1443 QUIT
; /* allow user to bail out with ^C */
1444 if (aexpr
->reg_mask
[ndx1
] != 0)
1446 /* assume chars have 8 bits */
1447 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1448 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1449 /* it's used -- record it */
1450 add_register (collect
,
1456 action_exp
= strchr (action_exp
, ','); /* more? */
1458 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1460 add_static_trace_data (collect
);
1461 action_exp
= strchr (action_exp
, ','); /* more? */
1466 struct cleanup
*old_chain
= NULL
;
1467 struct cleanup
*old_chain1
= NULL
;
1469 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1470 block_for_pc (tloc
->address
), 1);
1471 old_chain
= make_cleanup (free_current_contents
, &exp
);
1473 switch (exp
->elts
[0].opcode
)
1477 const char *name
= &exp
->elts
[2].string
;
1479 i
= user_reg_map_name_to_regnum (tloc
->gdbarch
,
1480 name
, strlen (name
));
1482 internal_error (__FILE__
, __LINE__
,
1483 _("Register $%s not available"),
1486 printf_filtered ("OP_REGISTER: ");
1487 add_register (collect
, i
);
1492 /* Safe because we know it's a simple expression. */
1493 tempval
= evaluate_expression (exp
);
1494 addr
= value_address (tempval
);
1495 /* Initialize the TYPE_LENGTH if it is a typedef. */
1496 check_typedef (exp
->elts
[1].type
);
1497 add_memrange (collect
, memrange_absolute
, addr
,
1498 TYPE_LENGTH (exp
->elts
[1].type
));
1502 collect_symbol (collect
,
1503 exp
->elts
[2].symbol
,
1510 default: /* Full-fledged expression. */
1511 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1513 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1517 report_agent_reqs_errors (aexpr
);
1519 discard_cleanups (old_chain1
);
1520 add_aexpr (collect
, aexpr
);
1522 /* Take care of the registers. */
1523 if (aexpr
->reg_mask_len
> 0)
1528 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1530 QUIT
; /* Allow user to bail out with ^C. */
1531 if (aexpr
->reg_mask
[ndx1
] != 0)
1533 /* Assume chars have 8 bits. */
1534 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1535 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1536 /* It's used -- record it. */
1537 add_register (collect
,
1544 do_cleanups (old_chain
);
1547 while (action_exp
&& *action_exp
++ == ',');
1549 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1552 { /* Repeat over a comma-separated list. */
1553 QUIT
; /* Allow user to bail out with ^C. */
1554 action_exp
= skip_spaces (action_exp
);
1557 struct cleanup
*old_chain
= NULL
;
1558 struct cleanup
*old_chain1
= NULL
;
1560 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1561 block_for_pc (tloc
->address
), 1);
1562 old_chain
= make_cleanup (free_current_contents
, &exp
);
1564 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1565 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1568 report_agent_reqs_errors (aexpr
);
1570 discard_cleanups (old_chain1
);
1571 /* Even though we're not officially collecting, add
1572 to the collect list anyway. */
1573 add_aexpr (collect
, aexpr
);
1575 do_cleanups (old_chain
);
1578 while (action_exp
&& *action_exp
++ == ',');
1580 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1582 /* We check against nested while-stepping when setting
1583 breakpoint action, so no way to run into nested
1585 gdb_assert (stepping_list
);
1587 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
,
1588 frame_offset
, stepping_list
, NULL
);
1591 error (_("Invalid tracepoint command '%s'"), action
->line
);
1595 /* Render all actions into gdb protocol. */
1598 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1599 char ***tdp_actions
, char ***stepping_actions
)
1601 static char tdp_buff
[2048], step_buff
[2048];
1602 char *default_collect_line
= NULL
;
1603 struct command_line
*actions
;
1604 struct command_line
*default_collect_action
= NULL
;
1606 LONGEST frame_offset
;
1607 struct cleanup
*back_to
;
1609 back_to
= make_cleanup (null_cleanup
, NULL
);
1611 clear_collection_list (&tracepoint_list
);
1612 clear_collection_list (&stepping_list
);
1614 *tdp_actions
= NULL
;
1615 *stepping_actions
= NULL
;
1617 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1618 tloc
->address
, &frame_reg
, &frame_offset
);
1620 actions
= breakpoint_commands (t
);
1622 /* If there are default expressions to collect, make up a collect
1623 action and prepend to the action list to encode. Note that since
1624 validation is per-tracepoint (local var "xyz" might be valid for
1625 one tracepoint and not another, etc), we make up the action on
1626 the fly, and don't cache it. */
1627 if (*default_collect
)
1631 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1632 make_cleanup (xfree
, default_collect_line
);
1634 line
= default_collect_line
;
1635 validate_actionline (&line
, t
);
1637 default_collect_action
= xmalloc (sizeof (struct command_line
));
1638 make_cleanup (xfree
, default_collect_action
);
1639 default_collect_action
->next
= actions
;
1640 default_collect_action
->line
= line
;
1641 actions
= default_collect_action
;
1643 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1644 &tracepoint_list
, &stepping_list
);
1646 memrange_sortmerge (&tracepoint_list
);
1647 memrange_sortmerge (&stepping_list
);
1649 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1651 *stepping_actions
= stringify_collection_list (&stepping_list
,
1654 do_cleanups (back_to
);
1658 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1660 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1662 collect
->aexpr_list
=
1663 xrealloc (collect
->aexpr_list
,
1664 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1665 collect
->aexpr_listsize
*= 2;
1667 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1668 collect
->next_aexpr_elt
++;
1672 process_tracepoint_on_disconnect (void)
1674 VEC(breakpoint_p
) *tp_vec
= NULL
;
1676 struct breakpoint
*b
;
1677 int has_pending_p
= 0;
1679 /* Check whether we still have pending tracepoint. If we have, warn the
1680 user that pending tracepoint will no longer work. */
1681 tp_vec
= all_tracepoints ();
1682 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1691 struct bp_location
*loc1
;
1693 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1695 if (loc1
->shlib_disabled
)
1706 VEC_free (breakpoint_p
, tp_vec
);
1709 warning (_("Pending tracepoints will not be resolved while"
1710 " GDB is disconnected\n"));
1715 start_tracing (char *notes
)
1717 VEC(breakpoint_p
) *tp_vec
= NULL
;
1719 struct breakpoint
*b
;
1720 struct trace_state_variable
*tsv
;
1721 int any_enabled
= 0, num_to_download
= 0;
1724 tp_vec
= all_tracepoints ();
1726 /* No point in tracing without any tracepoints... */
1727 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1729 VEC_free (breakpoint_p
, tp_vec
);
1730 error (_("No tracepoints defined, not starting trace"));
1733 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1735 struct tracepoint
*t
= (struct tracepoint
*) b
;
1736 struct bp_location
*loc
;
1738 if (b
->enable_state
== bp_enabled
)
1741 if ((b
->type
== bp_fast_tracepoint
1742 ? may_insert_fast_tracepoints
1743 : may_insert_tracepoints
))
1746 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1747 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1752 if (target_supports_enable_disable_tracepoint ())
1753 warning (_("No tracepoints enabled"));
1756 /* No point in tracing with only disabled tracepoints that
1757 cannot be re-enabled. */
1758 VEC_free (breakpoint_p
, tp_vec
);
1759 error (_("No tracepoints enabled, not starting trace"));
1763 if (num_to_download
<= 0)
1765 VEC_free (breakpoint_p
, tp_vec
);
1766 error (_("No tracepoints that may be downloaded, not starting trace"));
1769 target_trace_init ();
1771 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1773 struct tracepoint
*t
= (struct tracepoint
*) b
;
1774 struct bp_location
*loc
;
1775 int bp_location_downloaded
= 0;
1777 /* Clear `inserted' flag. */
1778 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1781 if ((b
->type
== bp_fast_tracepoint
1782 ? !may_insert_fast_tracepoints
1783 : !may_insert_tracepoints
))
1786 t
->number_on_target
= 0;
1788 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1790 /* Since tracepoint locations are never duplicated, `inserted'
1791 flag should be zero. */
1792 gdb_assert (!loc
->inserted
);
1794 target_download_tracepoint (loc
);
1797 bp_location_downloaded
= 1;
1800 t
->number_on_target
= b
->number
;
1802 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1803 if (loc
->probe
!= NULL
)
1804 loc
->probe
->pops
->set_semaphore (loc
->probe
, loc
->gdbarch
);
1806 if (bp_location_downloaded
)
1807 observer_notify_breakpoint_modified (b
);
1809 VEC_free (breakpoint_p
, tp_vec
);
1811 /* Send down all the trace state variables too. */
1812 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1814 target_download_trace_state_variable (tsv
);
1817 /* Tell target to treat text-like sections as transparent. */
1818 target_trace_set_readonly_regions ();
1819 /* Set some mode flags. */
1820 target_set_disconnected_tracing (disconnected_tracing
);
1821 target_set_circular_trace_buffer (circular_trace_buffer
);
1824 notes
= trace_notes
;
1825 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1827 if (!ret
&& (trace_user
|| notes
))
1828 warning (_("Target does not support trace user/notes, info ignored"));
1830 /* Now insert traps and begin collecting data. */
1831 target_trace_start ();
1833 /* Reset our local state. */
1834 set_traceframe_num (-1);
1835 set_tracepoint_num (-1);
1836 set_traceframe_context (NULL
);
1837 current_trace_status()->running
= 1;
1838 clear_traceframe_info ();
1841 /* The tstart command requests the target to start a new trace run.
1842 The command passes any arguments it has to the target verbatim, as
1843 an optional "trace note". This is useful as for instance a warning
1844 to other users if the trace runs disconnected, and you don't want
1845 anybody else messing with the target. */
1848 trace_start_command (char *args
, int from_tty
)
1850 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1852 if (current_trace_status ()->running
)
1855 && !query (_("A trace is running already. Start a new run? ")))
1856 error (_("New trace run not started."));
1859 start_tracing (args
);
1862 /* The tstop command stops the tracing run. The command passes any
1863 supplied arguments to the target verbatim as a "stop note"; if the
1864 target supports trace notes, then it will be reported back as part
1865 of the trace run's status. */
1868 trace_stop_command (char *args
, int from_tty
)
1870 if (!current_trace_status ()->running
)
1871 error (_("Trace is not running."));
1873 stop_tracing (args
);
1877 stop_tracing (char *note
)
1880 VEC(breakpoint_p
) *tp_vec
= NULL
;
1882 struct breakpoint
*t
;
1884 target_trace_stop ();
1886 tp_vec
= all_tracepoints ();
1887 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1889 struct bp_location
*loc
;
1891 if ((t
->type
== bp_fast_tracepoint
1892 ? !may_insert_fast_tracepoints
1893 : !may_insert_tracepoints
))
1896 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1898 /* GDB can be totally absent in some disconnected trace scenarios,
1899 but we don't really care if this semaphore goes out of sync.
1900 That's why we are decrementing it here, but not taking care
1902 if (loc
->probe
!= NULL
)
1903 loc
->probe
->pops
->clear_semaphore (loc
->probe
, loc
->gdbarch
);
1907 VEC_free (breakpoint_p
, tp_vec
);
1910 note
= trace_stop_notes
;
1911 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1914 warning (_("Target does not support trace notes, note ignored"));
1916 /* Should change in response to reply? */
1917 current_trace_status ()->running
= 0;
1920 /* tstatus command */
1922 trace_status_command (char *args
, int from_tty
)
1924 struct trace_status
*ts
= current_trace_status ();
1926 VEC(breakpoint_p
) *tp_vec
= NULL
;
1927 struct breakpoint
*t
;
1929 status
= target_get_trace_status (ts
);
1933 if (ts
->filename
!= NULL
)
1934 printf_filtered (_("Using a trace file.\n"));
1937 printf_filtered (_("Trace can not be run on this target.\n"));
1942 if (!ts
->running_known
)
1944 printf_filtered (_("Run/stop status is unknown.\n"));
1946 else if (ts
->running
)
1948 printf_filtered (_("Trace is running on the target.\n"));
1952 switch (ts
->stop_reason
)
1954 case trace_never_run
:
1955 printf_filtered (_("No trace has been run on the target.\n"));
1959 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1962 printf_filtered (_("Trace stopped by a tstop command.\n"));
1964 case trace_buffer_full
:
1965 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1967 case trace_disconnected
:
1968 printf_filtered (_("Trace stopped because of disconnection.\n"));
1970 case tracepoint_passcount
:
1971 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1972 ts
->stopping_tracepoint
);
1974 case tracepoint_error
:
1975 if (ts
->stopping_tracepoint
)
1976 printf_filtered (_("Trace stopped by an "
1977 "error (%s, tracepoint %d).\n"),
1978 ts
->stop_desc
, ts
->stopping_tracepoint
);
1980 printf_filtered (_("Trace stopped by an error (%s).\n"),
1983 case trace_stop_reason_unknown
:
1984 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1987 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1993 if (ts
->traceframes_created
>= 0
1994 && ts
->traceframe_count
!= ts
->traceframes_created
)
1996 printf_filtered (_("Buffer contains %d trace "
1997 "frames (of %d created total).\n"),
1998 ts
->traceframe_count
, ts
->traceframes_created
);
2000 else if (ts
->traceframe_count
>= 0)
2002 printf_filtered (_("Collected %d trace frames.\n"),
2003 ts
->traceframe_count
);
2006 if (ts
->buffer_free
>= 0)
2008 if (ts
->buffer_size
>= 0)
2010 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2011 ts
->buffer_free
, ts
->buffer_size
);
2012 if (ts
->buffer_size
> 0)
2013 printf_filtered (_(" (%d%% full)"),
2014 ((int) ((((long long) (ts
->buffer_size
2015 - ts
->buffer_free
)) * 100)
2016 / ts
->buffer_size
)));
2017 printf_filtered (_(".\n"));
2020 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2024 if (ts
->disconnected_tracing
)
2025 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2027 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2029 if (ts
->circular_buffer
)
2030 printf_filtered (_("Trace buffer is circular.\n"));
2032 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
2033 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
2035 if (ts
->notes
&& strlen (ts
->notes
) > 0)
2036 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
2038 /* Now report on what we're doing with tfind. */
2039 if (traceframe_number
>= 0)
2040 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2041 traceframe_number
, tracepoint_number
);
2043 printf_filtered (_("Not looking at any trace frame.\n"));
2045 /* Report start/stop times if supplied. */
2050 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
2052 /* Reporting a run time is more readable than two long numbers. */
2053 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2054 (long int) ts
->start_time
/ 1000000,
2055 (long int) ts
->start_time
% 1000000,
2056 (long int) run_time
/ 1000000,
2057 (long int) run_time
% 1000000);
2060 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2061 (long int) ts
->start_time
/ 1000000,
2062 (long int) ts
->start_time
% 1000000);
2064 else if (ts
->stop_time
)
2065 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2066 (long int) ts
->stop_time
/ 1000000,
2067 (long int) ts
->stop_time
% 1000000);
2069 /* Now report any per-tracepoint status available. */
2070 tp_vec
= all_tracepoints ();
2072 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2073 target_get_tracepoint_status (t
, NULL
);
2075 VEC_free (breakpoint_p
, tp_vec
);
2078 /* Report the trace status to uiout, in a way suitable for MI, and not
2079 suitable for CLI. If ON_STOP is true, suppress a few fields that
2080 are not meaningful in the -trace-stop response.
2082 The implementation is essentially parallel to trace_status_command, but
2083 merging them will result in unreadable code. */
2085 trace_status_mi (int on_stop
)
2087 struct ui_out
*uiout
= current_uiout
;
2088 struct trace_status
*ts
= current_trace_status ();
2091 status
= target_get_trace_status (ts
);
2093 if (status
== -1 && ts
->filename
== NULL
)
2095 ui_out_field_string (uiout
, "supported", "0");
2099 if (ts
->filename
!= NULL
)
2100 ui_out_field_string (uiout
, "supported", "file");
2102 ui_out_field_string (uiout
, "supported", "1");
2104 if (ts
->filename
!= NULL
)
2105 ui_out_field_string (uiout
, "trace-file", ts
->filename
);
2107 gdb_assert (ts
->running_known
);
2111 ui_out_field_string (uiout
, "running", "1");
2113 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2114 Given that the frontend gets the status either on -trace-stop, or from
2115 -trace-status after re-connection, it does not seem like this
2116 information is necessary for anything. It is not necessary for either
2117 figuring the vital state of the target nor for navigation of trace
2118 frames. If the frontend wants to show the current state is some
2119 configure dialog, it can request the value when such dialog is
2120 invoked by the user. */
2124 char *stop_reason
= NULL
;
2125 int stopping_tracepoint
= -1;
2128 ui_out_field_string (uiout
, "running", "0");
2130 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2132 switch (ts
->stop_reason
)
2135 stop_reason
= "request";
2137 case trace_buffer_full
:
2138 stop_reason
= "overflow";
2140 case trace_disconnected
:
2141 stop_reason
= "disconnection";
2143 case tracepoint_passcount
:
2144 stop_reason
= "passcount";
2145 stopping_tracepoint
= ts
->stopping_tracepoint
;
2147 case tracepoint_error
:
2148 stop_reason
= "error";
2149 stopping_tracepoint
= ts
->stopping_tracepoint
;
2155 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2156 if (stopping_tracepoint
!= -1)
2157 ui_out_field_int (uiout
, "stopping-tracepoint",
2158 stopping_tracepoint
);
2159 if (ts
->stop_reason
== tracepoint_error
)
2160 ui_out_field_string (uiout
, "error-description",
2166 if (ts
->traceframe_count
!= -1)
2167 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2168 if (ts
->traceframes_created
!= -1)
2169 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2170 if (ts
->buffer_size
!= -1)
2171 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2172 if (ts
->buffer_free
!= -1)
2173 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2175 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2176 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2178 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2179 ui_out_field_string (uiout
, "notes", ts
->notes
);
2184 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2185 (long int) ts
->start_time
/ 1000000,
2186 (long int) ts
->start_time
% 1000000);
2187 ui_out_field_string (uiout
, "start-time", buf
);
2188 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2189 (long int) ts
->stop_time
/ 1000000,
2190 (long int) ts
->stop_time
% 1000000);
2191 ui_out_field_string (uiout
, "stop-time", buf
);
2195 /* This function handles the details of what to do about an ongoing
2196 tracing run if the user has asked to detach or otherwise disconnect
2199 disconnect_tracing (int from_tty
)
2201 /* It can happen that the target that was tracing went away on its
2202 own, and we didn't notice. Get a status update, and if the
2203 current target doesn't even do tracing, then assume it's not
2205 if (target_get_trace_status (current_trace_status ()) < 0)
2206 current_trace_status ()->running
= 0;
2208 /* If running interactively, give the user the option to cancel and
2209 then decide what to do differently with the run. Scripts are
2210 just going to disconnect and let the target deal with it,
2211 according to how it's been instructed previously via
2212 disconnected-tracing. */
2213 if (current_trace_status ()->running
&& from_tty
)
2215 process_tracepoint_on_disconnect ();
2217 if (current_trace_status ()->disconnected_tracing
)
2219 if (!query (_("Trace is running and will "
2220 "continue after detach; detach anyway? ")))
2221 error (_("Not confirmed."));
2225 if (!query (_("Trace is running but will "
2226 "stop on detach; detach anyway? ")))
2227 error (_("Not confirmed."));
2231 /* Also we want to be out of tfind mode, otherwise things can get
2232 confusing upon reconnection. Just use these calls instead of
2233 full tfind_1 behavior because we're in the middle of detaching,
2234 and there's no point to updating current stack frame etc. */
2235 set_current_traceframe (-1);
2236 set_tracepoint_num (-1);
2237 set_traceframe_context (NULL
);
2240 /* Worker function for the various flavors of the tfind command. */
2242 tfind_1 (enum trace_find_type type
, int num
,
2243 ULONGEST addr1
, ULONGEST addr2
,
2246 int target_frameno
= -1, target_tracept
= -1;
2247 struct frame_id old_frame_id
= null_frame_id
;
2248 struct tracepoint
*tp
;
2249 struct ui_out
*uiout
= current_uiout
;
2251 /* Only try to get the current stack frame if we have a chance of
2252 succeeding. In particular, if we're trying to get a first trace
2253 frame while all threads are running, it's not going to succeed,
2254 so leave it with a default value and let the frame comparison
2255 below (correctly) decide to print out the source location of the
2257 if (!(type
== tfind_number
&& num
== -1)
2258 && (has_stack_frames () || traceframe_number
>= 0))
2259 old_frame_id
= get_frame_id (get_current_frame ());
2261 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2264 if (type
== tfind_number
2266 && target_frameno
== -1)
2268 /* We told the target to get out of tfind mode, and it did. */
2270 else if (target_frameno
== -1)
2272 /* A request for a non-existent trace frame has failed.
2273 Our response will be different, depending on FROM_TTY:
2275 If FROM_TTY is true, meaning that this command was
2276 typed interactively by the user, then give an error
2277 and DO NOT change the state of traceframe_number etc.
2279 However if FROM_TTY is false, meaning that we're either
2280 in a script, a loop, or a user-defined command, then
2281 DON'T give an error, but DO change the state of
2282 traceframe_number etc. to invalid.
2284 The rationalle is that if you typed the command, you
2285 might just have committed a typo or something, and you'd
2286 like to NOT lose your current debugging state. However
2287 if you're in a user-defined command or especially in a
2288 loop, then you need a way to detect that the command
2289 failed WITHOUT aborting. This allows you to write
2290 scripts that search thru the trace buffer until the end,
2291 and then continue on to do something else. */
2294 error (_("Target failed to find requested trace frame."));
2298 printf_filtered ("End of trace buffer.\n");
2299 #if 0 /* dubious now? */
2300 /* The following will not recurse, since it's
2302 trace_find_command ("-1", from_tty
);
2307 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2309 reinit_frame_cache ();
2310 target_dcache_invalidate ();
2312 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2314 if (target_frameno
!= get_traceframe_number ())
2315 observer_notify_traceframe_changed (target_frameno
, tracepoint_number
);
2317 set_current_traceframe (target_frameno
);
2319 if (target_frameno
== -1)
2320 set_traceframe_context (NULL
);
2322 set_traceframe_context (get_current_frame ());
2324 if (traceframe_number
>= 0)
2326 /* Use different branches for MI and CLI to make CLI messages
2328 if (ui_out_is_mi_like_p (uiout
))
2330 ui_out_field_string (uiout
, "found", "1");
2331 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2332 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2336 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2337 traceframe_number
, tracepoint_number
);
2342 if (ui_out_is_mi_like_p (uiout
))
2343 ui_out_field_string (uiout
, "found", "0");
2344 else if (type
== tfind_number
&& num
== -1)
2345 printf_unfiltered (_("No longer looking at any trace frame\n"));
2346 else /* This case may never occur, check. */
2347 printf_unfiltered (_("No trace frame found\n"));
2350 /* If we're in nonstop mode and getting out of looking at trace
2351 frames, there won't be any current frame to go back to and
2354 && (has_stack_frames () || traceframe_number
>= 0))
2356 enum print_what print_what
;
2358 /* NOTE: in imitation of the step command, try to determine
2359 whether we have made a transition from one function to
2360 another. If so, we'll print the "stack frame" (ie. the new
2361 function and it's arguments) -- otherwise we'll just show the
2364 if (frame_id_eq (old_frame_id
,
2365 get_frame_id (get_current_frame ())))
2366 print_what
= SRC_LINE
;
2368 print_what
= SRC_AND_LOC
;
2370 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2375 /* trace_find_command takes a trace frame number n,
2376 sends "QTFrame:<n>" to the target,
2377 and accepts a reply that may contain several optional pieces
2378 of information: a frame number, a tracepoint number, and an
2379 indication of whether this is a trap frame or a stepping frame.
2381 The minimal response is just "OK" (which indicates that the
2382 target does not give us a frame number or a tracepoint number).
2383 Instead of that, the target may send us a string containing
2385 F<hexnum> (gives the selected frame number)
2386 T<hexnum> (gives the selected tracepoint number)
2391 trace_find_command (char *args
, int from_tty
)
2392 { /* This should only be called with a numeric argument. */
2395 if (current_trace_status ()->running
2396 && current_trace_status ()->filename
== NULL
)
2397 error (_("May not look at trace frames while trace is running."));
2399 if (args
== 0 || *args
== 0)
2400 { /* TFIND with no args means find NEXT trace frame. */
2401 if (traceframe_number
== -1)
2402 frameno
= 0; /* "next" is first one. */
2404 frameno
= traceframe_number
+ 1;
2406 else if (0 == strcmp (args
, "-"))
2408 if (traceframe_number
== -1)
2409 error (_("not debugging trace buffer"));
2410 else if (from_tty
&& traceframe_number
== 0)
2411 error (_("already at start of trace buffer"));
2413 frameno
= traceframe_number
- 1;
2415 /* A hack to work around eval's need for fp to have been collected. */
2416 else if (0 == strcmp (args
, "-1"))
2419 frameno
= parse_and_eval_long (args
);
2422 error (_("invalid input (%d is less than zero)"), frameno
);
2424 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2429 trace_find_end_command (char *args
, int from_tty
)
2431 trace_find_command ("-1", from_tty
);
2436 trace_find_start_command (char *args
, int from_tty
)
2438 trace_find_command ("0", from_tty
);
2441 /* tfind pc command */
2443 trace_find_pc_command (char *args
, int from_tty
)
2447 if (current_trace_status ()->running
2448 && current_trace_status ()->filename
== NULL
)
2449 error (_("May not look at trace frames while trace is running."));
2451 if (args
== 0 || *args
== 0)
2452 pc
= regcache_read_pc (get_current_regcache ());
2454 pc
= parse_and_eval_address (args
);
2456 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2459 /* tfind tracepoint command */
2461 trace_find_tracepoint_command (char *args
, int from_tty
)
2464 struct tracepoint
*tp
;
2466 if (current_trace_status ()->running
2467 && current_trace_status ()->filename
== NULL
)
2468 error (_("May not look at trace frames while trace is running."));
2470 if (args
== 0 || *args
== 0)
2472 if (tracepoint_number
== -1)
2473 error (_("No current tracepoint -- please supply an argument."));
2475 tdp
= tracepoint_number
; /* Default is current TDP. */
2478 tdp
= parse_and_eval_long (args
);
2480 /* If we have the tracepoint on hand, use the number that the
2481 target knows about (which may be different if we disconnected
2482 and reconnected). */
2483 tp
= get_tracepoint (tdp
);
2485 tdp
= tp
->number_on_target
;
2487 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2490 /* TFIND LINE command:
2492 This command will take a sourceline for argument, just like BREAK
2493 or TRACE (ie. anything that "decode_line_1" can handle).
2495 With no argument, this command will find the next trace frame
2496 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2499 trace_find_line_command (char *args
, int from_tty
)
2501 static CORE_ADDR start_pc
, end_pc
;
2502 struct symtabs_and_lines sals
;
2503 struct symtab_and_line sal
;
2504 struct cleanup
*old_chain
;
2506 if (current_trace_status ()->running
2507 && current_trace_status ()->filename
== NULL
)
2508 error (_("May not look at trace frames while trace is running."));
2510 if (args
== 0 || *args
== 0)
2512 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2514 sals
.sals
= (struct symtab_and_line
*)
2515 xmalloc (sizeof (struct symtab_and_line
));
2520 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2524 old_chain
= make_cleanup (xfree
, sals
.sals
);
2525 if (sal
.symtab
== 0)
2526 error (_("No line number information available."));
2528 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2530 if (start_pc
== end_pc
)
2532 printf_filtered ("Line %d of \"%s\"",
2534 symtab_to_filename_for_display (sal
.symtab
));
2536 printf_filtered (" is at address ");
2537 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2539 printf_filtered (" but contains no code.\n");
2540 sal
= find_pc_line (start_pc
, 0);
2542 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2543 && start_pc
!= end_pc
)
2544 printf_filtered ("Attempting to find line %d instead.\n",
2547 error (_("Cannot find a good line."));
2551 /* Is there any case in which we get here, and have an address
2552 which the user would want to see? If we have debugging
2553 symbols and no line numbers? */
2554 error (_("Line number %d is out of range for \"%s\"."),
2555 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2557 /* Find within range of stated line. */
2559 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2561 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2562 do_cleanups (old_chain
);
2565 /* tfind range command */
2567 trace_find_range_command (char *args
, int from_tty
)
2569 static CORE_ADDR start
, stop
;
2572 if (current_trace_status ()->running
2573 && current_trace_status ()->filename
== NULL
)
2574 error (_("May not look at trace frames while trace is running."));
2576 if (args
== 0 || *args
== 0)
2577 { /* XXX FIXME: what should default behavior be? */
2578 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2582 if (0 != (tmp
= strchr (args
, ',')))
2584 *tmp
++ = '\0'; /* Terminate start address. */
2585 tmp
= skip_spaces (tmp
);
2586 start
= parse_and_eval_address (args
);
2587 stop
= parse_and_eval_address (tmp
);
2590 { /* No explicit end address? */
2591 start
= parse_and_eval_address (args
);
2592 stop
= start
+ 1; /* ??? */
2595 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2598 /* tfind outside command */
2600 trace_find_outside_command (char *args
, int from_tty
)
2602 CORE_ADDR start
, stop
;
2605 if (current_trace_status ()->running
2606 && current_trace_status ()->filename
== NULL
)
2607 error (_("May not look at trace frames while trace is running."));
2609 if (args
== 0 || *args
== 0)
2610 { /* XXX FIXME: what should default behavior be? */
2611 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2615 if (0 != (tmp
= strchr (args
, ',')))
2617 *tmp
++ = '\0'; /* Terminate start address. */
2618 tmp
= skip_spaces (tmp
);
2619 start
= parse_and_eval_address (args
);
2620 stop
= parse_and_eval_address (tmp
);
2623 { /* No explicit end address? */
2624 start
= parse_and_eval_address (args
);
2625 stop
= start
+ 1; /* ??? */
2628 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2631 /* info scope command: list the locals for a scope. */
2633 scope_info (char *args
, int from_tty
)
2635 struct symtabs_and_lines sals
;
2637 struct minimal_symbol
*msym
;
2638 struct block
*block
;
2639 const char *symname
;
2640 char *save_args
= args
;
2641 struct block_iterator iter
;
2643 struct gdbarch
*gdbarch
;
2646 if (args
== 0 || *args
== 0)
2647 error (_("requires an argument (function, "
2648 "line or *addr) to define a scope"));
2650 sals
= decode_line_1 (&args
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2651 if (sals
.nelts
== 0)
2652 return; /* Presumably decode_line_1 has already warned. */
2654 /* Resolve line numbers to PC. */
2655 resolve_sal_pc (&sals
.sals
[0]);
2656 block
= block_for_pc (sals
.sals
[0].pc
);
2660 QUIT
; /* Allow user to bail out with ^C. */
2661 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2663 QUIT
; /* Allow user to bail out with ^C. */
2665 printf_filtered ("Scope for %s:\n", save_args
);
2668 symname
= SYMBOL_PRINT_NAME (sym
);
2669 if (symname
== NULL
|| *symname
== '\0')
2670 continue; /* Probably botched, certainly useless. */
2672 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2674 printf_filtered ("Symbol %s is ", symname
);
2675 switch (SYMBOL_CLASS (sym
))
2678 case LOC_UNDEF
: /* Messed up symbol? */
2679 printf_filtered ("a bogus symbol, class %d.\n",
2680 SYMBOL_CLASS (sym
));
2681 count
--; /* Don't count this one. */
2684 printf_filtered ("a constant with value %s (%s)",
2685 plongest (SYMBOL_VALUE (sym
)),
2686 hex_string (SYMBOL_VALUE (sym
)));
2688 case LOC_CONST_BYTES
:
2689 printf_filtered ("constant bytes: ");
2690 if (SYMBOL_TYPE (sym
))
2691 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2692 fprintf_filtered (gdb_stdout
, " %02x",
2693 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2696 printf_filtered ("in static storage at address ");
2697 printf_filtered ("%s", paddress (gdbarch
,
2698 SYMBOL_VALUE_ADDRESS (sym
)));
2701 /* GDBARCH is the architecture associated with the objfile
2702 the symbol is defined in; the target architecture may be
2703 different, and may provide additional registers. However,
2704 we do not know the target architecture at this point.
2705 We assume the objfile architecture will contain all the
2706 standard registers that occur in debug info in that
2708 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2711 if (SYMBOL_IS_ARGUMENT (sym
))
2712 printf_filtered ("an argument in register $%s",
2713 gdbarch_register_name (gdbarch
, regno
));
2715 printf_filtered ("a local variable in register $%s",
2716 gdbarch_register_name (gdbarch
, regno
));
2719 printf_filtered ("an argument at stack/frame offset %s",
2720 plongest (SYMBOL_VALUE (sym
)));
2723 printf_filtered ("a local variable at frame offset %s",
2724 plongest (SYMBOL_VALUE (sym
)));
2727 printf_filtered ("a reference argument at offset %s",
2728 plongest (SYMBOL_VALUE (sym
)));
2730 case LOC_REGPARM_ADDR
:
2731 /* Note comment at LOC_REGISTER. */
2732 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2734 printf_filtered ("the address of an argument, in register $%s",
2735 gdbarch_register_name (gdbarch
, regno
));
2738 printf_filtered ("a typedef.\n");
2741 printf_filtered ("a label at address ");
2742 printf_filtered ("%s", paddress (gdbarch
,
2743 SYMBOL_VALUE_ADDRESS (sym
)));
2746 printf_filtered ("a function at address ");
2747 printf_filtered ("%s",
2748 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2750 case LOC_UNRESOLVED
:
2751 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2754 printf_filtered ("Unresolved Static");
2757 printf_filtered ("static storage at address ");
2758 printf_filtered ("%s",
2759 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2762 case LOC_OPTIMIZED_OUT
:
2763 printf_filtered ("optimized out.\n");
2766 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2767 BLOCK_START (block
),
2771 if (SYMBOL_TYPE (sym
))
2772 printf_filtered (", length %d.\n",
2773 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2775 if (BLOCK_FUNCTION (block
))
2778 block
= BLOCK_SUPERBLOCK (block
);
2781 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2785 /* worker function (cleanup) */
2787 replace_comma (void *data
)
2794 /* Helper for trace_dump_command. Dump the action list starting at
2795 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2796 actions of the body of a while-stepping action. STEPPING_FRAME is
2797 set if the current traceframe was determined to be a while-stepping
2801 trace_dump_actions (struct command_line
*action
,
2802 int stepping_actions
, int stepping_frame
,
2805 char *action_exp
, *next_comma
;
2807 for (; action
!= NULL
; action
= action
->next
)
2809 struct cmd_list_element
*cmd
;
2811 QUIT
; /* Allow user to bail out with ^C. */
2812 action_exp
= action
->line
;
2813 action_exp
= skip_spaces (action_exp
);
2815 /* The collection actions to be done while stepping are
2816 bracketed by the commands "while-stepping" and "end". */
2818 if (*action_exp
== '#') /* comment line */
2821 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2823 error (_("Bad action list item: %s"), action_exp
);
2825 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2829 for (i
= 0; i
< action
->body_count
; ++i
)
2830 trace_dump_actions (action
->body_list
[i
],
2831 1, stepping_frame
, from_tty
);
2833 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2835 /* Display the collected data.
2836 For the trap frame, display only what was collected at
2837 the trap. Likewise for stepping frames, display only
2838 what was collected while stepping. This means that the
2839 two boolean variables, STEPPING_FRAME and
2840 STEPPING_ACTIONS should be equal. */
2841 if (stepping_frame
== stepping_actions
)
2843 if (*action_exp
== '/')
2844 action_exp
= decode_agent_options (action_exp
);
2847 { /* Repeat over a comma-separated list. */
2848 QUIT
; /* Allow user to bail out with ^C. */
2849 if (*action_exp
== ',')
2851 action_exp
= skip_spaces (action_exp
);
2853 next_comma
= strchr (action_exp
, ',');
2855 if (0 == strncasecmp (action_exp
, "$reg", 4))
2856 registers_info (NULL
, from_tty
);
2857 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2859 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2860 locals_info (NULL
, from_tty
);
2861 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2862 args_info (NULL
, from_tty
);
2867 make_cleanup (replace_comma
, next_comma
);
2870 printf_filtered ("%s = ", action_exp
);
2871 output_command (action_exp
, from_tty
);
2872 printf_filtered ("\n");
2876 action_exp
= next_comma
;
2878 while (action_exp
&& *action_exp
== ',');
2884 /* The tdump command. */
2887 trace_dump_command (char *args
, int from_tty
)
2889 struct regcache
*regcache
;
2890 struct tracepoint
*t
;
2891 int stepping_frame
= 0;
2892 struct bp_location
*loc
;
2893 char *line
, *default_collect_line
= NULL
;
2894 struct command_line
*actions
, *default_collect_action
= NULL
;
2895 struct cleanup
*old_chain
= NULL
;
2897 if (tracepoint_number
== -1)
2899 warning (_("No current trace frame."));
2903 t
= get_tracepoint (tracepoint_number
);
2906 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2909 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2910 tracepoint_number
, traceframe_number
);
2912 /* The current frame is a trap frame if the frame PC is equal
2913 to the tracepoint PC. If not, then the current frame was
2914 collected during single-stepping. */
2916 regcache
= get_current_regcache ();
2918 /* If the traceframe's address matches any of the tracepoint's
2919 locations, assume it is a direct hit rather than a while-stepping
2920 frame. (FIXME this is not reliable, should record each frame's
2923 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
2924 if (loc
->address
== regcache_read_pc (regcache
))
2927 actions
= breakpoint_commands (&t
->base
);
2929 /* If there is a default-collect list, make up a collect command,
2930 prepend to the tracepoint's commands, and pass the whole mess to
2931 the trace dump scanner. We need to validate because
2932 default-collect might have been junked since the trace run. */
2933 if (*default_collect
)
2935 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2936 old_chain
= make_cleanup (xfree
, default_collect_line
);
2937 line
= default_collect_line
;
2938 validate_actionline (&line
, &t
->base
);
2939 default_collect_action
= xmalloc (sizeof (struct command_line
));
2940 make_cleanup (xfree
, default_collect_action
);
2941 default_collect_action
->next
= actions
;
2942 default_collect_action
->line
= line
;
2943 actions
= default_collect_action
;
2946 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2948 if (*default_collect
)
2949 do_cleanups (old_chain
);
2952 /* Encode a piece of a tracepoint's source-level definition in a form
2953 that is suitable for both protocol and saving in files. */
2954 /* This version does not do multiple encodes for long strings; it should
2955 return an offset to the next piece to encode. FIXME */
2958 encode_source_string (int tpnum
, ULONGEST addr
,
2959 char *srctype
, char *src
, char *buf
, int buf_size
)
2961 if (80 + strlen (srctype
) > buf_size
)
2962 error (_("Buffer too small for source encoding"));
2963 sprintf (buf
, "%x:%s:%s:%x:%x:",
2964 tpnum
, phex_nz (addr
, sizeof (addr
)),
2965 srctype
, 0, (int) strlen (src
));
2966 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2967 error (_("Source string too long for buffer"));
2968 bin2hex (src
, buf
+ strlen (buf
), 0);
2972 extern int trace_regblock_size
;
2974 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2975 non-zero, the save is performed on the target, otherwise GDB obtains all
2976 trace data and saves it locally. */
2979 trace_save (const char *filename
, int target_does_save
)
2981 struct cleanup
*cleanup
;
2983 struct trace_status
*ts
= current_trace_status ();
2986 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2987 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2991 ULONGEST offset
= 0;
2992 #define MAX_TRACE_UPLOAD 2000
2993 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2996 /* If the target is to save the data to a file on its own, then just
2997 send the command and be done with it. */
2998 if (target_does_save
)
3000 err
= target_save_trace_data (filename
);
3002 error (_("Target failed to save trace data to '%s'."),
3007 /* Get the trace status first before opening the file, so if the
3008 target is losing, we can get out without touching files. */
3009 status
= target_get_trace_status (ts
);
3011 pathname
= tilde_expand (filename
);
3012 cleanup
= make_cleanup (xfree
, pathname
);
3014 fp
= fopen (pathname
, "wb");
3016 error (_("Unable to open file '%s' for saving trace data (%s)"),
3017 filename
, safe_strerror (errno
));
3018 make_cleanup_fclose (fp
);
3020 /* Write a file header, with a high-bit-set char to indicate a
3021 binary file, plus a hint as what this file is, and a version
3022 number in case of future needs. */
3023 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
3025 perror_with_name (pathname
);
3027 /* Write descriptive info. */
3029 /* Write out the size of a register block. */
3030 fprintf (fp
, "R %x\n", trace_regblock_size
);
3032 /* Write out status of the tracing run (aka "tstatus" info). */
3033 fprintf (fp
, "status %c;%s",
3034 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
3035 if (ts
->stop_reason
== tracepoint_error
)
3037 char *buf
= (char *) alloca (strlen (ts
->stop_desc
) * 2 + 1);
3039 bin2hex ((gdb_byte
*) ts
->stop_desc
, buf
, 0);
3040 fprintf (fp
, ":%s", buf
);
3042 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
3043 if (ts
->traceframe_count
>= 0)
3044 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
3045 if (ts
->traceframes_created
>= 0)
3046 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
3047 if (ts
->buffer_free
>= 0)
3048 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
3049 if (ts
->buffer_size
>= 0)
3050 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
3051 if (ts
->disconnected_tracing
)
3052 fprintf (fp
, ";disconn:%x", ts
->disconnected_tracing
);
3053 if (ts
->circular_buffer
)
3054 fprintf (fp
, ";circular:%x", ts
->circular_buffer
);
3057 /* Note that we want to upload tracepoints and save those, rather
3058 than simply writing out the local ones, because the user may have
3059 changed tracepoints in GDB in preparation for a future tracing
3060 run, or maybe just mass-deleted all types of breakpoints as part
3061 of cleaning up. So as not to contaminate the session, leave the
3062 data in its uploaded form, don't make into real tracepoints. */
3064 /* Get trace state variables first, they may be checked when parsing
3065 uploaded commands. */
3067 target_upload_trace_state_variables (&uploaded_tsvs
);
3069 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3075 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
3076 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
3079 fprintf (fp
, "tsv %x:%s:%x:%s\n",
3080 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
3081 utsv
->builtin
, buf
);
3087 free_uploaded_tsvs (&uploaded_tsvs
);
3089 target_upload_tracepoints (&uploaded_tps
);
3091 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3092 target_get_tracepoint_status (NULL
, utp
);
3094 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3096 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
3097 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3098 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
3099 if (utp
->type
== bp_fast_tracepoint
)
3100 fprintf (fp
, ":F%x", utp
->orig_size
);
3102 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
3105 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
3106 fprintf (fp
, "tp A%x:%s:%s\n",
3107 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3108 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
3109 fprintf (fp
, "tp S%x:%s:%s\n",
3110 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3113 encode_source_string (utp
->number
, utp
->addr
,
3114 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
3115 fprintf (fp
, "tp Z%s\n", buf
);
3117 if (utp
->cond_string
)
3119 encode_source_string (utp
->number
, utp
->addr
,
3120 "cond", utp
->cond_string
,
3121 buf
, MAX_TRACE_UPLOAD
);
3122 fprintf (fp
, "tp Z%s\n", buf
);
3124 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
3126 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
3127 buf
, MAX_TRACE_UPLOAD
);
3128 fprintf (fp
, "tp Z%s\n", buf
);
3130 fprintf (fp
, "tp V%x:%s:%x:%s\n",
3131 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3133 phex_nz (utp
->traceframe_usage
,
3134 sizeof (utp
->traceframe_usage
)));
3137 free_uploaded_tps (&uploaded_tps
);
3139 /* Mark the end of the definition section. */
3142 /* Get and write the trace data proper. We ask for big blocks, in
3143 the hopes of efficiency, but will take less if the target has
3144 packet size limitations or some such. */
3147 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
3149 error (_("Failure to get requested trace buffer data"));
3150 /* No more data is forthcoming, we're done. */
3153 written
= fwrite (buf
, gotten
, 1, fp
);
3155 perror_with_name (pathname
);
3159 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
3160 written
= fwrite (&gotten
, 4, 1, fp
);
3162 perror_with_name (pathname
);
3164 do_cleanups (cleanup
);
3168 trace_save_command (char *args
, int from_tty
)
3170 int target_does_save
= 0;
3172 char *filename
= NULL
;
3173 struct cleanup
*back_to
;
3176 error_no_arg (_("file in which to save trace data"));
3178 argv
= gdb_buildargv (args
);
3179 back_to
= make_cleanup_freeargv (argv
);
3181 for (; *argv
; ++argv
)
3183 if (strcmp (*argv
, "-r") == 0)
3184 target_does_save
= 1;
3185 else if (**argv
== '-')
3186 error (_("unknown option `%s'"), *argv
);
3192 error_no_arg (_("file in which to save trace data"));
3194 trace_save (filename
, target_does_save
);
3197 printf_filtered (_("Trace data saved to file '%s'.\n"), filename
);
3199 do_cleanups (back_to
);
3202 /* Tell the target what to do with an ongoing tracing run if GDB
3203 disconnects for some reason. */
3206 set_disconnected_tracing (char *args
, int from_tty
,
3207 struct cmd_list_element
*c
)
3209 target_set_disconnected_tracing (disconnected_tracing
);
3213 set_circular_trace_buffer (char *args
, int from_tty
,
3214 struct cmd_list_element
*c
)
3216 target_set_circular_trace_buffer (circular_trace_buffer
);
3220 set_trace_user (char *args
, int from_tty
,
3221 struct cmd_list_element
*c
)
3225 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3228 warning (_("Target does not support trace notes, user ignored"));
3232 set_trace_notes (char *args
, int from_tty
,
3233 struct cmd_list_element
*c
)
3237 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3240 warning (_("Target does not support trace notes, note ignored"));
3244 set_trace_stop_notes (char *args
, int from_tty
,
3245 struct cmd_list_element
*c
)
3249 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3252 warning (_("Target does not support trace notes, stop note ignored"));
3255 /* Convert the memory pointed to by mem into hex, placing result in buf.
3256 * Return a pointer to the last char put in buf (null)
3257 * "stolen" from sparc-stub.c
3260 static const char hexchars
[] = "0123456789abcdef";
3263 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3271 *buf
++ = hexchars
[ch
>> 4];
3272 *buf
++ = hexchars
[ch
& 0xf];
3281 get_traceframe_number (void)
3283 return traceframe_number
;
3286 /* Make the traceframe NUM be the current trace frame. Does nothing
3287 if NUM is already current. */
3290 set_current_traceframe (int num
)
3294 if (traceframe_number
== num
)
3296 /* Nothing to do. */
3300 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3303 warning (_("could not change traceframe"));
3305 set_traceframe_num (newnum
);
3307 /* Changing the traceframe changes our view of registers and of the
3309 registers_changed ();
3311 clear_traceframe_info ();
3314 /* Make the traceframe NUM be the current trace frame, and do nothing
3318 set_traceframe_number (int num
)
3320 traceframe_number
= num
;
3323 /* A cleanup used when switching away and back from tfind mode. */
3325 struct current_traceframe_cleanup
3327 /* The traceframe we were inspecting. */
3328 int traceframe_number
;
3332 do_restore_current_traceframe_cleanup (void *arg
)
3334 struct current_traceframe_cleanup
*old
= arg
;
3336 set_current_traceframe (old
->traceframe_number
);
3340 restore_current_traceframe_cleanup_dtor (void *arg
)
3342 struct current_traceframe_cleanup
*old
= arg
;
3348 make_cleanup_restore_current_traceframe (void)
3350 struct current_traceframe_cleanup
*old
;
3352 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3353 old
->traceframe_number
= traceframe_number
;
3355 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3356 restore_current_traceframe_cleanup_dtor
);
3360 make_cleanup_restore_traceframe_number (void)
3362 return make_cleanup_restore_integer (&traceframe_number
);
3365 /* Given a number and address, return an uploaded tracepoint with that
3366 number, creating if necessary. */
3368 struct uploaded_tp
*
3369 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3371 struct uploaded_tp
*utp
;
3373 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3374 if (utp
->number
== num
&& utp
->addr
== addr
)
3376 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3377 memset (utp
, 0, sizeof (struct uploaded_tp
));
3380 utp
->actions
= NULL
;
3381 utp
->step_actions
= NULL
;
3382 utp
->cmd_strings
= NULL
;
3389 free_uploaded_tps (struct uploaded_tp
**utpp
)
3391 struct uploaded_tp
*next_one
;
3395 next_one
= (*utpp
)->next
;
3401 /* Given a number and address, return an uploaded tracepoint with that
3402 number, creating if necessary. */
3404 static struct uploaded_tsv
*
3405 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3407 struct uploaded_tsv
*utsv
;
3409 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3410 if (utsv
->number
== num
)
3412 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3413 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3415 utsv
->next
= *utsvp
;
3421 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3423 struct uploaded_tsv
*next_one
;
3427 next_one
= (*utsvp
)->next
;
3433 /* FIXME this function is heuristic and will miss the cases where the
3434 conditional is semantically identical but differs in whitespace,
3435 such as "x == 0" vs "x==0". */
3438 cond_string_is_same (char *str1
, char *str2
)
3440 if (str1
== NULL
|| str2
== NULL
)
3441 return (str1
== str2
);
3443 return (strcmp (str1
, str2
) == 0);
3446 /* Look for an existing tracepoint that seems similar enough to the
3447 uploaded one. Enablement isn't compared, because the user can
3448 toggle that freely, and may have done so in anticipation of the
3449 next trace run. Return the location of matched tracepoint. */
3451 static struct bp_location
*
3452 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3454 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3456 struct breakpoint
*b
;
3457 struct bp_location
*loc
;
3459 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3461 struct tracepoint
*t
= (struct tracepoint
*) b
;
3463 if (b
->type
== utp
->type
3464 && t
->step_count
== utp
->step
3465 && t
->pass_count
== utp
->pass
3466 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3467 /* FIXME also test actions. */
3470 /* Scan the locations for an address match. */
3471 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3473 if (loc
->address
== utp
->addr
)
3481 /* Given a list of tracepoints uploaded from a target, attempt to
3482 match them up with existing tracepoints, and create new ones if not
3486 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3488 struct uploaded_tp
*utp
;
3489 /* A set of tracepoints which are modified. */
3490 VEC(breakpoint_p
) *modified_tp
= NULL
;
3492 struct breakpoint
*b
;
3494 /* Look for GDB tracepoints that match up with our uploaded versions. */
3495 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3497 struct bp_location
*loc
;
3498 struct tracepoint
*t
;
3500 loc
= find_matching_tracepoint_location (utp
);
3505 /* Mark this location as already inserted. */
3507 t
= (struct tracepoint
*) loc
->owner
;
3508 printf_filtered (_("Assuming tracepoint %d is same "
3509 "as target's tracepoint %d at %s.\n"),
3510 loc
->owner
->number
, utp
->number
,
3511 paddress (loc
->gdbarch
, utp
->addr
));
3513 /* The tracepoint LOC->owner was modified (the location LOC
3514 was marked as inserted in the target). Save it in
3515 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3516 observers will be notified later once for each tracepoint
3517 saved in MODIFIED_TP. */
3519 VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
);
3521 if (b
== loc
->owner
)
3527 VEC_safe_push (breakpoint_p
, modified_tp
, loc
->owner
);
3531 t
= create_tracepoint_from_upload (utp
);
3533 printf_filtered (_("Created tracepoint %d for "
3534 "target's tracepoint %d at %s.\n"),
3535 t
->base
.number
, utp
->number
,
3536 paddress (get_current_arch (), utp
->addr
));
3538 printf_filtered (_("Failed to create tracepoint for target's "
3539 "tracepoint %d at %s, skipping it.\n"),
3541 paddress (get_current_arch (), utp
->addr
));
3543 /* Whether found or created, record the number used by the
3544 target, to help with mapping target tracepoints back to their
3545 counterparts here. */
3547 t
->number_on_target
= utp
->number
;
3550 /* Notify 'breakpoint-modified' observer that at least one of B's
3551 locations was changed. */
3552 for (ix
= 0; VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
); ix
++)
3553 observer_notify_breakpoint_modified (b
);
3555 VEC_free (breakpoint_p
, modified_tp
);
3556 free_uploaded_tps (uploaded_tps
);
3559 /* Trace state variables don't have much to identify them beyond their
3560 name, so just use that to detect matches. */
3562 static struct trace_state_variable
*
3563 find_matching_tsv (struct uploaded_tsv
*utsv
)
3568 return find_trace_state_variable (utsv
->name
);
3571 static struct trace_state_variable
*
3572 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3574 const char *namebase
;
3577 struct trace_state_variable
*tsv
;
3578 struct cleanup
*old_chain
;
3582 namebase
= utsv
->name
;
3583 buf
= xstrprintf ("%s", namebase
);
3588 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3591 /* Fish for a name that is not in use. */
3592 /* (should check against all internal vars?) */
3593 while (find_trace_state_variable (buf
))
3596 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3599 old_chain
= make_cleanup (xfree
, buf
);
3601 /* We have an available name, create the variable. */
3602 tsv
= create_trace_state_variable (buf
);
3603 tsv
->initial_value
= utsv
->initial_value
;
3604 tsv
->builtin
= utsv
->builtin
;
3606 observer_notify_tsv_created (tsv
);
3608 do_cleanups (old_chain
);
3613 /* Given a list of uploaded trace state variables, try to match them
3614 up with existing variables, or create additional ones. */
3617 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3620 struct uploaded_tsv
*utsv
;
3621 struct trace_state_variable
*tsv
;
3624 /* Most likely some numbers will have to be reassigned as part of
3625 the merge, so clear them all in anticipation. */
3626 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3629 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3631 tsv
= find_matching_tsv (utsv
);
3635 printf_filtered (_("Assuming trace state variable $%s "
3636 "is same as target's variable %d.\n"),
3637 tsv
->name
, utsv
->number
);
3641 tsv
= create_tsv_from_upload (utsv
);
3643 printf_filtered (_("Created trace state variable "
3644 "$%s for target's variable %d.\n"),
3645 tsv
->name
, utsv
->number
);
3647 /* Give precedence to numberings that come from the target. */
3649 tsv
->number
= utsv
->number
;
3652 /* Renumber everything that didn't get a target-assigned number. */
3654 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3655 if (tsv
->number
> highest
)
3656 highest
= tsv
->number
;
3659 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3660 if (tsv
->number
== 0)
3661 tsv
->number
= highest
++;
3663 free_uploaded_tsvs (uploaded_tsvs
);
3666 /* target tfile command */
3668 static struct target_ops tfile_ops
;
3670 /* Fill in tfile_ops with its defined operations and properties. */
3672 #define TRACE_HEADER_SIZE 8
3674 static char *trace_filename
;
3675 static int trace_fd
= -1;
3676 static off_t trace_frames_offset
;
3677 static off_t cur_offset
;
3678 static int cur_data_size
;
3679 int trace_regblock_size
;
3681 static void tfile_interp_line (char *line
,
3682 struct uploaded_tp
**utpp
,
3683 struct uploaded_tsv
**utsvp
);
3685 /* Read SIZE bytes into READBUF from the trace frame, starting at
3686 TRACE_FD's current position. Note that this call `read'
3687 underneath, hence it advances the file's seek position. Throws an
3688 error if the `read' syscall fails, or less than SIZE bytes are
3692 tfile_read (gdb_byte
*readbuf
, int size
)
3696 gotten
= read (trace_fd
, readbuf
, size
);
3698 perror_with_name (trace_filename
);
3699 else if (gotten
< size
)
3700 error (_("Premature end of file while reading trace file"));
3704 tfile_open (char *filename
, int from_tty
)
3706 volatile struct gdb_exception ex
;
3708 struct cleanup
*old_chain
;
3711 char header
[TRACE_HEADER_SIZE
];
3712 char linebuf
[1000]; /* Should be max remote packet size or so. */
3715 struct trace_status
*ts
;
3716 struct uploaded_tp
*uploaded_tps
= NULL
;
3717 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3719 target_preopen (from_tty
);
3721 error (_("No trace file specified."));
3723 filename
= tilde_expand (filename
);
3724 if (!IS_ABSOLUTE_PATH(filename
))
3726 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
3731 old_chain
= make_cleanup (xfree
, filename
);
3733 flags
= O_BINARY
| O_LARGEFILE
;
3735 scratch_chan
= open (filename
, flags
, 0);
3736 if (scratch_chan
< 0)
3737 perror_with_name (filename
);
3739 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3741 discard_cleanups (old_chain
); /* Don't free filename any more. */
3742 unpush_target (&tfile_ops
);
3744 trace_filename
= xstrdup (filename
);
3745 trace_fd
= scratch_chan
;
3748 /* Read the file header and test for validity. */
3749 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
3751 bytes
+= TRACE_HEADER_SIZE
;
3752 if (!(header
[0] == 0x7f
3753 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3754 error (_("File is not a valid trace file."));
3756 push_target (&tfile_ops
);
3758 trace_regblock_size
= 0;
3759 ts
= current_trace_status ();
3760 /* We know we're working with a file. Record its name. */
3761 ts
->filename
= trace_filename
;
3762 /* Set defaults in case there is no status line. */
3763 ts
->running_known
= 0;
3764 ts
->stop_reason
= trace_stop_reason_unknown
;
3765 ts
->traceframe_count
= -1;
3766 ts
->buffer_free
= 0;
3767 ts
->disconnected_tracing
= 0;
3768 ts
->circular_buffer
= 0;
3770 TRY_CATCH (ex
, RETURN_MASK_ALL
)
3772 /* Read through a section of newline-terminated lines that
3773 define things like tracepoints. */
3777 tfile_read (&byte
, 1);
3782 /* Empty line marks end of the definition section. */
3787 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3790 linebuf
[i
++] = byte
;
3792 error (_("Excessively long lines in trace file"));
3795 /* Record the starting offset of the binary trace data. */
3796 trace_frames_offset
= bytes
;
3798 /* If we don't have a blocksize, we can't interpret the
3800 if (trace_regblock_size
== 0)
3801 error (_("No register block size recorded in trace file"));
3805 /* Pop the partially set up target. */
3807 throw_exception (ex
);
3810 inferior_appeared (current_inferior (), TFILE_PID
);
3811 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3812 add_thread_silent (inferior_ptid
);
3814 if (ts
->traceframe_count
<= 0)
3815 warning (_("No traceframes present in this file."));
3817 /* Add the file's tracepoints and variables into the current mix. */
3819 /* Get trace state variables first, they may be checked when parsing
3820 uploaded commands. */
3821 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3823 merge_uploaded_tracepoints (&uploaded_tps
);
3825 post_create_inferior (&tfile_ops
, from_tty
);
3828 /* Interpret the given line from the definitions part of the trace
3832 tfile_interp_line (char *line
,
3833 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3837 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3840 trace_regblock_size
= strtol (p
, &p
, 16);
3842 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3844 p
+= strlen ("status ");
3845 parse_trace_status (p
, current_trace_status ());
3847 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3849 p
+= strlen ("tp ");
3850 parse_tracepoint_definition (p
, utpp
);
3852 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3854 p
+= strlen ("tsv ");
3855 parse_tsv_definition (p
, utsvp
);
3858 warning (_("Ignoring trace file definition \"%s\""), line
);
3861 /* Parse the part of trace status syntax that is shared between
3862 the remote protocol and the trace file reader. */
3865 parse_trace_status (char *line
, struct trace_status
*ts
)
3867 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
3871 ts
->running_known
= 1;
3872 ts
->running
= (*p
++ == '1');
3873 ts
->stop_reason
= trace_stop_reason_unknown
;
3874 xfree (ts
->stop_desc
);
3875 ts
->stop_desc
= NULL
;
3876 ts
->traceframe_count
= -1;
3877 ts
->traceframes_created
= -1;
3878 ts
->buffer_free
= -1;
3879 ts
->buffer_size
= -1;
3880 ts
->disconnected_tracing
= 0;
3881 ts
->circular_buffer
= 0;
3882 xfree (ts
->user_name
);
3883 ts
->user_name
= NULL
;
3886 ts
->start_time
= ts
->stop_time
= 0;
3890 p1
= strchr (p
, ':');
3892 error (_("Malformed trace status, at %s\n\
3893 Status line: '%s'\n"), p
, line
);
3894 p3
= strchr (p
, ';');
3896 p3
= p
+ strlen (p
);
3897 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3899 p
= unpack_varlen_hex (++p1
, &val
);
3900 ts
->stop_reason
= trace_buffer_full
;
3902 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3904 p
= unpack_varlen_hex (++p1
, &val
);
3905 ts
->stop_reason
= trace_never_run
;
3907 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3910 p
= unpack_varlen_hex (++p1
, &val
);
3911 ts
->stop_reason
= tracepoint_passcount
;
3912 ts
->stopping_tracepoint
= val
;
3914 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3916 p2
= strchr (++p1
, ':');
3924 ts
->stop_desc
= xmalloc (strlen (line
));
3925 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
3926 ts
->stop_desc
[end
] = '\0';
3929 ts
->stop_desc
= xstrdup ("");
3931 p
= unpack_varlen_hex (++p2
, &val
);
3932 ts
->stop_reason
= tstop_command
;
3934 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3936 p
= unpack_varlen_hex (++p1
, &val
);
3937 ts
->stop_reason
= trace_disconnected
;
3939 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3941 p2
= strchr (++p1
, ':');
3944 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3945 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
3946 ts
->stop_desc
[end
] = '\0';
3949 ts
->stop_desc
= xstrdup ("");
3951 p
= unpack_varlen_hex (++p2
, &val
);
3952 ts
->stopping_tracepoint
= val
;
3953 ts
->stop_reason
= tracepoint_error
;
3955 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3957 p
= unpack_varlen_hex (++p1
, &val
);
3958 ts
->traceframe_count
= val
;
3960 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3962 p
= unpack_varlen_hex (++p1
, &val
);
3963 ts
->traceframes_created
= val
;
3965 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3967 p
= unpack_varlen_hex (++p1
, &val
);
3968 ts
->buffer_free
= val
;
3970 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3972 p
= unpack_varlen_hex (++p1
, &val
);
3973 ts
->buffer_size
= val
;
3975 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3977 p
= unpack_varlen_hex (++p1
, &val
);
3978 ts
->disconnected_tracing
= val
;
3980 else if (strncmp (p
, "circular", p1
- p
) == 0)
3982 p
= unpack_varlen_hex (++p1
, &val
);
3983 ts
->circular_buffer
= val
;
3985 else if (strncmp (p
, "starttime", p1
- p
) == 0)
3987 p
= unpack_varlen_hex (++p1
, &val
);
3988 ts
->start_time
= val
;
3990 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
3992 p
= unpack_varlen_hex (++p1
, &val
);
3993 ts
->stop_time
= val
;
3995 else if (strncmp (p
, "username", p1
- p
) == 0)
3998 ts
->user_name
= xmalloc (strlen (p
) / 2);
3999 end
= hex2bin (p1
, ts
->user_name
, (p3
- p1
) / 2);
4000 ts
->user_name
[end
] = '\0';
4003 else if (strncmp (p
, "notes", p1
- p
) == 0)
4006 ts
->notes
= xmalloc (strlen (p
) / 2);
4007 end
= hex2bin (p1
, ts
->notes
, (p3
- p1
) / 2);
4008 ts
->notes
[end
] = '\0';
4013 /* Silently skip unknown optional info. */
4014 p_temp
= strchr (p1
+ 1, ';');
4018 /* Must be at the end. */
4025 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
4026 struct uploaded_tp
*utp
)
4029 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
4031 p
= unpack_varlen_hex (p
, &uval
);
4033 tp
->base
.hit_count
+= uval
;
4035 utp
->hit_count
+= uval
;
4036 p
= unpack_varlen_hex (p
+ 1, &uval
);
4038 tp
->traceframe_usage
+= uval
;
4040 utp
->traceframe_usage
+= uval
;
4041 /* Ignore any extra, allowing for future extensions. */
4044 /* Given a line of text defining a part of a tracepoint, parse it into
4045 an "uploaded tracepoint". */
4048 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
4052 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
4055 char *cond
, *srctype
, *buf
;
4056 struct uploaded_tp
*utp
= NULL
;
4059 /* Both tracepoint and action definitions start with the same number
4060 and address sequence. */
4062 p
= unpack_varlen_hex (p
, &num
);
4063 p
++; /* skip a colon */
4064 p
= unpack_varlen_hex (p
, &addr
);
4065 p
++; /* skip a colon */
4068 enabled
= (*p
++ == 'E');
4069 p
++; /* skip a colon */
4070 p
= unpack_varlen_hex (p
, &step
);
4071 p
++; /* skip a colon */
4072 p
= unpack_varlen_hex (p
, &pass
);
4073 type
= bp_tracepoint
;
4075 /* Thumb through optional fields. */
4078 p
++; /* skip a colon */
4081 type
= bp_fast_tracepoint
;
4083 p
= unpack_varlen_hex (p
, &orig_size
);
4087 type
= bp_static_tracepoint
;
4093 p
= unpack_varlen_hex (p
, &xlen
);
4094 p
++; /* skip a comma */
4095 cond
= (char *) xmalloc (2 * xlen
+ 1);
4096 strncpy (cond
, p
, 2 * xlen
);
4097 cond
[2 * xlen
] = '\0';
4101 warning (_("Unrecognized char '%c' in tracepoint "
4102 "definition, skipping rest"), *p
);
4104 utp
= get_uploaded_tp (num
, addr
, utpp
);
4106 utp
->enabled
= enabled
;
4111 else if (piece
== 'A')
4113 utp
= get_uploaded_tp (num
, addr
, utpp
);
4114 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
4116 else if (piece
== 'S')
4118 utp
= get_uploaded_tp (num
, addr
, utpp
);
4119 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
4121 else if (piece
== 'Z')
4123 /* Parse a chunk of source form definition. */
4124 utp
= get_uploaded_tp (num
, addr
, utpp
);
4126 p
= strchr (p
, ':');
4127 p
++; /* skip a colon */
4128 p
= unpack_varlen_hex (p
, &start
);
4129 p
++; /* skip a colon */
4130 p
= unpack_varlen_hex (p
, &xlen
);
4131 p
++; /* skip a colon */
4133 buf
= alloca (strlen (line
));
4135 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4138 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
4139 utp
->at_string
= xstrdup (buf
);
4140 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
4141 utp
->cond_string
= xstrdup (buf
);
4142 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
4143 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
4145 else if (piece
== 'V')
4147 utp
= get_uploaded_tp (num
, addr
, utpp
);
4149 parse_tracepoint_status (p
, NULL
, utp
);
4153 /* Don't error out, the target might be sending us optional
4154 info that we don't care about. */
4155 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
4159 /* Convert a textual description of a trace state variable into an
4163 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
4166 ULONGEST num
, initval
, builtin
;
4168 struct uploaded_tsv
*utsv
= NULL
;
4170 buf
= alloca (strlen (line
));
4173 p
= unpack_varlen_hex (p
, &num
);
4174 p
++; /* skip a colon */
4175 p
= unpack_varlen_hex (p
, &initval
);
4176 p
++; /* skip a colon */
4177 p
= unpack_varlen_hex (p
, &builtin
);
4178 p
++; /* skip a colon */
4179 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4182 utsv
= get_uploaded_tsv (num
, utsvp
);
4183 utsv
->initial_value
= initval
;
4184 utsv
->builtin
= builtin
;
4185 utsv
->name
= xstrdup (buf
);
4188 /* Close the trace file and generally clean up. */
4191 tfile_close (int quitting
)
4198 pid
= ptid_get_pid (inferior_ptid
);
4199 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff. */
4200 exit_inferior_silent (pid
);
4204 xfree (trace_filename
);
4205 trace_filename
= NULL
;
4209 tfile_files_info (struct target_ops
*t
)
4211 printf_filtered ("\t`%s'\n", trace_filename
);
4214 /* The trace status for a file is that tracing can never be run. */
4217 tfile_get_trace_status (struct trace_status
*ts
)
4219 /* Other bits of trace status were collected as part of opening the
4220 trace files, so nothing to do here. */
4226 tfile_get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
4228 /* Other bits of trace status were collected as part of opening the
4229 trace files, so nothing to do here. */
4232 /* Given the position of a traceframe in the file, figure out what
4233 address the frame was collected at. This would normally be the
4234 value of a collected PC register, but if not available, we
4238 tfile_get_traceframe_address (off_t tframe_offset
)
4242 struct tracepoint
*tp
;
4243 off_t saved_offset
= cur_offset
;
4245 /* FIXME dig pc out of collected registers. */
4247 /* Fall back to using tracepoint address. */
4248 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
4249 tfile_read ((gdb_byte
*) &tpnum
, 2);
4250 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4252 (target_gdbarch ()));
4254 tp
= get_tracepoint_by_number_on_target (tpnum
);
4255 /* FIXME this is a poor heuristic if multiple locations. */
4256 if (tp
&& tp
->base
.loc
)
4257 addr
= tp
->base
.loc
->address
;
4259 /* Restore our seek position. */
4260 cur_offset
= saved_offset
;
4261 lseek (trace_fd
, cur_offset
, SEEK_SET
);
4265 /* Given a type of search and some parameters, scan the collection of
4266 traceframes in the file looking for a match. When found, return
4267 both the traceframe and tracepoint number, otherwise -1 for
4271 tfile_trace_find (enum trace_find_type type
, int num
,
4272 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
4275 int tfnum
= 0, found
= 0;
4276 unsigned int data_size
;
4277 struct tracepoint
*tp
;
4278 off_t offset
, tframe_offset
;
4288 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
4289 offset
= trace_frames_offset
;
4292 tframe_offset
= offset
;
4293 tfile_read ((gdb_byte
*) &tpnum
, 2);
4294 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4296 (target_gdbarch ()));
4300 tfile_read ((gdb_byte
*) &data_size
, 4);
4301 data_size
= (unsigned int) extract_unsigned_integer
4302 ((gdb_byte
*) &data_size
, 4,
4303 gdbarch_byte_order (target_gdbarch ()));
4306 if (type
== tfind_number
)
4308 /* Looking for a specific trace frame. */
4314 /* Start from the _next_ trace frame. */
4315 if (tfnum
> traceframe_number
)
4320 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4321 if (tfaddr
== addr1
)
4325 tp
= get_tracepoint (num
);
4326 if (tp
&& tpnum
== tp
->number_on_target
)
4330 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4331 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
4335 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4336 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
4340 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
4349 cur_offset
= offset
;
4350 cur_data_size
= data_size
;
4354 /* Skip past the traceframe's data. */
4355 lseek (trace_fd
, data_size
, SEEK_CUR
);
4356 offset
+= data_size
;
4357 /* Update our own count of traceframes. */
4360 /* Did not find what we were looking for. */
4366 /* Prototype of the callback passed to tframe_walk_blocks. */
4367 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
4369 /* Callback for traceframe_walk_blocks, used to find a given block
4370 type in a traceframe. */
4373 match_blocktype (char blocktype
, void *data
)
4375 char *wantedp
= data
;
4377 if (*wantedp
== blocktype
)
4383 /* Walk over all traceframe block starting at POS offset from
4384 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4385 unmodified. If CALLBACK returns true, this returns the position in
4386 the traceframe where the block is found, relative to the start of
4387 the traceframe (cur_offset). Returns -1 if no callback call
4388 returned true, indicating that all blocks have been walked. */
4391 traceframe_walk_blocks (walk_blocks_callback_func callback
,
4392 int pos
, void *data
)
4394 /* Iterate through a traceframe's blocks, looking for a block of the
4397 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
4398 while (pos
< cur_data_size
)
4400 unsigned short mlen
;
4403 tfile_read (&block_type
, 1);
4407 if ((*callback
) (block_type
, data
))
4413 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4414 pos
+= trace_regblock_size
;
4417 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4418 tfile_read ((gdb_byte
*) &mlen
, 2);
4419 mlen
= (unsigned short)
4420 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4422 (target_gdbarch ()));
4423 lseek (trace_fd
, mlen
, SEEK_CUR
);
4424 pos
+= (8 + 2 + mlen
);
4427 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
4431 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4432 block_type
, block_type
);
4440 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4441 position offset of a block of type TYPE_WANTED in the current trace
4442 frame, starting at POS. Returns -1 if no such block was found. */
4445 traceframe_find_block_type (char type_wanted
, int pos
)
4447 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
4450 /* Look for a block of saved registers in the traceframe, and get the
4451 requested register from it. */
4454 tfile_fetch_registers (struct target_ops
*ops
,
4455 struct regcache
*regcache
, int regno
)
4457 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4458 int offset
, regn
, regsize
, pc_regno
;
4461 /* An uninitialized reg size says we're not going to be
4462 successful at getting register blocks. */
4463 if (!trace_regblock_size
)
4466 regs
= alloca (trace_regblock_size
);
4468 if (traceframe_find_block_type ('R', 0) >= 0)
4470 tfile_read (regs
, trace_regblock_size
);
4472 /* Assume the block is laid out in GDB register number order,
4473 each register with the size that it has in GDB. */
4475 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4477 regsize
= register_size (gdbarch
, regn
);
4478 /* Make sure we stay within block bounds. */
4479 if (offset
+ regsize
>= trace_regblock_size
)
4481 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
4485 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
4488 else if (regno
== -1)
4490 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
4498 /* We get here if no register data has been found. Mark registers
4500 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4501 regcache_raw_supply (regcache
, regn
, NULL
);
4503 /* We can often usefully guess that the PC is going to be the same
4504 as the address of the tracepoint. */
4505 pc_regno
= gdbarch_pc_regnum (gdbarch
);
4506 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
4508 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
4510 if (tp
&& tp
->base
.loc
)
4512 /* But don't try to guess if tracepoint is multi-location... */
4513 if (tp
->base
.loc
->next
)
4515 warning (_("Tracepoint %d has multiple "
4516 "locations, cannot infer $pc"),
4520 /* ... or does while-stepping. */
4521 if (tp
->step_count
> 0)
4523 warning (_("Tracepoint %d does while-stepping, "
4524 "cannot infer $pc"),
4529 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
4530 gdbarch_byte_order (gdbarch
),
4531 tp
->base
.loc
->address
);
4532 regcache_raw_supply (regcache
, pc_regno
, regs
);
4538 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4539 const char *annex
, gdb_byte
*readbuf
,
4540 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
4542 /* We're only doing regular memory for now. */
4543 if (object
!= TARGET_OBJECT_MEMORY
)
4546 if (readbuf
== NULL
)
4547 error (_("tfile_xfer_partial: trace file is read-only"));
4549 if (traceframe_number
!= -1)
4553 /* Iterate through the traceframe's blocks, looking for
4555 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
4557 ULONGEST maddr
, amt
;
4558 unsigned short mlen
;
4559 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
4561 tfile_read ((gdb_byte
*) &maddr
, 8);
4562 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
4564 tfile_read ((gdb_byte
*) &mlen
, 2);
4565 mlen
= (unsigned short)
4566 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
4568 /* If the block includes the first part of the desired
4569 range, return as much it has; GDB will re-request the
4570 remainder, which might be in a different block of this
4572 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
4574 amt
= (maddr
+ mlen
) - offset
;
4578 if (maddr
!= offset
)
4579 lseek (trace_fd
, offset
- maddr
, SEEK_CUR
);
4580 tfile_read (readbuf
, amt
);
4584 /* Skip over this block. */
4585 pos
+= (8 + 2 + mlen
);
4589 /* It's unduly pedantic to refuse to look at the executable for
4590 read-only pieces; so do the equivalent of readonly regions aka
4592 /* FIXME account for relocation at some point. */
4599 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
4601 if ((s
->flags
& SEC_LOAD
) == 0
4602 || (s
->flags
& SEC_READONLY
) == 0)
4606 size
= bfd_get_section_size (s
);
4607 if (vma
<= offset
&& offset
< (vma
+ size
))
4611 amt
= (vma
+ size
) - offset
;
4615 amt
= bfd_get_section_contents (exec_bfd
, s
,
4616 readbuf
, offset
- vma
, amt
);
4622 /* Indicate failure to find the requested memory block. */
4626 /* Iterate through the blocks of a trace frame, looking for a 'V'
4627 block with a matching tsv number. */
4630 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
4635 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
4639 tfile_read ((gdb_byte
*) &vnum
, 4);
4640 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
4642 (target_gdbarch ()));
4645 tfile_read ((gdb_byte
*) val
, 8);
4646 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
4648 (target_gdbarch ()));
4654 /* Didn't find anything. */
4659 tfile_has_all_memory (struct target_ops
*ops
)
4665 tfile_has_memory (struct target_ops
*ops
)
4671 tfile_has_stack (struct target_ops
*ops
)
4673 return traceframe_number
!= -1;
4677 tfile_has_registers (struct target_ops
*ops
)
4679 return traceframe_number
!= -1;
4683 tfile_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
4688 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
4689 object for the tfile target's current traceframe. */
4692 build_traceframe_info (char blocktype
, void *data
)
4694 struct traceframe_info
*info
= data
;
4700 struct mem_range
*r
;
4702 unsigned short mlen
;
4704 tfile_read ((gdb_byte
*) &maddr
, 8);
4705 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
4707 (target_gdbarch ()));
4708 tfile_read ((gdb_byte
*) &mlen
, 2);
4709 mlen
= (unsigned short)
4710 extract_unsigned_integer ((gdb_byte
*) &mlen
,
4711 2, gdbarch_byte_order
4712 (target_gdbarch ()));
4714 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4727 warning (_("Unhandled trace block type (%d) '%c ' "
4728 "while building trace frame info."),
4729 blocktype
, blocktype
);
4736 static struct traceframe_info
*
4737 tfile_traceframe_info (void)
4739 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
4741 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
4746 init_tfile_ops (void)
4748 tfile_ops
.to_shortname
= "tfile";
4749 tfile_ops
.to_longname
= "Local trace dump file";
4751 = "Use a trace file as a target. Specify the filename of the trace file.";
4752 tfile_ops
.to_open
= tfile_open
;
4753 tfile_ops
.to_close
= tfile_close
;
4754 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
4755 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
4756 tfile_ops
.to_files_info
= tfile_files_info
;
4757 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
4758 tfile_ops
.to_get_tracepoint_status
= tfile_get_tracepoint_status
;
4759 tfile_ops
.to_trace_find
= tfile_trace_find
;
4760 tfile_ops
.to_get_trace_state_variable_value
4761 = tfile_get_trace_state_variable_value
;
4762 tfile_ops
.to_stratum
= process_stratum
;
4763 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
4764 tfile_ops
.to_has_memory
= tfile_has_memory
;
4765 tfile_ops
.to_has_stack
= tfile_has_stack
;
4766 tfile_ops
.to_has_registers
= tfile_has_registers
;
4767 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
4768 tfile_ops
.to_thread_alive
= tfile_thread_alive
;
4769 tfile_ops
.to_magic
= OPS_MAGIC
;
4773 free_current_marker (void *arg
)
4775 struct static_tracepoint_marker
**marker_p
= arg
;
4777 if (*marker_p
!= NULL
)
4779 release_static_tracepoint_marker (*marker_p
);
4786 /* Given a line of text defining a static tracepoint marker, parse it
4787 into a "static tracepoint marker" object. Throws an error is
4788 parsing fails. If PP is non-null, it points to one past the end of
4789 the parsed marker definition. */
4792 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
4793 struct static_tracepoint_marker
*marker
)
4800 p
= unpack_varlen_hex (p
, &addr
);
4801 p
++; /* skip a colon */
4803 marker
->gdbarch
= target_gdbarch ();
4804 marker
->address
= (CORE_ADDR
) addr
;
4806 endp
= strchr (p
, ':');
4808 error (_("bad marker definition: %s"), line
);
4810 marker
->str_id
= xmalloc (endp
- p
+ 1);
4811 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
4812 marker
->str_id
[end
] = '\0';
4815 p
++; /* skip a colon */
4817 marker
->extra
= xmalloc (strlen (p
) + 1);
4818 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
4819 marker
->extra
[end
] = '\0';
4825 /* Release a static tracepoint marker's contents. Note that the
4826 object itself isn't released here. There objects are usually on
4830 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
4832 xfree (marker
->str_id
);
4833 marker
->str_id
= NULL
;
4836 /* Print MARKER to gdb_stdout. */
4839 print_one_static_tracepoint_marker (int count
,
4840 struct static_tracepoint_marker
*marker
)
4842 struct command_line
*l
;
4845 char wrap_indent
[80];
4846 char extra_field_indent
[80];
4847 struct ui_out
*uiout
= current_uiout
;
4848 struct cleanup
*bkpt_chain
;
4849 VEC(breakpoint_p
) *tracepoints
;
4851 struct symtab_and_line sal
;
4855 sal
.pc
= marker
->address
;
4857 tracepoints
= static_tracepoints_here (marker
->address
);
4859 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
4861 /* A counter field to help readability. This is not a stable
4863 ui_out_field_int (uiout
, "count", count
);
4865 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
4867 ui_out_field_fmt (uiout
, "enabled", "%c",
4868 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
4869 ui_out_spaces (uiout
, 2);
4871 strcpy (wrap_indent
, " ");
4873 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
4874 strcat (wrap_indent
, " ");
4876 strcat (wrap_indent
, " ");
4878 strcpy (extra_field_indent
, " ");
4880 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
4882 sal
= find_pc_line (marker
->address
, 0);
4883 sym
= find_pc_sect_function (marker
->address
, NULL
);
4886 ui_out_text (uiout
, "in ");
4887 ui_out_field_string (uiout
, "func",
4888 SYMBOL_PRINT_NAME (sym
));
4889 ui_out_wrap_hint (uiout
, wrap_indent
);
4890 ui_out_text (uiout
, " at ");
4893 ui_out_field_skip (uiout
, "func");
4895 if (sal
.symtab
!= NULL
)
4897 ui_out_field_string (uiout
, "file",
4898 symtab_to_filename_for_display (sal
.symtab
));
4899 ui_out_text (uiout
, ":");
4901 if (ui_out_is_mi_like_p (uiout
))
4903 const char *fullname
= symtab_to_fullname (sal
.symtab
);
4905 ui_out_field_string (uiout
, "fullname", fullname
);
4908 ui_out_field_skip (uiout
, "fullname");
4910 ui_out_field_int (uiout
, "line", sal
.line
);
4914 ui_out_field_skip (uiout
, "fullname");
4915 ui_out_field_skip (uiout
, "line");
4918 ui_out_text (uiout
, "\n");
4919 ui_out_text (uiout
, extra_field_indent
);
4920 ui_out_text (uiout
, _("Data: \""));
4921 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
4922 ui_out_text (uiout
, "\"\n");
4924 if (!VEC_empty (breakpoint_p
, tracepoints
))
4926 struct cleanup
*cleanup_chain
;
4928 struct breakpoint
*b
;
4930 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
4933 ui_out_text (uiout
, extra_field_indent
);
4934 ui_out_text (uiout
, _("Probed by static tracepoints: "));
4935 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
4938 ui_out_text (uiout
, ", ");
4939 ui_out_text (uiout
, "#");
4940 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
4943 do_cleanups (cleanup_chain
);
4945 if (ui_out_is_mi_like_p (uiout
))
4946 ui_out_field_int (uiout
, "number-of-tracepoints",
4947 VEC_length(breakpoint_p
, tracepoints
));
4949 ui_out_text (uiout
, "\n");
4951 VEC_free (breakpoint_p
, tracepoints
);
4953 do_cleanups (bkpt_chain
);
4957 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
4959 VEC(static_tracepoint_marker_p
) *markers
;
4960 struct cleanup
*old_chain
;
4961 struct static_tracepoint_marker
*marker
;
4962 struct ui_out
*uiout
= current_uiout
;
4965 /* We don't have to check target_can_use_agent and agent's capability on
4966 static tracepoint here, in order to be compatible with older GDBserver.
4967 We don't check USE_AGENT is true or not, because static tracepoints
4968 don't work without in-process agent, so we don't bother users to type
4969 `set agent on' when to use static tracepoint. */
4972 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
4973 "StaticTracepointMarkersTable");
4975 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
4977 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
4979 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
4980 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
4981 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
4983 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
4984 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
4986 ui_out_table_body (uiout
);
4988 markers
= target_static_tracepoint_markers_by_strid (NULL
);
4989 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
4992 VEC_iterate (static_tracepoint_marker_p
,
4993 markers
, i
, marker
);
4996 print_one_static_tracepoint_marker (i
+ 1, marker
);
4997 release_static_tracepoint_marker (marker
);
5000 do_cleanups (old_chain
);
5003 /* The $_sdata convenience variable is a bit special. We don't know
5004 for sure type of the value until we actually have a chance to fetch
5005 the data --- the size of the object depends on what has been
5006 collected. We solve this by making $_sdata be an internalvar that
5007 creates a new value on access. */
5009 /* Return a new value with the correct type for the sdata object of
5010 the current trace frame. Return a void value if there's no object
5013 static struct value
*
5014 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
5020 /* We need to read the whole object before we know its size. */
5021 size
= target_read_alloc (¤t_target
,
5022 TARGET_OBJECT_STATIC_TRACE_DATA
,
5029 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
5031 v
= allocate_value (type
);
5032 memcpy (value_contents_raw (v
), buf
, size
);
5037 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
5040 #if !defined(HAVE_LIBEXPAT)
5042 struct traceframe_info
*
5043 parse_traceframe_info (const char *tframe_info
)
5045 static int have_warned
;
5050 warning (_("Can not parse XML trace frame info; XML support "
5051 "was disabled at compile time"));
5057 #else /* HAVE_LIBEXPAT */
5059 #include "xml-support.h"
5061 /* Handle the start of a <memory> element. */
5064 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
5065 const struct gdb_xml_element
*element
,
5066 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
5068 struct traceframe_info
*info
= user_data
;
5069 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5070 ULONGEST
*start_p
, *length_p
;
5072 start_p
= xml_find_attribute (attributes
, "start")->value
;
5073 length_p
= xml_find_attribute (attributes
, "length")->value
;
5075 r
->start
= *start_p
;
5076 r
->length
= *length_p
;
5079 /* Discard the constructed trace frame info (if an error occurs). */
5082 free_result (void *p
)
5084 struct traceframe_info
*result
= p
;
5086 free_traceframe_info (result
);
5089 /* The allowed elements and attributes for an XML memory map. */
5091 static const struct gdb_xml_attribute memory_attributes
[] = {
5092 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5093 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5094 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5097 static const struct gdb_xml_element traceframe_info_children
[] = {
5098 { "memory", memory_attributes
, NULL
,
5099 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5100 traceframe_info_start_memory
, NULL
},
5101 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5104 static const struct gdb_xml_element traceframe_info_elements
[] = {
5105 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
5107 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5110 /* Parse a traceframe-info XML document. */
5112 struct traceframe_info
*
5113 parse_traceframe_info (const char *tframe_info
)
5115 struct traceframe_info
*result
;
5116 struct cleanup
*back_to
;
5118 result
= XCNEW (struct traceframe_info
);
5119 back_to
= make_cleanup (free_result
, result
);
5121 if (gdb_xml_parse_quick (_("trace frame info"),
5122 "traceframe-info.dtd", traceframe_info_elements
,
5123 tframe_info
, result
) == 0)
5125 /* Parsed successfully, keep the result. */
5126 discard_cleanups (back_to
);
5131 do_cleanups (back_to
);
5135 #endif /* HAVE_LIBEXPAT */
5137 /* Returns the traceframe_info object for the current traceframe.
5138 This is where we avoid re-fetching the object from the target if we
5139 already have it cached. */
5141 static struct traceframe_info
*
5142 get_traceframe_info (void)
5144 if (traceframe_info
== NULL
)
5145 traceframe_info
= target_traceframe_info ();
5147 return traceframe_info
;
5150 /* If the target supports the query, return in RESULT the set of
5151 collected memory in the current traceframe, found within the LEN
5152 bytes range starting at MEMADDR. Returns true if the target
5153 supports the query, otherwise returns false, and RESULT is left
5157 traceframe_available_memory (VEC(mem_range_s
) **result
,
5158 CORE_ADDR memaddr
, ULONGEST len
)
5160 struct traceframe_info
*info
= get_traceframe_info ();
5164 struct mem_range
*r
;
5169 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
5170 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
5172 ULONGEST lo1
, hi1
, lo2
, hi2
;
5173 struct mem_range
*nr
;
5176 hi1
= memaddr
+ len
;
5179 hi2
= r
->start
+ r
->length
;
5181 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
5183 nr
->start
= max (lo1
, lo2
);
5184 nr
->length
= min (hi1
, hi2
) - nr
->start
;
5187 normalize_mem_ranges (*result
);
5194 /* Implementation of `sdata' variable. */
5196 static const struct internalvar_funcs sdata_funcs
=
5203 /* module initialization */
5205 _initialize_tracepoint (void)
5207 struct cmd_list_element
*c
;
5209 /* Explicitly create without lookup, since that tries to create a
5210 value with a void typed value, and when we get here, gdbarch
5211 isn't initialized yet. At this point, we're quite sure there
5212 isn't another convenience variable of the same name. */
5213 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
5215 traceframe_number
= -1;
5216 tracepoint_number
= -1;
5218 if (tracepoint_list
.list
== NULL
)
5220 tracepoint_list
.listsize
= 128;
5221 tracepoint_list
.list
= xmalloc
5222 (tracepoint_list
.listsize
* sizeof (struct memrange
));
5224 if (tracepoint_list
.aexpr_list
== NULL
)
5226 tracepoint_list
.aexpr_listsize
= 128;
5227 tracepoint_list
.aexpr_list
= xmalloc
5228 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5231 if (stepping_list
.list
== NULL
)
5233 stepping_list
.listsize
= 128;
5234 stepping_list
.list
= xmalloc
5235 (stepping_list
.listsize
* sizeof (struct memrange
));
5238 if (stepping_list
.aexpr_list
== NULL
)
5240 stepping_list
.aexpr_listsize
= 128;
5241 stepping_list
.aexpr_list
= xmalloc
5242 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5245 add_info ("scope", scope_info
,
5246 _("List the variables local to a scope"));
5248 add_cmd ("tracepoints", class_trace
, NULL
,
5249 _("Tracing of program execution without stopping the program."),
5252 add_com ("tdump", class_trace
, trace_dump_command
,
5253 _("Print everything collected at the current tracepoint."));
5255 add_com ("tsave", class_trace
, trace_save_command
, _("\
5256 Save the trace data to a file.\n\
5257 Use the '-r' option to direct the target to save directly to the file,\n\
5258 using its own filesystem."));
5260 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
5261 Define a trace state variable.\n\
5262 Argument is a $-prefixed name, optionally followed\n\
5263 by '=' and an expression that sets the initial value\n\
5264 at the start of tracing."));
5265 set_cmd_completer (c
, expression_completer
);
5267 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
5268 Delete one or more trace state variables.\n\
5269 Arguments are the names of the variables to delete.\n\
5270 If no arguments are supplied, delete all variables."), &deletelist
);
5271 /* FIXME add a trace variable completer. */
5273 add_info ("tvariables", tvariables_info
, _("\
5274 Status of trace state variables and their values.\n\
5277 add_info ("static-tracepoint-markers",
5278 info_static_tracepoint_markers_command
, _("\
5279 List target static tracepoints markers.\n\
5282 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
5283 Select a trace frame;\n\
5284 No argument means forward by one frame; '-' means backward by one frame."),
5285 &tfindlist
, "tfind ", 1, &cmdlist
);
5287 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
5288 Select a trace frame whose PC is outside the given range (exclusive).\n\
5289 Usage: tfind outside addr1, addr2"),
5292 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
5293 Select a trace frame whose PC is in the given range (inclusive).\n\
5294 Usage: tfind range addr1,addr2"),
5297 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
5298 Select a trace frame by source line.\n\
5299 Argument can be a line number (with optional source file),\n\
5300 a function name, or '*' followed by an address.\n\
5301 Default argument is 'the next source line that was traced'."),
5304 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
5305 Select a trace frame by tracepoint number.\n\
5306 Default is the tracepoint for the current trace frame."),
5309 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
5310 Select a trace frame by PC.\n\
5311 Default is the current PC, or the PC of the current trace frame."),
5314 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
5315 De-select any trace frame and resume 'live' debugging."),
5318 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
5320 add_cmd ("start", class_trace
, trace_find_start_command
,
5321 _("Select the first trace frame in the trace buffer."),
5324 add_com ("tstatus", class_trace
, trace_status_command
,
5325 _("Display the status of the current trace data collection."));
5327 add_com ("tstop", class_trace
, trace_stop_command
, _("\
5328 Stop trace data collection.\n\
5329 Usage: tstop [ <notes> ... ]\n\
5330 Any arguments supplied are recorded with the trace as a stop reason and\n\
5331 reported by tstatus (if the target supports trace notes)."));
5333 add_com ("tstart", class_trace
, trace_start_command
, _("\
5334 Start trace data collection.\n\
5335 Usage: tstart [ <notes> ... ]\n\
5336 Any arguments supplied are recorded with the trace as a note and\n\
5337 reported by tstatus (if the target supports trace notes)."));
5339 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
5340 Ends a list of commands or actions.\n\
5341 Several GDB commands allow you to enter a list of commands or actions.\n\
5342 Entering \"end\" on a line by itself is the normal way to terminate\n\
5344 Note: the \"end\" command cannot be used at the gdb prompt."));
5346 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
5347 Specify single-stepping behavior at a tracepoint.\n\
5348 Argument is number of instructions to trace in single-step mode\n\
5349 following the tracepoint. This command is normally followed by\n\
5350 one or more \"collect\" commands, to specify what to collect\n\
5351 while single-stepping.\n\n\
5352 Note: this command can only be used in a tracepoint \"actions\" list."));
5354 add_com_alias ("ws", "while-stepping", class_alias
, 0);
5355 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
5357 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
5358 Specify one or more data items to be collected at a tracepoint.\n\
5359 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5360 collect all data (variables, registers) referenced by that expression.\n\
5361 Also accepts the following special arguments:\n\
5362 $regs -- all registers.\n\
5363 $args -- all function arguments.\n\
5364 $locals -- all variables local to the block/function scope.\n\
5365 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5366 Note: this command can only be used in a tracepoint \"actions\" list."));
5368 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
5369 Specify one or more expressions to be evaluated at a tracepoint.\n\
5370 Accepts a comma-separated list of (one or more) expressions.\n\
5371 The result of each evaluation will be discarded.\n\
5372 Note: this command can only be used in a tracepoint \"actions\" list."));
5374 add_com ("actions", class_trace
, trace_actions_command
, _("\
5375 Specify the actions to be taken at a tracepoint.\n\
5376 Tracepoint actions may include collecting of specified data,\n\
5377 single-stepping, or enabling/disabling other tracepoints,\n\
5378 depending on target's capabilities."));
5380 default_collect
= xstrdup ("");
5381 add_setshow_string_cmd ("default-collect", class_trace
,
5382 &default_collect
, _("\
5383 Set the list of expressions to collect by default"), _("\
5384 Show the list of expressions to collect by default"), NULL
,
5386 &setlist
, &showlist
);
5388 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
5389 &disconnected_tracing
, _("\
5390 Set whether tracing continues after GDB disconnects."), _("\
5391 Show whether tracing continues after GDB disconnects."), _("\
5392 Use this to continue a tracing run even if GDB disconnects\n\
5393 or detaches from the target. You can reconnect later and look at\n\
5394 trace data collected in the meantime."),
5395 set_disconnected_tracing
,
5400 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
5401 &circular_trace_buffer
, _("\
5402 Set target's use of circular trace buffer."), _("\
5403 Show target's use of circular trace buffer."), _("\
5404 Use this to make the trace buffer into a circular buffer,\n\
5405 which will discard traceframes (oldest first) instead of filling\n\
5406 up and stopping the trace run."),
5407 set_circular_trace_buffer
,
5412 add_setshow_string_cmd ("trace-user", class_trace
,
5414 Set the user name to use for current and future trace runs"), _("\
5415 Show the user name to use for current and future trace runs"), NULL
,
5416 set_trace_user
, NULL
,
5417 &setlist
, &showlist
);
5419 add_setshow_string_cmd ("trace-notes", class_trace
,
5421 Set notes string to use for current and future trace runs"), _("\
5422 Show the notes string to use for current and future trace runs"), NULL
,
5423 set_trace_notes
, NULL
,
5424 &setlist
, &showlist
);
5426 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
5427 &trace_stop_notes
, _("\
5428 Set notes string to use for future tstop commands"), _("\
5429 Show the notes string to use for future tstop commands"), NULL
,
5430 set_trace_stop_notes
, NULL
,
5431 &setlist
, &showlist
);
5435 add_target (&tfile_ops
);