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 extern int hex2bin (const char *hex
, gdb_byte
*bin
, int count
);
73 extern int bin2hex (const gdb_byte
*bin
, char *hex
, int count
);
75 /* Maximum length of an agent aexpression.
76 This accounts for the fact that packets are limited to 400 bytes
77 (which includes everything -- including the checksum), and assumes
78 the worst case of maximum length for each of the pieces of a
81 NOTE: expressions get mem2hex'ed otherwise this would be twice as
82 large. (400 - 31)/2 == 184 */
83 #define MAX_AGENT_EXPR_LEN 184
87 /* A hook used to notify the UI of tracepoint operations. */
89 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
90 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
92 extern void (*deprecated_readline_begin_hook
) (char *, ...);
93 extern char *(*deprecated_readline_hook
) (char *);
94 extern void (*deprecated_readline_end_hook
) (void);
99 This module defines the following debugger commands:
100 trace : set a tracepoint on a function, line, or address.
101 info trace : list all debugger-defined tracepoints.
102 delete trace : delete one or more tracepoints.
103 enable trace : enable one or more tracepoints.
104 disable trace : disable one or more tracepoints.
105 actions : specify actions to be taken at a tracepoint.
106 passcount : specify a pass count for a tracepoint.
107 tstart : start a trace experiment.
108 tstop : stop a trace experiment.
109 tstatus : query the status of a trace experiment.
110 tfind : find a trace frame in the trace buffer.
111 tdump : print everything collected at the current tracepoint.
112 save-tracepoints : write tracepoint setup into a file.
114 This module defines the following user-visible debugger variables:
115 $trace_frame : sequence number of trace frame currently being debugged.
116 $trace_line : source line of trace frame currently being debugged.
117 $trace_file : source file of trace frame currently being debugged.
118 $tracepoint : tracepoint number of trace frame currently being debugged.
122 /* ======= Important global variables: ======= */
124 /* The list of all trace state variables. We don't retain pointers to
125 any of these for any reason - API is by name or number only - so it
126 works to have a vector of objects. */
128 typedef struct trace_state_variable tsv_s
;
131 /* An object describing the contents of a traceframe. */
133 struct traceframe_info
135 /* Collected memory. */
136 VEC(mem_range_s
) *memory
;
139 static VEC(tsv_s
) *tvariables
;
141 /* The next integer to assign to a variable. */
143 static int next_tsv_number
= 1;
145 /* Number of last traceframe collected. */
146 static int traceframe_number
;
148 /* Tracepoint for last traceframe collected. */
149 static int tracepoint_number
;
151 /* Symbol for function for last traceframe collected. */
152 static struct symbol
*traceframe_fun
;
154 /* Symtab and line for last traceframe collected. */
155 static struct symtab_and_line traceframe_sal
;
157 /* The traceframe info of the current traceframe. NULL if we haven't
158 yet attempted to fetch it, or if the target does not support
159 fetching this object, or if we're not inspecting a traceframe
161 static struct traceframe_info
*traceframe_info
;
163 /* Tracing command lists. */
164 static struct cmd_list_element
*tfindlist
;
166 /* List of expressions to collect by default at each tracepoint hit. */
167 char *default_collect
= "";
169 static int disconnected_tracing
;
171 /* This variable controls whether we ask the target for a linear or
172 circular trace buffer. */
174 static int circular_trace_buffer
;
176 /* Textual notes applying to the current and/or future trace runs. */
178 char *trace_user
= NULL
;
180 /* Textual notes applying to the current and/or future trace runs. */
182 char *trace_notes
= NULL
;
184 /* Textual notes applying to the stopping of a trace. */
186 char *trace_stop_notes
= NULL
;
188 /* ======= Important command functions: ======= */
189 static void trace_actions_command (char *, int);
190 static void trace_start_command (char *, int);
191 static void trace_stop_command (char *, int);
192 static void trace_status_command (char *, int);
193 static void trace_find_command (char *, int);
194 static void trace_find_pc_command (char *, int);
195 static void trace_find_tracepoint_command (char *, int);
196 static void trace_find_line_command (char *, int);
197 static void trace_find_range_command (char *, int);
198 static void trace_find_outside_command (char *, int);
199 static void trace_dump_command (char *, int);
201 /* support routines */
203 struct collection_list
;
204 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
205 static char *mem2hex (gdb_byte
*, char *, int);
206 static void add_register (struct collection_list
*collection
,
209 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
210 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
213 extern void _initialize_tracepoint (void);
215 static struct trace_status trace_status
;
217 char *stop_reason_names
[] = {
227 struct trace_status
*
228 current_trace_status (void)
230 return &trace_status
;
236 free_traceframe_info (struct traceframe_info
*info
)
240 VEC_free (mem_range_s
, info
->memory
);
246 /* Free and clear the traceframe info cache of the current
250 clear_traceframe_info (void)
252 free_traceframe_info (traceframe_info
);
253 traceframe_info
= NULL
;
256 /* Set traceframe number to NUM. */
258 set_traceframe_num (int num
)
260 traceframe_number
= num
;
261 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
264 /* Set tracepoint number to NUM. */
266 set_tracepoint_num (int num
)
268 tracepoint_number
= num
;
269 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
272 /* Set externally visible debug variables for querying/printing
273 the traceframe context (line, function, file). */
276 set_traceframe_context (struct frame_info
*trace_frame
)
280 /* Save as globals for internal use. */
281 if (trace_frame
!= NULL
282 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
284 traceframe_sal
= find_pc_line (trace_pc
, 0);
285 traceframe_fun
= find_pc_function (trace_pc
);
287 /* Save linenumber as "$trace_line", a debugger variable visible to
289 set_internalvar_integer (lookup_internalvar ("trace_line"),
290 traceframe_sal
.line
);
294 init_sal (&traceframe_sal
);
295 traceframe_fun
= NULL
;
296 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
299 /* Save func name as "$trace_func", a debugger variable visible to
301 if (traceframe_fun
== NULL
302 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
303 clear_internalvar (lookup_internalvar ("trace_func"));
305 set_internalvar_string (lookup_internalvar ("trace_func"),
306 SYMBOL_LINKAGE_NAME (traceframe_fun
));
308 /* Save file name as "$trace_file", a debugger variable visible to
310 if (traceframe_sal
.symtab
== NULL
)
311 clear_internalvar (lookup_internalvar ("trace_file"));
313 set_internalvar_string (lookup_internalvar ("trace_file"),
314 traceframe_sal
.symtab
->filename
);
317 /* Create a new trace state variable with the given name. */
319 struct trace_state_variable
*
320 create_trace_state_variable (const char *name
)
322 struct trace_state_variable tsv
;
324 memset (&tsv
, 0, sizeof (tsv
));
325 tsv
.name
= xstrdup (name
);
326 tsv
.number
= next_tsv_number
++;
327 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
330 /* Look for a trace state variable of the given name. */
332 struct trace_state_variable
*
333 find_trace_state_variable (const char *name
)
335 struct trace_state_variable
*tsv
;
338 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
339 if (strcmp (name
, tsv
->name
) == 0)
346 delete_trace_state_variable (const char *name
)
348 struct trace_state_variable
*tsv
;
351 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
352 if (strcmp (name
, tsv
->name
) == 0)
354 xfree ((void *)tsv
->name
);
355 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
357 observer_notify_tsv_deleted (name
);
362 warning (_("No trace variable named \"$%s\", not deleting"), name
);
365 /* The 'tvariable' command collects a name and optional expression to
366 evaluate into an initial value. */
369 trace_variable_command (char *args
, int from_tty
)
371 struct expression
*expr
;
372 struct cleanup
*old_chain
;
373 struct internalvar
*intvar
= NULL
;
375 struct trace_state_variable
*tsv
;
378 error_no_arg (_("trace state variable name"));
380 /* All the possible valid arguments are expressions. */
381 expr
= parse_expression (args
);
382 old_chain
= make_cleanup (free_current_contents
, &expr
);
384 if (expr
->nelts
== 0)
385 error (_("No expression?"));
387 /* Only allow two syntaxes; "$name" and "$name=value". */
388 if (expr
->elts
[0].opcode
== OP_INTERNALVAR
)
390 intvar
= expr
->elts
[1].internalvar
;
392 else if (expr
->elts
[0].opcode
== BINOP_ASSIGN
393 && expr
->elts
[1].opcode
== OP_INTERNALVAR
)
395 intvar
= expr
->elts
[2].internalvar
;
396 initval
= value_as_long (evaluate_subexpression_type (expr
, 4));
399 error (_("Syntax must be $NAME [ = EXPR ]"));
402 error (_("No name given"));
404 if (strlen (internalvar_name (intvar
)) <= 0)
405 error (_("Must supply a non-empty variable name"));
407 /* If the variable already exists, just change its initial value. */
408 tsv
= find_trace_state_variable (internalvar_name (intvar
));
411 tsv
->initial_value
= initval
;
412 printf_filtered (_("Trace state variable $%s "
413 "now has initial value %s.\n"),
414 tsv
->name
, plongest (tsv
->initial_value
));
415 do_cleanups (old_chain
);
419 /* Create a new variable. */
420 tsv
= create_trace_state_variable (internalvar_name (intvar
));
421 tsv
->initial_value
= initval
;
423 observer_notify_tsv_created (tsv
->name
, initval
);
425 printf_filtered (_("Trace state variable $%s "
426 "created, with initial value %s.\n"),
427 tsv
->name
, plongest (tsv
->initial_value
));
429 do_cleanups (old_chain
);
433 delete_trace_variable_command (char *args
, int from_tty
)
437 struct cleanup
*back_to
;
441 if (query (_("Delete all trace state variables? ")))
442 VEC_free (tsv_s
, tvariables
);
444 observer_notify_tsv_deleted (NULL
);
448 argv
= gdb_buildargv (args
);
449 back_to
= make_cleanup_freeargv (argv
);
451 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
453 if (*argv
[ix
] == '$')
454 delete_trace_state_variable (argv
[ix
] + 1);
456 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
459 do_cleanups (back_to
);
465 tvariables_info_1 (void)
467 struct trace_state_variable
*tsv
;
470 struct cleanup
*back_to
;
471 struct ui_out
*uiout
= current_uiout
;
473 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
475 printf_filtered (_("No trace state variables.\n"));
479 /* Try to acquire values from the target. */
480 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
481 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
484 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
485 count
, "trace-variables");
486 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
487 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
488 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
490 ui_out_table_body (uiout
);
492 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
494 struct cleanup
*back_to2
;
498 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
500 name
= concat ("$", tsv
->name
, (char *) NULL
);
501 make_cleanup (xfree
, name
);
502 ui_out_field_string (uiout
, "name", name
);
503 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
505 if (tsv
->value_known
)
506 c
= plongest (tsv
->value
);
507 else if (ui_out_is_mi_like_p (uiout
))
508 /* For MI, we prefer not to use magic string constants, but rather
509 omit the field completely. The difference between unknown and
510 undefined does not seem important enough to represent. */
512 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
513 /* The value is/was defined, but we don't have it. */
516 /* It is not meaningful to ask about the value. */
519 ui_out_field_string (uiout
, "current", c
);
520 ui_out_text (uiout
, "\n");
522 do_cleanups (back_to2
);
525 do_cleanups (back_to
);
528 /* List all the trace state variables. */
531 tvariables_info (char *args
, int from_tty
)
533 tvariables_info_1 ();
536 /* Stash definitions of tsvs into the given file. */
539 save_trace_state_variables (struct ui_file
*fp
)
541 struct trace_state_variable
*tsv
;
544 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
546 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
547 if (tsv
->initial_value
)
548 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
549 fprintf_unfiltered (fp
, "\n");
553 /* ACTIONS functions: */
555 /* The three functions:
556 collect_pseudocommand,
557 while_stepping_pseudocommand, and
558 end_actions_pseudocommand
559 are placeholders for "commands" that are actually ONLY to be used
560 within a tracepoint action list. If the actual function is ever called,
561 it means that somebody issued the "command" at the top level,
562 which is always an error. */
565 end_actions_pseudocommand (char *args
, int from_tty
)
567 error (_("This command cannot be used at the top level."));
571 while_stepping_pseudocommand (char *args
, int from_tty
)
573 error (_("This command can only be used in a tracepoint actions list."));
577 collect_pseudocommand (char *args
, int from_tty
)
579 error (_("This command can only be used in a tracepoint actions list."));
583 teval_pseudocommand (char *args
, int from_tty
)
585 error (_("This command can only be used in a tracepoint actions list."));
588 /* Parse any collection options, such as /s for strings. */
591 decode_agent_options (char *exp
)
593 struct value_print_options opts
;
598 /* Call this to borrow the print elements default for collection
600 get_user_print_options (&opts
);
605 if (target_supports_string_tracing ())
607 /* Allow an optional decimal number giving an explicit maximum
608 string length, defaulting it to the "print elements" value;
609 so "collect/s80 mystr" gets at most 80 bytes of string. */
610 trace_string_kludge
= opts
.print_max
;
612 if (*exp
>= '0' && *exp
<= '9')
613 trace_string_kludge
= atoi (exp
);
614 while (*exp
>= '0' && *exp
<= '9')
618 error (_("Target does not support \"/s\" option for string tracing."));
621 error (_("Undefined collection format \"%c\"."), *exp
);
623 exp
= skip_spaces (exp
);
628 /* Enter a list of actions for a tracepoint. */
630 trace_actions_command (char *args
, int from_tty
)
632 struct tracepoint
*t
;
633 struct command_line
*l
;
635 t
= get_tracepoint_by_number (&args
, NULL
, 1);
639 xstrprintf ("Enter actions for tracepoint %d, one per line.",
641 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
643 l
= read_command_lines (tmpbuf
, from_tty
, 1,
644 check_tracepoint_command
, t
);
645 do_cleanups (cleanups
);
646 breakpoint_set_commands (&t
->base
, l
);
648 /* else just return */
651 /* Report the results of checking the agent expression, as errors or
655 report_agent_reqs_errors (struct agent_expr
*aexpr
)
657 /* All of the "flaws" are serious bytecode generation issues that
658 should never occur. */
659 if (aexpr
->flaw
!= agent_flaw_none
)
660 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
662 /* If analysis shows a stack underflow, GDB must have done something
663 badly wrong in its bytecode generation. */
664 if (aexpr
->min_height
< 0)
665 internal_error (__FILE__
, __LINE__
,
666 _("expression has min height < 0"));
668 /* Issue this error if the stack is predicted to get too deep. The
669 limit is rather arbitrary; a better scheme might be for the
670 target to report how much stack it will have available. The
671 depth roughly corresponds to parenthesization, so a limit of 20
672 amounts to 20 levels of expression nesting, which is actually
673 a pretty big hairy expression. */
674 if (aexpr
->max_height
> 20)
675 error (_("Expression is too complicated."));
678 /* worker function */
680 validate_actionline (char **line
, struct breakpoint
*b
)
682 struct cmd_list_element
*c
;
683 struct expression
*exp
= NULL
;
684 struct cleanup
*old_chain
= NULL
;
686 struct bp_location
*loc
;
687 struct agent_expr
*aexpr
;
688 struct tracepoint
*t
= (struct tracepoint
*) b
;
690 /* If EOF is typed, *line is NULL. */
694 for (p
= *line
; isspace ((int) *p
);)
697 /* Symbol lookup etc. */
698 if (*p
== '\0') /* empty line: just prompt for another line. */
701 if (*p
== '#') /* comment line */
704 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
706 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
708 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
710 trace_string_kludge
= 0;
712 p
= decode_agent_options (p
);
715 { /* Repeat over a comma-separated list. */
716 QUIT
; /* Allow user to bail out with ^C. */
717 while (isspace ((int) *p
))
720 if (*p
== '$') /* Look for special pseudo-symbols. */
722 if (0 == strncasecmp ("reg", p
+ 1, 3)
723 || 0 == strncasecmp ("arg", p
+ 1, 3)
724 || 0 == strncasecmp ("loc", p
+ 1, 3)
725 || 0 == strncasecmp ("_ret", p
+ 1, 4)
726 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
731 /* else fall thru, treat p as an expression and parse it! */
734 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
737 exp
= parse_exp_1 (&p
, loc
->address
,
738 block_for_pc (loc
->address
), 1);
739 old_chain
= make_cleanup (free_current_contents
, &exp
);
741 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
743 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
745 error (_("constant `%s' (value %s) "
746 "will not be collected."),
747 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
748 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
750 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
751 == LOC_OPTIMIZED_OUT
)
753 error (_("`%s' is optimized away "
754 "and cannot be collected."),
755 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
759 /* We have something to collect, make sure that the expr to
760 bytecode translator can handle it and that it's not too
762 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
763 make_cleanup_free_agent_expr (aexpr
);
765 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
766 error (_("Expression is too complicated."));
770 report_agent_reqs_errors (aexpr
);
772 do_cleanups (old_chain
);
775 while (p
&& *p
++ == ',');
778 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
781 { /* Repeat over a comma-separated list. */
782 QUIT
; /* Allow user to bail out with ^C. */
783 while (isspace ((int) *p
))
787 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
790 /* Only expressions are allowed for this action. */
791 exp
= parse_exp_1 (&p
, loc
->address
,
792 block_for_pc (loc
->address
), 1);
793 old_chain
= make_cleanup (free_current_contents
, &exp
);
795 /* We have something to evaluate, make sure that the expr to
796 bytecode translator can handle it and that it's not too
798 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
799 make_cleanup_free_agent_expr (aexpr
);
801 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
802 error (_("Expression is too complicated."));
805 report_agent_reqs_errors (aexpr
);
807 do_cleanups (old_chain
);
810 while (p
&& *p
++ == ',');
813 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
815 char *steparg
; /* In case warning is necessary. */
817 while (isspace ((int) *p
))
821 if (*p
== '\0' || (t
->step_count
= strtol (p
, &p
, 0)) == 0)
822 error (_("while-stepping step count `%s' is malformed."), *line
);
825 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
829 error (_("`%s' is not a supported tracepoint action."), *line
);
833 memrange_absolute
= -1
838 int type
; /* memrange_absolute for absolute memory range,
839 else basereg number. */
840 bfd_signed_vma start
;
844 struct collection_list
846 unsigned char regs_mask
[32]; /* room for up to 256 regs */
849 struct memrange
*list
;
850 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
852 struct agent_expr
**aexpr_list
;
854 /* True is the user requested a collection of "$_sdata", "static
858 tracepoint_list
, stepping_list
;
860 /* MEMRANGE functions: */
862 static int memrange_cmp (const void *, const void *);
864 /* Compare memranges for qsort. */
866 memrange_cmp (const void *va
, const void *vb
)
868 const struct memrange
*a
= va
, *b
= vb
;
870 if (a
->type
< b
->type
)
872 if (a
->type
> b
->type
)
874 if (a
->type
== memrange_absolute
)
876 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
878 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
883 if (a
->start
< b
->start
)
885 if (a
->start
> b
->start
)
891 /* Sort the memrange list using qsort, and merge adjacent memranges. */
893 memrange_sortmerge (struct collection_list
*memranges
)
897 qsort (memranges
->list
, memranges
->next_memrange
,
898 sizeof (struct memrange
), memrange_cmp
);
899 if (memranges
->next_memrange
> 0)
901 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
903 /* If memrange b overlaps or is adjacent to memrange a,
905 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
906 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
908 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
909 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
910 continue; /* next b, same a */
914 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
915 sizeof (struct memrange
));
917 memranges
->next_memrange
= a
+ 1;
921 /* Add a register to a collection list. */
923 add_register (struct collection_list
*collection
, unsigned int regno
)
926 printf_filtered ("collect register %d\n", regno
);
927 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
928 error (_("Internal: register number %d too large for tracepoint"),
930 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
933 /* Add a memrange to a collection list. */
935 add_memrange (struct collection_list
*memranges
,
936 int type
, bfd_signed_vma base
,
941 printf_filtered ("(%d,", type
);
943 printf_filtered (",%ld)\n", len
);
946 /* type: memrange_absolute == memory, other n == basereg */
947 memranges
->list
[memranges
->next_memrange
].type
= type
;
948 /* base: addr if memory, offset if reg relative. */
949 memranges
->list
[memranges
->next_memrange
].start
= base
;
950 /* len: we actually save end (base + len) for convenience */
951 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
952 memranges
->next_memrange
++;
953 if (memranges
->next_memrange
>= memranges
->listsize
)
955 memranges
->listsize
*= 2;
956 memranges
->list
= xrealloc (memranges
->list
,
957 memranges
->listsize
);
960 if (type
!= memrange_absolute
) /* Better collect the base register! */
961 add_register (memranges
, type
);
964 /* Add a symbol to a collection list. */
966 collect_symbol (struct collection_list
*collect
,
968 struct gdbarch
*gdbarch
,
969 long frame_regno
, long frame_offset
,
974 bfd_signed_vma offset
;
975 int treat_as_expr
= 0;
977 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
978 switch (SYMBOL_CLASS (sym
))
981 printf_filtered ("%s: don't know symbol class %d\n",
982 SYMBOL_PRINT_NAME (sym
),
986 printf_filtered ("constant %s (value %s) will not be collected.\n",
987 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
990 offset
= SYMBOL_VALUE_ADDRESS (sym
);
995 sprintf_vma (tmp
, offset
);
996 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
997 SYMBOL_PRINT_NAME (sym
), len
,
1000 /* A struct may be a C++ class with static fields, go to general
1001 expression handling. */
1002 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
1005 add_memrange (collect
, memrange_absolute
, offset
, len
);
1008 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1010 printf_filtered ("LOC_REG[parm] %s: ",
1011 SYMBOL_PRINT_NAME (sym
));
1012 add_register (collect
, reg
);
1013 /* Check for doubles stored in two registers. */
1014 /* FIXME: how about larger types stored in 3 or more regs? */
1015 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1016 len
> register_size (gdbarch
, reg
))
1017 add_register (collect
, reg
+ 1);
1020 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1021 printf_filtered (" (will not collect %s)\n",
1022 SYMBOL_PRINT_NAME (sym
));
1026 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1029 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1030 SYMBOL_PRINT_NAME (sym
), len
);
1031 printf_vma (offset
);
1032 printf_filtered (" from frame ptr reg %d\n", reg
);
1034 add_memrange (collect
, reg
, offset
, len
);
1036 case LOC_REGPARM_ADDR
:
1037 reg
= SYMBOL_VALUE (sym
);
1041 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1042 SYMBOL_PRINT_NAME (sym
), len
);
1043 printf_vma (offset
);
1044 printf_filtered (" from reg %d\n", reg
);
1046 add_memrange (collect
, reg
, offset
, len
);
1050 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1053 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1054 SYMBOL_PRINT_NAME (sym
), len
);
1055 printf_vma (offset
);
1056 printf_filtered (" from frame ptr reg %d\n", reg
);
1058 add_memrange (collect
, reg
, offset
, len
);
1061 case LOC_UNRESOLVED
:
1065 case LOC_OPTIMIZED_OUT
:
1066 printf_filtered ("%s has been optimized out of existence.\n",
1067 SYMBOL_PRINT_NAME (sym
));
1075 /* Expressions are the most general case. */
1078 struct agent_expr
*aexpr
;
1079 struct cleanup
*old_chain1
= NULL
;
1081 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
1083 /* It can happen that the symbol is recorded as a computed
1084 location, but it's been optimized away and doesn't actually
1085 have a location expression. */
1088 printf_filtered ("%s has been optimized out of existence.\n",
1089 SYMBOL_PRINT_NAME (sym
));
1093 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1097 report_agent_reqs_errors (aexpr
);
1099 discard_cleanups (old_chain1
);
1100 add_aexpr (collect
, aexpr
);
1102 /* Take care of the registers. */
1103 if (aexpr
->reg_mask_len
> 0)
1107 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1109 QUIT
; /* Allow user to bail out with ^C. */
1110 if (aexpr
->reg_mask
[ndx1
] != 0)
1112 /* Assume chars have 8 bits. */
1113 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1114 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1115 /* It's used -- record it. */
1116 add_register (collect
, ndx1
* 8 + ndx2
);
1123 /* Data to be passed around in the calls to the locals and args
1126 struct add_local_symbols_data
1128 struct collection_list
*collect
;
1129 struct gdbarch
*gdbarch
;
1136 /* The callback for the locals and args iterators. */
1139 do_collect_symbol (const char *print_name
,
1143 struct add_local_symbols_data
*p
= cb_data
;
1145 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1146 p
->frame_offset
, p
->pc
);
1150 /* Add all locals (or args) symbols to collection list. */
1152 add_local_symbols (struct collection_list
*collect
,
1153 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1154 long frame_regno
, long frame_offset
, int type
)
1156 struct block
*block
;
1157 struct add_local_symbols_data cb_data
;
1159 cb_data
.collect
= collect
;
1160 cb_data
.gdbarch
= gdbarch
;
1162 cb_data
.frame_regno
= frame_regno
;
1163 cb_data
.frame_offset
= frame_offset
;
1168 block
= block_for_pc (pc
);
1171 warning (_("Can't collect locals; "
1172 "no symbol table info available.\n"));
1176 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1177 if (cb_data
.count
== 0)
1178 warning (_("No locals found in scope."));
1182 pc
= get_pc_function_start (pc
);
1183 block
= block_for_pc (pc
);
1186 warning (_("Can't collect args; no symbol table info available."));
1190 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1191 if (cb_data
.count
== 0)
1192 warning (_("No args found in scope."));
1197 add_static_trace_data (struct collection_list
*collection
)
1200 printf_filtered ("collect static trace data\n");
1201 collection
->strace_data
= 1;
1204 /* worker function */
1206 clear_collection_list (struct collection_list
*list
)
1210 list
->next_memrange
= 0;
1211 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1213 free_agent_expr (list
->aexpr_list
[ndx
]);
1214 list
->aexpr_list
[ndx
] = NULL
;
1216 list
->next_aexpr_elt
= 0;
1217 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1218 list
->strace_data
= 0;
1221 /* Reduce a collection list to string form (for gdb protocol). */
1223 stringify_collection_list (struct collection_list
*list
, char *string
)
1225 char temp_buf
[2048];
1229 char *(*str_list
)[];
1233 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1234 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1236 if (list
->strace_data
)
1239 printf_filtered ("\nCollecting static trace data\n");
1242 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1246 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1247 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1249 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1252 printf_filtered ("\nCollecting registers (mask): 0x");
1257 QUIT
; /* Allow user to bail out with ^C. */
1259 printf_filtered ("%02X", list
->regs_mask
[i
]);
1260 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1263 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1267 printf_filtered ("\n");
1268 if (list
->next_memrange
> 0 && info_verbose
)
1269 printf_filtered ("Collecting memranges: \n");
1270 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1272 QUIT
; /* Allow user to bail out with ^C. */
1273 sprintf_vma (tmp2
, list
->list
[i
].start
);
1276 printf_filtered ("(%d, %s, %ld)\n",
1279 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1281 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1283 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1290 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1292 /* The "%X" conversion specifier expects an unsigned argument,
1293 so passing -1 (memrange_absolute) to it directly gives you
1294 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1296 if (list
->list
[i
].type
== memrange_absolute
)
1297 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1299 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1302 count
+= strlen (end
);
1303 end
= temp_buf
+ count
;
1306 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1308 QUIT
; /* Allow user to bail out with ^C. */
1309 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1311 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1316 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1317 end
+= 10; /* 'X' + 8 hex digits + ',' */
1320 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1321 end
, list
->aexpr_list
[i
]->len
);
1322 count
+= 2 * list
->aexpr_list
[i
]->len
;
1327 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1332 (*str_list
)[ndx
] = NULL
;
1345 encode_actions_1 (struct command_line
*action
,
1346 struct breakpoint
*t
,
1347 struct bp_location
*tloc
,
1349 LONGEST frame_offset
,
1350 struct collection_list
*collect
,
1351 struct collection_list
*stepping_list
)
1354 struct expression
*exp
= NULL
;
1356 struct value
*tempval
;
1357 struct cmd_list_element
*cmd
;
1358 struct agent_expr
*aexpr
;
1360 for (; action
; action
= action
->next
)
1362 QUIT
; /* Allow user to bail out with ^C. */
1363 action_exp
= action
->line
;
1364 while (isspace ((int) *action_exp
))
1367 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1369 error (_("Bad action list item: %s"), action_exp
);
1371 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1373 trace_string_kludge
= 0;
1374 if (*action_exp
== '/')
1375 action_exp
= decode_agent_options (action_exp
);
1378 { /* Repeat over a comma-separated list. */
1379 QUIT
; /* Allow user to bail out with ^C. */
1380 while (isspace ((int) *action_exp
))
1383 if (0 == strncasecmp ("$reg", action_exp
, 4))
1385 for (i
= 0; i
< gdbarch_num_regs (tloc
->gdbarch
); i
++)
1386 add_register (collect
, i
);
1387 action_exp
= strchr (action_exp
, ','); /* more? */
1389 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1391 add_local_symbols (collect
,
1397 action_exp
= strchr (action_exp
, ','); /* more? */
1399 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1401 add_local_symbols (collect
,
1407 action_exp
= strchr (action_exp
, ','); /* more? */
1409 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1411 struct cleanup
*old_chain1
= NULL
;
1413 aexpr
= gen_trace_for_return_address (tloc
->address
,
1416 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1419 report_agent_reqs_errors (aexpr
);
1421 discard_cleanups (old_chain1
);
1422 add_aexpr (collect
, aexpr
);
1424 /* take care of the registers */
1425 if (aexpr
->reg_mask_len
> 0)
1429 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1431 QUIT
; /* allow user to bail out with ^C */
1432 if (aexpr
->reg_mask
[ndx1
] != 0)
1434 /* assume chars have 8 bits */
1435 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1436 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1437 /* it's used -- record it */
1438 add_register (collect
,
1444 action_exp
= strchr (action_exp
, ','); /* more? */
1446 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1448 add_static_trace_data (collect
);
1449 action_exp
= strchr (action_exp
, ','); /* more? */
1454 struct cleanup
*old_chain
= NULL
;
1455 struct cleanup
*old_chain1
= NULL
;
1457 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1458 block_for_pc (tloc
->address
), 1);
1459 old_chain
= make_cleanup (free_current_contents
, &exp
);
1461 switch (exp
->elts
[0].opcode
)
1465 const char *name
= &exp
->elts
[2].string
;
1467 i
= user_reg_map_name_to_regnum (tloc
->gdbarch
,
1468 name
, strlen (name
));
1470 internal_error (__FILE__
, __LINE__
,
1471 _("Register $%s not available"),
1474 printf_filtered ("OP_REGISTER: ");
1475 add_register (collect
, i
);
1480 /* Safe because we know it's a simple expression. */
1481 tempval
= evaluate_expression (exp
);
1482 addr
= value_address (tempval
);
1483 /* Initialize the TYPE_LENGTH if it is a typedef. */
1484 check_typedef (exp
->elts
[1].type
);
1485 add_memrange (collect
, memrange_absolute
, addr
,
1486 TYPE_LENGTH (exp
->elts
[1].type
));
1490 collect_symbol (collect
,
1491 exp
->elts
[2].symbol
,
1498 default: /* Full-fledged expression. */
1499 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1501 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1505 report_agent_reqs_errors (aexpr
);
1507 discard_cleanups (old_chain1
);
1508 add_aexpr (collect
, aexpr
);
1510 /* Take care of the registers. */
1511 if (aexpr
->reg_mask_len
> 0)
1516 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1518 QUIT
; /* Allow user to bail out with ^C. */
1519 if (aexpr
->reg_mask
[ndx1
] != 0)
1521 /* Assume chars have 8 bits. */
1522 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1523 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1524 /* It's used -- record it. */
1525 add_register (collect
,
1532 do_cleanups (old_chain
);
1535 while (action_exp
&& *action_exp
++ == ',');
1537 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1540 { /* Repeat over a comma-separated list. */
1541 QUIT
; /* Allow user to bail out with ^C. */
1542 while (isspace ((int) *action_exp
))
1546 struct cleanup
*old_chain
= NULL
;
1547 struct cleanup
*old_chain1
= NULL
;
1549 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1550 block_for_pc (tloc
->address
), 1);
1551 old_chain
= make_cleanup (free_current_contents
, &exp
);
1553 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1554 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1557 report_agent_reqs_errors (aexpr
);
1559 discard_cleanups (old_chain1
);
1560 /* Even though we're not officially collecting, add
1561 to the collect list anyway. */
1562 add_aexpr (collect
, aexpr
);
1564 do_cleanups (old_chain
);
1567 while (action_exp
&& *action_exp
++ == ',');
1569 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1571 /* We check against nested while-stepping when setting
1572 breakpoint action, so no way to run into nested
1574 gdb_assert (stepping_list
);
1576 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
,
1577 frame_offset
, stepping_list
, NULL
);
1580 error (_("Invalid tracepoint command '%s'"), action
->line
);
1584 /* Render all actions into gdb protocol. */
1587 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1588 char ***tdp_actions
, char ***stepping_actions
)
1590 static char tdp_buff
[2048], step_buff
[2048];
1591 char *default_collect_line
= NULL
;
1592 struct command_line
*actions
;
1593 struct command_line
*default_collect_action
= NULL
;
1595 LONGEST frame_offset
;
1596 struct cleanup
*back_to
;
1598 back_to
= make_cleanup (null_cleanup
, NULL
);
1600 clear_collection_list (&tracepoint_list
);
1601 clear_collection_list (&stepping_list
);
1603 *tdp_actions
= NULL
;
1604 *stepping_actions
= NULL
;
1606 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1607 tloc
->address
, &frame_reg
, &frame_offset
);
1609 actions
= breakpoint_commands (t
);
1611 /* If there are default expressions to collect, make up a collect
1612 action and prepend to the action list to encode. Note that since
1613 validation is per-tracepoint (local var "xyz" might be valid for
1614 one tracepoint and not another, etc), we make up the action on
1615 the fly, and don't cache it. */
1616 if (*default_collect
)
1620 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1621 make_cleanup (xfree
, default_collect_line
);
1623 line
= default_collect_line
;
1624 validate_actionline (&line
, t
);
1626 default_collect_action
= xmalloc (sizeof (struct command_line
));
1627 make_cleanup (xfree
, default_collect_action
);
1628 default_collect_action
->next
= actions
;
1629 default_collect_action
->line
= line
;
1630 actions
= default_collect_action
;
1632 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1633 &tracepoint_list
, &stepping_list
);
1635 memrange_sortmerge (&tracepoint_list
);
1636 memrange_sortmerge (&stepping_list
);
1638 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1640 *stepping_actions
= stringify_collection_list (&stepping_list
,
1643 do_cleanups (back_to
);
1647 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1649 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1651 collect
->aexpr_list
=
1652 xrealloc (collect
->aexpr_list
,
1653 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1654 collect
->aexpr_listsize
*= 2;
1656 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1657 collect
->next_aexpr_elt
++;
1661 process_tracepoint_on_disconnect (void)
1663 VEC(breakpoint_p
) *tp_vec
= NULL
;
1665 struct breakpoint
*b
;
1666 int has_pending_p
= 0;
1668 /* Check whether we still have pending tracepoint. If we have, warn the
1669 user that pending tracepoint will no longer work. */
1670 tp_vec
= all_tracepoints ();
1671 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1680 struct bp_location
*loc1
;
1682 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1684 if (loc1
->shlib_disabled
)
1695 VEC_free (breakpoint_p
, tp_vec
);
1698 warning (_("Pending tracepoints will not be resolved while"
1699 " GDB is disconnected\n"));
1704 start_tracing (char *notes
)
1706 VEC(breakpoint_p
) *tp_vec
= NULL
;
1708 struct breakpoint
*b
;
1709 struct trace_state_variable
*tsv
;
1710 int any_enabled
= 0, num_to_download
= 0;
1713 tp_vec
= all_tracepoints ();
1715 /* No point in tracing without any tracepoints... */
1716 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1718 VEC_free (breakpoint_p
, tp_vec
);
1719 error (_("No tracepoints defined, not starting trace"));
1722 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1724 struct tracepoint
*t
= (struct tracepoint
*) b
;
1725 struct bp_location
*loc
;
1727 if (b
->enable_state
== bp_enabled
)
1730 if ((b
->type
== bp_fast_tracepoint
1731 ? may_insert_fast_tracepoints
1732 : may_insert_tracepoints
))
1735 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1736 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1741 if (target_supports_enable_disable_tracepoint ())
1742 warning (_("No tracepoints enabled"));
1745 /* No point in tracing with only disabled tracepoints that
1746 cannot be re-enabled. */
1747 VEC_free (breakpoint_p
, tp_vec
);
1748 error (_("No tracepoints enabled, not starting trace"));
1752 if (num_to_download
<= 0)
1754 VEC_free (breakpoint_p
, tp_vec
);
1755 error (_("No tracepoints that may be downloaded, not starting trace"));
1758 target_trace_init ();
1760 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1762 struct tracepoint
*t
= (struct tracepoint
*) b
;
1763 struct bp_location
*loc
;
1764 int bp_location_downloaded
= 0;
1766 /* Clear `inserted' flag. */
1767 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1770 if ((b
->type
== bp_fast_tracepoint
1771 ? !may_insert_fast_tracepoints
1772 : !may_insert_tracepoints
))
1775 t
->number_on_target
= 0;
1777 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1779 /* Since tracepoint locations are never duplicated, `inserted'
1780 flag should be zero. */
1781 gdb_assert (!loc
->inserted
);
1783 target_download_tracepoint (loc
);
1786 bp_location_downloaded
= 1;
1789 t
->number_on_target
= b
->number
;
1791 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1792 if (loc
->probe
!= NULL
)
1793 loc
->probe
->pops
->set_semaphore (loc
->probe
, loc
->gdbarch
);
1795 if (bp_location_downloaded
)
1796 observer_notify_breakpoint_modified (b
);
1798 VEC_free (breakpoint_p
, tp_vec
);
1800 /* Send down all the trace state variables too. */
1801 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1803 target_download_trace_state_variable (tsv
);
1806 /* Tell target to treat text-like sections as transparent. */
1807 target_trace_set_readonly_regions ();
1808 /* Set some mode flags. */
1809 target_set_disconnected_tracing (disconnected_tracing
);
1810 target_set_circular_trace_buffer (circular_trace_buffer
);
1813 notes
= trace_notes
;
1814 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1816 if (!ret
&& (trace_user
|| notes
))
1817 warning (_("Target does not support trace user/notes, info ignored"));
1819 /* Now insert traps and begin collecting data. */
1820 target_trace_start ();
1822 /* Reset our local state. */
1823 set_traceframe_num (-1);
1824 set_tracepoint_num (-1);
1825 set_traceframe_context (NULL
);
1826 current_trace_status()->running
= 1;
1827 clear_traceframe_info ();
1830 /* The tstart command requests the target to start a new trace run.
1831 The command passes any arguments it has to the target verbatim, as
1832 an optional "trace note". This is useful as for instance a warning
1833 to other users if the trace runs disconnected, and you don't want
1834 anybody else messing with the target. */
1837 trace_start_command (char *args
, int from_tty
)
1839 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1841 if (current_trace_status ()->running
)
1844 && !query (_("A trace is running already. Start a new run? ")))
1845 error (_("New trace run not started."));
1848 start_tracing (args
);
1851 /* The tstop command stops the tracing run. The command passes any
1852 supplied arguments to the target verbatim as a "stop note"; if the
1853 target supports trace notes, then it will be reported back as part
1854 of the trace run's status. */
1857 trace_stop_command (char *args
, int from_tty
)
1859 if (!current_trace_status ()->running
)
1860 error (_("Trace is not running."));
1862 stop_tracing (args
);
1866 stop_tracing (char *note
)
1869 VEC(breakpoint_p
) *tp_vec
= NULL
;
1871 struct breakpoint
*t
;
1873 target_trace_stop ();
1875 tp_vec
= all_tracepoints ();
1876 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1878 struct bp_location
*loc
;
1880 if ((t
->type
== bp_fast_tracepoint
1881 ? !may_insert_fast_tracepoints
1882 : !may_insert_tracepoints
))
1885 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1887 /* GDB can be totally absent in some disconnected trace scenarios,
1888 but we don't really care if this semaphore goes out of sync.
1889 That's why we are decrementing it here, but not taking care
1891 if (loc
->probe
!= NULL
)
1892 loc
->probe
->pops
->clear_semaphore (loc
->probe
, loc
->gdbarch
);
1896 VEC_free (breakpoint_p
, tp_vec
);
1899 note
= trace_stop_notes
;
1900 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1903 warning (_("Target does not support trace notes, note ignored"));
1905 /* Should change in response to reply? */
1906 current_trace_status ()->running
= 0;
1909 /* tstatus command */
1911 trace_status_command (char *args
, int from_tty
)
1913 struct trace_status
*ts
= current_trace_status ();
1915 VEC(breakpoint_p
) *tp_vec
= NULL
;
1916 struct breakpoint
*t
;
1918 status
= target_get_trace_status (ts
);
1923 printf_filtered (_("Using a trace file.\n"));
1926 printf_filtered (_("Trace can not be run on this target.\n"));
1931 if (!ts
->running_known
)
1933 printf_filtered (_("Run/stop status is unknown.\n"));
1935 else if (ts
->running
)
1937 printf_filtered (_("Trace is running on the target.\n"));
1941 switch (ts
->stop_reason
)
1943 case trace_never_run
:
1944 printf_filtered (_("No trace has been run on the target.\n"));
1948 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1951 printf_filtered (_("Trace stopped by a tstop command.\n"));
1953 case trace_buffer_full
:
1954 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1956 case trace_disconnected
:
1957 printf_filtered (_("Trace stopped because of disconnection.\n"));
1959 case tracepoint_passcount
:
1960 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1961 ts
->stopping_tracepoint
);
1963 case tracepoint_error
:
1964 if (ts
->stopping_tracepoint
)
1965 printf_filtered (_("Trace stopped by an "
1966 "error (%s, tracepoint %d).\n"),
1967 ts
->stop_desc
, ts
->stopping_tracepoint
);
1969 printf_filtered (_("Trace stopped by an error (%s).\n"),
1972 case trace_stop_reason_unknown
:
1973 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1976 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1982 if (ts
->traceframes_created
>= 0
1983 && ts
->traceframe_count
!= ts
->traceframes_created
)
1985 printf_filtered (_("Buffer contains %d trace "
1986 "frames (of %d created total).\n"),
1987 ts
->traceframe_count
, ts
->traceframes_created
);
1989 else if (ts
->traceframe_count
>= 0)
1991 printf_filtered (_("Collected %d trace frames.\n"),
1992 ts
->traceframe_count
);
1995 if (ts
->buffer_free
>= 0)
1997 if (ts
->buffer_size
>= 0)
1999 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2000 ts
->buffer_free
, ts
->buffer_size
);
2001 if (ts
->buffer_size
> 0)
2002 printf_filtered (_(" (%d%% full)"),
2003 ((int) ((((long long) (ts
->buffer_size
2004 - ts
->buffer_free
)) * 100)
2005 / ts
->buffer_size
)));
2006 printf_filtered (_(".\n"));
2009 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2013 if (ts
->disconnected_tracing
)
2014 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2016 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2018 if (ts
->circular_buffer
)
2019 printf_filtered (_("Trace buffer is circular.\n"));
2021 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
2022 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
2024 if (ts
->notes
&& strlen (ts
->notes
) > 0)
2025 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
2027 /* Now report on what we're doing with tfind. */
2028 if (traceframe_number
>= 0)
2029 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2030 traceframe_number
, tracepoint_number
);
2032 printf_filtered (_("Not looking at any trace frame.\n"));
2034 /* Report start/stop times if supplied. */
2039 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
2041 /* Reporting a run time is more readable than two long numbers. */
2042 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2043 (long int) ts
->start_time
/ 1000000,
2044 (long int) ts
->start_time
% 1000000,
2045 (long int) run_time
/ 1000000,
2046 (long int) run_time
% 1000000);
2049 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2050 (long int) ts
->start_time
/ 1000000,
2051 (long int) ts
->start_time
% 1000000);
2053 else if (ts
->stop_time
)
2054 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2055 (long int) ts
->stop_time
/ 1000000,
2056 (long int) ts
->stop_time
% 1000000);
2058 /* Now report any per-tracepoint status available. */
2059 tp_vec
= all_tracepoints ();
2061 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2062 target_get_tracepoint_status (t
, NULL
);
2064 VEC_free (breakpoint_p
, tp_vec
);
2067 /* Report the trace status to uiout, in a way suitable for MI, and not
2068 suitable for CLI. If ON_STOP is true, suppress a few fields that
2069 are not meaningful in the -trace-stop response.
2071 The implementation is essentially parallel to trace_status_command, but
2072 merging them will result in unreadable code. */
2074 trace_status_mi (int on_stop
)
2076 struct ui_out
*uiout
= current_uiout
;
2077 struct trace_status
*ts
= current_trace_status ();
2080 status
= target_get_trace_status (ts
);
2082 if (status
== -1 && !ts
->from_file
)
2084 ui_out_field_string (uiout
, "supported", "0");
2089 ui_out_field_string (uiout
, "supported", "file");
2091 ui_out_field_string (uiout
, "supported", "1");
2093 gdb_assert (ts
->running_known
);
2097 ui_out_field_string (uiout
, "running", "1");
2099 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2100 Given that the frontend gets the status either on -trace-stop, or from
2101 -trace-status after re-connection, it does not seem like this
2102 information is necessary for anything. It is not necessary for either
2103 figuring the vital state of the target nor for navigation of trace
2104 frames. If the frontend wants to show the current state is some
2105 configure dialog, it can request the value when such dialog is
2106 invoked by the user. */
2110 char *stop_reason
= NULL
;
2111 int stopping_tracepoint
= -1;
2114 ui_out_field_string (uiout
, "running", "0");
2116 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2118 switch (ts
->stop_reason
)
2121 stop_reason
= "request";
2123 case trace_buffer_full
:
2124 stop_reason
= "overflow";
2126 case trace_disconnected
:
2127 stop_reason
= "disconnection";
2129 case tracepoint_passcount
:
2130 stop_reason
= "passcount";
2131 stopping_tracepoint
= ts
->stopping_tracepoint
;
2133 case tracepoint_error
:
2134 stop_reason
= "error";
2135 stopping_tracepoint
= ts
->stopping_tracepoint
;
2141 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2142 if (stopping_tracepoint
!= -1)
2143 ui_out_field_int (uiout
, "stopping-tracepoint",
2144 stopping_tracepoint
);
2145 if (ts
->stop_reason
== tracepoint_error
)
2146 ui_out_field_string (uiout
, "error-description",
2152 if (ts
->traceframe_count
!= -1)
2153 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2154 if (ts
->traceframes_created
!= -1)
2155 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2156 if (ts
->buffer_size
!= -1)
2157 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2158 if (ts
->buffer_free
!= -1)
2159 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2161 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2162 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2164 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2165 ui_out_field_string (uiout
, "notes", ts
->notes
);
2170 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2171 (long int) ts
->start_time
/ 1000000,
2172 (long int) ts
->start_time
% 1000000);
2173 ui_out_field_string (uiout
, "start-time", buf
);
2174 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2175 (long int) ts
->stop_time
/ 1000000,
2176 (long int) ts
->stop_time
% 1000000);
2177 ui_out_field_string (uiout
, "stop-time", buf
);
2181 /* This function handles the details of what to do about an ongoing
2182 tracing run if the user has asked to detach or otherwise disconnect
2185 disconnect_tracing (int from_tty
)
2187 /* It can happen that the target that was tracing went away on its
2188 own, and we didn't notice. Get a status update, and if the
2189 current target doesn't even do tracing, then assume it's not
2191 if (target_get_trace_status (current_trace_status ()) < 0)
2192 current_trace_status ()->running
= 0;
2194 /* If running interactively, give the user the option to cancel and
2195 then decide what to do differently with the run. Scripts are
2196 just going to disconnect and let the target deal with it,
2197 according to how it's been instructed previously via
2198 disconnected-tracing. */
2199 if (current_trace_status ()->running
&& from_tty
)
2201 process_tracepoint_on_disconnect ();
2203 if (current_trace_status ()->disconnected_tracing
)
2205 if (!query (_("Trace is running and will "
2206 "continue after detach; detach anyway? ")))
2207 error (_("Not confirmed."));
2211 if (!query (_("Trace is running but will "
2212 "stop on detach; detach anyway? ")))
2213 error (_("Not confirmed."));
2217 /* Also we want to be out of tfind mode, otherwise things can get
2218 confusing upon reconnection. Just use these calls instead of
2219 full tfind_1 behavior because we're in the middle of detaching,
2220 and there's no point to updating current stack frame etc. */
2221 set_current_traceframe (-1);
2222 set_tracepoint_num (-1);
2223 set_traceframe_context (NULL
);
2226 /* Worker function for the various flavors of the tfind command. */
2228 tfind_1 (enum trace_find_type type
, int num
,
2229 ULONGEST addr1
, ULONGEST addr2
,
2232 int target_frameno
= -1, target_tracept
= -1;
2233 struct frame_id old_frame_id
= null_frame_id
;
2234 struct tracepoint
*tp
;
2235 struct ui_out
*uiout
= current_uiout
;
2237 /* Only try to get the current stack frame if we have a chance of
2238 succeeding. In particular, if we're trying to get a first trace
2239 frame while all threads are running, it's not going to succeed,
2240 so leave it with a default value and let the frame comparison
2241 below (correctly) decide to print out the source location of the
2243 if (!(type
== tfind_number
&& num
== -1)
2244 && (has_stack_frames () || traceframe_number
>= 0))
2245 old_frame_id
= get_frame_id (get_current_frame ());
2247 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2250 if (type
== tfind_number
2252 && target_frameno
== -1)
2254 /* We told the target to get out of tfind mode, and it did. */
2256 else if (target_frameno
== -1)
2258 /* A request for a non-existent trace frame has failed.
2259 Our response will be different, depending on FROM_TTY:
2261 If FROM_TTY is true, meaning that this command was
2262 typed interactively by the user, then give an error
2263 and DO NOT change the state of traceframe_number etc.
2265 However if FROM_TTY is false, meaning that we're either
2266 in a script, a loop, or a user-defined command, then
2267 DON'T give an error, but DO change the state of
2268 traceframe_number etc. to invalid.
2270 The rationalle is that if you typed the command, you
2271 might just have committed a typo or something, and you'd
2272 like to NOT lose your current debugging state. However
2273 if you're in a user-defined command or especially in a
2274 loop, then you need a way to detect that the command
2275 failed WITHOUT aborting. This allows you to write
2276 scripts that search thru the trace buffer until the end,
2277 and then continue on to do something else. */
2280 error (_("Target failed to find requested trace frame."));
2284 printf_filtered ("End of trace buffer.\n");
2285 #if 0 /* dubious now? */
2286 /* The following will not recurse, since it's
2288 trace_find_command ("-1", from_tty
);
2293 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2295 reinit_frame_cache ();
2296 target_dcache_invalidate ();
2298 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2300 if (target_frameno
!= get_traceframe_number ())
2301 observer_notify_traceframe_changed (target_frameno
, tracepoint_number
);
2303 set_current_traceframe (target_frameno
);
2305 if (target_frameno
== -1)
2306 set_traceframe_context (NULL
);
2308 set_traceframe_context (get_current_frame ());
2310 if (traceframe_number
>= 0)
2312 /* Use different branches for MI and CLI to make CLI messages
2314 if (ui_out_is_mi_like_p (uiout
))
2316 ui_out_field_string (uiout
, "found", "1");
2317 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2318 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2322 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2323 traceframe_number
, tracepoint_number
);
2328 if (ui_out_is_mi_like_p (uiout
))
2329 ui_out_field_string (uiout
, "found", "0");
2330 else if (type
== tfind_number
&& num
== -1)
2331 printf_unfiltered (_("No longer looking at any trace frame\n"));
2332 else /* This case may never occur, check. */
2333 printf_unfiltered (_("No trace frame found\n"));
2336 /* If we're in nonstop mode and getting out of looking at trace
2337 frames, there won't be any current frame to go back to and
2340 && (has_stack_frames () || traceframe_number
>= 0))
2342 enum print_what print_what
;
2344 /* NOTE: in imitation of the step command, try to determine
2345 whether we have made a transition from one function to
2346 another. If so, we'll print the "stack frame" (ie. the new
2347 function and it's arguments) -- otherwise we'll just show the
2350 if (frame_id_eq (old_frame_id
,
2351 get_frame_id (get_current_frame ())))
2352 print_what
= SRC_LINE
;
2354 print_what
= SRC_AND_LOC
;
2356 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2361 /* trace_find_command takes a trace frame number n,
2362 sends "QTFrame:<n>" to the target,
2363 and accepts a reply that may contain several optional pieces
2364 of information: a frame number, a tracepoint number, and an
2365 indication of whether this is a trap frame or a stepping frame.
2367 The minimal response is just "OK" (which indicates that the
2368 target does not give us a frame number or a tracepoint number).
2369 Instead of that, the target may send us a string containing
2371 F<hexnum> (gives the selected frame number)
2372 T<hexnum> (gives the selected tracepoint number)
2377 trace_find_command (char *args
, int from_tty
)
2378 { /* This should only be called with a numeric argument. */
2381 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2382 error (_("May not look at trace frames while trace is running."));
2384 if (args
== 0 || *args
== 0)
2385 { /* TFIND with no args means find NEXT trace frame. */
2386 if (traceframe_number
== -1)
2387 frameno
= 0; /* "next" is first one. */
2389 frameno
= traceframe_number
+ 1;
2391 else if (0 == strcmp (args
, "-"))
2393 if (traceframe_number
== -1)
2394 error (_("not debugging trace buffer"));
2395 else if (from_tty
&& traceframe_number
== 0)
2396 error (_("already at start of trace buffer"));
2398 frameno
= traceframe_number
- 1;
2400 /* A hack to work around eval's need for fp to have been collected. */
2401 else if (0 == strcmp (args
, "-1"))
2404 frameno
= parse_and_eval_long (args
);
2407 error (_("invalid input (%d is less than zero)"), frameno
);
2409 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2414 trace_find_end_command (char *args
, int from_tty
)
2416 trace_find_command ("-1", from_tty
);
2421 trace_find_start_command (char *args
, int from_tty
)
2423 trace_find_command ("0", from_tty
);
2426 /* tfind pc command */
2428 trace_find_pc_command (char *args
, int from_tty
)
2432 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2433 error (_("May not look at trace frames while trace is running."));
2435 if (args
== 0 || *args
== 0)
2436 pc
= regcache_read_pc (get_current_regcache ());
2438 pc
= parse_and_eval_address (args
);
2440 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2443 /* tfind tracepoint command */
2445 trace_find_tracepoint_command (char *args
, int from_tty
)
2448 struct tracepoint
*tp
;
2450 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2451 error (_("May not look at trace frames while trace is running."));
2453 if (args
== 0 || *args
== 0)
2455 if (tracepoint_number
== -1)
2456 error (_("No current tracepoint -- please supply an argument."));
2458 tdp
= tracepoint_number
; /* Default is current TDP. */
2461 tdp
= parse_and_eval_long (args
);
2463 /* If we have the tracepoint on hand, use the number that the
2464 target knows about (which may be different if we disconnected
2465 and reconnected). */
2466 tp
= get_tracepoint (tdp
);
2468 tdp
= tp
->number_on_target
;
2470 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2473 /* TFIND LINE command:
2475 This command will take a sourceline for argument, just like BREAK
2476 or TRACE (ie. anything that "decode_line_1" can handle).
2478 With no argument, this command will find the next trace frame
2479 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2482 trace_find_line_command (char *args
, int from_tty
)
2484 static CORE_ADDR start_pc
, end_pc
;
2485 struct symtabs_and_lines sals
;
2486 struct symtab_and_line sal
;
2487 struct cleanup
*old_chain
;
2489 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2490 error (_("May not look at trace frames while trace is running."));
2492 if (args
== 0 || *args
== 0)
2494 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2496 sals
.sals
= (struct symtab_and_line
*)
2497 xmalloc (sizeof (struct symtab_and_line
));
2502 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2506 old_chain
= make_cleanup (xfree
, sals
.sals
);
2507 if (sal
.symtab
== 0)
2508 error (_("No line number information available."));
2510 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2512 if (start_pc
== end_pc
)
2514 printf_filtered ("Line %d of \"%s\"",
2515 sal
.line
, sal
.symtab
->filename
);
2517 printf_filtered (" is at address ");
2518 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2520 printf_filtered (" but contains no code.\n");
2521 sal
= find_pc_line (start_pc
, 0);
2523 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2524 && start_pc
!= end_pc
)
2525 printf_filtered ("Attempting to find line %d instead.\n",
2528 error (_("Cannot find a good line."));
2532 /* Is there any case in which we get here, and have an address
2533 which the user would want to see? If we have debugging
2534 symbols and no line numbers? */
2535 error (_("Line number %d is out of range for \"%s\"."),
2536 sal
.line
, sal
.symtab
->filename
);
2538 /* Find within range of stated line. */
2540 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2542 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2543 do_cleanups (old_chain
);
2546 /* tfind range command */
2548 trace_find_range_command (char *args
, int from_tty
)
2550 static CORE_ADDR start
, stop
;
2553 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2554 error (_("May not look at trace frames while trace is running."));
2556 if (args
== 0 || *args
== 0)
2557 { /* XXX FIXME: what should default behavior be? */
2558 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2562 if (0 != (tmp
= strchr (args
, ',')))
2564 *tmp
++ = '\0'; /* Terminate start address. */
2565 while (isspace ((int) *tmp
))
2567 start
= parse_and_eval_address (args
);
2568 stop
= parse_and_eval_address (tmp
);
2571 { /* No explicit end address? */
2572 start
= parse_and_eval_address (args
);
2573 stop
= start
+ 1; /* ??? */
2576 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2579 /* tfind outside command */
2581 trace_find_outside_command (char *args
, int from_tty
)
2583 CORE_ADDR start
, stop
;
2586 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2587 error (_("May not look at trace frames while trace is running."));
2589 if (args
== 0 || *args
== 0)
2590 { /* XXX FIXME: what should default behavior be? */
2591 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2595 if (0 != (tmp
= strchr (args
, ',')))
2597 *tmp
++ = '\0'; /* Terminate start address. */
2598 while (isspace ((int) *tmp
))
2600 start
= parse_and_eval_address (args
);
2601 stop
= parse_and_eval_address (tmp
);
2604 { /* No explicit end address? */
2605 start
= parse_and_eval_address (args
);
2606 stop
= start
+ 1; /* ??? */
2609 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2612 /* info scope command: list the locals for a scope. */
2614 scope_info (char *args
, int from_tty
)
2616 struct symtabs_and_lines sals
;
2618 struct minimal_symbol
*msym
;
2619 struct block
*block
;
2620 const char *symname
;
2621 char *save_args
= args
;
2622 struct block_iterator iter
;
2624 struct gdbarch
*gdbarch
;
2627 if (args
== 0 || *args
== 0)
2628 error (_("requires an argument (function, "
2629 "line or *addr) to define a scope"));
2631 sals
= decode_line_1 (&args
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2632 if (sals
.nelts
== 0)
2633 return; /* Presumably decode_line_1 has already warned. */
2635 /* Resolve line numbers to PC. */
2636 resolve_sal_pc (&sals
.sals
[0]);
2637 block
= block_for_pc (sals
.sals
[0].pc
);
2641 QUIT
; /* Allow user to bail out with ^C. */
2642 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2644 QUIT
; /* Allow user to bail out with ^C. */
2646 printf_filtered ("Scope for %s:\n", save_args
);
2649 symname
= SYMBOL_PRINT_NAME (sym
);
2650 if (symname
== NULL
|| *symname
== '\0')
2651 continue; /* Probably botched, certainly useless. */
2653 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2655 printf_filtered ("Symbol %s is ", symname
);
2656 switch (SYMBOL_CLASS (sym
))
2659 case LOC_UNDEF
: /* Messed up symbol? */
2660 printf_filtered ("a bogus symbol, class %d.\n",
2661 SYMBOL_CLASS (sym
));
2662 count
--; /* Don't count this one. */
2665 printf_filtered ("a constant with value %s (%s)",
2666 plongest (SYMBOL_VALUE (sym
)),
2667 hex_string (SYMBOL_VALUE (sym
)));
2669 case LOC_CONST_BYTES
:
2670 printf_filtered ("constant bytes: ");
2671 if (SYMBOL_TYPE (sym
))
2672 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2673 fprintf_filtered (gdb_stdout
, " %02x",
2674 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2677 printf_filtered ("in static storage at address ");
2678 printf_filtered ("%s", paddress (gdbarch
,
2679 SYMBOL_VALUE_ADDRESS (sym
)));
2682 /* GDBARCH is the architecture associated with the objfile
2683 the symbol is defined in; the target architecture may be
2684 different, and may provide additional registers. However,
2685 we do not know the target architecture at this point.
2686 We assume the objfile architecture will contain all the
2687 standard registers that occur in debug info in that
2689 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2692 if (SYMBOL_IS_ARGUMENT (sym
))
2693 printf_filtered ("an argument in register $%s",
2694 gdbarch_register_name (gdbarch
, regno
));
2696 printf_filtered ("a local variable in register $%s",
2697 gdbarch_register_name (gdbarch
, regno
));
2700 printf_filtered ("an argument at stack/frame offset %s",
2701 plongest (SYMBOL_VALUE (sym
)));
2704 printf_filtered ("a local variable at frame offset %s",
2705 plongest (SYMBOL_VALUE (sym
)));
2708 printf_filtered ("a reference argument at offset %s",
2709 plongest (SYMBOL_VALUE (sym
)));
2711 case LOC_REGPARM_ADDR
:
2712 /* Note comment at LOC_REGISTER. */
2713 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2715 printf_filtered ("the address of an argument, in register $%s",
2716 gdbarch_register_name (gdbarch
, regno
));
2719 printf_filtered ("a typedef.\n");
2722 printf_filtered ("a label at address ");
2723 printf_filtered ("%s", paddress (gdbarch
,
2724 SYMBOL_VALUE_ADDRESS (sym
)));
2727 printf_filtered ("a function at address ");
2728 printf_filtered ("%s",
2729 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2731 case LOC_UNRESOLVED
:
2732 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2735 printf_filtered ("Unresolved Static");
2738 printf_filtered ("static storage at address ");
2739 printf_filtered ("%s",
2740 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2743 case LOC_OPTIMIZED_OUT
:
2744 printf_filtered ("optimized out.\n");
2747 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2748 BLOCK_START (block
),
2752 if (SYMBOL_TYPE (sym
))
2753 printf_filtered (", length %d.\n",
2754 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2756 if (BLOCK_FUNCTION (block
))
2759 block
= BLOCK_SUPERBLOCK (block
);
2762 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2766 /* worker function (cleanup) */
2768 replace_comma (void *data
)
2775 /* Helper for trace_dump_command. Dump the action list starting at
2776 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2777 actions of the body of a while-stepping action. STEPPING_FRAME is
2778 set if the current traceframe was determined to be a while-stepping
2782 trace_dump_actions (struct command_line
*action
,
2783 int stepping_actions
, int stepping_frame
,
2786 char *action_exp
, *next_comma
;
2788 for (; action
!= NULL
; action
= action
->next
)
2790 struct cmd_list_element
*cmd
;
2792 QUIT
; /* Allow user to bail out with ^C. */
2793 action_exp
= action
->line
;
2794 while (isspace ((int) *action_exp
))
2797 /* The collection actions to be done while stepping are
2798 bracketed by the commands "while-stepping" and "end". */
2800 if (*action_exp
== '#') /* comment line */
2803 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2805 error (_("Bad action list item: %s"), action_exp
);
2807 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2811 for (i
= 0; i
< action
->body_count
; ++i
)
2812 trace_dump_actions (action
->body_list
[i
],
2813 1, stepping_frame
, from_tty
);
2815 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2817 /* Display the collected data.
2818 For the trap frame, display only what was collected at
2819 the trap. Likewise for stepping frames, display only
2820 what was collected while stepping. This means that the
2821 two boolean variables, STEPPING_FRAME and
2822 STEPPING_ACTIONS should be equal. */
2823 if (stepping_frame
== stepping_actions
)
2825 if (*action_exp
== '/')
2826 action_exp
= decode_agent_options (action_exp
);
2829 { /* Repeat over a comma-separated list. */
2830 QUIT
; /* Allow user to bail out with ^C. */
2831 if (*action_exp
== ',')
2833 while (isspace ((int) *action_exp
))
2836 next_comma
= strchr (action_exp
, ',');
2838 if (0 == strncasecmp (action_exp
, "$reg", 4))
2839 registers_info (NULL
, from_tty
);
2840 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2842 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2843 locals_info (NULL
, from_tty
);
2844 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2845 args_info (NULL
, from_tty
);
2850 make_cleanup (replace_comma
, next_comma
);
2853 printf_filtered ("%s = ", action_exp
);
2854 output_command (action_exp
, from_tty
);
2855 printf_filtered ("\n");
2859 action_exp
= next_comma
;
2861 while (action_exp
&& *action_exp
== ',');
2867 /* The tdump command. */
2870 trace_dump_command (char *args
, int from_tty
)
2872 struct regcache
*regcache
;
2873 struct tracepoint
*t
;
2874 int stepping_frame
= 0;
2875 struct bp_location
*loc
;
2876 char *line
, *default_collect_line
= NULL
;
2877 struct command_line
*actions
, *default_collect_action
= NULL
;
2878 struct cleanup
*old_chain
= NULL
;
2880 if (tracepoint_number
== -1)
2882 warning (_("No current trace frame."));
2886 t
= get_tracepoint (tracepoint_number
);
2889 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2892 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2893 tracepoint_number
, traceframe_number
);
2895 /* The current frame is a trap frame if the frame PC is equal
2896 to the tracepoint PC. If not, then the current frame was
2897 collected during single-stepping. */
2899 regcache
= get_current_regcache ();
2901 /* If the traceframe's address matches any of the tracepoint's
2902 locations, assume it is a direct hit rather than a while-stepping
2903 frame. (FIXME this is not reliable, should record each frame's
2906 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
2907 if (loc
->address
== regcache_read_pc (regcache
))
2910 actions
= breakpoint_commands (&t
->base
);
2912 /* If there is a default-collect list, make up a collect command,
2913 prepend to the tracepoint's commands, and pass the whole mess to
2914 the trace dump scanner. We need to validate because
2915 default-collect might have been junked since the trace run. */
2916 if (*default_collect
)
2918 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2919 old_chain
= make_cleanup (xfree
, default_collect_line
);
2920 line
= default_collect_line
;
2921 validate_actionline (&line
, &t
->base
);
2922 default_collect_action
= xmalloc (sizeof (struct command_line
));
2923 make_cleanup (xfree
, default_collect_action
);
2924 default_collect_action
->next
= actions
;
2925 default_collect_action
->line
= line
;
2926 actions
= default_collect_action
;
2929 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2931 if (*default_collect
)
2932 do_cleanups (old_chain
);
2935 /* Encode a piece of a tracepoint's source-level definition in a form
2936 that is suitable for both protocol and saving in files. */
2937 /* This version does not do multiple encodes for long strings; it should
2938 return an offset to the next piece to encode. FIXME */
2941 encode_source_string (int tpnum
, ULONGEST addr
,
2942 char *srctype
, char *src
, char *buf
, int buf_size
)
2944 if (80 + strlen (srctype
) > buf_size
)
2945 error (_("Buffer too small for source encoding"));
2946 sprintf (buf
, "%x:%s:%s:%x:%x:",
2947 tpnum
, phex_nz (addr
, sizeof (addr
)),
2948 srctype
, 0, (int) strlen (src
));
2949 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2950 error (_("Source string too long for buffer"));
2951 bin2hex (src
, buf
+ strlen (buf
), 0);
2955 extern int trace_regblock_size
;
2957 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2958 non-zero, the save is performed on the target, otherwise GDB obtains all
2959 trace data and saves it locally. */
2962 trace_save (const char *filename
, int target_does_save
)
2964 struct cleanup
*cleanup
;
2966 struct trace_status
*ts
= current_trace_status ();
2969 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2970 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2974 ULONGEST offset
= 0;
2975 #define MAX_TRACE_UPLOAD 2000
2976 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2979 /* If the target is to save the data to a file on its own, then just
2980 send the command and be done with it. */
2981 if (target_does_save
)
2983 err
= target_save_trace_data (filename
);
2985 error (_("Target failed to save trace data to '%s'."),
2990 /* Get the trace status first before opening the file, so if the
2991 target is losing, we can get out without touching files. */
2992 status
= target_get_trace_status (ts
);
2994 pathname
= tilde_expand (filename
);
2995 cleanup
= make_cleanup (xfree
, pathname
);
2997 fp
= fopen (pathname
, "wb");
2999 error (_("Unable to open file '%s' for saving trace data (%s)"),
3000 filename
, safe_strerror (errno
));
3001 make_cleanup_fclose (fp
);
3003 /* Write a file header, with a high-bit-set char to indicate a
3004 binary file, plus a hint as what this file is, and a version
3005 number in case of future needs. */
3006 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
3008 perror_with_name (pathname
);
3010 /* Write descriptive info. */
3012 /* Write out the size of a register block. */
3013 fprintf (fp
, "R %x\n", trace_regblock_size
);
3015 /* Write out status of the tracing run (aka "tstatus" info). */
3016 fprintf (fp
, "status %c;%s",
3017 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
3018 if (ts
->stop_reason
== tracepoint_error
)
3020 char *buf
= (char *) alloca (strlen (ts
->stop_desc
) * 2 + 1);
3022 bin2hex ((gdb_byte
*) ts
->stop_desc
, buf
, 0);
3023 fprintf (fp
, ":%s", buf
);
3025 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
3026 if (ts
->traceframe_count
>= 0)
3027 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
3028 if (ts
->traceframes_created
>= 0)
3029 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
3030 if (ts
->buffer_free
>= 0)
3031 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
3032 if (ts
->buffer_size
>= 0)
3033 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
3034 if (ts
->disconnected_tracing
)
3035 fprintf (fp
, ";disconn:%x", ts
->disconnected_tracing
);
3036 if (ts
->circular_buffer
)
3037 fprintf (fp
, ";circular:%x", ts
->circular_buffer
);
3040 /* Note that we want to upload tracepoints and save those, rather
3041 than simply writing out the local ones, because the user may have
3042 changed tracepoints in GDB in preparation for a future tracing
3043 run, or maybe just mass-deleted all types of breakpoints as part
3044 of cleaning up. So as not to contaminate the session, leave the
3045 data in its uploaded form, don't make into real tracepoints. */
3047 /* Get trace state variables first, they may be checked when parsing
3048 uploaded commands. */
3050 target_upload_trace_state_variables (&uploaded_tsvs
);
3052 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3058 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
3059 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
3062 fprintf (fp
, "tsv %x:%s:%x:%s\n",
3063 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
3064 utsv
->builtin
, buf
);
3070 free_uploaded_tsvs (&uploaded_tsvs
);
3072 target_upload_tracepoints (&uploaded_tps
);
3074 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3075 target_get_tracepoint_status (NULL
, utp
);
3077 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3079 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
3080 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3081 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
3082 if (utp
->type
== bp_fast_tracepoint
)
3083 fprintf (fp
, ":F%x", utp
->orig_size
);
3085 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
3088 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
3089 fprintf (fp
, "tp A%x:%s:%s\n",
3090 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3091 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
3092 fprintf (fp
, "tp S%x:%s:%s\n",
3093 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3096 encode_source_string (utp
->number
, utp
->addr
,
3097 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
3098 fprintf (fp
, "tp Z%s\n", buf
);
3100 if (utp
->cond_string
)
3102 encode_source_string (utp
->number
, utp
->addr
,
3103 "cond", utp
->cond_string
,
3104 buf
, MAX_TRACE_UPLOAD
);
3105 fprintf (fp
, "tp Z%s\n", buf
);
3107 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
3109 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
3110 buf
, MAX_TRACE_UPLOAD
);
3111 fprintf (fp
, "tp Z%s\n", buf
);
3113 fprintf (fp
, "tp V%x:%s:%x:%s\n",
3114 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3116 phex_nz (utp
->traceframe_usage
,
3117 sizeof (utp
->traceframe_usage
)));
3120 free_uploaded_tps (&uploaded_tps
);
3122 /* Mark the end of the definition section. */
3125 /* Get and write the trace data proper. We ask for big blocks, in
3126 the hopes of efficiency, but will take less if the target has
3127 packet size limitations or some such. */
3130 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
3132 error (_("Failure to get requested trace buffer data"));
3133 /* No more data is forthcoming, we're done. */
3136 written
= fwrite (buf
, gotten
, 1, fp
);
3138 perror_with_name (pathname
);
3142 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
3143 written
= fwrite (&gotten
, 4, 1, fp
);
3145 perror_with_name (pathname
);
3147 do_cleanups (cleanup
);
3151 trace_save_command (char *args
, int from_tty
)
3153 int target_does_save
= 0;
3155 char *filename
= NULL
;
3156 struct cleanup
*back_to
;
3159 error_no_arg (_("file in which to save trace data"));
3161 argv
= gdb_buildargv (args
);
3162 back_to
= make_cleanup_freeargv (argv
);
3164 for (; *argv
; ++argv
)
3166 if (strcmp (*argv
, "-r") == 0)
3167 target_does_save
= 1;
3168 else if (**argv
== '-')
3169 error (_("unknown option `%s'"), *argv
);
3175 error_no_arg (_("file in which to save trace data"));
3177 trace_save (filename
, target_does_save
);
3180 printf_filtered (_("Trace data saved to file '%s'.\n"), filename
);
3182 do_cleanups (back_to
);
3185 /* Tell the target what to do with an ongoing tracing run if GDB
3186 disconnects for some reason. */
3189 set_disconnected_tracing (char *args
, int from_tty
,
3190 struct cmd_list_element
*c
)
3192 target_set_disconnected_tracing (disconnected_tracing
);
3196 set_circular_trace_buffer (char *args
, int from_tty
,
3197 struct cmd_list_element
*c
)
3199 target_set_circular_trace_buffer (circular_trace_buffer
);
3203 set_trace_user (char *args
, int from_tty
,
3204 struct cmd_list_element
*c
)
3208 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3211 warning (_("Target does not support trace notes, user ignored"));
3215 set_trace_notes (char *args
, int from_tty
,
3216 struct cmd_list_element
*c
)
3220 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3223 warning (_("Target does not support trace notes, note ignored"));
3227 set_trace_stop_notes (char *args
, int from_tty
,
3228 struct cmd_list_element
*c
)
3232 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3235 warning (_("Target does not support trace notes, stop note ignored"));
3238 /* Convert the memory pointed to by mem into hex, placing result in buf.
3239 * Return a pointer to the last char put in buf (null)
3240 * "stolen" from sparc-stub.c
3243 static const char hexchars
[] = "0123456789abcdef";
3246 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3254 *buf
++ = hexchars
[ch
>> 4];
3255 *buf
++ = hexchars
[ch
& 0xf];
3264 get_traceframe_number (void)
3266 return traceframe_number
;
3269 /* Make the traceframe NUM be the current trace frame. Does nothing
3270 if NUM is already current. */
3273 set_current_traceframe (int num
)
3277 if (traceframe_number
== num
)
3279 /* Nothing to do. */
3283 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3286 warning (_("could not change traceframe"));
3288 set_traceframe_num (newnum
);
3290 /* Changing the traceframe changes our view of registers and of the
3292 registers_changed ();
3294 clear_traceframe_info ();
3297 /* Make the traceframe NUM be the current trace frame, and do nothing
3301 set_traceframe_number (int num
)
3303 traceframe_number
= num
;
3306 /* A cleanup used when switching away and back from tfind mode. */
3308 struct current_traceframe_cleanup
3310 /* The traceframe we were inspecting. */
3311 int traceframe_number
;
3315 do_restore_current_traceframe_cleanup (void *arg
)
3317 struct current_traceframe_cleanup
*old
= arg
;
3319 set_current_traceframe (old
->traceframe_number
);
3323 restore_current_traceframe_cleanup_dtor (void *arg
)
3325 struct current_traceframe_cleanup
*old
= arg
;
3331 make_cleanup_restore_current_traceframe (void)
3333 struct current_traceframe_cleanup
*old
;
3335 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3336 old
->traceframe_number
= traceframe_number
;
3338 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3339 restore_current_traceframe_cleanup_dtor
);
3343 make_cleanup_restore_traceframe_number (void)
3345 return make_cleanup_restore_integer (&traceframe_number
);
3348 /* Given a number and address, return an uploaded tracepoint with that
3349 number, creating if necessary. */
3351 struct uploaded_tp
*
3352 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3354 struct uploaded_tp
*utp
;
3356 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3357 if (utp
->number
== num
&& utp
->addr
== addr
)
3359 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3360 memset (utp
, 0, sizeof (struct uploaded_tp
));
3363 utp
->actions
= NULL
;
3364 utp
->step_actions
= NULL
;
3365 utp
->cmd_strings
= NULL
;
3372 free_uploaded_tps (struct uploaded_tp
**utpp
)
3374 struct uploaded_tp
*next_one
;
3378 next_one
= (*utpp
)->next
;
3384 /* Given a number and address, return an uploaded tracepoint with that
3385 number, creating if necessary. */
3387 static struct uploaded_tsv
*
3388 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3390 struct uploaded_tsv
*utsv
;
3392 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3393 if (utsv
->number
== num
)
3395 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3396 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3398 utsv
->next
= *utsvp
;
3404 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3406 struct uploaded_tsv
*next_one
;
3410 next_one
= (*utsvp
)->next
;
3416 /* FIXME this function is heuristic and will miss the cases where the
3417 conditional is semantically identical but differs in whitespace,
3418 such as "x == 0" vs "x==0". */
3421 cond_string_is_same (char *str1
, char *str2
)
3423 if (str1
== NULL
|| str2
== NULL
)
3424 return (str1
== str2
);
3426 return (strcmp (str1
, str2
) == 0);
3429 /* Look for an existing tracepoint that seems similar enough to the
3430 uploaded one. Enablement isn't compared, because the user can
3431 toggle that freely, and may have done so in anticipation of the
3432 next trace run. Return the location of matched tracepoint. */
3434 static struct bp_location
*
3435 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3437 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3439 struct breakpoint
*b
;
3440 struct bp_location
*loc
;
3442 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3444 struct tracepoint
*t
= (struct tracepoint
*) b
;
3446 if (b
->type
== utp
->type
3447 && t
->step_count
== utp
->step
3448 && t
->pass_count
== utp
->pass
3449 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3450 /* FIXME also test actions. */
3453 /* Scan the locations for an address match. */
3454 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3456 if (loc
->address
== utp
->addr
)
3464 /* Given a list of tracepoints uploaded from a target, attempt to
3465 match them up with existing tracepoints, and create new ones if not
3469 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3471 struct uploaded_tp
*utp
;
3472 /* A set of tracepoints which are modified. */
3473 VEC(breakpoint_p
) *modified_tp
= NULL
;
3475 struct breakpoint
*b
;
3477 /* Look for GDB tracepoints that match up with our uploaded versions. */
3478 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3480 struct bp_location
*loc
;
3481 struct tracepoint
*t
;
3483 loc
= find_matching_tracepoint_location (utp
);
3488 /* Mark this location as already inserted. */
3490 t
= (struct tracepoint
*) loc
->owner
;
3491 printf_filtered (_("Assuming tracepoint %d is same "
3492 "as target's tracepoint %d at %s.\n"),
3493 loc
->owner
->number
, utp
->number
,
3494 paddress (loc
->gdbarch
, utp
->addr
));
3496 /* The tracepoint LOC->owner was modified (the location LOC
3497 was marked as inserted in the target). Save it in
3498 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3499 observers will be notified later once for each tracepoint
3500 saved in MODIFIED_TP. */
3502 VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
);
3504 if (b
== loc
->owner
)
3510 VEC_safe_push (breakpoint_p
, modified_tp
, loc
->owner
);
3514 t
= create_tracepoint_from_upload (utp
);
3516 printf_filtered (_("Created tracepoint %d for "
3517 "target's tracepoint %d at %s.\n"),
3518 t
->base
.number
, utp
->number
,
3519 paddress (get_current_arch (), utp
->addr
));
3521 printf_filtered (_("Failed to create tracepoint for target's "
3522 "tracepoint %d at %s, skipping it.\n"),
3524 paddress (get_current_arch (), utp
->addr
));
3526 /* Whether found or created, record the number used by the
3527 target, to help with mapping target tracepoints back to their
3528 counterparts here. */
3530 t
->number_on_target
= utp
->number
;
3533 /* Notify 'breakpoint-modified' observer that at least one of B's
3534 locations was changed. */
3535 for (ix
= 0; VEC_iterate (breakpoint_p
, modified_tp
, ix
, b
); ix
++)
3536 observer_notify_breakpoint_modified (b
);
3538 VEC_free (breakpoint_p
, modified_tp
);
3539 free_uploaded_tps (uploaded_tps
);
3542 /* Trace state variables don't have much to identify them beyond their
3543 name, so just use that to detect matches. */
3545 static struct trace_state_variable
*
3546 find_matching_tsv (struct uploaded_tsv
*utsv
)
3551 return find_trace_state_variable (utsv
->name
);
3554 static struct trace_state_variable
*
3555 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3557 const char *namebase
;
3560 struct trace_state_variable
*tsv
;
3561 struct cleanup
*old_chain
;
3565 namebase
= utsv
->name
;
3566 buf
= xstrprintf ("%s", namebase
);
3571 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3574 /* Fish for a name that is not in use. */
3575 /* (should check against all internal vars?) */
3576 while (find_trace_state_variable (buf
))
3579 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3582 old_chain
= make_cleanup (xfree
, buf
);
3584 /* We have an available name, create the variable. */
3585 tsv
= create_trace_state_variable (buf
);
3586 tsv
->initial_value
= utsv
->initial_value
;
3587 tsv
->builtin
= utsv
->builtin
;
3589 observer_notify_tsv_created (tsv
->name
, tsv
->initial_value
);
3591 do_cleanups (old_chain
);
3596 /* Given a list of uploaded trace state variables, try to match them
3597 up with existing variables, or create additional ones. */
3600 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3603 struct uploaded_tsv
*utsv
;
3604 struct trace_state_variable
*tsv
;
3607 /* Most likely some numbers will have to be reassigned as part of
3608 the merge, so clear them all in anticipation. */
3609 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3612 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3614 tsv
= find_matching_tsv (utsv
);
3618 printf_filtered (_("Assuming trace state variable $%s "
3619 "is same as target's variable %d.\n"),
3620 tsv
->name
, utsv
->number
);
3624 tsv
= create_tsv_from_upload (utsv
);
3626 printf_filtered (_("Created trace state variable "
3627 "$%s for target's variable %d.\n"),
3628 tsv
->name
, utsv
->number
);
3630 /* Give precedence to numberings that come from the target. */
3632 tsv
->number
= utsv
->number
;
3635 /* Renumber everything that didn't get a target-assigned number. */
3637 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3638 if (tsv
->number
> highest
)
3639 highest
= tsv
->number
;
3642 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3643 if (tsv
->number
== 0)
3644 tsv
->number
= highest
++;
3646 free_uploaded_tsvs (uploaded_tsvs
);
3649 /* target tfile command */
3651 static struct target_ops tfile_ops
;
3653 /* Fill in tfile_ops with its defined operations and properties. */
3655 #define TRACE_HEADER_SIZE 8
3657 static char *trace_filename
;
3658 static int trace_fd
= -1;
3659 static off_t trace_frames_offset
;
3660 static off_t cur_offset
;
3661 static int cur_data_size
;
3662 int trace_regblock_size
;
3664 static void tfile_interp_line (char *line
,
3665 struct uploaded_tp
**utpp
,
3666 struct uploaded_tsv
**utsvp
);
3668 /* Read SIZE bytes into READBUF from the trace frame, starting at
3669 TRACE_FD's current position. Note that this call `read'
3670 underneath, hence it advances the file's seek position. Throws an
3671 error if the `read' syscall fails, or less than SIZE bytes are
3675 tfile_read (gdb_byte
*readbuf
, int size
)
3679 gotten
= read (trace_fd
, readbuf
, size
);
3681 perror_with_name (trace_filename
);
3682 else if (gotten
< size
)
3683 error (_("Premature end of file while reading trace file"));
3687 tfile_open (char *filename
, int from_tty
)
3689 volatile struct gdb_exception ex
;
3691 struct cleanup
*old_chain
;
3694 char header
[TRACE_HEADER_SIZE
];
3695 char linebuf
[1000]; /* Should be max remote packet size or so. */
3698 struct trace_status
*ts
;
3699 struct uploaded_tp
*uploaded_tps
= NULL
;
3700 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3702 target_preopen (from_tty
);
3704 error (_("No trace file specified."));
3706 filename
= tilde_expand (filename
);
3707 if (!IS_ABSOLUTE_PATH(filename
))
3709 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
3714 old_chain
= make_cleanup (xfree
, filename
);
3716 flags
= O_BINARY
| O_LARGEFILE
;
3718 scratch_chan
= open (filename
, flags
, 0);
3719 if (scratch_chan
< 0)
3720 perror_with_name (filename
);
3722 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3724 discard_cleanups (old_chain
); /* Don't free filename any more. */
3725 unpush_target (&tfile_ops
);
3727 trace_filename
= xstrdup (filename
);
3728 trace_fd
= scratch_chan
;
3731 /* Read the file header and test for validity. */
3732 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
3734 bytes
+= TRACE_HEADER_SIZE
;
3735 if (!(header
[0] == 0x7f
3736 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3737 error (_("File is not a valid trace file."));
3739 push_target (&tfile_ops
);
3741 trace_regblock_size
= 0;
3742 ts
= current_trace_status ();
3743 /* We know we're working with a file. */
3745 /* Set defaults in case there is no status line. */
3746 ts
->running_known
= 0;
3747 ts
->stop_reason
= trace_stop_reason_unknown
;
3748 ts
->traceframe_count
= -1;
3749 ts
->buffer_free
= 0;
3750 ts
->disconnected_tracing
= 0;
3751 ts
->circular_buffer
= 0;
3753 TRY_CATCH (ex
, RETURN_MASK_ALL
)
3755 /* Read through a section of newline-terminated lines that
3756 define things like tracepoints. */
3760 tfile_read (&byte
, 1);
3765 /* Empty line marks end of the definition section. */
3770 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3773 linebuf
[i
++] = byte
;
3775 error (_("Excessively long lines in trace file"));
3778 /* Record the starting offset of the binary trace data. */
3779 trace_frames_offset
= bytes
;
3781 /* If we don't have a blocksize, we can't interpret the
3783 if (trace_regblock_size
== 0)
3784 error (_("No register block size recorded in trace file"));
3788 /* Pop the partially set up target. */
3790 throw_exception (ex
);
3793 inferior_appeared (current_inferior (), TFILE_PID
);
3794 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3795 add_thread_silent (inferior_ptid
);
3797 if (ts
->traceframe_count
<= 0)
3798 warning (_("No traceframes present in this file."));
3800 /* Add the file's tracepoints and variables into the current mix. */
3802 /* Get trace state variables first, they may be checked when parsing
3803 uploaded commands. */
3804 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3806 merge_uploaded_tracepoints (&uploaded_tps
);
3808 post_create_inferior (&tfile_ops
, from_tty
);
3811 /* Interpret the given line from the definitions part of the trace
3815 tfile_interp_line (char *line
,
3816 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3820 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3823 trace_regblock_size
= strtol (p
, &p
, 16);
3825 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3827 p
+= strlen ("status ");
3828 parse_trace_status (p
, current_trace_status ());
3830 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3832 p
+= strlen ("tp ");
3833 parse_tracepoint_definition (p
, utpp
);
3835 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3837 p
+= strlen ("tsv ");
3838 parse_tsv_definition (p
, utsvp
);
3841 warning (_("Ignoring trace file definition \"%s\""), line
);
3844 /* Parse the part of trace status syntax that is shared between
3845 the remote protocol and the trace file reader. */
3848 parse_trace_status (char *line
, struct trace_status
*ts
)
3850 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
3854 ts
->running_known
= 1;
3855 ts
->running
= (*p
++ == '1');
3856 ts
->stop_reason
= trace_stop_reason_unknown
;
3857 xfree (ts
->stop_desc
);
3858 ts
->stop_desc
= NULL
;
3859 ts
->traceframe_count
= -1;
3860 ts
->traceframes_created
= -1;
3861 ts
->buffer_free
= -1;
3862 ts
->buffer_size
= -1;
3863 ts
->disconnected_tracing
= 0;
3864 ts
->circular_buffer
= 0;
3865 xfree (ts
->user_name
);
3866 ts
->user_name
= NULL
;
3869 ts
->start_time
= ts
->stop_time
= 0;
3873 p1
= strchr (p
, ':');
3875 error (_("Malformed trace status, at %s\n\
3876 Status line: '%s'\n"), p
, line
);
3877 p3
= strchr (p
, ';');
3879 p3
= p
+ strlen (p
);
3880 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3882 p
= unpack_varlen_hex (++p1
, &val
);
3883 ts
->stop_reason
= trace_buffer_full
;
3885 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3887 p
= unpack_varlen_hex (++p1
, &val
);
3888 ts
->stop_reason
= trace_never_run
;
3890 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3893 p
= unpack_varlen_hex (++p1
, &val
);
3894 ts
->stop_reason
= tracepoint_passcount
;
3895 ts
->stopping_tracepoint
= val
;
3897 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3899 p2
= strchr (++p1
, ':');
3907 ts
->stop_desc
= xmalloc (strlen (line
));
3908 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
3909 ts
->stop_desc
[end
] = '\0';
3912 ts
->stop_desc
= xstrdup ("");
3914 p
= unpack_varlen_hex (++p2
, &val
);
3915 ts
->stop_reason
= tstop_command
;
3917 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3919 p
= unpack_varlen_hex (++p1
, &val
);
3920 ts
->stop_reason
= trace_disconnected
;
3922 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3924 p2
= strchr (++p1
, ':');
3927 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3928 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
3929 ts
->stop_desc
[end
] = '\0';
3932 ts
->stop_desc
= xstrdup ("");
3934 p
= unpack_varlen_hex (++p2
, &val
);
3935 ts
->stopping_tracepoint
= val
;
3936 ts
->stop_reason
= tracepoint_error
;
3938 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3940 p
= unpack_varlen_hex (++p1
, &val
);
3941 ts
->traceframe_count
= val
;
3943 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3945 p
= unpack_varlen_hex (++p1
, &val
);
3946 ts
->traceframes_created
= val
;
3948 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3950 p
= unpack_varlen_hex (++p1
, &val
);
3951 ts
->buffer_free
= val
;
3953 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3955 p
= unpack_varlen_hex (++p1
, &val
);
3956 ts
->buffer_size
= val
;
3958 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3960 p
= unpack_varlen_hex (++p1
, &val
);
3961 ts
->disconnected_tracing
= val
;
3963 else if (strncmp (p
, "circular", p1
- p
) == 0)
3965 p
= unpack_varlen_hex (++p1
, &val
);
3966 ts
->circular_buffer
= val
;
3968 else if (strncmp (p
, "starttime", p1
- p
) == 0)
3970 p
= unpack_varlen_hex (++p1
, &val
);
3971 ts
->start_time
= val
;
3973 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
3975 p
= unpack_varlen_hex (++p1
, &val
);
3976 ts
->stop_time
= val
;
3978 else if (strncmp (p
, "username", p1
- p
) == 0)
3981 ts
->user_name
= xmalloc (strlen (p
) / 2);
3982 end
= hex2bin (p1
, ts
->user_name
, (p3
- p1
) / 2);
3983 ts
->user_name
[end
] = '\0';
3986 else if (strncmp (p
, "notes", p1
- p
) == 0)
3989 ts
->notes
= xmalloc (strlen (p
) / 2);
3990 end
= hex2bin (p1
, ts
->notes
, (p3
- p1
) / 2);
3991 ts
->notes
[end
] = '\0';
3996 /* Silently skip unknown optional info. */
3997 p_temp
= strchr (p1
+ 1, ';');
4001 /* Must be at the end. */
4008 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
4009 struct uploaded_tp
*utp
)
4012 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
4014 p
= unpack_varlen_hex (p
, &uval
);
4016 tp
->base
.hit_count
+= uval
;
4018 utp
->hit_count
+= uval
;
4019 p
= unpack_varlen_hex (p
+ 1, &uval
);
4021 tp
->traceframe_usage
+= uval
;
4023 utp
->traceframe_usage
+= uval
;
4024 /* Ignore any extra, allowing for future extensions. */
4027 /* Given a line of text defining a part of a tracepoint, parse it into
4028 an "uploaded tracepoint". */
4031 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
4035 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
4038 char *cond
, *srctype
, *buf
;
4039 struct uploaded_tp
*utp
= NULL
;
4042 /* Both tracepoint and action definitions start with the same number
4043 and address sequence. */
4045 p
= unpack_varlen_hex (p
, &num
);
4046 p
++; /* skip a colon */
4047 p
= unpack_varlen_hex (p
, &addr
);
4048 p
++; /* skip a colon */
4051 enabled
= (*p
++ == 'E');
4052 p
++; /* skip a colon */
4053 p
= unpack_varlen_hex (p
, &step
);
4054 p
++; /* skip a colon */
4055 p
= unpack_varlen_hex (p
, &pass
);
4056 type
= bp_tracepoint
;
4058 /* Thumb through optional fields. */
4061 p
++; /* skip a colon */
4064 type
= bp_fast_tracepoint
;
4066 p
= unpack_varlen_hex (p
, &orig_size
);
4070 type
= bp_static_tracepoint
;
4076 p
= unpack_varlen_hex (p
, &xlen
);
4077 p
++; /* skip a comma */
4078 cond
= (char *) xmalloc (2 * xlen
+ 1);
4079 strncpy (cond
, p
, 2 * xlen
);
4080 cond
[2 * xlen
] = '\0';
4084 warning (_("Unrecognized char '%c' in tracepoint "
4085 "definition, skipping rest"), *p
);
4087 utp
= get_uploaded_tp (num
, addr
, utpp
);
4089 utp
->enabled
= enabled
;
4094 else if (piece
== 'A')
4096 utp
= get_uploaded_tp (num
, addr
, utpp
);
4097 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
4099 else if (piece
== 'S')
4101 utp
= get_uploaded_tp (num
, addr
, utpp
);
4102 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
4104 else if (piece
== 'Z')
4106 /* Parse a chunk of source form definition. */
4107 utp
= get_uploaded_tp (num
, addr
, utpp
);
4109 p
= strchr (p
, ':');
4110 p
++; /* skip a colon */
4111 p
= unpack_varlen_hex (p
, &start
);
4112 p
++; /* skip a colon */
4113 p
= unpack_varlen_hex (p
, &xlen
);
4114 p
++; /* skip a colon */
4116 buf
= alloca (strlen (line
));
4118 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4121 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
4122 utp
->at_string
= xstrdup (buf
);
4123 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
4124 utp
->cond_string
= xstrdup (buf
);
4125 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
4126 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
4128 else if (piece
== 'V')
4130 utp
= get_uploaded_tp (num
, addr
, utpp
);
4132 parse_tracepoint_status (p
, NULL
, utp
);
4136 /* Don't error out, the target might be sending us optional
4137 info that we don't care about. */
4138 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
4142 /* Convert a textual description of a trace state variable into an
4146 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
4149 ULONGEST num
, initval
, builtin
;
4151 struct uploaded_tsv
*utsv
= NULL
;
4153 buf
= alloca (strlen (line
));
4156 p
= unpack_varlen_hex (p
, &num
);
4157 p
++; /* skip a colon */
4158 p
= unpack_varlen_hex (p
, &initval
);
4159 p
++; /* skip a colon */
4160 p
= unpack_varlen_hex (p
, &builtin
);
4161 p
++; /* skip a colon */
4162 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4165 utsv
= get_uploaded_tsv (num
, utsvp
);
4166 utsv
->initial_value
= initval
;
4167 utsv
->builtin
= builtin
;
4168 utsv
->name
= xstrdup (buf
);
4171 /* Close the trace file and generally clean up. */
4174 tfile_close (int quitting
)
4181 pid
= ptid_get_pid (inferior_ptid
);
4182 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff. */
4183 exit_inferior_silent (pid
);
4187 xfree (trace_filename
);
4188 trace_filename
= NULL
;
4192 tfile_files_info (struct target_ops
*t
)
4194 /* (it would be useful to mention the name of the file). */
4195 printf_filtered ("Looking at a trace file.\n");
4198 /* The trace status for a file is that tracing can never be run. */
4201 tfile_get_trace_status (struct trace_status
*ts
)
4203 /* Other bits of trace status were collected as part of opening the
4204 trace files, so nothing to do here. */
4210 tfile_get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
4212 /* Other bits of trace status were collected as part of opening the
4213 trace files, so nothing to do here. */
4216 /* Given the position of a traceframe in the file, figure out what
4217 address the frame was collected at. This would normally be the
4218 value of a collected PC register, but if not available, we
4222 tfile_get_traceframe_address (off_t tframe_offset
)
4226 struct tracepoint
*tp
;
4227 off_t saved_offset
= cur_offset
;
4229 /* FIXME dig pc out of collected registers. */
4231 /* Fall back to using tracepoint address. */
4232 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
4233 tfile_read ((gdb_byte
*) &tpnum
, 2);
4234 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4236 (target_gdbarch ()));
4238 tp
= get_tracepoint_by_number_on_target (tpnum
);
4239 /* FIXME this is a poor heuristic if multiple locations. */
4240 if (tp
&& tp
->base
.loc
)
4241 addr
= tp
->base
.loc
->address
;
4243 /* Restore our seek position. */
4244 cur_offset
= saved_offset
;
4245 lseek (trace_fd
, cur_offset
, SEEK_SET
);
4249 /* Given a type of search and some parameters, scan the collection of
4250 traceframes in the file looking for a match. When found, return
4251 both the traceframe and tracepoint number, otherwise -1 for
4255 tfile_trace_find (enum trace_find_type type
, int num
,
4256 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
4259 int tfnum
= 0, found
= 0;
4260 unsigned int data_size
;
4261 struct tracepoint
*tp
;
4262 off_t offset
, tframe_offset
;
4272 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
4273 offset
= trace_frames_offset
;
4276 tframe_offset
= offset
;
4277 tfile_read ((gdb_byte
*) &tpnum
, 2);
4278 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4280 (target_gdbarch ()));
4284 tfile_read ((gdb_byte
*) &data_size
, 4);
4285 data_size
= (unsigned int) extract_unsigned_integer
4286 ((gdb_byte
*) &data_size
, 4,
4287 gdbarch_byte_order (target_gdbarch ()));
4296 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4297 if (tfaddr
== addr1
)
4301 tp
= get_tracepoint (num
);
4302 if (tp
&& tpnum
== tp
->number_on_target
)
4306 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4307 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
4311 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4312 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
4316 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
4322 cur_offset
= offset
;
4323 cur_data_size
= data_size
;
4327 /* Skip past the traceframe's data. */
4328 lseek (trace_fd
, data_size
, SEEK_CUR
);
4329 offset
+= data_size
;
4330 /* Update our own count of traceframes. */
4333 /* Did not find what we were looking for. */
4339 /* Prototype of the callback passed to tframe_walk_blocks. */
4340 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
4342 /* Callback for traceframe_walk_blocks, used to find a given block
4343 type in a traceframe. */
4346 match_blocktype (char blocktype
, void *data
)
4348 char *wantedp
= data
;
4350 if (*wantedp
== blocktype
)
4356 /* Walk over all traceframe block starting at POS offset from
4357 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4358 unmodified. If CALLBACK returns true, this returns the position in
4359 the traceframe where the block is found, relative to the start of
4360 the traceframe (cur_offset). Returns -1 if no callback call
4361 returned true, indicating that all blocks have been walked. */
4364 traceframe_walk_blocks (walk_blocks_callback_func callback
,
4365 int pos
, void *data
)
4367 /* Iterate through a traceframe's blocks, looking for a block of the
4370 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
4371 while (pos
< cur_data_size
)
4373 unsigned short mlen
;
4376 tfile_read (&block_type
, 1);
4380 if ((*callback
) (block_type
, data
))
4386 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4387 pos
+= trace_regblock_size
;
4390 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4391 tfile_read ((gdb_byte
*) &mlen
, 2);
4392 mlen
= (unsigned short)
4393 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4395 (target_gdbarch ()));
4396 lseek (trace_fd
, mlen
, SEEK_CUR
);
4397 pos
+= (8 + 2 + mlen
);
4400 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
4404 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4405 block_type
, block_type
);
4413 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4414 position offset of a block of type TYPE_WANTED in the current trace
4415 frame, starting at POS. Returns -1 if no such block was found. */
4418 traceframe_find_block_type (char type_wanted
, int pos
)
4420 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
4423 /* Look for a block of saved registers in the traceframe, and get the
4424 requested register from it. */
4427 tfile_fetch_registers (struct target_ops
*ops
,
4428 struct regcache
*regcache
, int regno
)
4430 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4431 int offset
, regn
, regsize
, pc_regno
;
4434 /* An uninitialized reg size says we're not going to be
4435 successful at getting register blocks. */
4436 if (!trace_regblock_size
)
4439 regs
= alloca (trace_regblock_size
);
4441 if (traceframe_find_block_type ('R', 0) >= 0)
4443 tfile_read (regs
, trace_regblock_size
);
4445 /* Assume the block is laid out in GDB register number order,
4446 each register with the size that it has in GDB. */
4448 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4450 regsize
= register_size (gdbarch
, regn
);
4451 /* Make sure we stay within block bounds. */
4452 if (offset
+ regsize
>= trace_regblock_size
)
4454 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
4458 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
4461 else if (regno
== -1)
4463 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
4471 /* We get here if no register data has been found. Mark registers
4473 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4474 regcache_raw_supply (regcache
, regn
, NULL
);
4476 /* We can often usefully guess that the PC is going to be the same
4477 as the address of the tracepoint. */
4478 pc_regno
= gdbarch_pc_regnum (gdbarch
);
4479 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
4481 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
4483 if (tp
&& tp
->base
.loc
)
4485 /* But don't try to guess if tracepoint is multi-location... */
4486 if (tp
->base
.loc
->next
)
4488 warning (_("Tracepoint %d has multiple "
4489 "locations, cannot infer $pc"),
4493 /* ... or does while-stepping. */
4494 if (tp
->step_count
> 0)
4496 warning (_("Tracepoint %d does while-stepping, "
4497 "cannot infer $pc"),
4502 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
4503 gdbarch_byte_order (gdbarch
),
4504 tp
->base
.loc
->address
);
4505 regcache_raw_supply (regcache
, pc_regno
, regs
);
4511 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4512 const char *annex
, gdb_byte
*readbuf
,
4513 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
4515 /* We're only doing regular memory for now. */
4516 if (object
!= TARGET_OBJECT_MEMORY
)
4519 if (readbuf
== NULL
)
4520 error (_("tfile_xfer_partial: trace file is read-only"));
4522 if (traceframe_number
!= -1)
4526 /* Iterate through the traceframe's blocks, looking for
4528 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
4530 ULONGEST maddr
, amt
;
4531 unsigned short mlen
;
4532 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch ());
4534 tfile_read ((gdb_byte
*) &maddr
, 8);
4535 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
4537 tfile_read ((gdb_byte
*) &mlen
, 2);
4538 mlen
= (unsigned short)
4539 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
4541 /* If the block includes the first part of the desired
4542 range, return as much it has; GDB will re-request the
4543 remainder, which might be in a different block of this
4545 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
4547 amt
= (maddr
+ mlen
) - offset
;
4551 if (maddr
!= offset
)
4552 lseek (trace_fd
, offset
- maddr
, SEEK_CUR
);
4553 tfile_read (readbuf
, amt
);
4557 /* Skip over this block. */
4558 pos
+= (8 + 2 + mlen
);
4562 /* It's unduly pedantic to refuse to look at the executable for
4563 read-only pieces; so do the equivalent of readonly regions aka
4565 /* FIXME account for relocation at some point. */
4572 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
4574 if ((s
->flags
& SEC_LOAD
) == 0
4575 || (s
->flags
& SEC_READONLY
) == 0)
4579 size
= bfd_get_section_size (s
);
4580 if (vma
<= offset
&& offset
< (vma
+ size
))
4584 amt
= (vma
+ size
) - offset
;
4588 amt
= bfd_get_section_contents (exec_bfd
, s
,
4589 readbuf
, offset
- vma
, amt
);
4595 /* Indicate failure to find the requested memory block. */
4599 /* Iterate through the blocks of a trace frame, looking for a 'V'
4600 block with a matching tsv number. */
4603 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
4608 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
4612 tfile_read ((gdb_byte
*) &vnum
, 4);
4613 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
4615 (target_gdbarch ()));
4618 tfile_read ((gdb_byte
*) val
, 8);
4619 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
4621 (target_gdbarch ()));
4627 /* Didn't find anything. */
4632 tfile_has_all_memory (struct target_ops
*ops
)
4638 tfile_has_memory (struct target_ops
*ops
)
4644 tfile_has_stack (struct target_ops
*ops
)
4646 return traceframe_number
!= -1;
4650 tfile_has_registers (struct target_ops
*ops
)
4652 return traceframe_number
!= -1;
4656 tfile_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
4661 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
4662 object for the tfile target's current traceframe. */
4665 build_traceframe_info (char blocktype
, void *data
)
4667 struct traceframe_info
*info
= data
;
4673 struct mem_range
*r
;
4675 unsigned short mlen
;
4677 tfile_read ((gdb_byte
*) &maddr
, 8);
4678 tfile_read ((gdb_byte
*) &mlen
, 2);
4680 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4693 warning (_("Unhandled trace block type (%d) '%c ' "
4694 "while building trace frame info."),
4695 blocktype
, blocktype
);
4702 static struct traceframe_info
*
4703 tfile_traceframe_info (void)
4705 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
4707 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
4712 init_tfile_ops (void)
4714 tfile_ops
.to_shortname
= "tfile";
4715 tfile_ops
.to_longname
= "Local trace dump file";
4717 = "Use a trace file as a target. Specify the filename of the trace file.";
4718 tfile_ops
.to_open
= tfile_open
;
4719 tfile_ops
.to_close
= tfile_close
;
4720 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
4721 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
4722 tfile_ops
.to_files_info
= tfile_files_info
;
4723 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
4724 tfile_ops
.to_get_tracepoint_status
= tfile_get_tracepoint_status
;
4725 tfile_ops
.to_trace_find
= tfile_trace_find
;
4726 tfile_ops
.to_get_trace_state_variable_value
4727 = tfile_get_trace_state_variable_value
;
4728 tfile_ops
.to_stratum
= process_stratum
;
4729 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
4730 tfile_ops
.to_has_memory
= tfile_has_memory
;
4731 tfile_ops
.to_has_stack
= tfile_has_stack
;
4732 tfile_ops
.to_has_registers
= tfile_has_registers
;
4733 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
4734 tfile_ops
.to_thread_alive
= tfile_thread_alive
;
4735 tfile_ops
.to_magic
= OPS_MAGIC
;
4739 free_current_marker (void *arg
)
4741 struct static_tracepoint_marker
**marker_p
= arg
;
4743 if (*marker_p
!= NULL
)
4745 release_static_tracepoint_marker (*marker_p
);
4752 /* Given a line of text defining a static tracepoint marker, parse it
4753 into a "static tracepoint marker" object. Throws an error is
4754 parsing fails. If PP is non-null, it points to one past the end of
4755 the parsed marker definition. */
4758 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
4759 struct static_tracepoint_marker
*marker
)
4766 p
= unpack_varlen_hex (p
, &addr
);
4767 p
++; /* skip a colon */
4769 marker
->gdbarch
= target_gdbarch ();
4770 marker
->address
= (CORE_ADDR
) addr
;
4772 endp
= strchr (p
, ':');
4774 error (_("bad marker definition: %s"), line
);
4776 marker
->str_id
= xmalloc (endp
- p
+ 1);
4777 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
4778 marker
->str_id
[end
] = '\0';
4781 p
++; /* skip a colon */
4783 marker
->extra
= xmalloc (strlen (p
) + 1);
4784 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
4785 marker
->extra
[end
] = '\0';
4791 /* Release a static tracepoint marker's contents. Note that the
4792 object itself isn't released here. There objects are usually on
4796 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
4798 xfree (marker
->str_id
);
4799 marker
->str_id
= NULL
;
4802 /* Print MARKER to gdb_stdout. */
4805 print_one_static_tracepoint_marker (int count
,
4806 struct static_tracepoint_marker
*marker
)
4808 struct command_line
*l
;
4811 char wrap_indent
[80];
4812 char extra_field_indent
[80];
4813 struct ui_out
*uiout
= current_uiout
;
4814 struct cleanup
*bkpt_chain
;
4815 VEC(breakpoint_p
) *tracepoints
;
4817 struct symtab_and_line sal
;
4821 sal
.pc
= marker
->address
;
4823 tracepoints
= static_tracepoints_here (marker
->address
);
4825 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
4827 /* A counter field to help readability. This is not a stable
4829 ui_out_field_int (uiout
, "count", count
);
4831 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
4833 ui_out_field_fmt (uiout
, "enabled", "%c",
4834 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
4835 ui_out_spaces (uiout
, 2);
4837 strcpy (wrap_indent
, " ");
4839 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
4840 strcat (wrap_indent
, " ");
4842 strcat (wrap_indent
, " ");
4844 strcpy (extra_field_indent
, " ");
4846 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
4848 sal
= find_pc_line (marker
->address
, 0);
4849 sym
= find_pc_sect_function (marker
->address
, NULL
);
4852 ui_out_text (uiout
, "in ");
4853 ui_out_field_string (uiout
, "func",
4854 SYMBOL_PRINT_NAME (sym
));
4855 ui_out_wrap_hint (uiout
, wrap_indent
);
4856 ui_out_text (uiout
, " at ");
4859 ui_out_field_skip (uiout
, "func");
4861 if (sal
.symtab
!= NULL
)
4863 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
4864 ui_out_text (uiout
, ":");
4866 if (ui_out_is_mi_like_p (uiout
))
4868 const char *fullname
= symtab_to_fullname (sal
.symtab
);
4870 ui_out_field_string (uiout
, "fullname", fullname
);
4873 ui_out_field_skip (uiout
, "fullname");
4875 ui_out_field_int (uiout
, "line", sal
.line
);
4879 ui_out_field_skip (uiout
, "fullname");
4880 ui_out_field_skip (uiout
, "line");
4883 ui_out_text (uiout
, "\n");
4884 ui_out_text (uiout
, extra_field_indent
);
4885 ui_out_text (uiout
, _("Data: \""));
4886 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
4887 ui_out_text (uiout
, "\"\n");
4889 if (!VEC_empty (breakpoint_p
, tracepoints
))
4891 struct cleanup
*cleanup_chain
;
4893 struct breakpoint
*b
;
4895 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
4898 ui_out_text (uiout
, extra_field_indent
);
4899 ui_out_text (uiout
, _("Probed by static tracepoints: "));
4900 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
4903 ui_out_text (uiout
, ", ");
4904 ui_out_text (uiout
, "#");
4905 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
4908 do_cleanups (cleanup_chain
);
4910 if (ui_out_is_mi_like_p (uiout
))
4911 ui_out_field_int (uiout
, "number-of-tracepoints",
4912 VEC_length(breakpoint_p
, tracepoints
));
4914 ui_out_text (uiout
, "\n");
4916 VEC_free (breakpoint_p
, tracepoints
);
4918 do_cleanups (bkpt_chain
);
4922 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
4924 VEC(static_tracepoint_marker_p
) *markers
;
4925 struct cleanup
*old_chain
;
4926 struct static_tracepoint_marker
*marker
;
4927 struct ui_out
*uiout
= current_uiout
;
4930 /* We don't have to check target_can_use_agent and agent's capability on
4931 static tracepoint here, in order to be compatible with older GDBserver.
4932 We don't check USE_AGENT is true or not, because static tracepoints
4933 don't work without in-process agent, so we don't bother users to type
4934 `set agent on' when to use static tracepoint. */
4937 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
4938 "StaticTracepointMarkersTable");
4940 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
4942 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
4944 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
4945 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
4946 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
4948 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
4949 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
4951 ui_out_table_body (uiout
);
4953 markers
= target_static_tracepoint_markers_by_strid (NULL
);
4954 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
4957 VEC_iterate (static_tracepoint_marker_p
,
4958 markers
, i
, marker
);
4961 print_one_static_tracepoint_marker (i
+ 1, marker
);
4962 release_static_tracepoint_marker (marker
);
4965 do_cleanups (old_chain
);
4968 /* The $_sdata convenience variable is a bit special. We don't know
4969 for sure type of the value until we actually have a chance to fetch
4970 the data --- the size of the object depends on what has been
4971 collected. We solve this by making $_sdata be an internalvar that
4972 creates a new value on access. */
4974 /* Return a new value with the correct type for the sdata object of
4975 the current trace frame. Return a void value if there's no object
4978 static struct value
*
4979 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
4985 /* We need to read the whole object before we know its size. */
4986 size
= target_read_alloc (¤t_target
,
4987 TARGET_OBJECT_STATIC_TRACE_DATA
,
4994 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
4996 v
= allocate_value (type
);
4997 memcpy (value_contents_raw (v
), buf
, size
);
5002 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
5005 #if !defined(HAVE_LIBEXPAT)
5007 struct traceframe_info
*
5008 parse_traceframe_info (const char *tframe_info
)
5010 static int have_warned
;
5015 warning (_("Can not parse XML trace frame info; XML support "
5016 "was disabled at compile time"));
5022 #else /* HAVE_LIBEXPAT */
5024 #include "xml-support.h"
5026 /* Handle the start of a <memory> element. */
5029 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
5030 const struct gdb_xml_element
*element
,
5031 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
5033 struct traceframe_info
*info
= user_data
;
5034 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5035 ULONGEST
*start_p
, *length_p
;
5037 start_p
= xml_find_attribute (attributes
, "start")->value
;
5038 length_p
= xml_find_attribute (attributes
, "length")->value
;
5040 r
->start
= *start_p
;
5041 r
->length
= *length_p
;
5044 /* Discard the constructed trace frame info (if an error occurs). */
5047 free_result (void *p
)
5049 struct traceframe_info
*result
= p
;
5051 free_traceframe_info (result
);
5054 /* The allowed elements and attributes for an XML memory map. */
5056 static const struct gdb_xml_attribute memory_attributes
[] = {
5057 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5058 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5059 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5062 static const struct gdb_xml_element traceframe_info_children
[] = {
5063 { "memory", memory_attributes
, NULL
,
5064 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5065 traceframe_info_start_memory
, NULL
},
5066 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5069 static const struct gdb_xml_element traceframe_info_elements
[] = {
5070 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
5072 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5075 /* Parse a traceframe-info XML document. */
5077 struct traceframe_info
*
5078 parse_traceframe_info (const char *tframe_info
)
5080 struct traceframe_info
*result
;
5081 struct cleanup
*back_to
;
5083 result
= XCNEW (struct traceframe_info
);
5084 back_to
= make_cleanup (free_result
, result
);
5086 if (gdb_xml_parse_quick (_("trace frame info"),
5087 "traceframe-info.dtd", traceframe_info_elements
,
5088 tframe_info
, result
) == 0)
5090 /* Parsed successfully, keep the result. */
5091 discard_cleanups (back_to
);
5096 do_cleanups (back_to
);
5100 #endif /* HAVE_LIBEXPAT */
5102 /* Returns the traceframe_info object for the current traceframe.
5103 This is where we avoid re-fetching the object from the target if we
5104 already have it cached. */
5106 static struct traceframe_info
*
5107 get_traceframe_info (void)
5109 if (traceframe_info
== NULL
)
5110 traceframe_info
= target_traceframe_info ();
5112 return traceframe_info
;
5115 /* If the target supports the query, return in RESULT the set of
5116 collected memory in the current traceframe, found within the LEN
5117 bytes range starting at MEMADDR. Returns true if the target
5118 supports the query, otherwise returns false, and RESULT is left
5122 traceframe_available_memory (VEC(mem_range_s
) **result
,
5123 CORE_ADDR memaddr
, ULONGEST len
)
5125 struct traceframe_info
*info
= get_traceframe_info ();
5129 struct mem_range
*r
;
5134 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
5135 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
5137 ULONGEST lo1
, hi1
, lo2
, hi2
;
5138 struct mem_range
*nr
;
5141 hi1
= memaddr
+ len
;
5144 hi2
= r
->start
+ r
->length
;
5146 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
5148 nr
->start
= max (lo1
, lo2
);
5149 nr
->length
= min (hi1
, hi2
) - nr
->start
;
5152 normalize_mem_ranges (*result
);
5159 /* Implementation of `sdata' variable. */
5161 static const struct internalvar_funcs sdata_funcs
=
5168 /* module initialization */
5170 _initialize_tracepoint (void)
5172 struct cmd_list_element
*c
;
5174 /* Explicitly create without lookup, since that tries to create a
5175 value with a void typed value, and when we get here, gdbarch
5176 isn't initialized yet. At this point, we're quite sure there
5177 isn't another convenience variable of the same name. */
5178 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
5180 traceframe_number
= -1;
5181 tracepoint_number
= -1;
5183 if (tracepoint_list
.list
== NULL
)
5185 tracepoint_list
.listsize
= 128;
5186 tracepoint_list
.list
= xmalloc
5187 (tracepoint_list
.listsize
* sizeof (struct memrange
));
5189 if (tracepoint_list
.aexpr_list
== NULL
)
5191 tracepoint_list
.aexpr_listsize
= 128;
5192 tracepoint_list
.aexpr_list
= xmalloc
5193 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5196 if (stepping_list
.list
== NULL
)
5198 stepping_list
.listsize
= 128;
5199 stepping_list
.list
= xmalloc
5200 (stepping_list
.listsize
* sizeof (struct memrange
));
5203 if (stepping_list
.aexpr_list
== NULL
)
5205 stepping_list
.aexpr_listsize
= 128;
5206 stepping_list
.aexpr_list
= xmalloc
5207 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5210 add_info ("scope", scope_info
,
5211 _("List the variables local to a scope"));
5213 add_cmd ("tracepoints", class_trace
, NULL
,
5214 _("Tracing of program execution without stopping the program."),
5217 add_com ("tdump", class_trace
, trace_dump_command
,
5218 _("Print everything collected at the current tracepoint."));
5220 add_com ("tsave", class_trace
, trace_save_command
, _("\
5221 Save the trace data to a file.\n\
5222 Use the '-r' option to direct the target to save directly to the file,\n\
5223 using its own filesystem."));
5225 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
5226 Define a trace state variable.\n\
5227 Argument is a $-prefixed name, optionally followed\n\
5228 by '=' and an expression that sets the initial value\n\
5229 at the start of tracing."));
5230 set_cmd_completer (c
, expression_completer
);
5232 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
5233 Delete one or more trace state variables.\n\
5234 Arguments are the names of the variables to delete.\n\
5235 If no arguments are supplied, delete all variables."), &deletelist
);
5236 /* FIXME add a trace variable completer. */
5238 add_info ("tvariables", tvariables_info
, _("\
5239 Status of trace state variables and their values.\n\
5242 add_info ("static-tracepoint-markers",
5243 info_static_tracepoint_markers_command
, _("\
5244 List target static tracepoints markers.\n\
5247 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
5248 Select a trace frame;\n\
5249 No argument means forward by one frame; '-' means backward by one frame."),
5250 &tfindlist
, "tfind ", 1, &cmdlist
);
5252 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
5253 Select a trace frame whose PC is outside the given range (exclusive).\n\
5254 Usage: tfind outside addr1, addr2"),
5257 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
5258 Select a trace frame whose PC is in the given range (inclusive).\n\
5259 Usage: tfind range addr1,addr2"),
5262 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
5263 Select a trace frame by source line.\n\
5264 Argument can be a line number (with optional source file),\n\
5265 a function name, or '*' followed by an address.\n\
5266 Default argument is 'the next source line that was traced'."),
5269 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
5270 Select a trace frame by tracepoint number.\n\
5271 Default is the tracepoint for the current trace frame."),
5274 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
5275 Select a trace frame by PC.\n\
5276 Default is the current PC, or the PC of the current trace frame."),
5279 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
5280 De-select any trace frame and resume 'live' debugging."),
5283 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
5285 add_cmd ("start", class_trace
, trace_find_start_command
,
5286 _("Select the first trace frame in the trace buffer."),
5289 add_com ("tstatus", class_trace
, trace_status_command
,
5290 _("Display the status of the current trace data collection."));
5292 add_com ("tstop", class_trace
, trace_stop_command
, _("\
5293 Stop trace data collection.\n\
5294 Usage: tstop [ <notes> ... ]\n\
5295 Any arguments supplied are recorded with the trace as a stop reason and\n\
5296 reported by tstatus (if the target supports trace notes)."));
5298 add_com ("tstart", class_trace
, trace_start_command
, _("\
5299 Start trace data collection.\n\
5300 Usage: tstart [ <notes> ... ]\n\
5301 Any arguments supplied are recorded with the trace as a note and\n\
5302 reported by tstatus (if the target supports trace notes)."));
5304 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
5305 Ends a list of commands or actions.\n\
5306 Several GDB commands allow you to enter a list of commands or actions.\n\
5307 Entering \"end\" on a line by itself is the normal way to terminate\n\
5309 Note: the \"end\" command cannot be used at the gdb prompt."));
5311 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
5312 Specify single-stepping behavior at a tracepoint.\n\
5313 Argument is number of instructions to trace in single-step mode\n\
5314 following the tracepoint. This command is normally followed by\n\
5315 one or more \"collect\" commands, to specify what to collect\n\
5316 while single-stepping.\n\n\
5317 Note: this command can only be used in a tracepoint \"actions\" list."));
5319 add_com_alias ("ws", "while-stepping", class_alias
, 0);
5320 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
5322 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
5323 Specify one or more data items to be collected at a tracepoint.\n\
5324 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5325 collect all data (variables, registers) referenced by that expression.\n\
5326 Also accepts the following special arguments:\n\
5327 $regs -- all registers.\n\
5328 $args -- all function arguments.\n\
5329 $locals -- all variables local to the block/function scope.\n\
5330 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5331 Note: this command can only be used in a tracepoint \"actions\" list."));
5333 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
5334 Specify one or more expressions to be evaluated at a tracepoint.\n\
5335 Accepts a comma-separated list of (one or more) expressions.\n\
5336 The result of each evaluation will be discarded.\n\
5337 Note: this command can only be used in a tracepoint \"actions\" list."));
5339 add_com ("actions", class_trace
, trace_actions_command
, _("\
5340 Specify the actions to be taken at a tracepoint.\n\
5341 Tracepoint actions may include collecting of specified data,\n\
5342 single-stepping, or enabling/disabling other tracepoints,\n\
5343 depending on target's capabilities."));
5345 default_collect
= xstrdup ("");
5346 add_setshow_string_cmd ("default-collect", class_trace
,
5347 &default_collect
, _("\
5348 Set the list of expressions to collect by default"), _("\
5349 Show the list of expressions to collect by default"), NULL
,
5351 &setlist
, &showlist
);
5353 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
5354 &disconnected_tracing
, _("\
5355 Set whether tracing continues after GDB disconnects."), _("\
5356 Show whether tracing continues after GDB disconnects."), _("\
5357 Use this to continue a tracing run even if GDB disconnects\n\
5358 or detaches from the target. You can reconnect later and look at\n\
5359 trace data collected in the meantime."),
5360 set_disconnected_tracing
,
5365 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
5366 &circular_trace_buffer
, _("\
5367 Set target's use of circular trace buffer."), _("\
5368 Show target's use of circular trace buffer."), _("\
5369 Use this to make the trace buffer into a circular buffer,\n\
5370 which will discard traceframes (oldest first) instead of filling\n\
5371 up and stopping the trace run."),
5372 set_circular_trace_buffer
,
5377 add_setshow_string_cmd ("trace-user", class_trace
,
5379 Set the user name to use for current and future trace runs"), _("\
5380 Show the user name to use for current and future trace runs"), NULL
,
5381 set_trace_user
, NULL
,
5382 &setlist
, &showlist
);
5384 add_setshow_string_cmd ("trace-notes", class_trace
,
5386 Set notes string to use for current and future trace runs"), _("\
5387 Show the notes string to use for current and future trace runs"), NULL
,
5388 set_trace_notes
, NULL
,
5389 &setlist
, &showlist
);
5391 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
5392 &trace_stop_notes
, _("\
5393 Set notes string to use for future tstop commands"), _("\
5394 Show the notes string to use for future tstop commands"), NULL
,
5395 set_trace_stop_notes
, NULL
,
5396 &setlist
, &showlist
);
5400 add_target (&tfile_ops
);