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 /* This variable is the requested trace buffer size, or -1 to indicate
174 that we don't care and leave it up to the target to set a size. */
176 static int trace_buffer_size
= -1;
178 /* Textual notes applying to the current and/or future trace runs. */
180 char *trace_user
= NULL
;
182 /* Textual notes applying to the current and/or future trace runs. */
184 char *trace_notes
= NULL
;
186 /* Textual notes applying to the stopping of a trace. */
188 char *trace_stop_notes
= NULL
;
190 /* ======= Important command functions: ======= */
191 static void trace_actions_command (char *, int);
192 static void trace_start_command (char *, int);
193 static void trace_stop_command (char *, int);
194 static void trace_status_command (char *, int);
195 static void trace_find_command (char *, int);
196 static void trace_find_pc_command (char *, int);
197 static void trace_find_tracepoint_command (char *, int);
198 static void trace_find_line_command (char *, int);
199 static void trace_find_range_command (char *, int);
200 static void trace_find_outside_command (char *, int);
201 static void trace_dump_command (char *, int);
203 /* support routines */
205 struct collection_list
;
206 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
207 static char *mem2hex (gdb_byte
*, char *, int);
208 static void add_register (struct collection_list
*collection
,
211 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
212 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
215 extern void _initialize_tracepoint (void);
217 static struct trace_status trace_status
;
219 char *stop_reason_names
[] = {
229 struct trace_status
*
230 current_trace_status (void)
232 return &trace_status
;
238 free_traceframe_info (struct traceframe_info
*info
)
242 VEC_free (mem_range_s
, info
->memory
);
248 /* Free and clear the traceframe info cache of the current
252 clear_traceframe_info (void)
254 free_traceframe_info (traceframe_info
);
255 traceframe_info
= NULL
;
258 /* Set traceframe number to NUM. */
260 set_traceframe_num (int num
)
262 traceframe_number
= num
;
263 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
266 /* Set tracepoint number to NUM. */
268 set_tracepoint_num (int num
)
270 tracepoint_number
= num
;
271 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
274 /* Set externally visible debug variables for querying/printing
275 the traceframe context (line, function, file). */
278 set_traceframe_context (struct frame_info
*trace_frame
)
282 /* Save as globals for internal use. */
283 if (trace_frame
!= NULL
284 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
286 traceframe_sal
= find_pc_line (trace_pc
, 0);
287 traceframe_fun
= find_pc_function (trace_pc
);
289 /* Save linenumber as "$trace_line", a debugger variable visible to
291 set_internalvar_integer (lookup_internalvar ("trace_line"),
292 traceframe_sal
.line
);
296 init_sal (&traceframe_sal
);
297 traceframe_fun
= NULL
;
298 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
301 /* Save func name as "$trace_func", a debugger variable visible to
303 if (traceframe_fun
== NULL
304 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
305 clear_internalvar (lookup_internalvar ("trace_func"));
307 set_internalvar_string (lookup_internalvar ("trace_func"),
308 SYMBOL_LINKAGE_NAME (traceframe_fun
));
310 /* Save file name as "$trace_file", a debugger variable visible to
312 if (traceframe_sal
.symtab
== NULL
)
313 clear_internalvar (lookup_internalvar ("trace_file"));
315 set_internalvar_string (lookup_internalvar ("trace_file"),
316 symtab_to_filename_for_display (traceframe_sal
.symtab
));
319 /* Create a new trace state variable with the given name. */
321 struct trace_state_variable
*
322 create_trace_state_variable (const char *name
)
324 struct trace_state_variable tsv
;
326 memset (&tsv
, 0, sizeof (tsv
));
327 tsv
.name
= xstrdup (name
);
328 tsv
.number
= next_tsv_number
++;
329 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
332 /* Look for a trace state variable of the given name. */
334 struct trace_state_variable
*
335 find_trace_state_variable (const char *name
)
337 struct trace_state_variable
*tsv
;
340 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
341 if (strcmp (name
, tsv
->name
) == 0)
348 delete_trace_state_variable (const char *name
)
350 struct trace_state_variable
*tsv
;
353 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
354 if (strcmp (name
, tsv
->name
) == 0)
356 observer_notify_tsv_deleted (tsv
);
358 xfree ((void *)tsv
->name
);
359 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
364 warning (_("No trace variable named \"$%s\", not deleting"), name
);
367 /* Throws an error if NAME is not valid syntax for a trace state
371 validate_trace_state_variable_name (const char *name
)
376 error (_("Must supply a non-empty variable name"));
378 /* All digits in the name is reserved for value history
380 for (p
= name
; isdigit (*p
); p
++)
383 error (_("$%s is not a valid trace state variable name"), name
);
385 for (p
= name
; isalnum (*p
) || *p
== '_'; p
++)
388 error (_("$%s is not a valid trace state variable name"), name
);
391 /* The 'tvariable' command collects a name and optional expression to
392 evaluate into an initial value. */
395 trace_variable_command (char *args
, int from_tty
)
397 struct cleanup
*old_chain
;
399 struct trace_state_variable
*tsv
;
403 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
405 /* Only allow two syntaxes; "$name" and "$name=value". */
406 p
= skip_spaces (args
);
409 error (_("Name of trace variable should start with '$'"));
412 while (isalnum (*p
) || *p
== '_')
414 name
= savestring (name
, p
- name
);
415 old_chain
= make_cleanup (xfree
, name
);
418 if (*p
!= '=' && *p
!= '\0')
419 error (_("Syntax must be $NAME [ = EXPR ]"));
421 validate_trace_state_variable_name (name
);
424 initval
= value_as_long (parse_and_eval (++p
));
426 /* If the variable already exists, just change its initial value. */
427 tsv
= find_trace_state_variable (name
);
430 if (tsv
->initial_value
!= initval
)
432 tsv
->initial_value
= initval
;
433 observer_notify_tsv_modified (tsv
);
435 printf_filtered (_("Trace state variable $%s "
436 "now has initial value %s.\n"),
437 tsv
->name
, plongest (tsv
->initial_value
));
438 do_cleanups (old_chain
);
442 /* Create a new variable. */
443 tsv
= create_trace_state_variable (name
);
444 tsv
->initial_value
= initval
;
446 observer_notify_tsv_created (tsv
);
448 printf_filtered (_("Trace state variable $%s "
449 "created, with initial value %s.\n"),
450 tsv
->name
, plongest (tsv
->initial_value
));
452 do_cleanups (old_chain
);
456 delete_trace_variable_command (char *args
, int from_tty
)
460 struct cleanup
*back_to
;
464 if (query (_("Delete all trace state variables? ")))
465 VEC_free (tsv_s
, tvariables
);
467 observer_notify_tsv_deleted (NULL
);
471 argv
= gdb_buildargv (args
);
472 back_to
= make_cleanup_freeargv (argv
);
474 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
476 if (*argv
[ix
] == '$')
477 delete_trace_state_variable (argv
[ix
] + 1);
479 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
482 do_cleanups (back_to
);
488 tvariables_info_1 (void)
490 struct trace_state_variable
*tsv
;
493 struct cleanup
*back_to
;
494 struct ui_out
*uiout
= current_uiout
;
496 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
498 printf_filtered (_("No trace state variables.\n"));
502 /* Try to acquire values from the target. */
503 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
504 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
507 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
508 count
, "trace-variables");
509 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
510 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
511 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
513 ui_out_table_body (uiout
);
515 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
517 struct cleanup
*back_to2
;
521 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
523 name
= concat ("$", tsv
->name
, (char *) NULL
);
524 make_cleanup (xfree
, name
);
525 ui_out_field_string (uiout
, "name", name
);
526 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
528 if (tsv
->value_known
)
529 c
= plongest (tsv
->value
);
530 else if (ui_out_is_mi_like_p (uiout
))
531 /* For MI, we prefer not to use magic string constants, but rather
532 omit the field completely. The difference between unknown and
533 undefined does not seem important enough to represent. */
535 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
536 /* The value is/was defined, but we don't have it. */
539 /* It is not meaningful to ask about the value. */
542 ui_out_field_string (uiout
, "current", c
);
543 ui_out_text (uiout
, "\n");
545 do_cleanups (back_to2
);
548 do_cleanups (back_to
);
551 /* List all the trace state variables. */
554 tvariables_info (char *args
, int from_tty
)
556 tvariables_info_1 ();
559 /* Stash definitions of tsvs into the given file. */
562 save_trace_state_variables (struct ui_file
*fp
)
564 struct trace_state_variable
*tsv
;
567 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
569 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
570 if (tsv
->initial_value
)
571 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
572 fprintf_unfiltered (fp
, "\n");
576 /* ACTIONS functions: */
578 /* The three functions:
579 collect_pseudocommand,
580 while_stepping_pseudocommand, and
581 end_actions_pseudocommand
582 are placeholders for "commands" that are actually ONLY to be used
583 within a tracepoint action list. If the actual function is ever called,
584 it means that somebody issued the "command" at the top level,
585 which is always an error. */
588 end_actions_pseudocommand (char *args
, int from_tty
)
590 error (_("This command cannot be used at the top level."));
594 while_stepping_pseudocommand (char *args
, int from_tty
)
596 error (_("This command can only be used in a tracepoint actions list."));
600 collect_pseudocommand (char *args
, int from_tty
)
602 error (_("This command can only be used in a tracepoint actions list."));
606 teval_pseudocommand (char *args
, int from_tty
)
608 error (_("This command can only be used in a tracepoint actions list."));
611 /* Parse any collection options, such as /s for strings. */
614 decode_agent_options (const char *exp
)
616 struct value_print_options opts
;
621 /* Call this to borrow the print elements default for collection
623 get_user_print_options (&opts
);
628 if (target_supports_string_tracing ())
630 /* Allow an optional decimal number giving an explicit maximum
631 string length, defaulting it to the "print elements" value;
632 so "collect/s80 mystr" gets at most 80 bytes of string. */
633 trace_string_kludge
= opts
.print_max
;
635 if (*exp
>= '0' && *exp
<= '9')
636 trace_string_kludge
= atoi (exp
);
637 while (*exp
>= '0' && *exp
<= '9')
641 error (_("Target does not support \"/s\" option for string tracing."));
644 error (_("Undefined collection format \"%c\"."), *exp
);
646 exp
= skip_spaces_const (exp
);
651 /* Enter a list of actions for a tracepoint. */
653 trace_actions_command (char *args
, int from_tty
)
655 struct tracepoint
*t
;
656 struct command_line
*l
;
658 t
= get_tracepoint_by_number (&args
, NULL
, 1);
662 xstrprintf ("Enter actions for tracepoint %d, one per line.",
664 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
666 l
= read_command_lines (tmpbuf
, from_tty
, 1,
667 check_tracepoint_command
, t
);
668 do_cleanups (cleanups
);
669 breakpoint_set_commands (&t
->base
, l
);
671 /* else just return */
674 /* Report the results of checking the agent expression, as errors or
678 report_agent_reqs_errors (struct agent_expr
*aexpr
)
680 /* All of the "flaws" are serious bytecode generation issues that
681 should never occur. */
682 if (aexpr
->flaw
!= agent_flaw_none
)
683 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
685 /* If analysis shows a stack underflow, GDB must have done something
686 badly wrong in its bytecode generation. */
687 if (aexpr
->min_height
< 0)
688 internal_error (__FILE__
, __LINE__
,
689 _("expression has min height < 0"));
691 /* Issue this error if the stack is predicted to get too deep. The
692 limit is rather arbitrary; a better scheme might be for the
693 target to report how much stack it will have available. The
694 depth roughly corresponds to parenthesization, so a limit of 20
695 amounts to 20 levels of expression nesting, which is actually
696 a pretty big hairy expression. */
697 if (aexpr
->max_height
> 20)
698 error (_("Expression is too complicated."));
701 /* worker function */
703 validate_actionline (const char *line
, struct breakpoint
*b
)
705 struct cmd_list_element
*c
;
706 struct expression
*exp
= NULL
;
707 struct cleanup
*old_chain
= NULL
;
710 struct bp_location
*loc
;
711 struct agent_expr
*aexpr
;
712 struct tracepoint
*t
= (struct tracepoint
*) b
;
714 /* If EOF is typed, *line is NULL. */
718 p
= skip_spaces_const (line
);
720 /* Symbol lookup etc. */
721 if (*p
== '\0') /* empty line: just prompt for another line. */
724 if (*p
== '#') /* comment line */
727 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
729 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
731 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
733 trace_string_kludge
= 0;
735 p
= decode_agent_options (p
);
738 { /* Repeat over a comma-separated list. */
739 QUIT
; /* Allow user to bail out with ^C. */
740 p
= skip_spaces_const (p
);
742 if (*p
== '$') /* Look for special pseudo-symbols. */
744 if (0 == strncasecmp ("reg", p
+ 1, 3)
745 || 0 == strncasecmp ("arg", p
+ 1, 3)
746 || 0 == strncasecmp ("loc", p
+ 1, 3)
747 || 0 == strncasecmp ("_ret", p
+ 1, 4)
748 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
753 /* else fall thru, treat p as an expression and parse it! */
756 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
759 exp
= parse_exp_1 (&p
, loc
->address
,
760 block_for_pc (loc
->address
), 1);
761 old_chain
= make_cleanup (free_current_contents
, &exp
);
763 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
765 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
767 error (_("constant `%s' (value %s) "
768 "will not be collected."),
769 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
770 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
772 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
773 == LOC_OPTIMIZED_OUT
)
775 error (_("`%s' is optimized away "
776 "and cannot be collected."),
777 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
781 /* We have something to collect, make sure that the expr to
782 bytecode translator can handle it and that it's not too
784 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
785 make_cleanup_free_agent_expr (aexpr
);
787 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
788 error (_("Expression is too complicated."));
792 report_agent_reqs_errors (aexpr
);
794 do_cleanups (old_chain
);
797 while (p
&& *p
++ == ',');
800 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
803 { /* Repeat over a comma-separated list. */
804 QUIT
; /* Allow user to bail out with ^C. */
805 p
= skip_spaces_const (p
);
808 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
812 /* Only expressions are allowed for this action. */
813 exp
= parse_exp_1 (&p
, loc
->address
,
814 block_for_pc (loc
->address
), 1);
815 old_chain
= make_cleanup (free_current_contents
, &exp
);
817 /* We have something to evaluate, make sure that the expr to
818 bytecode translator can handle it and that it's not too
820 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
821 make_cleanup_free_agent_expr (aexpr
);
823 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
824 error (_("Expression is too complicated."));
827 report_agent_reqs_errors (aexpr
);
829 do_cleanups (old_chain
);
832 while (p
&& *p
++ == ',');
835 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
839 p
= skip_spaces_const (p
);
840 t
->step_count
= strtol (p
, &endp
, 0);
841 if (endp
== p
|| t
->step_count
== 0)
842 error (_("while-stepping step count `%s' is malformed."), line
);
846 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
850 error (_("`%s' is not a supported tracepoint action."), line
);
854 memrange_absolute
= -1
859 int type
; /* memrange_absolute for absolute memory range,
860 else basereg number. */
861 bfd_signed_vma start
;
865 struct collection_list
867 unsigned char regs_mask
[32]; /* room for up to 256 regs */
870 struct memrange
*list
;
871 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
873 struct agent_expr
**aexpr_list
;
875 /* True is the user requested a collection of "$_sdata", "static
879 tracepoint_list
, stepping_list
;
881 /* MEMRANGE functions: */
883 static int memrange_cmp (const void *, const void *);
885 /* Compare memranges for qsort. */
887 memrange_cmp (const void *va
, const void *vb
)
889 const struct memrange
*a
= va
, *b
= vb
;
891 if (a
->type
< b
->type
)
893 if (a
->type
> b
->type
)
895 if (a
->type
== memrange_absolute
)
897 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
899 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
904 if (a
->start
< b
->start
)
906 if (a
->start
> b
->start
)
912 /* Sort the memrange list using qsort, and merge adjacent memranges. */
914 memrange_sortmerge (struct collection_list
*memranges
)
918 qsort (memranges
->list
, memranges
->next_memrange
,
919 sizeof (struct memrange
), memrange_cmp
);
920 if (memranges
->next_memrange
> 0)
922 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
924 /* If memrange b overlaps or is adjacent to memrange a,
926 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
927 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
929 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
930 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
931 continue; /* next b, same a */
935 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
936 sizeof (struct memrange
));
938 memranges
->next_memrange
= a
+ 1;
942 /* Add a register to a collection list. */
944 add_register (struct collection_list
*collection
, unsigned int regno
)
947 printf_filtered ("collect register %d\n", regno
);
948 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
949 error (_("Internal: register number %d too large for tracepoint"),
951 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
954 /* Add a memrange to a collection list. */
956 add_memrange (struct collection_list
*memranges
,
957 int type
, bfd_signed_vma base
,
962 printf_filtered ("(%d,", type
);
964 printf_filtered (",%ld)\n", len
);
967 /* type: memrange_absolute == memory, other n == basereg */
968 memranges
->list
[memranges
->next_memrange
].type
= type
;
969 /* base: addr if memory, offset if reg relative. */
970 memranges
->list
[memranges
->next_memrange
].start
= base
;
971 /* len: we actually save end (base + len) for convenience */
972 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
973 memranges
->next_memrange
++;
974 if (memranges
->next_memrange
>= memranges
->listsize
)
976 memranges
->listsize
*= 2;
977 memranges
->list
= xrealloc (memranges
->list
,
978 memranges
->listsize
);
981 if (type
!= memrange_absolute
) /* Better collect the base register! */
982 add_register (memranges
, type
);
985 /* Add a symbol to a collection list. */
987 collect_symbol (struct collection_list
*collect
,
989 struct gdbarch
*gdbarch
,
990 long frame_regno
, long frame_offset
,
995 bfd_signed_vma offset
;
996 int treat_as_expr
= 0;
998 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
999 switch (SYMBOL_CLASS (sym
))
1002 printf_filtered ("%s: don't know symbol class %d\n",
1003 SYMBOL_PRINT_NAME (sym
),
1004 SYMBOL_CLASS (sym
));
1007 printf_filtered ("constant %s (value %s) will not be collected.\n",
1008 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
1011 offset
= SYMBOL_VALUE_ADDRESS (sym
);
1016 sprintf_vma (tmp
, offset
);
1017 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1018 SYMBOL_PRINT_NAME (sym
), len
,
1021 /* A struct may be a C++ class with static fields, go to general
1022 expression handling. */
1023 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
1026 add_memrange (collect
, memrange_absolute
, offset
, len
);
1029 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1031 printf_filtered ("LOC_REG[parm] %s: ",
1032 SYMBOL_PRINT_NAME (sym
));
1033 add_register (collect
, reg
);
1034 /* Check for doubles stored in two registers. */
1035 /* FIXME: how about larger types stored in 3 or more regs? */
1036 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1037 len
> register_size (gdbarch
, reg
))
1038 add_register (collect
, reg
+ 1);
1041 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1042 printf_filtered (" (will not collect %s)\n",
1043 SYMBOL_PRINT_NAME (sym
));
1047 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1050 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1051 SYMBOL_PRINT_NAME (sym
), len
);
1052 printf_vma (offset
);
1053 printf_filtered (" from frame ptr reg %d\n", reg
);
1055 add_memrange (collect
, reg
, offset
, len
);
1057 case LOC_REGPARM_ADDR
:
1058 reg
= SYMBOL_VALUE (sym
);
1062 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1063 SYMBOL_PRINT_NAME (sym
), len
);
1064 printf_vma (offset
);
1065 printf_filtered (" from reg %d\n", reg
);
1067 add_memrange (collect
, reg
, offset
, len
);
1071 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1074 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1075 SYMBOL_PRINT_NAME (sym
), len
);
1076 printf_vma (offset
);
1077 printf_filtered (" from frame ptr reg %d\n", reg
);
1079 add_memrange (collect
, reg
, offset
, len
);
1082 case LOC_UNRESOLVED
:
1086 case LOC_OPTIMIZED_OUT
:
1087 printf_filtered ("%s has been optimized out of existence.\n",
1088 SYMBOL_PRINT_NAME (sym
));
1096 /* Expressions are the most general case. */
1099 struct agent_expr
*aexpr
;
1100 struct cleanup
*old_chain1
= NULL
;
1102 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
1104 /* It can happen that the symbol is recorded as a computed
1105 location, but it's been optimized away and doesn't actually
1106 have a location expression. */
1109 printf_filtered ("%s has been optimized out of existence.\n",
1110 SYMBOL_PRINT_NAME (sym
));
1114 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1118 report_agent_reqs_errors (aexpr
);
1120 discard_cleanups (old_chain1
);
1121 add_aexpr (collect
, aexpr
);
1123 /* Take care of the registers. */
1124 if (aexpr
->reg_mask_len
> 0)
1128 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1130 QUIT
; /* Allow user to bail out with ^C. */
1131 if (aexpr
->reg_mask
[ndx1
] != 0)
1133 /* Assume chars have 8 bits. */
1134 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1135 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1136 /* It's used -- record it. */
1137 add_register (collect
, ndx1
* 8 + ndx2
);
1144 /* Data to be passed around in the calls to the locals and args
1147 struct add_local_symbols_data
1149 struct collection_list
*collect
;
1150 struct gdbarch
*gdbarch
;
1157 /* The callback for the locals and args iterators. */
1160 do_collect_symbol (const char *print_name
,
1164 struct add_local_symbols_data
*p
= cb_data
;
1166 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1167 p
->frame_offset
, p
->pc
);
1171 /* Add all locals (or args) symbols to collection list. */
1173 add_local_symbols (struct collection_list
*collect
,
1174 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1175 long frame_regno
, long frame_offset
, int type
)
1177 struct block
*block
;
1178 struct add_local_symbols_data cb_data
;
1180 cb_data
.collect
= collect
;
1181 cb_data
.gdbarch
= gdbarch
;
1183 cb_data
.frame_regno
= frame_regno
;
1184 cb_data
.frame_offset
= frame_offset
;
1189 block
= block_for_pc (pc
);
1192 warning (_("Can't collect locals; "
1193 "no symbol table info available.\n"));
1197 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1198 if (cb_data
.count
== 0)
1199 warning (_("No locals found in scope."));
1203 pc
= get_pc_function_start (pc
);
1204 block
= block_for_pc (pc
);
1207 warning (_("Can't collect args; no symbol table info available."));
1211 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1212 if (cb_data
.count
== 0)
1213 warning (_("No args found in scope."));
1218 add_static_trace_data (struct collection_list
*collection
)
1221 printf_filtered ("collect static trace data\n");
1222 collection
->strace_data
= 1;
1225 /* worker function */
1227 clear_collection_list (struct collection_list
*list
)
1231 list
->next_memrange
= 0;
1232 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1234 free_agent_expr (list
->aexpr_list
[ndx
]);
1235 list
->aexpr_list
[ndx
] = NULL
;
1237 list
->next_aexpr_elt
= 0;
1238 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1239 list
->strace_data
= 0;
1242 /* Reduce a collection list to string form (for gdb protocol). */
1244 stringify_collection_list (struct collection_list
*list
, char *string
)
1246 char temp_buf
[2048];
1250 char *(*str_list
)[];
1254 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1255 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1257 if (list
->strace_data
)
1260 printf_filtered ("\nCollecting static trace data\n");
1263 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1267 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1268 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1270 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1273 printf_filtered ("\nCollecting registers (mask): 0x");
1278 QUIT
; /* Allow user to bail out with ^C. */
1280 printf_filtered ("%02X", list
->regs_mask
[i
]);
1281 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1284 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1288 printf_filtered ("\n");
1289 if (list
->next_memrange
> 0 && info_verbose
)
1290 printf_filtered ("Collecting memranges: \n");
1291 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1293 QUIT
; /* Allow user to bail out with ^C. */
1294 sprintf_vma (tmp2
, list
->list
[i
].start
);
1297 printf_filtered ("(%d, %s, %ld)\n",
1300 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1302 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1304 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1311 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1313 /* The "%X" conversion specifier expects an unsigned argument,
1314 so passing -1 (memrange_absolute) to it directly gives you
1315 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1317 if (list
->list
[i
].type
== memrange_absolute
)
1318 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1320 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1323 count
+= strlen (end
);
1324 end
= temp_buf
+ count
;
1327 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1329 QUIT
; /* Allow user to bail out with ^C. */
1330 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1332 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1337 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1338 end
+= 10; /* 'X' + 8 hex digits + ',' */
1341 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1342 end
, list
->aexpr_list
[i
]->len
);
1343 count
+= 2 * list
->aexpr_list
[i
]->len
;
1348 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1353 (*str_list
)[ndx
] = NULL
;
1366 encode_actions_1 (struct command_line
*action
,
1367 struct breakpoint
*t
,
1368 struct bp_location
*tloc
,
1370 LONGEST frame_offset
,
1371 struct collection_list
*collect
,
1372 struct collection_list
*stepping_list
)
1374 const char *action_exp
;
1375 struct expression
*exp
= NULL
;
1377 struct value
*tempval
;
1378 struct cmd_list_element
*cmd
;
1379 struct agent_expr
*aexpr
;
1381 for (; action
; action
= action
->next
)
1383 QUIT
; /* Allow user to bail out with ^C. */
1384 action_exp
= action
->line
;
1385 action_exp
= skip_spaces_const (action_exp
);
1387 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1389 error (_("Bad action list item: %s"), action_exp
);
1391 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1393 trace_string_kludge
= 0;
1394 if (*action_exp
== '/')
1395 action_exp
= decode_agent_options (action_exp
);
1398 { /* Repeat over a comma-separated list. */
1399 QUIT
; /* Allow user to bail out with ^C. */
1400 action_exp
= skip_spaces_const (action_exp
);
1402 if (0 == strncasecmp ("$reg", action_exp
, 4))
1404 for (i
= 0; i
< gdbarch_num_regs (tloc
->gdbarch
); i
++)
1405 add_register (collect
, i
);
1406 action_exp
= strchr (action_exp
, ','); /* more? */
1408 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1410 add_local_symbols (collect
,
1416 action_exp
= strchr (action_exp
, ','); /* more? */
1418 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1420 add_local_symbols (collect
,
1426 action_exp
= strchr (action_exp
, ','); /* more? */
1428 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1430 struct cleanup
*old_chain1
= NULL
;
1432 aexpr
= gen_trace_for_return_address (tloc
->address
,
1435 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1438 report_agent_reqs_errors (aexpr
);
1440 discard_cleanups (old_chain1
);
1441 add_aexpr (collect
, aexpr
);
1443 /* take care of the registers */
1444 if (aexpr
->reg_mask_len
> 0)
1448 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1450 QUIT
; /* allow user to bail out with ^C */
1451 if (aexpr
->reg_mask
[ndx1
] != 0)
1453 /* assume chars have 8 bits */
1454 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1455 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1456 /* it's used -- record it */
1457 add_register (collect
,
1463 action_exp
= strchr (action_exp
, ','); /* more? */
1465 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1467 add_static_trace_data (collect
);
1468 action_exp
= strchr (action_exp
, ','); /* more? */
1473 struct cleanup
*old_chain
= NULL
;
1474 struct cleanup
*old_chain1
= NULL
;
1476 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1477 block_for_pc (tloc
->address
), 1);
1478 old_chain
= make_cleanup (free_current_contents
, &exp
);
1480 switch (exp
->elts
[0].opcode
)
1484 const char *name
= &exp
->elts
[2].string
;
1486 i
= user_reg_map_name_to_regnum (tloc
->gdbarch
,
1487 name
, strlen (name
));
1489 internal_error (__FILE__
, __LINE__
,
1490 _("Register $%s not available"),
1493 printf_filtered ("OP_REGISTER: ");
1494 add_register (collect
, i
);
1499 /* Safe because we know it's a simple expression. */
1500 tempval
= evaluate_expression (exp
);
1501 addr
= value_address (tempval
);
1502 /* Initialize the TYPE_LENGTH if it is a typedef. */
1503 check_typedef (exp
->elts
[1].type
);
1504 add_memrange (collect
, memrange_absolute
, addr
,
1505 TYPE_LENGTH (exp
->elts
[1].type
));
1509 collect_symbol (collect
,
1510 exp
->elts
[2].symbol
,
1517 default: /* Full-fledged expression. */
1518 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1520 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1524 report_agent_reqs_errors (aexpr
);
1526 discard_cleanups (old_chain1
);
1527 add_aexpr (collect
, aexpr
);
1529 /* Take care of the registers. */
1530 if (aexpr
->reg_mask_len
> 0)
1535 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1537 QUIT
; /* Allow user to bail out with ^C. */
1538 if (aexpr
->reg_mask
[ndx1
] != 0)
1540 /* Assume chars have 8 bits. */
1541 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1542 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1543 /* It's used -- record it. */
1544 add_register (collect
,
1551 do_cleanups (old_chain
);
1554 while (action_exp
&& *action_exp
++ == ',');
1556 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1559 { /* Repeat over a comma-separated list. */
1560 QUIT
; /* Allow user to bail out with ^C. */
1561 action_exp
= skip_spaces_const (action_exp
);
1564 struct cleanup
*old_chain
= NULL
;
1565 struct cleanup
*old_chain1
= NULL
;
1567 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1568 block_for_pc (tloc
->address
), 1);
1569 old_chain
= make_cleanup (free_current_contents
, &exp
);
1571 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1572 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1575 report_agent_reqs_errors (aexpr
);
1577 discard_cleanups (old_chain1
);
1578 /* Even though we're not officially collecting, add
1579 to the collect list anyway. */
1580 add_aexpr (collect
, aexpr
);
1582 do_cleanups (old_chain
);
1585 while (action_exp
&& *action_exp
++ == ',');
1587 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1589 /* We check against nested while-stepping when setting
1590 breakpoint action, so no way to run into nested
1592 gdb_assert (stepping_list
);
1594 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
,
1595 frame_offset
, stepping_list
, NULL
);
1598 error (_("Invalid tracepoint command '%s'"), action
->line
);
1602 /* Render all actions into gdb protocol. */
1605 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1606 char ***tdp_actions
, char ***stepping_actions
)
1608 static char tdp_buff
[2048], step_buff
[2048];
1609 char *default_collect_line
= NULL
;
1610 struct command_line
*actions
;
1611 struct command_line
*default_collect_action
= NULL
;
1613 LONGEST frame_offset
;
1614 struct cleanup
*back_to
;
1616 back_to
= make_cleanup (null_cleanup
, NULL
);
1618 clear_collection_list (&tracepoint_list
);
1619 clear_collection_list (&stepping_list
);
1621 *tdp_actions
= NULL
;
1622 *stepping_actions
= NULL
;
1624 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1625 tloc
->address
, &frame_reg
, &frame_offset
);
1627 actions
= breakpoint_commands (t
);
1629 /* If there are default expressions to collect, make up a collect
1630 action and prepend to the action list to encode. Note that since
1631 validation is per-tracepoint (local var "xyz" might be valid for
1632 one tracepoint and not another, etc), we make up the action on
1633 the fly, and don't cache it. */
1634 if (*default_collect
)
1636 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1637 make_cleanup (xfree
, default_collect_line
);
1639 validate_actionline (default_collect_line
, t
);
1641 default_collect_action
= xmalloc (sizeof (struct command_line
));
1642 make_cleanup (xfree
, default_collect_action
);
1643 default_collect_action
->next
= actions
;
1644 default_collect_action
->line
= default_collect_line
;
1645 actions
= default_collect_action
;
1647 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1648 &tracepoint_list
, &stepping_list
);
1650 memrange_sortmerge (&tracepoint_list
);
1651 memrange_sortmerge (&stepping_list
);
1653 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1655 *stepping_actions
= stringify_collection_list (&stepping_list
,
1658 do_cleanups (back_to
);
1662 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1664 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1666 collect
->aexpr_list
=
1667 xrealloc (collect
->aexpr_list
,
1668 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1669 collect
->aexpr_listsize
*= 2;
1671 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1672 collect
->next_aexpr_elt
++;
1676 process_tracepoint_on_disconnect (void)
1678 VEC(breakpoint_p
) *tp_vec
= NULL
;
1680 struct breakpoint
*b
;
1681 int has_pending_p
= 0;
1683 /* Check whether we still have pending tracepoint. If we have, warn the
1684 user that pending tracepoint will no longer work. */
1685 tp_vec
= all_tracepoints ();
1686 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1695 struct bp_location
*loc1
;
1697 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1699 if (loc1
->shlib_disabled
)
1710 VEC_free (breakpoint_p
, tp_vec
);
1713 warning (_("Pending tracepoints will not be resolved while"
1714 " GDB is disconnected\n"));
1719 start_tracing (char *notes
)
1721 VEC(breakpoint_p
) *tp_vec
= NULL
;
1723 struct breakpoint
*b
;
1724 struct trace_state_variable
*tsv
;
1725 int any_enabled
= 0, num_to_download
= 0;
1728 tp_vec
= all_tracepoints ();
1730 /* No point in tracing without any tracepoints... */
1731 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1733 VEC_free (breakpoint_p
, tp_vec
);
1734 error (_("No tracepoints defined, not starting trace"));
1737 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1739 struct tracepoint
*t
= (struct tracepoint
*) b
;
1740 struct bp_location
*loc
;
1742 if (b
->enable_state
== bp_enabled
)
1745 if ((b
->type
== bp_fast_tracepoint
1746 ? may_insert_fast_tracepoints
1747 : may_insert_tracepoints
))
1750 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1751 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1756 if (target_supports_enable_disable_tracepoint ())
1757 warning (_("No tracepoints enabled"));
1760 /* No point in tracing with only disabled tracepoints that
1761 cannot be re-enabled. */
1762 VEC_free (breakpoint_p
, tp_vec
);
1763 error (_("No tracepoints enabled, not starting trace"));
1767 if (num_to_download
<= 0)
1769 VEC_free (breakpoint_p
, tp_vec
);
1770 error (_("No tracepoints that may be downloaded, not starting trace"));
1773 target_trace_init ();
1775 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1777 struct tracepoint
*t
= (struct tracepoint
*) b
;
1778 struct bp_location
*loc
;
1779 int bp_location_downloaded
= 0;
1781 /* Clear `inserted' flag. */
1782 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1785 if ((b
->type
== bp_fast_tracepoint
1786 ? !may_insert_fast_tracepoints
1787 : !may_insert_tracepoints
))
1790 t
->number_on_target
= 0;
1792 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1794 /* Since tracepoint locations are never duplicated, `inserted'
1795 flag should be zero. */
1796 gdb_assert (!loc
->inserted
);
1798 target_download_tracepoint (loc
);
1801 bp_location_downloaded
= 1;
1804 t
->number_on_target
= b
->number
;
1806 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1807 if (loc
->probe
!= NULL
)
1808 loc
->probe
->pops
->set_semaphore (loc
->probe
, loc
->gdbarch
);
1810 if (bp_location_downloaded
)
1811 observer_notify_breakpoint_modified (b
);
1813 VEC_free (breakpoint_p
, tp_vec
);
1815 /* Send down all the trace state variables too. */
1816 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1818 target_download_trace_state_variable (tsv
);
1821 /* Tell target to treat text-like sections as transparent. */
1822 target_trace_set_readonly_regions ();
1823 /* Set some mode flags. */
1824 target_set_disconnected_tracing (disconnected_tracing
);
1825 target_set_circular_trace_buffer (circular_trace_buffer
);
1826 target_set_trace_buffer_size (trace_buffer_size
);
1829 notes
= trace_notes
;
1830 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1832 if (!ret
&& (trace_user
|| notes
))
1833 warning (_("Target does not support trace user/notes, info ignored"));
1835 /* Now insert traps and begin collecting data. */
1836 target_trace_start ();
1838 /* Reset our local state. */
1839 set_traceframe_num (-1);
1840 set_tracepoint_num (-1);
1841 set_traceframe_context (NULL
);
1842 current_trace_status()->running
= 1;
1843 clear_traceframe_info ();
1846 /* The tstart command requests the target to start a new trace run.
1847 The command passes any arguments it has to the target verbatim, as
1848 an optional "trace note". This is useful as for instance a warning
1849 to other users if the trace runs disconnected, and you don't want
1850 anybody else messing with the target. */
1853 trace_start_command (char *args
, int from_tty
)
1855 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1857 if (current_trace_status ()->running
)
1860 && !query (_("A trace is running already. Start a new run? ")))
1861 error (_("New trace run not started."));
1864 start_tracing (args
);
1867 /* The tstop command stops the tracing run. The command passes any
1868 supplied arguments to the target verbatim as a "stop note"; if the
1869 target supports trace notes, then it will be reported back as part
1870 of the trace run's status. */
1873 trace_stop_command (char *args
, int from_tty
)
1875 if (!current_trace_status ()->running
)
1876 error (_("Trace is not running."));
1878 stop_tracing (args
);
1882 stop_tracing (char *note
)
1885 VEC(breakpoint_p
) *tp_vec
= NULL
;
1887 struct breakpoint
*t
;
1889 target_trace_stop ();
1891 tp_vec
= all_tracepoints ();
1892 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1894 struct bp_location
*loc
;
1896 if ((t
->type
== bp_fast_tracepoint
1897 ? !may_insert_fast_tracepoints
1898 : !may_insert_tracepoints
))
1901 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1903 /* GDB can be totally absent in some disconnected trace scenarios,
1904 but we don't really care if this semaphore goes out of sync.
1905 That's why we are decrementing it here, but not taking care
1907 if (loc
->probe
!= NULL
)
1908 loc
->probe
->pops
->clear_semaphore (loc
->probe
, loc
->gdbarch
);
1912 VEC_free (breakpoint_p
, tp_vec
);
1915 note
= trace_stop_notes
;
1916 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1919 warning (_("Target does not support trace notes, note ignored"));
1921 /* Should change in response to reply? */
1922 current_trace_status ()->running
= 0;
1925 /* tstatus command */
1927 trace_status_command (char *args
, int from_tty
)
1929 struct trace_status
*ts
= current_trace_status ();
1931 VEC(breakpoint_p
) *tp_vec
= NULL
;
1932 struct breakpoint
*t
;
1934 status
= target_get_trace_status (ts
);
1938 if (ts
->filename
!= NULL
)
1939 printf_filtered (_("Using a trace file.\n"));
1942 printf_filtered (_("Trace can not be run on this target.\n"));
1947 if (!ts
->running_known
)
1949 printf_filtered (_("Run/stop status is unknown.\n"));
1951 else if (ts
->running
)
1953 printf_filtered (_("Trace is running on the target.\n"));
1957 switch (ts
->stop_reason
)
1959 case trace_never_run
:
1960 printf_filtered (_("No trace has been run on the target.\n"));
1964 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1967 printf_filtered (_("Trace stopped by a tstop command.\n"));
1969 case trace_buffer_full
:
1970 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1972 case trace_disconnected
:
1973 printf_filtered (_("Trace stopped because of disconnection.\n"));
1975 case tracepoint_passcount
:
1976 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1977 ts
->stopping_tracepoint
);
1979 case tracepoint_error
:
1980 if (ts
->stopping_tracepoint
)
1981 printf_filtered (_("Trace stopped by an "
1982 "error (%s, tracepoint %d).\n"),
1983 ts
->stop_desc
, ts
->stopping_tracepoint
);
1985 printf_filtered (_("Trace stopped by an error (%s).\n"),
1988 case trace_stop_reason_unknown
:
1989 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1992 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1998 if (ts
->traceframes_created
>= 0
1999 && ts
->traceframe_count
!= ts
->traceframes_created
)
2001 printf_filtered (_("Buffer contains %d trace "
2002 "frames (of %d created total).\n"),
2003 ts
->traceframe_count
, ts
->traceframes_created
);
2005 else if (ts
->traceframe_count
>= 0)
2007 printf_filtered (_("Collected %d trace frames.\n"),
2008 ts
->traceframe_count
);
2011 if (ts
->buffer_free
>= 0)
2013 if (ts
->buffer_size
>= 0)
2015 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2016 ts
->buffer_free
, ts
->buffer_size
);
2017 if (ts
->buffer_size
> 0)
2018 printf_filtered (_(" (%d%% full)"),
2019 ((int) ((((long long) (ts
->buffer_size
2020 - ts
->buffer_free
)) * 100)
2021 / ts
->buffer_size
)));
2022 printf_filtered (_(".\n"));
2025 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2029 if (ts
->disconnected_tracing
)
2030 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2032 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2034 if (ts
->circular_buffer
)
2035 printf_filtered (_("Trace buffer is circular.\n"));
2037 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
2038 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
2040 if (ts
->notes
&& strlen (ts
->notes
) > 0)
2041 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
2043 /* Now report on what we're doing with tfind. */
2044 if (traceframe_number
>= 0)
2045 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2046 traceframe_number
, tracepoint_number
);
2048 printf_filtered (_("Not looking at any trace frame.\n"));
2050 /* Report start/stop times if supplied. */
2055 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
2057 /* Reporting a run time is more readable than two long numbers. */
2058 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2059 (long int) ts
->start_time
/ 1000000,
2060 (long int) ts
->start_time
% 1000000,
2061 (long int) run_time
/ 1000000,
2062 (long int) run_time
% 1000000);
2065 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2066 (long int) ts
->start_time
/ 1000000,
2067 (long int) ts
->start_time
% 1000000);
2069 else if (ts
->stop_time
)
2070 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2071 (long int) ts
->stop_time
/ 1000000,
2072 (long int) ts
->stop_time
% 1000000);
2074 /* Now report any per-tracepoint status available. */
2075 tp_vec
= all_tracepoints ();
2077 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2078 target_get_tracepoint_status (t
, NULL
);
2080 VEC_free (breakpoint_p
, tp_vec
);
2083 /* Report the trace status to uiout, in a way suitable for MI, and not
2084 suitable for CLI. If ON_STOP is true, suppress a few fields that
2085 are not meaningful in the -trace-stop response.
2087 The implementation is essentially parallel to trace_status_command, but
2088 merging them will result in unreadable code. */
2090 trace_status_mi (int on_stop
)
2092 struct ui_out
*uiout
= current_uiout
;
2093 struct trace_status
*ts
= current_trace_status ();
2096 status
= target_get_trace_status (ts
);
2098 if (status
== -1 && ts
->filename
== NULL
)
2100 ui_out_field_string (uiout
, "supported", "0");
2104 if (ts
->filename
!= NULL
)
2105 ui_out_field_string (uiout
, "supported", "file");
2107 ui_out_field_string (uiout
, "supported", "1");
2109 if (ts
->filename
!= NULL
)
2110 ui_out_field_string (uiout
, "trace-file", ts
->filename
);
2112 gdb_assert (ts
->running_known
);
2116 ui_out_field_string (uiout
, "running", "1");
2118 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2119 Given that the frontend gets the status either on -trace-stop, or from
2120 -trace-status after re-connection, it does not seem like this
2121 information is necessary for anything. It is not necessary for either
2122 figuring the vital state of the target nor for navigation of trace
2123 frames. If the frontend wants to show the current state is some
2124 configure dialog, it can request the value when such dialog is
2125 invoked by the user. */
2129 char *stop_reason
= NULL
;
2130 int stopping_tracepoint
= -1;
2133 ui_out_field_string (uiout
, "running", "0");
2135 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2137 switch (ts
->stop_reason
)
2140 stop_reason
= "request";
2142 case trace_buffer_full
:
2143 stop_reason
= "overflow";
2145 case trace_disconnected
:
2146 stop_reason
= "disconnection";
2148 case tracepoint_passcount
:
2149 stop_reason
= "passcount";
2150 stopping_tracepoint
= ts
->stopping_tracepoint
;
2152 case tracepoint_error
:
2153 stop_reason
= "error";
2154 stopping_tracepoint
= ts
->stopping_tracepoint
;
2160 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2161 if (stopping_tracepoint
!= -1)
2162 ui_out_field_int (uiout
, "stopping-tracepoint",
2163 stopping_tracepoint
);
2164 if (ts
->stop_reason
== tracepoint_error
)
2165 ui_out_field_string (uiout
, "error-description",
2171 if (ts
->traceframe_count
!= -1)
2172 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2173 if (ts
->traceframes_created
!= -1)
2174 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2175 if (ts
->buffer_size
!= -1)
2176 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2177 if (ts
->buffer_free
!= -1)
2178 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2180 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2181 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2183 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2184 ui_out_field_string (uiout
, "notes", ts
->notes
);
2189 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2190 (long int) ts
->start_time
/ 1000000,
2191 (long int) ts
->start_time
% 1000000);
2192 ui_out_field_string (uiout
, "start-time", buf
);
2193 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2194 (long int) ts
->stop_time
/ 1000000,
2195 (long int) ts
->stop_time
% 1000000);
2196 ui_out_field_string (uiout
, "stop-time", buf
);
2200 /* This function handles the details of what to do about an ongoing
2201 tracing run if the user has asked to detach or otherwise disconnect
2204 disconnect_tracing (int from_tty
)
2206 /* It can happen that the target that was tracing went away on its
2207 own, and we didn't notice. Get a status update, and if the
2208 current target doesn't even do tracing, then assume it's not
2210 if (target_get_trace_status (current_trace_status ()) < 0)
2211 current_trace_status ()->running
= 0;
2213 /* If running interactively, give the user the option to cancel and
2214 then decide what to do differently with the run. Scripts are
2215 just going to disconnect and let the target deal with it,
2216 according to how it's been instructed previously via
2217 disconnected-tracing. */
2218 if (current_trace_status ()->running
&& from_tty
)
2220 process_tracepoint_on_disconnect ();
2222 if (current_trace_status ()->disconnected_tracing
)
2224 if (!query (_("Trace is running and will "
2225 "continue after detach; detach anyway? ")))
2226 error (_("Not confirmed."));
2230 if (!query (_("Trace is running but will "
2231 "stop on detach; detach anyway? ")))
2232 error (_("Not confirmed."));
2236 /* Also we want to be out of tfind mode, otherwise things can get
2237 confusing upon reconnection. Just use these calls instead of
2238 full tfind_1 behavior because we're in the middle of detaching,
2239 and there's no point to updating current stack frame etc. */
2240 set_current_traceframe (-1);
2241 set_tracepoint_num (-1);
2242 set_traceframe_context (NULL
);
2245 /* Worker function for the various flavors of the tfind command. */
2247 tfind_1 (enum trace_find_type type
, int num
,
2248 ULONGEST addr1
, ULONGEST addr2
,
2251 int target_frameno
= -1, target_tracept
= -1;
2252 struct frame_id old_frame_id
= null_frame_id
;
2253 struct tracepoint
*tp
;
2254 struct ui_out
*uiout
= current_uiout
;
2256 /* Only try to get the current stack frame if we have a chance of
2257 succeeding. In particular, if we're trying to get a first trace
2258 frame while all threads are running, it's not going to succeed,
2259 so leave it with a default value and let the frame comparison
2260 below (correctly) decide to print out the source location of the
2262 if (!(type
== tfind_number
&& num
== -1)
2263 && (has_stack_frames () || traceframe_number
>= 0))
2264 old_frame_id
= get_frame_id (get_current_frame ());
2266 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2269 if (type
== tfind_number
2271 && target_frameno
== -1)
2273 /* We told the target to get out of tfind mode, and it did. */
2275 else if (target_frameno
== -1)
2277 /* A request for a non-existent trace frame has failed.
2278 Our response will be different, depending on FROM_TTY:
2280 If FROM_TTY is true, meaning that this command was
2281 typed interactively by the user, then give an error
2282 and DO NOT change the state of traceframe_number etc.
2284 However if FROM_TTY is false, meaning that we're either
2285 in a script, a loop, or a user-defined command, then
2286 DON'T give an error, but DO change the state of
2287 traceframe_number etc. to invalid.
2289 The rationalle is that if you typed the command, you
2290 might just have committed a typo or something, and you'd
2291 like to NOT lose your current debugging state. However
2292 if you're in a user-defined command or especially in a
2293 loop, then you need a way to detect that the command
2294 failed WITHOUT aborting. This allows you to write
2295 scripts that search thru the trace buffer until the end,
2296 and then continue on to do something else. */
2299 error (_("Target failed to find requested trace frame."));
2303 printf_filtered ("End of trace buffer.\n");
2304 #if 0 /* dubious now? */
2305 /* The following will not recurse, since it's
2307 trace_find_command ("-1", from_tty
);
2312 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2314 reinit_frame_cache ();
2315 target_dcache_invalidate ();
2317 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2319 if (target_frameno
!= get_traceframe_number ())
2320 observer_notify_traceframe_changed (target_frameno
, tracepoint_number
);
2322 set_current_traceframe (target_frameno
);
2324 if (target_frameno
== -1)
2325 set_traceframe_context (NULL
);
2327 set_traceframe_context (get_current_frame ());
2329 if (traceframe_number
>= 0)
2331 /* Use different branches for MI and CLI to make CLI messages
2333 if (ui_out_is_mi_like_p (uiout
))
2335 ui_out_field_string (uiout
, "found", "1");
2336 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2337 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2341 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2342 traceframe_number
, tracepoint_number
);
2347 if (ui_out_is_mi_like_p (uiout
))
2348 ui_out_field_string (uiout
, "found", "0");
2349 else if (type
== tfind_number
&& num
== -1)
2350 printf_unfiltered (_("No longer looking at any trace frame\n"));
2351 else /* This case may never occur, check. */
2352 printf_unfiltered (_("No trace frame found\n"));
2355 /* If we're in nonstop mode and getting out of looking at trace
2356 frames, there won't be any current frame to go back to and
2359 && (has_stack_frames () || traceframe_number
>= 0))
2361 enum print_what print_what
;
2363 /* NOTE: in imitation of the step command, try to determine
2364 whether we have made a transition from one function to
2365 another. If so, we'll print the "stack frame" (ie. the new
2366 function and it's arguments) -- otherwise we'll just show the
2369 if (frame_id_eq (old_frame_id
,
2370 get_frame_id (get_current_frame ())))
2371 print_what
= SRC_LINE
;
2373 print_what
= SRC_AND_LOC
;
2375 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2380 /* trace_find_command takes a trace frame number n,
2381 sends "QTFrame:<n>" to the target,
2382 and accepts a reply that may contain several optional pieces
2383 of information: a frame number, a tracepoint number, and an
2384 indication of whether this is a trap frame or a stepping frame.
2386 The minimal response is just "OK" (which indicates that the
2387 target does not give us a frame number or a tracepoint number).
2388 Instead of that, the target may send us a string containing
2390 F<hexnum> (gives the selected frame number)
2391 T<hexnum> (gives the selected tracepoint number)
2396 trace_find_command (char *args
, int from_tty
)
2397 { /* This should only be called with a numeric argument. */
2400 if (current_trace_status ()->running
2401 && current_trace_status ()->filename
== NULL
)
2402 error (_("May not look at trace frames while trace is running."));
2404 if (args
== 0 || *args
== 0)
2405 { /* TFIND with no args means find NEXT trace frame. */
2406 if (traceframe_number
== -1)
2407 frameno
= 0; /* "next" is first one. */
2409 frameno
= traceframe_number
+ 1;
2411 else if (0 == strcmp (args
, "-"))
2413 if (traceframe_number
== -1)
2414 error (_("not debugging trace buffer"));
2415 else if (from_tty
&& traceframe_number
== 0)
2416 error (_("already at start of trace buffer"));
2418 frameno
= traceframe_number
- 1;
2420 /* A hack to work around eval's need for fp to have been collected. */
2421 else if (0 == strcmp (args
, "-1"))
2424 frameno
= parse_and_eval_long (args
);
2427 error (_("invalid input (%d is less than zero)"), frameno
);
2429 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2434 trace_find_end_command (char *args
, int from_tty
)
2436 trace_find_command ("-1", from_tty
);
2441 trace_find_start_command (char *args
, int from_tty
)
2443 trace_find_command ("0", from_tty
);
2446 /* tfind pc command */
2448 trace_find_pc_command (char *args
, int from_tty
)
2452 if (current_trace_status ()->running
2453 && current_trace_status ()->filename
== NULL
)
2454 error (_("May not look at trace frames while trace is running."));
2456 if (args
== 0 || *args
== 0)
2457 pc
= regcache_read_pc (get_current_regcache ());
2459 pc
= parse_and_eval_address (args
);
2461 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2464 /* tfind tracepoint command */
2466 trace_find_tracepoint_command (char *args
, int from_tty
)
2469 struct tracepoint
*tp
;
2471 if (current_trace_status ()->running
2472 && current_trace_status ()->filename
== NULL
)
2473 error (_("May not look at trace frames while trace is running."));
2475 if (args
== 0 || *args
== 0)
2477 if (tracepoint_number
== -1)
2478 error (_("No current tracepoint -- please supply an argument."));
2480 tdp
= tracepoint_number
; /* Default is current TDP. */
2483 tdp
= parse_and_eval_long (args
);
2485 /* If we have the tracepoint on hand, use the number that the
2486 target knows about (which may be different if we disconnected
2487 and reconnected). */
2488 tp
= get_tracepoint (tdp
);
2490 tdp
= tp
->number_on_target
;
2492 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2495 /* TFIND LINE command:
2497 This command will take a sourceline for argument, just like BREAK
2498 or TRACE (ie. anything that "decode_line_1" can handle).
2500 With no argument, this command will find the next trace frame
2501 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2504 trace_find_line_command (char *args
, int from_tty
)
2506 static CORE_ADDR start_pc
, end_pc
;
2507 struct symtabs_and_lines sals
;
2508 struct symtab_and_line sal
;
2509 struct cleanup
*old_chain
;
2511 if (current_trace_status ()->running
2512 && current_trace_status ()->filename
== NULL
)
2513 error (_("May not look at trace frames while trace is running."));
2515 if (args
== 0 || *args
== 0)
2517 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2519 sals
.sals
= (struct symtab_and_line
*)
2520 xmalloc (sizeof (struct symtab_and_line
));
2525 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2529 old_chain
= make_cleanup (xfree
, sals
.sals
);
2530 if (sal
.symtab
== 0)
2531 error (_("No line number information available."));
2533 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2535 if (start_pc
== end_pc
)
2537 printf_filtered ("Line %d of \"%s\"",
2539 symtab_to_filename_for_display (sal
.symtab
));
2541 printf_filtered (" is at address ");
2542 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2544 printf_filtered (" but contains no code.\n");
2545 sal
= find_pc_line (start_pc
, 0);
2547 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2548 && start_pc
!= end_pc
)
2549 printf_filtered ("Attempting to find line %d instead.\n",
2552 error (_("Cannot find a good line."));
2556 /* Is there any case in which we get here, and have an address
2557 which the user would want to see? If we have debugging
2558 symbols and no line numbers? */
2559 error (_("Line number %d is out of range for \"%s\"."),
2560 sal
.line
, symtab_to_filename_for_display (sal
.symtab
));
2562 /* Find within range of stated line. */
2564 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2566 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2567 do_cleanups (old_chain
);
2570 /* tfind range command */
2572 trace_find_range_command (char *args
, int from_tty
)
2574 static CORE_ADDR start
, stop
;
2577 if (current_trace_status ()->running
2578 && current_trace_status ()->filename
== NULL
)
2579 error (_("May not look at trace frames while trace is running."));
2581 if (args
== 0 || *args
== 0)
2582 { /* XXX FIXME: what should default behavior be? */
2583 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2587 if (0 != (tmp
= strchr (args
, ',')))
2589 *tmp
++ = '\0'; /* Terminate start address. */
2590 tmp
= skip_spaces (tmp
);
2591 start
= parse_and_eval_address (args
);
2592 stop
= parse_and_eval_address (tmp
);
2595 { /* No explicit end address? */
2596 start
= parse_and_eval_address (args
);
2597 stop
= start
+ 1; /* ??? */
2600 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2603 /* tfind outside command */
2605 trace_find_outside_command (char *args
, int from_tty
)
2607 CORE_ADDR start
, stop
;
2610 if (current_trace_status ()->running
2611 && current_trace_status ()->filename
== NULL
)
2612 error (_("May not look at trace frames while trace is running."));
2614 if (args
== 0 || *args
== 0)
2615 { /* XXX FIXME: what should default behavior be? */
2616 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2620 if (0 != (tmp
= strchr (args
, ',')))
2622 *tmp
++ = '\0'; /* Terminate start address. */
2623 tmp
= skip_spaces (tmp
);
2624 start
= parse_and_eval_address (args
);
2625 stop
= parse_and_eval_address (tmp
);
2628 { /* No explicit end address? */
2629 start
= parse_and_eval_address (args
);
2630 stop
= start
+ 1; /* ??? */
2633 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2636 /* info scope command: list the locals for a scope. */
2638 scope_info (char *args
, int from_tty
)
2640 struct symtabs_and_lines sals
;
2642 struct minimal_symbol
*msym
;
2643 struct block
*block
;
2644 const char *symname
;
2645 char *save_args
= args
;
2646 struct block_iterator iter
;
2648 struct gdbarch
*gdbarch
;
2651 if (args
== 0 || *args
== 0)
2652 error (_("requires an argument (function, "
2653 "line or *addr) to define a scope"));
2655 sals
= decode_line_1 (&args
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2656 if (sals
.nelts
== 0)
2657 return; /* Presumably decode_line_1 has already warned. */
2659 /* Resolve line numbers to PC. */
2660 resolve_sal_pc (&sals
.sals
[0]);
2661 block
= block_for_pc (sals
.sals
[0].pc
);
2665 QUIT
; /* Allow user to bail out with ^C. */
2666 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2668 QUIT
; /* Allow user to bail out with ^C. */
2670 printf_filtered ("Scope for %s:\n", save_args
);
2673 symname
= SYMBOL_PRINT_NAME (sym
);
2674 if (symname
== NULL
|| *symname
== '\0')
2675 continue; /* Probably botched, certainly useless. */
2677 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2679 printf_filtered ("Symbol %s is ", symname
);
2680 switch (SYMBOL_CLASS (sym
))
2683 case LOC_UNDEF
: /* Messed up symbol? */
2684 printf_filtered ("a bogus symbol, class %d.\n",
2685 SYMBOL_CLASS (sym
));
2686 count
--; /* Don't count this one. */
2689 printf_filtered ("a constant with value %s (%s)",
2690 plongest (SYMBOL_VALUE (sym
)),
2691 hex_string (SYMBOL_VALUE (sym
)));
2693 case LOC_CONST_BYTES
:
2694 printf_filtered ("constant bytes: ");
2695 if (SYMBOL_TYPE (sym
))
2696 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2697 fprintf_filtered (gdb_stdout
, " %02x",
2698 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2701 printf_filtered ("in static storage at address ");
2702 printf_filtered ("%s", paddress (gdbarch
,
2703 SYMBOL_VALUE_ADDRESS (sym
)));
2706 /* GDBARCH is the architecture associated with the objfile
2707 the symbol is defined in; the target architecture may be
2708 different, and may provide additional registers. However,
2709 we do not know the target architecture at this point.
2710 We assume the objfile architecture will contain all the
2711 standard registers that occur in debug info in that
2713 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2716 if (SYMBOL_IS_ARGUMENT (sym
))
2717 printf_filtered ("an argument in register $%s",
2718 gdbarch_register_name (gdbarch
, regno
));
2720 printf_filtered ("a local variable in register $%s",
2721 gdbarch_register_name (gdbarch
, regno
));
2724 printf_filtered ("an argument at stack/frame offset %s",
2725 plongest (SYMBOL_VALUE (sym
)));
2728 printf_filtered ("a local variable at frame offset %s",
2729 plongest (SYMBOL_VALUE (sym
)));
2732 printf_filtered ("a reference argument at offset %s",
2733 plongest (SYMBOL_VALUE (sym
)));
2735 case LOC_REGPARM_ADDR
:
2736 /* Note comment at LOC_REGISTER. */
2737 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2739 printf_filtered ("the address of an argument, in register $%s",
2740 gdbarch_register_name (gdbarch
, regno
));
2743 printf_filtered ("a typedef.\n");
2746 printf_filtered ("a label at address ");
2747 printf_filtered ("%s", paddress (gdbarch
,
2748 SYMBOL_VALUE_ADDRESS (sym
)));
2751 printf_filtered ("a function at address ");
2752 printf_filtered ("%s",
2753 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2755 case LOC_UNRESOLVED
:
2756 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2759 printf_filtered ("Unresolved Static");
2762 printf_filtered ("static storage at address ");
2763 printf_filtered ("%s",
2764 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2767 case LOC_OPTIMIZED_OUT
:
2768 printf_filtered ("optimized out.\n");
2771 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2772 BLOCK_START (block
),
2776 if (SYMBOL_TYPE (sym
))
2777 printf_filtered (", length %d.\n",
2778 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2780 if (BLOCK_FUNCTION (block
))
2783 block
= BLOCK_SUPERBLOCK (block
);
2786 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2790 /* Helper for trace_dump_command. Dump the action list starting at
2791 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2792 actions of the body of a while-stepping action. STEPPING_FRAME is
2793 set if the current traceframe was determined to be a while-stepping
2797 trace_dump_actions (struct command_line
*action
,
2798 int stepping_actions
, int stepping_frame
,
2801 const char *action_exp
, *next_comma
;
2803 for (; action
!= NULL
; action
= action
->next
)
2805 struct cmd_list_element
*cmd
;
2807 QUIT
; /* Allow user to bail out with ^C. */
2808 action_exp
= action
->line
;
2809 action_exp
= skip_spaces_const (action_exp
);
2811 /* The collection actions to be done while stepping are
2812 bracketed by the commands "while-stepping" and "end". */
2814 if (*action_exp
== '#') /* comment line */
2817 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2819 error (_("Bad action list item: %s"), action_exp
);
2821 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2825 for (i
= 0; i
< action
->body_count
; ++i
)
2826 trace_dump_actions (action
->body_list
[i
],
2827 1, stepping_frame
, from_tty
);
2829 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2831 /* Display the collected data.
2832 For the trap frame, display only what was collected at
2833 the trap. Likewise for stepping frames, display only
2834 what was collected while stepping. This means that the
2835 two boolean variables, STEPPING_FRAME and
2836 STEPPING_ACTIONS should be equal. */
2837 if (stepping_frame
== stepping_actions
)
2840 struct cleanup
*old_chain
2841 = make_cleanup (free_current_contents
, &cmd
);
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_const (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
);
2865 if (next_comma
!= NULL
)
2867 size_t len
= next_comma
- action_exp
;
2869 cmd
= xrealloc (cmd
, len
+ 1);
2870 memcpy (cmd
, action_exp
, len
);
2875 size_t len
= strlen (action_exp
);
2877 cmd
= xrealloc (cmd
, len
+ 1);
2878 memcpy (cmd
, action_exp
, len
+ 1);
2881 printf_filtered ("%s = ", cmd
);
2882 output_command_const (cmd
, from_tty
);
2883 printf_filtered ("\n");
2885 action_exp
= next_comma
;
2887 while (action_exp
&& *action_exp
== ',');
2889 do_cleanups (old_chain
);
2895 /* The tdump command. */
2898 trace_dump_command (char *args
, int from_tty
)
2900 struct regcache
*regcache
;
2901 struct tracepoint
*t
;
2902 int stepping_frame
= 0;
2903 struct bp_location
*loc
;
2904 char *default_collect_line
= NULL
;
2905 struct command_line
*actions
, *default_collect_action
= NULL
;
2906 struct cleanup
*old_chain
= NULL
;
2908 if (tracepoint_number
== -1)
2910 warning (_("No current trace frame."));
2914 t
= get_tracepoint (tracepoint_number
);
2917 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2920 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2921 tracepoint_number
, traceframe_number
);
2923 /* The current frame is a trap frame if the frame PC is equal
2924 to the tracepoint PC. If not, then the current frame was
2925 collected during single-stepping. */
2927 regcache
= get_current_regcache ();
2929 /* If the traceframe's address matches any of the tracepoint's
2930 locations, assume it is a direct hit rather than a while-stepping
2931 frame. (FIXME this is not reliable, should record each frame's
2934 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
2935 if (loc
->address
== regcache_read_pc (regcache
))
2938 actions
= breakpoint_commands (&t
->base
);
2940 /* If there is a default-collect list, make up a collect command,
2941 prepend to the tracepoint's commands, and pass the whole mess to
2942 the trace dump scanner. We need to validate because
2943 default-collect might have been junked since the trace run. */
2944 if (*default_collect
)
2946 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2947 old_chain
= make_cleanup (xfree
, default_collect_line
);
2948 validate_actionline (default_collect_line
, &t
->base
);
2949 default_collect_action
= xmalloc (sizeof (struct command_line
));
2950 make_cleanup (xfree
, default_collect_action
);
2951 default_collect_action
->next
= actions
;
2952 default_collect_action
->line
= default_collect_line
;
2953 actions
= default_collect_action
;
2956 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2958 if (*default_collect
)
2959 do_cleanups (old_chain
);
2962 /* Encode a piece of a tracepoint's source-level definition in a form
2963 that is suitable for both protocol and saving in files. */
2964 /* This version does not do multiple encodes for long strings; it should
2965 return an offset to the next piece to encode. FIXME */
2968 encode_source_string (int tpnum
, ULONGEST addr
,
2969 char *srctype
, char *src
, char *buf
, int buf_size
)
2971 if (80 + strlen (srctype
) > buf_size
)
2972 error (_("Buffer too small for source encoding"));
2973 sprintf (buf
, "%x:%s:%s:%x:%x:",
2974 tpnum
, phex_nz (addr
, sizeof (addr
)),
2975 srctype
, 0, (int) strlen (src
));
2976 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2977 error (_("Source string too long for buffer"));
2978 bin2hex (src
, buf
+ strlen (buf
), 0);
2982 extern int trace_regblock_size
;
2984 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2985 non-zero, the save is performed on the target, otherwise GDB obtains all
2986 trace data and saves it locally. */
2989 trace_save (const char *filename
, int target_does_save
)
2991 struct cleanup
*cleanup
;
2993 struct trace_status
*ts
= current_trace_status ();
2996 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2997 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
3001 ULONGEST offset
= 0;
3002 #define MAX_TRACE_UPLOAD 2000
3003 gdb_byte buf
[MAX_TRACE_UPLOAD
];
3006 /* If the target is to save the data to a file on its own, then just
3007 send the command and be done with it. */
3008 if (target_does_save
)
3010 err
= target_save_trace_data (filename
);
3012 error (_("Target failed to save trace data to '%s'."),
3017 /* Get the trace status first before opening the file, so if the
3018 target is losing, we can get out without touching files. */
3019 status
= target_get_trace_status (ts
);
3021 pathname
= tilde_expand (filename
);
3022 cleanup
= make_cleanup (xfree
, pathname
);
3024 fp
= fopen (pathname
, "wb");
3026 error (_("Unable to open file '%s' for saving trace data (%s)"),
3027 filename
, safe_strerror (errno
));
3028 make_cleanup_fclose (fp
);
3030 /* Write a file header, with a high-bit-set char to indicate a
3031 binary file, plus a hint as what this file is, and a version
3032 number in case of future needs. */
3033 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
3035 perror_with_name (pathname
);
3037 /* Write descriptive info. */
3039 /* Write out the size of a register block. */
3040 fprintf (fp
, "R %x\n", trace_regblock_size
);
3042 /* Write out status of the tracing run (aka "tstatus" info). */
3043 fprintf (fp
, "status %c;%s",
3044 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
3045 if (ts
->stop_reason
== tracepoint_error
)
3047 char *buf
= (char *) alloca (strlen (ts
->stop_desc
) * 2 + 1);
3049 bin2hex ((gdb_byte
*) ts
->stop_desc
, buf
, 0);
3050 fprintf (fp
, ":%s", buf
);
3052 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
3053 if (ts
->traceframe_count
>= 0)
3054 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
3055 if (ts
->traceframes_created
>= 0)
3056 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
3057 if (ts
->buffer_free
>= 0)
3058 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
3059 if (ts
->buffer_size
>= 0)
3060 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
3061 if (ts
->disconnected_tracing
)
3062 fprintf (fp
, ";disconn:%x", ts
->disconnected_tracing
);
3063 if (ts
->circular_buffer
)
3064 fprintf (fp
, ";circular:%x", ts
->circular_buffer
);
3067 /* Note that we want to upload tracepoints and save those, rather
3068 than simply writing out the local ones, because the user may have
3069 changed tracepoints in GDB in preparation for a future tracing
3070 run, or maybe just mass-deleted all types of breakpoints as part
3071 of cleaning up. So as not to contaminate the session, leave the
3072 data in its uploaded form, don't make into real tracepoints. */
3074 /* Get trace state variables first, they may be checked when parsing
3075 uploaded commands. */
3077 target_upload_trace_state_variables (&uploaded_tsvs
);
3079 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3085 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
3086 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
3089 fprintf (fp
, "tsv %x:%s:%x:%s\n",
3090 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
3091 utsv
->builtin
, buf
);
3097 free_uploaded_tsvs (&uploaded_tsvs
);
3099 target_upload_tracepoints (&uploaded_tps
);
3101 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3102 target_get_tracepoint_status (NULL
, utp
);
3104 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3106 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
3107 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3108 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
3109 if (utp
->type
== bp_fast_tracepoint
)
3110 fprintf (fp
, ":F%x", utp
->orig_size
);
3112 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
3115 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
3116 fprintf (fp
, "tp A%x:%s:%s\n",
3117 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3118 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
3119 fprintf (fp
, "tp S%x:%s:%s\n",
3120 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3123 encode_source_string (utp
->number
, utp
->addr
,
3124 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
3125 fprintf (fp
, "tp Z%s\n", buf
);
3127 if (utp
->cond_string
)
3129 encode_source_string (utp
->number
, utp
->addr
,
3130 "cond", utp
->cond_string
,
3131 buf
, MAX_TRACE_UPLOAD
);
3132 fprintf (fp
, "tp Z%s\n", buf
);
3134 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
3136 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
3137 buf
, MAX_TRACE_UPLOAD
);
3138 fprintf (fp
, "tp Z%s\n", buf
);
3140 fprintf (fp
, "tp V%x:%s:%x:%s\n",
3141 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3143 phex_nz (utp
->traceframe_usage
,
3144 sizeof (utp
->traceframe_usage
)));
3147 free_uploaded_tps (&uploaded_tps
);
3149 /* Mark the end of the definition section. */
3152 /* Get and write the trace data proper. We ask for big blocks, in
3153 the hopes of efficiency, but will take less if the target has
3154 packet size limitations or some such. */
3157 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
3159 error (_("Failure to get requested trace buffer data"));
3160 /* No more data is forthcoming, we're done. */
3163 written
= fwrite (buf
, gotten
, 1, fp
);
3165 perror_with_name (pathname
);
3169 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
3170 written
= fwrite (&gotten
, 4, 1, fp
);
3172 perror_with_name (pathname
);
3174 do_cleanups (cleanup
);
3178 trace_save_command (char *args
, int from_tty
)
3180 int target_does_save
= 0;
3182 char *filename
= NULL
;
3183 struct cleanup
*back_to
;
3186 error_no_arg (_("file in which to save trace data"));
3188 argv
= gdb_buildargv (args
);
3189 back_to
= make_cleanup_freeargv (argv
);
3191 for (; *argv
; ++argv
)
3193 if (strcmp (*argv
, "-r") == 0)
3194 target_does_save
= 1;
3195 else if (**argv
== '-')
3196 error (_("unknown option `%s'"), *argv
);
3202 error_no_arg (_("file in which to save trace data"));
3204 trace_save (filename
, target_does_save
);
3207 printf_filtered (_("Trace data saved to file '%s'.\n"), filename
);
3209 do_cleanups (back_to
);
3212 /* Tell the target what to do with an ongoing tracing run if GDB
3213 disconnects for some reason. */
3216 set_disconnected_tracing (char *args
, int from_tty
,
3217 struct cmd_list_element
*c
)
3219 target_set_disconnected_tracing (disconnected_tracing
);
3223 set_circular_trace_buffer (char *args
, int from_tty
,
3224 struct cmd_list_element
*c
)
3226 target_set_circular_trace_buffer (circular_trace_buffer
);
3230 set_trace_buffer_size (char *args
, int from_tty
,
3231 struct cmd_list_element
*c
)
3233 target_set_trace_buffer_size (trace_buffer_size
);
3237 set_trace_user (char *args
, int from_tty
,
3238 struct cmd_list_element
*c
)
3242 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3245 warning (_("Target does not support trace notes, user ignored"));
3249 set_trace_notes (char *args
, int from_tty
,
3250 struct cmd_list_element
*c
)
3254 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3257 warning (_("Target does not support trace notes, note ignored"));
3261 set_trace_stop_notes (char *args
, int from_tty
,
3262 struct cmd_list_element
*c
)
3266 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3269 warning (_("Target does not support trace notes, stop note ignored"));
3272 /* Convert the memory pointed to by mem into hex, placing result in buf.
3273 * Return a pointer to the last char put in buf (null)
3274 * "stolen" from sparc-stub.c
3277 static const char hexchars
[] = "0123456789abcdef";
3280 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3288 *buf
++ = hexchars
[ch
>> 4];
3289 *buf
++ = hexchars
[ch
& 0xf];
3298 get_traceframe_number (void)
3300 return traceframe_number
;
3303 /* Make the traceframe NUM be the current trace frame. Does nothing
3304 if NUM is already current. */
3307 set_current_traceframe (int num
)
3311 if (traceframe_number
== num
)
3313 /* Nothing to do. */
3317 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3320 warning (_("could not change traceframe"));
3322 set_traceframe_num (newnum
);
3324 /* Changing the traceframe changes our view of registers and of the
3326 registers_changed ();
3328 clear_traceframe_info ();
3331 /* Make the traceframe NUM be the current trace frame, and do nothing
3335 set_traceframe_number (int num
)
3337 traceframe_number
= num
;
3340 /* A cleanup used when switching away and back from tfind mode. */
3342 struct current_traceframe_cleanup
3344 /* The traceframe we were inspecting. */
3345 int traceframe_number
;
3349 do_restore_current_traceframe_cleanup (void *arg
)
3351 struct current_traceframe_cleanup
*old
= arg
;
3353 set_current_traceframe (old
->traceframe_number
);
3357 restore_current_traceframe_cleanup_dtor (void *arg
)
3359 struct current_traceframe_cleanup
*old
= arg
;
3365 make_cleanup_restore_current_traceframe (void)
3367 struct current_traceframe_cleanup
*old
;
3369 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3370 old
->traceframe_number
= traceframe_number
;
3372 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3373 restore_current_traceframe_cleanup_dtor
);
3377 make_cleanup_restore_traceframe_number (void)
3379 return make_cleanup_restore_integer (&traceframe_number
);
3382 /* Given a number and address, return an uploaded tracepoint with that
3383 number, creating if necessary. */
3385 struct uploaded_tp
*
3386 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3388 struct uploaded_tp
*utp
;
3390 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3391 if (utp
->number
== num
&& utp
->addr
== addr
)
3393 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3394 memset (utp
, 0, sizeof (struct uploaded_tp
));
3397 utp
->actions
= NULL
;
3398 utp
->step_actions
= NULL
;
3399 utp
->cmd_strings
= NULL
;
3406 free_uploaded_tps (struct uploaded_tp
**utpp
)
3408 struct uploaded_tp
*next_one
;
3412 next_one
= (*utpp
)->next
;
3418 /* Given a number and address, return an uploaded tracepoint with that
3419 number, creating if necessary. */
3421 static struct uploaded_tsv
*
3422 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3424 struct uploaded_tsv
*utsv
;
3426 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3427 if (utsv
->number
== num
)
3429 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3430 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3432 utsv
->next
= *utsvp
;
3438 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3440 struct uploaded_tsv
*next_one
;
3444 next_one
= (*utsvp
)->next
;
3450 /* FIXME this function is heuristic and will miss the cases where the
3451 conditional is semantically identical but differs in whitespace,
3452 such as "x == 0" vs "x==0". */
3455 cond_string_is_same (char *str1
, char *str2
)
3457 if (str1
== NULL
|| str2
== NULL
)
3458 return (str1
== str2
);
3460 return (strcmp (str1
, str2
) == 0);
3463 /* Look for an existing tracepoint that seems similar enough to the
3464 uploaded one. Enablement isn't compared, because the user can
3465 toggle that freely, and may have done so in anticipation of the
3466 next trace run. Return the location of matched tracepoint. */
3468 static struct bp_location
*
3469 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3471 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3473 struct breakpoint
*b
;
3474 struct bp_location
*loc
;
3476 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3478 struct tracepoint
*t
= (struct tracepoint
*) b
;
3480 if (b
->type
== utp
->type
3481 && t
->step_count
== utp
->step
3482 && t
->pass_count
== utp
->pass
3483 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3484 /* FIXME also test actions. */
3487 /* Scan the locations for an address match. */
3488 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3490 if (loc
->address
== utp
->addr
)
3498 /* Given a list of tracepoints uploaded from a target, attempt to
3499 match them up with existing tracepoints, and create new ones if not
3503 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3505 struct uploaded_tp
*utp
;
3506 /* A set of tracepoints which are modified. */
3507 VEC(breakpoint_p
) *modified_tp
= NULL
;
3509 struct breakpoint
*b
;
3511 /* Look for GDB tracepoints that match up with our uploaded versions. */
3512 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3514 struct bp_location
*loc
;
3515 struct tracepoint
*t
;
3517 loc
= find_matching_tracepoint_location (utp
);
3522 /* Mark this location as already inserted. */
3524 t
= (struct tracepoint
*) loc
->owner
;
3525 printf_filtered (_("Assuming tracepoint %d is same "
3526 "as target's tracepoint %d at %s.\n"),
3527 loc
->owner
->number
, utp
->number
,
3528 paddress (loc
->gdbarch
, utp
->addr
));
3530 /* The tracepoint LOC->owner was modified (the location LOC
3531 was marked as inserted in the target). Save it in
3532 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3533 observers will be notified later once for each tracepoint
3534 saved in MODIFIED_TP. */
3536 VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
);
3538 if (b
== loc
->owner
)
3544 VEC_safe_push (breakpoint_p
, modified_tp
, loc
->owner
);
3548 t
= create_tracepoint_from_upload (utp
);
3550 printf_filtered (_("Created tracepoint %d for "
3551 "target's tracepoint %d at %s.\n"),
3552 t
->base
.number
, utp
->number
,
3553 paddress (get_current_arch (), utp
->addr
));
3555 printf_filtered (_("Failed to create tracepoint for target's "
3556 "tracepoint %d at %s, skipping it.\n"),
3558 paddress (get_current_arch (), utp
->addr
));
3560 /* Whether found or created, record the number used by the
3561 target, to help with mapping target tracepoints back to their
3562 counterparts here. */
3564 t
->number_on_target
= utp
->number
;
3567 /* Notify 'breakpoint-modified' observer that at least one of B's
3568 locations was changed. */
3569 for (ix
= 0; VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
); ix
++)
3570 observer_notify_breakpoint_modified (b
);
3572 VEC_free (breakpoint_p
, modified_tp
);
3573 free_uploaded_tps (uploaded_tps
);
3576 /* Trace state variables don't have much to identify them beyond their
3577 name, so just use that to detect matches. */
3579 static struct trace_state_variable
*
3580 find_matching_tsv (struct uploaded_tsv
*utsv
)
3585 return find_trace_state_variable (utsv
->name
);
3588 static struct trace_state_variable
*
3589 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3591 const char *namebase
;
3594 struct trace_state_variable
*tsv
;
3595 struct cleanup
*old_chain
;
3599 namebase
= utsv
->name
;
3600 buf
= xstrprintf ("%s", namebase
);
3605 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3608 /* Fish for a name that is not in use. */
3609 /* (should check against all internal vars?) */
3610 while (find_trace_state_variable (buf
))
3613 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3616 old_chain
= make_cleanup (xfree
, buf
);
3618 /* We have an available name, create the variable. */
3619 tsv
= create_trace_state_variable (buf
);
3620 tsv
->initial_value
= utsv
->initial_value
;
3621 tsv
->builtin
= utsv
->builtin
;
3623 observer_notify_tsv_created (tsv
);
3625 do_cleanups (old_chain
);
3630 /* Given a list of uploaded trace state variables, try to match them
3631 up with existing variables, or create additional ones. */
3634 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3637 struct uploaded_tsv
*utsv
;
3638 struct trace_state_variable
*tsv
;
3641 /* Most likely some numbers will have to be reassigned as part of
3642 the merge, so clear them all in anticipation. */
3643 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3646 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3648 tsv
= find_matching_tsv (utsv
);
3652 printf_filtered (_("Assuming trace state variable $%s "
3653 "is same as target's variable %d.\n"),
3654 tsv
->name
, utsv
->number
);
3658 tsv
= create_tsv_from_upload (utsv
);
3660 printf_filtered (_("Created trace state variable "
3661 "$%s for target's variable %d.\n"),
3662 tsv
->name
, utsv
->number
);
3664 /* Give precedence to numberings that come from the target. */
3666 tsv
->number
= utsv
->number
;
3669 /* Renumber everything that didn't get a target-assigned number. */
3671 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3672 if (tsv
->number
> highest
)
3673 highest
= tsv
->number
;
3676 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3677 if (tsv
->number
== 0)
3678 tsv
->number
= highest
++;
3680 free_uploaded_tsvs (uploaded_tsvs
);
3683 /* target tfile command */
3685 static struct target_ops tfile_ops
;
3687 /* Fill in tfile_ops with its defined operations and properties. */
3689 #define TRACE_HEADER_SIZE 8
3691 static char *trace_filename
;
3692 static int trace_fd
= -1;
3693 static off_t trace_frames_offset
;
3694 static off_t cur_offset
;
3695 static int cur_data_size
;
3696 int trace_regblock_size
;
3698 static void tfile_interp_line (char *line
,
3699 struct uploaded_tp
**utpp
,
3700 struct uploaded_tsv
**utsvp
);
3702 /* Read SIZE bytes into READBUF from the trace frame, starting at
3703 TRACE_FD's current position. Note that this call `read'
3704 underneath, hence it advances the file's seek position. Throws an
3705 error if the `read' syscall fails, or less than SIZE bytes are
3709 tfile_read (gdb_byte
*readbuf
, int size
)
3713 gotten
= read (trace_fd
, readbuf
, size
);
3715 perror_with_name (trace_filename
);
3716 else if (gotten
< size
)
3717 error (_("Premature end of file while reading trace file"));
3721 tfile_open (char *filename
, int from_tty
)
3723 volatile struct gdb_exception ex
;
3725 struct cleanup
*old_chain
;
3728 char header
[TRACE_HEADER_SIZE
];
3729 char linebuf
[1000]; /* Should be max remote packet size or so. */
3732 struct trace_status
*ts
;
3733 struct uploaded_tp
*uploaded_tps
= NULL
;
3734 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3736 target_preopen (from_tty
);
3738 error (_("No trace file specified."));
3740 filename
= tilde_expand (filename
);
3741 if (!IS_ABSOLUTE_PATH(filename
))
3743 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
3748 old_chain
= make_cleanup (xfree
, filename
);
3750 flags
= O_BINARY
| O_LARGEFILE
;
3752 scratch_chan
= open (filename
, flags
, 0);
3753 if (scratch_chan
< 0)
3754 perror_with_name (filename
);
3756 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3758 discard_cleanups (old_chain
); /* Don't free filename any more. */
3759 unpush_target (&tfile_ops
);
3761 trace_filename
= xstrdup (filename
);
3762 trace_fd
= scratch_chan
;
3765 /* Read the file header and test for validity. */
3766 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
3768 bytes
+= TRACE_HEADER_SIZE
;
3769 if (!(header
[0] == 0x7f
3770 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3771 error (_("File is not a valid trace file."));
3773 push_target (&tfile_ops
);
3775 trace_regblock_size
= 0;
3776 ts
= current_trace_status ();
3777 /* We know we're working with a file. Record its name. */
3778 ts
->filename
= trace_filename
;
3779 /* Set defaults in case there is no status line. */
3780 ts
->running_known
= 0;
3781 ts
->stop_reason
= trace_stop_reason_unknown
;
3782 ts
->traceframe_count
= -1;
3783 ts
->buffer_free
= 0;
3784 ts
->disconnected_tracing
= 0;
3785 ts
->circular_buffer
= 0;
3787 TRY_CATCH (ex
, RETURN_MASK_ALL
)
3789 /* Read through a section of newline-terminated lines that
3790 define things like tracepoints. */
3794 tfile_read (&byte
, 1);
3799 /* Empty line marks end of the definition section. */
3804 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3807 linebuf
[i
++] = byte
;
3809 error (_("Excessively long lines in trace file"));
3812 /* Record the starting offset of the binary trace data. */
3813 trace_frames_offset
= bytes
;
3815 /* If we don't have a blocksize, we can't interpret the
3817 if (trace_regblock_size
== 0)
3818 error (_("No register block size recorded in trace file"));
3822 /* Pop the partially set up target. */
3824 throw_exception (ex
);
3827 inferior_appeared (current_inferior (), TFILE_PID
);
3828 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3829 add_thread_silent (inferior_ptid
);
3831 if (ts
->traceframe_count
<= 0)
3832 warning (_("No traceframes present in this file."));
3834 /* Add the file's tracepoints and variables into the current mix. */
3836 /* Get trace state variables first, they may be checked when parsing
3837 uploaded commands. */
3838 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3840 merge_uploaded_tracepoints (&uploaded_tps
);
3842 post_create_inferior (&tfile_ops
, from_tty
);
3845 /* Interpret the given line from the definitions part of the trace
3849 tfile_interp_line (char *line
,
3850 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3854 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3857 trace_regblock_size
= strtol (p
, &p
, 16);
3859 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3861 p
+= strlen ("status ");
3862 parse_trace_status (p
, current_trace_status ());
3864 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3866 p
+= strlen ("tp ");
3867 parse_tracepoint_definition (p
, utpp
);
3869 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3871 p
+= strlen ("tsv ");
3872 parse_tsv_definition (p
, utsvp
);
3875 warning (_("Ignoring trace file definition \"%s\""), line
);
3878 /* Parse the part of trace status syntax that is shared between
3879 the remote protocol and the trace file reader. */
3882 parse_trace_status (char *line
, struct trace_status
*ts
)
3884 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
3888 ts
->running_known
= 1;
3889 ts
->running
= (*p
++ == '1');
3890 ts
->stop_reason
= trace_stop_reason_unknown
;
3891 xfree (ts
->stop_desc
);
3892 ts
->stop_desc
= NULL
;
3893 ts
->traceframe_count
= -1;
3894 ts
->traceframes_created
= -1;
3895 ts
->buffer_free
= -1;
3896 ts
->buffer_size
= -1;
3897 ts
->disconnected_tracing
= 0;
3898 ts
->circular_buffer
= 0;
3899 xfree (ts
->user_name
);
3900 ts
->user_name
= NULL
;
3903 ts
->start_time
= ts
->stop_time
= 0;
3907 p1
= strchr (p
, ':');
3909 error (_("Malformed trace status, at %s\n\
3910 Status line: '%s'\n"), p
, line
);
3911 p3
= strchr (p
, ';');
3913 p3
= p
+ strlen (p
);
3914 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3916 p
= unpack_varlen_hex (++p1
, &val
);
3917 ts
->stop_reason
= trace_buffer_full
;
3919 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3921 p
= unpack_varlen_hex (++p1
, &val
);
3922 ts
->stop_reason
= trace_never_run
;
3924 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3927 p
= unpack_varlen_hex (++p1
, &val
);
3928 ts
->stop_reason
= tracepoint_passcount
;
3929 ts
->stopping_tracepoint
= val
;
3931 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3933 p2
= strchr (++p1
, ':');
3941 ts
->stop_desc
= xmalloc (strlen (line
));
3942 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
3943 ts
->stop_desc
[end
] = '\0';
3946 ts
->stop_desc
= xstrdup ("");
3948 p
= unpack_varlen_hex (++p2
, &val
);
3949 ts
->stop_reason
= tstop_command
;
3951 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3953 p
= unpack_varlen_hex (++p1
, &val
);
3954 ts
->stop_reason
= trace_disconnected
;
3956 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3958 p2
= strchr (++p1
, ':');
3961 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3962 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
3963 ts
->stop_desc
[end
] = '\0';
3966 ts
->stop_desc
= xstrdup ("");
3968 p
= unpack_varlen_hex (++p2
, &val
);
3969 ts
->stopping_tracepoint
= val
;
3970 ts
->stop_reason
= tracepoint_error
;
3972 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3974 p
= unpack_varlen_hex (++p1
, &val
);
3975 ts
->traceframe_count
= val
;
3977 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3979 p
= unpack_varlen_hex (++p1
, &val
);
3980 ts
->traceframes_created
= val
;
3982 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3984 p
= unpack_varlen_hex (++p1
, &val
);
3985 ts
->buffer_free
= val
;
3987 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3989 p
= unpack_varlen_hex (++p1
, &val
);
3990 ts
->buffer_size
= val
;
3992 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3994 p
= unpack_varlen_hex (++p1
, &val
);
3995 ts
->disconnected_tracing
= val
;
3997 else if (strncmp (p
, "circular", p1
- p
) == 0)
3999 p
= unpack_varlen_hex (++p1
, &val
);
4000 ts
->circular_buffer
= val
;
4002 else if (strncmp (p
, "starttime", p1
- p
) == 0)
4004 p
= unpack_varlen_hex (++p1
, &val
);
4005 ts
->start_time
= val
;
4007 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
4009 p
= unpack_varlen_hex (++p1
, &val
);
4010 ts
->stop_time
= val
;
4012 else if (strncmp (p
, "username", p1
- p
) == 0)
4015 ts
->user_name
= xmalloc (strlen (p
) / 2);
4016 end
= hex2bin (p1
, ts
->user_name
, (p3
- p1
) / 2);
4017 ts
->user_name
[end
] = '\0';
4020 else if (strncmp (p
, "notes", p1
- p
) == 0)
4023 ts
->notes
= xmalloc (strlen (p
) / 2);
4024 end
= hex2bin (p1
, ts
->notes
, (p3
- p1
) / 2);
4025 ts
->notes
[end
] = '\0';
4030 /* Silently skip unknown optional info. */
4031 p_temp
= strchr (p1
+ 1, ';');
4035 /* Must be at the end. */
4042 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
4043 struct uploaded_tp
*utp
)
4046 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
4048 p
= unpack_varlen_hex (p
, &uval
);
4050 tp
->base
.hit_count
+= uval
;
4052 utp
->hit_count
+= uval
;
4053 p
= unpack_varlen_hex (p
+ 1, &uval
);
4055 tp
->traceframe_usage
+= uval
;
4057 utp
->traceframe_usage
+= uval
;
4058 /* Ignore any extra, allowing for future extensions. */
4061 /* Given a line of text defining a part of a tracepoint, parse it into
4062 an "uploaded tracepoint". */
4065 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
4069 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
4072 char *cond
, *srctype
, *buf
;
4073 struct uploaded_tp
*utp
= NULL
;
4076 /* Both tracepoint and action definitions start with the same number
4077 and address sequence. */
4079 p
= unpack_varlen_hex (p
, &num
);
4080 p
++; /* skip a colon */
4081 p
= unpack_varlen_hex (p
, &addr
);
4082 p
++; /* skip a colon */
4085 enabled
= (*p
++ == 'E');
4086 p
++; /* skip a colon */
4087 p
= unpack_varlen_hex (p
, &step
);
4088 p
++; /* skip a colon */
4089 p
= unpack_varlen_hex (p
, &pass
);
4090 type
= bp_tracepoint
;
4092 /* Thumb through optional fields. */
4095 p
++; /* skip a colon */
4098 type
= bp_fast_tracepoint
;
4100 p
= unpack_varlen_hex (p
, &orig_size
);
4104 type
= bp_static_tracepoint
;
4110 p
= unpack_varlen_hex (p
, &xlen
);
4111 p
++; /* skip a comma */
4112 cond
= (char *) xmalloc (2 * xlen
+ 1);
4113 strncpy (cond
, p
, 2 * xlen
);
4114 cond
[2 * xlen
] = '\0';
4118 warning (_("Unrecognized char '%c' in tracepoint "
4119 "definition, skipping rest"), *p
);
4121 utp
= get_uploaded_tp (num
, addr
, utpp
);
4123 utp
->enabled
= enabled
;
4128 else if (piece
== 'A')
4130 utp
= get_uploaded_tp (num
, addr
, utpp
);
4131 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
4133 else if (piece
== 'S')
4135 utp
= get_uploaded_tp (num
, addr
, utpp
);
4136 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
4138 else if (piece
== 'Z')
4140 /* Parse a chunk of source form definition. */
4141 utp
= get_uploaded_tp (num
, addr
, utpp
);
4143 p
= strchr (p
, ':');
4144 p
++; /* skip a colon */
4145 p
= unpack_varlen_hex (p
, &start
);
4146 p
++; /* skip a colon */
4147 p
= unpack_varlen_hex (p
, &xlen
);
4148 p
++; /* skip a colon */
4150 buf
= alloca (strlen (line
));
4152 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4155 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
4156 utp
->at_string
= xstrdup (buf
);
4157 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
4158 utp
->cond_string
= xstrdup (buf
);
4159 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
4160 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
4162 else if (piece
== 'V')
4164 utp
= get_uploaded_tp (num
, addr
, utpp
);
4166 parse_tracepoint_status (p
, NULL
, utp
);
4170 /* Don't error out, the target might be sending us optional
4171 info that we don't care about. */
4172 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
4176 /* Convert a textual description of a trace state variable into an
4180 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
4183 ULONGEST num
, initval
, builtin
;
4185 struct uploaded_tsv
*utsv
= NULL
;
4187 buf
= alloca (strlen (line
));
4190 p
= unpack_varlen_hex (p
, &num
);
4191 p
++; /* skip a colon */
4192 p
= unpack_varlen_hex (p
, &initval
);
4193 p
++; /* skip a colon */
4194 p
= unpack_varlen_hex (p
, &builtin
);
4195 p
++; /* skip a colon */
4196 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4199 utsv
= get_uploaded_tsv (num
, utsvp
);
4200 utsv
->initial_value
= initval
;
4201 utsv
->builtin
= builtin
;
4202 utsv
->name
= xstrdup (buf
);
4205 /* Close the trace file and generally clean up. */
4208 tfile_close (int quitting
)
4215 pid
= ptid_get_pid (inferior_ptid
);
4216 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff. */
4217 exit_inferior_silent (pid
);
4221 xfree (trace_filename
);
4222 trace_filename
= NULL
;
4226 tfile_files_info (struct target_ops
*t
)
4228 printf_filtered ("\t`%s'\n", trace_filename
);
4231 /* The trace status for a file is that tracing can never be run. */
4234 tfile_get_trace_status (struct trace_status
*ts
)
4236 /* Other bits of trace status were collected as part of opening the
4237 trace files, so nothing to do here. */
4243 tfile_get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
4245 /* Other bits of trace status were collected as part of opening the
4246 trace files, so nothing to do here. */
4249 /* Given the position of a traceframe in the file, figure out what
4250 address the frame was collected at. This would normally be the
4251 value of a collected PC register, but if not available, we
4255 tfile_get_traceframe_address (off_t tframe_offset
)
4259 struct tracepoint
*tp
;
4260 off_t saved_offset
= cur_offset
;
4262 /* FIXME dig pc out of collected registers. */
4264 /* Fall back to using tracepoint address. */
4265 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
4266 tfile_read ((gdb_byte
*) &tpnum
, 2);
4267 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4269 (target_gdbarch ()));
4271 tp
= get_tracepoint_by_number_on_target (tpnum
);
4272 /* FIXME this is a poor heuristic if multiple locations. */
4273 if (tp
&& tp
->base
.loc
)
4274 addr
= tp
->base
.loc
->address
;
4276 /* Restore our seek position. */
4277 cur_offset
= saved_offset
;
4278 lseek (trace_fd
, cur_offset
, SEEK_SET
);
4282 /* Given a type of search and some parameters, scan the collection of
4283 traceframes in the file looking for a match. When found, return
4284 both the traceframe and tracepoint number, otherwise -1 for
4288 tfile_trace_find (enum trace_find_type type
, int num
,
4289 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
4292 int tfnum
= 0, found
= 0;
4293 unsigned int data_size
;
4294 struct tracepoint
*tp
;
4295 off_t offset
, tframe_offset
;
4305 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
4306 offset
= trace_frames_offset
;
4309 tframe_offset
= offset
;
4310 tfile_read ((gdb_byte
*) &tpnum
, 2);
4311 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4313 (target_gdbarch ()));
4317 tfile_read ((gdb_byte
*) &data_size
, 4);
4318 data_size
= (unsigned int) extract_unsigned_integer
4319 ((gdb_byte
*) &data_size
, 4,
4320 gdbarch_byte_order (target_gdbarch ()));
4323 if (type
== tfind_number
)
4325 /* Looking for a specific trace frame. */
4331 /* Start from the _next_ trace frame. */
4332 if (tfnum
> traceframe_number
)
4337 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4338 if (tfaddr
== addr1
)
4342 tp
= get_tracepoint (num
);
4343 if (tp
&& tpnum
== tp
->number_on_target
)
4347 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4348 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
4352 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4353 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
4357 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
4366 cur_offset
= offset
;
4367 cur_data_size
= data_size
;
4371 /* Skip past the traceframe's data. */
4372 lseek (trace_fd
, data_size
, SEEK_CUR
);
4373 offset
+= data_size
;
4374 /* Update our own count of traceframes. */
4377 /* Did not find what we were looking for. */
4383 /* Prototype of the callback passed to tframe_walk_blocks. */
4384 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
4386 /* Callback for traceframe_walk_blocks, used to find a given block
4387 type in a traceframe. */
4390 match_blocktype (char blocktype
, void *data
)
4392 char *wantedp
= data
;
4394 if (*wantedp
== blocktype
)
4400 /* Walk over all traceframe block starting at POS offset from
4401 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4402 unmodified. If CALLBACK returns true, this returns the position in
4403 the traceframe where the block is found, relative to the start of
4404 the traceframe (cur_offset). Returns -1 if no callback call
4405 returned true, indicating that all blocks have been walked. */
4408 traceframe_walk_blocks (walk_blocks_callback_func callback
,
4409 int pos
, void *data
)
4411 /* Iterate through a traceframe's blocks, looking for a block of the
4414 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
4415 while (pos
< cur_data_size
)
4417 unsigned short mlen
;
4420 tfile_read (&block_type
, 1);
4424 if ((*callback
) (block_type
, data
))
4430 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4431 pos
+= trace_regblock_size
;
4434 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4435 tfile_read ((gdb_byte
*) &mlen
, 2);
4436 mlen
= (unsigned short)
4437 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4439 (target_gdbarch ()));
4440 lseek (trace_fd
, mlen
, SEEK_CUR
);
4441 pos
+= (8 + 2 + mlen
);
4444 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
4448 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4449 block_type
, block_type
);
4457 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4458 position offset of a block of type TYPE_WANTED in the current trace
4459 frame, starting at POS. Returns -1 if no such block was found. */
4462 traceframe_find_block_type (char type_wanted
, int pos
)
4464 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
4467 /* Look for a block of saved registers in the traceframe, and get the
4468 requested register from it. */
4471 tfile_fetch_registers (struct target_ops
*ops
,
4472 struct regcache
*regcache
, int regno
)
4474 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4475 int offset
, regn
, regsize
, pc_regno
;
4478 /* An uninitialized reg size says we're not going to be
4479 successful at getting register blocks. */
4480 if (!trace_regblock_size
)
4483 regs
= alloca (trace_regblock_size
);
4485 if (traceframe_find_block_type ('R', 0) >= 0)
4487 tfile_read (regs
, trace_regblock_size
);
4489 /* Assume the block is laid out in GDB register number order,
4490 each register with the size that it has in GDB. */
4492 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4494 regsize
= register_size (gdbarch
, regn
);
4495 /* Make sure we stay within block bounds. */
4496 if (offset
+ regsize
>= trace_regblock_size
)
4498 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
4502 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
4505 else if (regno
== -1)
4507 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
4515 /* We get here if no register data has been found. Mark registers
4517 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4518 regcache_raw_supply (regcache
, regn
, NULL
);
4520 /* We can often usefully guess that the PC is going to be the same
4521 as the address of the tracepoint. */
4522 pc_regno
= gdbarch_pc_regnum (gdbarch
);
4523 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
4525 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
4527 if (tp
&& tp
->base
.loc
)
4529 /* But don't try to guess if tracepoint is multi-location... */
4530 if (tp
->base
.loc
->next
)
4532 warning (_("Tracepoint %d has multiple "
4533 "locations, cannot infer $pc"),
4537 /* ... or does while-stepping. */
4538 if (tp
->step_count
> 0)
4540 warning (_("Tracepoint %d does while-stepping, "
4541 "cannot infer $pc"),
4546 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
4547 gdbarch_byte_order (gdbarch
),
4548 tp
->base
.loc
->address
);
4549 regcache_raw_supply (regcache
, pc_regno
, regs
);
4555 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4556 const char *annex
, gdb_byte
*readbuf
,
4557 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
4559 /* We're only doing regular memory for now. */
4560 if (object
!= TARGET_OBJECT_MEMORY
)
4563 if (readbuf
== NULL
)
4564 error (_("tfile_xfer_partial: trace file is read-only"));
4566 if (traceframe_number
!= -1)
4570 /* Iterate through the traceframe's blocks, looking for
4572 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
4574 ULONGEST maddr
, amt
;
4575 unsigned short mlen
;
4576 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
4578 tfile_read ((gdb_byte
*) &maddr
, 8);
4579 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
4581 tfile_read ((gdb_byte
*) &mlen
, 2);
4582 mlen
= (unsigned short)
4583 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
4585 /* If the block includes the first part of the desired
4586 range, return as much it has; GDB will re-request the
4587 remainder, which might be in a different block of this
4589 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
4591 amt
= (maddr
+ mlen
) - offset
;
4595 if (maddr
!= offset
)
4596 lseek (trace_fd
, offset
- maddr
, SEEK_CUR
);
4597 tfile_read (readbuf
, amt
);
4601 /* Skip over this block. */
4602 pos
+= (8 + 2 + mlen
);
4606 /* It's unduly pedantic to refuse to look at the executable for
4607 read-only pieces; so do the equivalent of readonly regions aka
4609 /* FIXME account for relocation at some point. */
4616 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
4618 if ((s
->flags
& SEC_LOAD
) == 0
4619 || (s
->flags
& SEC_READONLY
) == 0)
4623 size
= bfd_get_section_size (s
);
4624 if (vma
<= offset
&& offset
< (vma
+ size
))
4628 amt
= (vma
+ size
) - offset
;
4632 amt
= bfd_get_section_contents (exec_bfd
, s
,
4633 readbuf
, offset
- vma
, amt
);
4639 /* Indicate failure to find the requested memory block. */
4643 /* Iterate through the blocks of a trace frame, looking for a 'V'
4644 block with a matching tsv number. */
4647 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
4652 /* Iterate over blocks in current frame and find the last 'V'
4653 block in which tsv number is TSVNUM. In one trace frame, there
4654 may be multiple 'V' blocks created for a given trace variable,
4655 and the last matched 'V' block contains the updated value. */
4657 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
4661 tfile_read ((gdb_byte
*) &vnum
, 4);
4662 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
4664 (target_gdbarch ()));
4667 tfile_read ((gdb_byte
*) val
, 8);
4668 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
4670 (target_gdbarch ()));
4680 tfile_has_all_memory (struct target_ops
*ops
)
4686 tfile_has_memory (struct target_ops
*ops
)
4692 tfile_has_stack (struct target_ops
*ops
)
4694 return traceframe_number
!= -1;
4698 tfile_has_registers (struct target_ops
*ops
)
4700 return traceframe_number
!= -1;
4704 tfile_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
4709 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
4710 object for the tfile target's current traceframe. */
4713 build_traceframe_info (char blocktype
, void *data
)
4715 struct traceframe_info
*info
= data
;
4721 struct mem_range
*r
;
4723 unsigned short mlen
;
4725 tfile_read ((gdb_byte
*) &maddr
, 8);
4726 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
4728 (target_gdbarch ()));
4729 tfile_read ((gdb_byte
*) &mlen
, 2);
4730 mlen
= (unsigned short)
4731 extract_unsigned_integer ((gdb_byte
*) &mlen
,
4732 2, gdbarch_byte_order
4733 (target_gdbarch ()));
4735 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4748 warning (_("Unhandled trace block type (%d) '%c ' "
4749 "while building trace frame info."),
4750 blocktype
, blocktype
);
4757 static struct traceframe_info
*
4758 tfile_traceframe_info (void)
4760 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
4762 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
4767 init_tfile_ops (void)
4769 tfile_ops
.to_shortname
= "tfile";
4770 tfile_ops
.to_longname
= "Local trace dump file";
4772 = "Use a trace file as a target. Specify the filename of the trace file.";
4773 tfile_ops
.to_open
= tfile_open
;
4774 tfile_ops
.to_close
= tfile_close
;
4775 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
4776 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
4777 tfile_ops
.to_files_info
= tfile_files_info
;
4778 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
4779 tfile_ops
.to_get_tracepoint_status
= tfile_get_tracepoint_status
;
4780 tfile_ops
.to_trace_find
= tfile_trace_find
;
4781 tfile_ops
.to_get_trace_state_variable_value
4782 = tfile_get_trace_state_variable_value
;
4783 tfile_ops
.to_stratum
= process_stratum
;
4784 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
4785 tfile_ops
.to_has_memory
= tfile_has_memory
;
4786 tfile_ops
.to_has_stack
= tfile_has_stack
;
4787 tfile_ops
.to_has_registers
= tfile_has_registers
;
4788 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
4789 tfile_ops
.to_thread_alive
= tfile_thread_alive
;
4790 tfile_ops
.to_magic
= OPS_MAGIC
;
4794 free_current_marker (void *arg
)
4796 struct static_tracepoint_marker
**marker_p
= arg
;
4798 if (*marker_p
!= NULL
)
4800 release_static_tracepoint_marker (*marker_p
);
4807 /* Given a line of text defining a static tracepoint marker, parse it
4808 into a "static tracepoint marker" object. Throws an error is
4809 parsing fails. If PP is non-null, it points to one past the end of
4810 the parsed marker definition. */
4813 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
4814 struct static_tracepoint_marker
*marker
)
4821 p
= unpack_varlen_hex (p
, &addr
);
4822 p
++; /* skip a colon */
4824 marker
->gdbarch
= target_gdbarch ();
4825 marker
->address
= (CORE_ADDR
) addr
;
4827 endp
= strchr (p
, ':');
4829 error (_("bad marker definition: %s"), line
);
4831 marker
->str_id
= xmalloc (endp
- p
+ 1);
4832 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
4833 marker
->str_id
[end
] = '\0';
4836 p
++; /* skip a colon */
4838 marker
->extra
= xmalloc (strlen (p
) + 1);
4839 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
4840 marker
->extra
[end
] = '\0';
4846 /* Release a static tracepoint marker's contents. Note that the
4847 object itself isn't released here. There objects are usually on
4851 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
4853 xfree (marker
->str_id
);
4854 marker
->str_id
= NULL
;
4857 /* Print MARKER to gdb_stdout. */
4860 print_one_static_tracepoint_marker (int count
,
4861 struct static_tracepoint_marker
*marker
)
4863 struct command_line
*l
;
4866 char wrap_indent
[80];
4867 char extra_field_indent
[80];
4868 struct ui_out
*uiout
= current_uiout
;
4869 struct cleanup
*bkpt_chain
;
4870 VEC(breakpoint_p
) *tracepoints
;
4872 struct symtab_and_line sal
;
4876 sal
.pc
= marker
->address
;
4878 tracepoints
= static_tracepoints_here (marker
->address
);
4880 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
4882 /* A counter field to help readability. This is not a stable
4884 ui_out_field_int (uiout
, "count", count
);
4886 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
4888 ui_out_field_fmt (uiout
, "enabled", "%c",
4889 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
4890 ui_out_spaces (uiout
, 2);
4892 strcpy (wrap_indent
, " ");
4894 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
4895 strcat (wrap_indent
, " ");
4897 strcat (wrap_indent
, " ");
4899 strcpy (extra_field_indent
, " ");
4901 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
4903 sal
= find_pc_line (marker
->address
, 0);
4904 sym
= find_pc_sect_function (marker
->address
, NULL
);
4907 ui_out_text (uiout
, "in ");
4908 ui_out_field_string (uiout
, "func",
4909 SYMBOL_PRINT_NAME (sym
));
4910 ui_out_wrap_hint (uiout
, wrap_indent
);
4911 ui_out_text (uiout
, " at ");
4914 ui_out_field_skip (uiout
, "func");
4916 if (sal
.symtab
!= NULL
)
4918 ui_out_field_string (uiout
, "file",
4919 symtab_to_filename_for_display (sal
.symtab
));
4920 ui_out_text (uiout
, ":");
4922 if (ui_out_is_mi_like_p (uiout
))
4924 const char *fullname
= symtab_to_fullname (sal
.symtab
);
4926 ui_out_field_string (uiout
, "fullname", fullname
);
4929 ui_out_field_skip (uiout
, "fullname");
4931 ui_out_field_int (uiout
, "line", sal
.line
);
4935 ui_out_field_skip (uiout
, "fullname");
4936 ui_out_field_skip (uiout
, "line");
4939 ui_out_text (uiout
, "\n");
4940 ui_out_text (uiout
, extra_field_indent
);
4941 ui_out_text (uiout
, _("Data: \""));
4942 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
4943 ui_out_text (uiout
, "\"\n");
4945 if (!VEC_empty (breakpoint_p
, tracepoints
))
4947 struct cleanup
*cleanup_chain
;
4949 struct breakpoint
*b
;
4951 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
4954 ui_out_text (uiout
, extra_field_indent
);
4955 ui_out_text (uiout
, _("Probed by static tracepoints: "));
4956 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
4959 ui_out_text (uiout
, ", ");
4960 ui_out_text (uiout
, "#");
4961 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
4964 do_cleanups (cleanup_chain
);
4966 if (ui_out_is_mi_like_p (uiout
))
4967 ui_out_field_int (uiout
, "number-of-tracepoints",
4968 VEC_length(breakpoint_p
, tracepoints
));
4970 ui_out_text (uiout
, "\n");
4972 VEC_free (breakpoint_p
, tracepoints
);
4974 do_cleanups (bkpt_chain
);
4978 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
4980 VEC(static_tracepoint_marker_p
) *markers
;
4981 struct cleanup
*old_chain
;
4982 struct static_tracepoint_marker
*marker
;
4983 struct ui_out
*uiout
= current_uiout
;
4986 /* We don't have to check target_can_use_agent and agent's capability on
4987 static tracepoint here, in order to be compatible with older GDBserver.
4988 We don't check USE_AGENT is true or not, because static tracepoints
4989 don't work without in-process agent, so we don't bother users to type
4990 `set agent on' when to use static tracepoint. */
4993 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
4994 "StaticTracepointMarkersTable");
4996 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
4998 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
5000 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
5001 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
5002 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
5004 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
5005 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
5007 ui_out_table_body (uiout
);
5009 markers
= target_static_tracepoint_markers_by_strid (NULL
);
5010 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
5013 VEC_iterate (static_tracepoint_marker_p
,
5014 markers
, i
, marker
);
5017 print_one_static_tracepoint_marker (i
+ 1, marker
);
5018 release_static_tracepoint_marker (marker
);
5021 do_cleanups (old_chain
);
5024 /* The $_sdata convenience variable is a bit special. We don't know
5025 for sure type of the value until we actually have a chance to fetch
5026 the data --- the size of the object depends on what has been
5027 collected. We solve this by making $_sdata be an internalvar that
5028 creates a new value on access. */
5030 /* Return a new value with the correct type for the sdata object of
5031 the current trace frame. Return a void value if there's no object
5034 static struct value
*
5035 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
5041 /* We need to read the whole object before we know its size. */
5042 size
= target_read_alloc (¤t_target
,
5043 TARGET_OBJECT_STATIC_TRACE_DATA
,
5050 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
5052 v
= allocate_value (type
);
5053 memcpy (value_contents_raw (v
), buf
, size
);
5058 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
5061 #if !defined(HAVE_LIBEXPAT)
5063 struct traceframe_info
*
5064 parse_traceframe_info (const char *tframe_info
)
5066 static int have_warned
;
5071 warning (_("Can not parse XML trace frame info; XML support "
5072 "was disabled at compile time"));
5078 #else /* HAVE_LIBEXPAT */
5080 #include "xml-support.h"
5082 /* Handle the start of a <memory> element. */
5085 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
5086 const struct gdb_xml_element
*element
,
5087 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
5089 struct traceframe_info
*info
= user_data
;
5090 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5091 ULONGEST
*start_p
, *length_p
;
5093 start_p
= xml_find_attribute (attributes
, "start")->value
;
5094 length_p
= xml_find_attribute (attributes
, "length")->value
;
5096 r
->start
= *start_p
;
5097 r
->length
= *length_p
;
5100 /* Discard the constructed trace frame info (if an error occurs). */
5103 free_result (void *p
)
5105 struct traceframe_info
*result
= p
;
5107 free_traceframe_info (result
);
5110 /* The allowed elements and attributes for an XML memory map. */
5112 static const struct gdb_xml_attribute memory_attributes
[] = {
5113 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5114 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5115 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5118 static const struct gdb_xml_element traceframe_info_children
[] = {
5119 { "memory", memory_attributes
, NULL
,
5120 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5121 traceframe_info_start_memory
, NULL
},
5122 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5125 static const struct gdb_xml_element traceframe_info_elements
[] = {
5126 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
5128 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5131 /* Parse a traceframe-info XML document. */
5133 struct traceframe_info
*
5134 parse_traceframe_info (const char *tframe_info
)
5136 struct traceframe_info
*result
;
5137 struct cleanup
*back_to
;
5139 result
= XCNEW (struct traceframe_info
);
5140 back_to
= make_cleanup (free_result
, result
);
5142 if (gdb_xml_parse_quick (_("trace frame info"),
5143 "traceframe-info.dtd", traceframe_info_elements
,
5144 tframe_info
, result
) == 0)
5146 /* Parsed successfully, keep the result. */
5147 discard_cleanups (back_to
);
5152 do_cleanups (back_to
);
5156 #endif /* HAVE_LIBEXPAT */
5158 /* Returns the traceframe_info object for the current traceframe.
5159 This is where we avoid re-fetching the object from the target if we
5160 already have it cached. */
5162 static struct traceframe_info
*
5163 get_traceframe_info (void)
5165 if (traceframe_info
== NULL
)
5166 traceframe_info
= target_traceframe_info ();
5168 return traceframe_info
;
5171 /* If the target supports the query, return in RESULT the set of
5172 collected memory in the current traceframe, found within the LEN
5173 bytes range starting at MEMADDR. Returns true if the target
5174 supports the query, otherwise returns false, and RESULT is left
5178 traceframe_available_memory (VEC(mem_range_s
) **result
,
5179 CORE_ADDR memaddr
, ULONGEST len
)
5181 struct traceframe_info
*info
= get_traceframe_info ();
5185 struct mem_range
*r
;
5190 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
5191 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
5193 ULONGEST lo1
, hi1
, lo2
, hi2
;
5194 struct mem_range
*nr
;
5197 hi1
= memaddr
+ len
;
5200 hi2
= r
->start
+ r
->length
;
5202 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
5204 nr
->start
= max (lo1
, lo2
);
5205 nr
->length
= min (hi1
, hi2
) - nr
->start
;
5208 normalize_mem_ranges (*result
);
5215 /* Implementation of `sdata' variable. */
5217 static const struct internalvar_funcs sdata_funcs
=
5224 /* module initialization */
5226 _initialize_tracepoint (void)
5228 struct cmd_list_element
*c
;
5230 /* Explicitly create without lookup, since that tries to create a
5231 value with a void typed value, and when we get here, gdbarch
5232 isn't initialized yet. At this point, we're quite sure there
5233 isn't another convenience variable of the same name. */
5234 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
5236 traceframe_number
= -1;
5237 tracepoint_number
= -1;
5239 if (tracepoint_list
.list
== NULL
)
5241 tracepoint_list
.listsize
= 128;
5242 tracepoint_list
.list
= xmalloc
5243 (tracepoint_list
.listsize
* sizeof (struct memrange
));
5245 if (tracepoint_list
.aexpr_list
== NULL
)
5247 tracepoint_list
.aexpr_listsize
= 128;
5248 tracepoint_list
.aexpr_list
= xmalloc
5249 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5252 if (stepping_list
.list
== NULL
)
5254 stepping_list
.listsize
= 128;
5255 stepping_list
.list
= xmalloc
5256 (stepping_list
.listsize
* sizeof (struct memrange
));
5259 if (stepping_list
.aexpr_list
== NULL
)
5261 stepping_list
.aexpr_listsize
= 128;
5262 stepping_list
.aexpr_list
= xmalloc
5263 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5266 add_info ("scope", scope_info
,
5267 _("List the variables local to a scope"));
5269 add_cmd ("tracepoints", class_trace
, NULL
,
5270 _("Tracing of program execution without stopping the program."),
5273 add_com ("tdump", class_trace
, trace_dump_command
,
5274 _("Print everything collected at the current tracepoint."));
5276 add_com ("tsave", class_trace
, trace_save_command
, _("\
5277 Save the trace data to a file.\n\
5278 Use the '-r' option to direct the target to save directly to the file,\n\
5279 using its own filesystem."));
5281 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
5282 Define a trace state variable.\n\
5283 Argument is a $-prefixed name, optionally followed\n\
5284 by '=' and an expression that sets the initial value\n\
5285 at the start of tracing."));
5286 set_cmd_completer (c
, expression_completer
);
5288 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
5289 Delete one or more trace state variables.\n\
5290 Arguments are the names of the variables to delete.\n\
5291 If no arguments are supplied, delete all variables."), &deletelist
);
5292 /* FIXME add a trace variable completer. */
5294 add_info ("tvariables", tvariables_info
, _("\
5295 Status of trace state variables and their values.\n\
5298 add_info ("static-tracepoint-markers",
5299 info_static_tracepoint_markers_command
, _("\
5300 List target static tracepoints markers.\n\
5303 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
5304 Select a trace frame;\n\
5305 No argument means forward by one frame; '-' means backward by one frame."),
5306 &tfindlist
, "tfind ", 1, &cmdlist
);
5308 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
5309 Select a trace frame whose PC is outside the given range (exclusive).\n\
5310 Usage: tfind outside addr1, addr2"),
5313 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
5314 Select a trace frame whose PC is in the given range (inclusive).\n\
5315 Usage: tfind range addr1,addr2"),
5318 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
5319 Select a trace frame by source line.\n\
5320 Argument can be a line number (with optional source file),\n\
5321 a function name, or '*' followed by an address.\n\
5322 Default argument is 'the next source line that was traced'."),
5325 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
5326 Select a trace frame by tracepoint number.\n\
5327 Default is the tracepoint for the current trace frame."),
5330 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
5331 Select a trace frame by PC.\n\
5332 Default is the current PC, or the PC of the current trace frame."),
5335 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
5336 De-select any trace frame and resume 'live' debugging."),
5339 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
5341 add_cmd ("start", class_trace
, trace_find_start_command
,
5342 _("Select the first trace frame in the trace buffer."),
5345 add_com ("tstatus", class_trace
, trace_status_command
,
5346 _("Display the status of the current trace data collection."));
5348 add_com ("tstop", class_trace
, trace_stop_command
, _("\
5349 Stop trace data collection.\n\
5350 Usage: tstop [ <notes> ... ]\n\
5351 Any arguments supplied are recorded with the trace as a stop reason and\n\
5352 reported by tstatus (if the target supports trace notes)."));
5354 add_com ("tstart", class_trace
, trace_start_command
, _("\
5355 Start trace data collection.\n\
5356 Usage: tstart [ <notes> ... ]\n\
5357 Any arguments supplied are recorded with the trace as a note and\n\
5358 reported by tstatus (if the target supports trace notes)."));
5360 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
5361 Ends a list of commands or actions.\n\
5362 Several GDB commands allow you to enter a list of commands or actions.\n\
5363 Entering \"end\" on a line by itself is the normal way to terminate\n\
5365 Note: the \"end\" command cannot be used at the gdb prompt."));
5367 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
5368 Specify single-stepping behavior at a tracepoint.\n\
5369 Argument is number of instructions to trace in single-step mode\n\
5370 following the tracepoint. This command is normally followed by\n\
5371 one or more \"collect\" commands, to specify what to collect\n\
5372 while single-stepping.\n\n\
5373 Note: this command can only be used in a tracepoint \"actions\" list."));
5375 add_com_alias ("ws", "while-stepping", class_alias
, 0);
5376 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
5378 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
5379 Specify one or more data items to be collected at a tracepoint.\n\
5380 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5381 collect all data (variables, registers) referenced by that expression.\n\
5382 Also accepts the following special arguments:\n\
5383 $regs -- all registers.\n\
5384 $args -- all function arguments.\n\
5385 $locals -- all variables local to the block/function scope.\n\
5386 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5387 Note: this command can only be used in a tracepoint \"actions\" list."));
5389 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
5390 Specify one or more expressions to be evaluated at a tracepoint.\n\
5391 Accepts a comma-separated list of (one or more) expressions.\n\
5392 The result of each evaluation will be discarded.\n\
5393 Note: this command can only be used in a tracepoint \"actions\" list."));
5395 add_com ("actions", class_trace
, trace_actions_command
, _("\
5396 Specify the actions to be taken at a tracepoint.\n\
5397 Tracepoint actions may include collecting of specified data,\n\
5398 single-stepping, or enabling/disabling other tracepoints,\n\
5399 depending on target's capabilities."));
5401 default_collect
= xstrdup ("");
5402 add_setshow_string_cmd ("default-collect", class_trace
,
5403 &default_collect
, _("\
5404 Set the list of expressions to collect by default"), _("\
5405 Show the list of expressions to collect by default"), NULL
,
5407 &setlist
, &showlist
);
5409 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
5410 &disconnected_tracing
, _("\
5411 Set whether tracing continues after GDB disconnects."), _("\
5412 Show whether tracing continues after GDB disconnects."), _("\
5413 Use this to continue a tracing run even if GDB disconnects\n\
5414 or detaches from the target. You can reconnect later and look at\n\
5415 trace data collected in the meantime."),
5416 set_disconnected_tracing
,
5421 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
5422 &circular_trace_buffer
, _("\
5423 Set target's use of circular trace buffer."), _("\
5424 Show target's use of circular trace buffer."), _("\
5425 Use this to make the trace buffer into a circular buffer,\n\
5426 which will discard traceframes (oldest first) instead of filling\n\
5427 up and stopping the trace run."),
5428 set_circular_trace_buffer
,
5433 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class
,
5434 &trace_buffer_size
, _("\
5435 Set requested size of trace buffer."), _("\
5436 Show requested size of trace buffer."), _("\
5437 Use this to choose a size for the trace buffer. Some targets\n\
5438 may have fixed or limited buffer sizes. A value of -1 disables\n\
5439 any attempt to set the buffer size and lets the target choose."),
5440 set_trace_buffer_size
, NULL
,
5441 &setlist
, &showlist
);
5443 add_setshow_string_cmd ("trace-user", class_trace
,
5445 Set the user name to use for current and future trace runs"), _("\
5446 Show the user name to use for current and future trace runs"), NULL
,
5447 set_trace_user
, NULL
,
5448 &setlist
, &showlist
);
5450 add_setshow_string_cmd ("trace-notes", class_trace
,
5452 Set notes string to use for current and future trace runs"), _("\
5453 Show the notes string to use for current and future trace runs"), NULL
,
5454 set_trace_notes
, NULL
,
5455 &setlist
, &showlist
);
5457 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
5458 &trace_stop_notes
, _("\
5459 Set notes string to use for future tstop commands"), _("\
5460 Show the notes string to use for future tstop commands"), NULL
,
5461 set_trace_stop_notes
, NULL
,
5462 &setlist
, &showlist
);
5466 add_target (&tfile_ops
);