1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2012 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
25 #include "expression.h"
30 #include "gdb_string.h"
32 #include "breakpoint.h"
33 #include "tracepoint.h"
36 #include "completer.h"
38 #include "dictionary.h"
40 #include "user-regs.h"
44 #include "filenames.h"
45 #include "gdbthread.h"
53 #include "exceptions.h"
54 #include "cli/cli-utils.h"
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);
96 /* GDB commands implemented in other modules:
99 extern void output_command (char *, int);
104 This module defines the following debugger commands:
105 trace : set a tracepoint on a function, line, or address.
106 info trace : list all debugger-defined tracepoints.
107 delete trace : delete one or more tracepoints.
108 enable trace : enable one or more tracepoints.
109 disable trace : disable one or more tracepoints.
110 actions : specify actions to be taken at a tracepoint.
111 passcount : specify a pass count for a tracepoint.
112 tstart : start a trace experiment.
113 tstop : stop a trace experiment.
114 tstatus : query the status of a trace experiment.
115 tfind : find a trace frame in the trace buffer.
116 tdump : print everything collected at the current tracepoint.
117 save-tracepoints : write tracepoint setup into a file.
119 This module defines the following user-visible debugger variables:
120 $trace_frame : sequence number of trace frame currently being debugged.
121 $trace_line : source line of trace frame currently being debugged.
122 $trace_file : source file of trace frame currently being debugged.
123 $tracepoint : tracepoint number of trace frame currently being debugged.
127 /* ======= Important global variables: ======= */
129 /* The list of all trace state variables. We don't retain pointers to
130 any of these for any reason - API is by name or number only - so it
131 works to have a vector of objects. */
133 typedef struct trace_state_variable tsv_s
;
136 /* An object describing the contents of a traceframe. */
138 struct traceframe_info
140 /* Collected memory. */
141 VEC(mem_range_s
) *memory
;
144 static VEC(tsv_s
) *tvariables
;
146 /* The next integer to assign to a variable. */
148 static int next_tsv_number
= 1;
150 /* Number of last traceframe collected. */
151 static int traceframe_number
;
153 /* Tracepoint for last traceframe collected. */
154 static int tracepoint_number
;
156 /* Symbol for function for last traceframe collected. */
157 static struct symbol
*traceframe_fun
;
159 /* Symtab and line for last traceframe collected. */
160 static struct symtab_and_line traceframe_sal
;
162 /* The traceframe info of the current traceframe. NULL if we haven't
163 yet attempted to fetch it, or if the target does not support
164 fetching this object, or if we're not inspecting a traceframe
166 static struct traceframe_info
*traceframe_info
;
168 /* Tracing command lists. */
169 static struct cmd_list_element
*tfindlist
;
171 /* List of expressions to collect by default at each tracepoint hit. */
172 char *default_collect
= "";
174 static int disconnected_tracing
;
176 /* This variable controls whether we ask the target for a linear or
177 circular trace buffer. */
179 static int circular_trace_buffer
;
181 /* Textual notes applying to the current and/or future trace runs. */
183 char *trace_user
= NULL
;
185 /* Textual notes applying to the current and/or future trace runs. */
187 char *trace_notes
= NULL
;
189 /* Textual notes applying to the stopping of a trace. */
191 char *trace_stop_notes
= NULL
;
193 /* ======= Important command functions: ======= */
194 static void trace_actions_command (char *, int);
195 static void trace_start_command (char *, int);
196 static void trace_stop_command (char *, int);
197 static void trace_status_command (char *, int);
198 static void trace_find_command (char *, int);
199 static void trace_find_pc_command (char *, int);
200 static void trace_find_tracepoint_command (char *, int);
201 static void trace_find_line_command (char *, int);
202 static void trace_find_range_command (char *, int);
203 static void trace_find_outside_command (char *, int);
204 static void trace_dump_command (char *, int);
206 /* support routines */
208 struct collection_list
;
209 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
210 static char *mem2hex (gdb_byte
*, char *, int);
211 static void add_register (struct collection_list
*collection
,
214 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
215 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
218 extern void _initialize_tracepoint (void);
220 static struct trace_status trace_status
;
222 char *stop_reason_names
[] = {
232 struct trace_status
*
233 current_trace_status (void)
235 return &trace_status
;
241 free_traceframe_info (struct traceframe_info
*info
)
245 VEC_free (mem_range_s
, info
->memory
);
251 /* Free and clear the traceframe info cache of the current
255 clear_traceframe_info (void)
257 free_traceframe_info (traceframe_info
);
258 traceframe_info
= NULL
;
261 /* Set traceframe number to NUM. */
263 set_traceframe_num (int num
)
265 traceframe_number
= num
;
266 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
269 /* Set tracepoint number to NUM. */
271 set_tracepoint_num (int num
)
273 tracepoint_number
= num
;
274 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
277 /* Set externally visible debug variables for querying/printing
278 the traceframe context (line, function, file). */
281 set_traceframe_context (struct frame_info
*trace_frame
)
285 /* Save as globals for internal use. */
286 if (trace_frame
!= NULL
287 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
289 traceframe_sal
= find_pc_line (trace_pc
, 0);
290 traceframe_fun
= find_pc_function (trace_pc
);
292 /* Save linenumber as "$trace_line", a debugger variable visible to
294 set_internalvar_integer (lookup_internalvar ("trace_line"),
295 traceframe_sal
.line
);
299 init_sal (&traceframe_sal
);
300 traceframe_fun
= NULL
;
301 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
304 /* Save func name as "$trace_func", a debugger variable visible to
306 if (traceframe_fun
== NULL
307 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
308 clear_internalvar (lookup_internalvar ("trace_func"));
310 set_internalvar_string (lookup_internalvar ("trace_func"),
311 SYMBOL_LINKAGE_NAME (traceframe_fun
));
313 /* Save file name as "$trace_file", a debugger variable visible to
315 if (traceframe_sal
.symtab
== NULL
316 || traceframe_sal
.symtab
->filename
== NULL
)
317 clear_internalvar (lookup_internalvar ("trace_file"));
319 set_internalvar_string (lookup_internalvar ("trace_file"),
320 traceframe_sal
.symtab
->filename
);
323 /* Create a new trace state variable with the given name. */
325 struct trace_state_variable
*
326 create_trace_state_variable (const char *name
)
328 struct trace_state_variable tsv
;
330 memset (&tsv
, 0, sizeof (tsv
));
331 tsv
.name
= xstrdup (name
);
332 tsv
.number
= next_tsv_number
++;
333 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
336 /* Look for a trace state variable of the given name. */
338 struct trace_state_variable
*
339 find_trace_state_variable (const char *name
)
341 struct trace_state_variable
*tsv
;
344 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
345 if (strcmp (name
, tsv
->name
) == 0)
352 delete_trace_state_variable (const char *name
)
354 struct trace_state_variable
*tsv
;
357 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
358 if (strcmp (name
, tsv
->name
) == 0)
360 xfree ((void *)tsv
->name
);
361 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
363 observer_notify_tsv_deleted (name
);
368 warning (_("No trace variable named \"$%s\", not deleting"), name
);
371 /* The 'tvariable' command collects a name and optional expression to
372 evaluate into an initial value. */
375 trace_variable_command (char *args
, int from_tty
)
377 struct expression
*expr
;
378 struct cleanup
*old_chain
;
379 struct internalvar
*intvar
= NULL
;
381 struct trace_state_variable
*tsv
;
384 error_no_arg (_("trace state variable name"));
386 /* All the possible valid arguments are expressions. */
387 expr
= parse_expression (args
);
388 old_chain
= make_cleanup (free_current_contents
, &expr
);
390 if (expr
->nelts
== 0)
391 error (_("No expression?"));
393 /* Only allow two syntaxes; "$name" and "$name=value". */
394 if (expr
->elts
[0].opcode
== OP_INTERNALVAR
)
396 intvar
= expr
->elts
[1].internalvar
;
398 else if (expr
->elts
[0].opcode
== BINOP_ASSIGN
399 && expr
->elts
[1].opcode
== OP_INTERNALVAR
)
401 intvar
= expr
->elts
[2].internalvar
;
402 initval
= value_as_long (evaluate_subexpression_type (expr
, 4));
405 error (_("Syntax must be $NAME [ = EXPR ]"));
408 error (_("No name given"));
410 if (strlen (internalvar_name (intvar
)) <= 0)
411 error (_("Must supply a non-empty variable name"));
413 /* If the variable already exists, just change its initial value. */
414 tsv
= find_trace_state_variable (internalvar_name (intvar
));
417 tsv
->initial_value
= initval
;
418 printf_filtered (_("Trace state variable $%s "
419 "now has initial value %s.\n"),
420 tsv
->name
, plongest (tsv
->initial_value
));
421 do_cleanups (old_chain
);
425 /* Create a new variable. */
426 tsv
= create_trace_state_variable (internalvar_name (intvar
));
427 tsv
->initial_value
= initval
;
429 observer_notify_tsv_created (tsv
->name
, initval
);
431 printf_filtered (_("Trace state variable $%s "
432 "created, with initial value %s.\n"),
433 tsv
->name
, plongest (tsv
->initial_value
));
435 do_cleanups (old_chain
);
439 delete_trace_variable_command (char *args
, int from_tty
)
443 struct cleanup
*back_to
;
447 if (query (_("Delete all trace state variables? ")))
448 VEC_free (tsv_s
, tvariables
);
450 observer_notify_tsv_deleted (NULL
);
454 argv
= gdb_buildargv (args
);
455 back_to
= make_cleanup_freeargv (argv
);
457 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
459 if (*argv
[ix
] == '$')
460 delete_trace_state_variable (argv
[ix
] + 1);
462 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
465 do_cleanups (back_to
);
471 tvariables_info_1 (void)
473 struct trace_state_variable
*tsv
;
476 struct cleanup
*back_to
;
477 struct ui_out
*uiout
= current_uiout
;
479 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
481 printf_filtered (_("No trace state variables.\n"));
485 /* Try to acquire values from the target. */
486 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
487 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
490 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
491 count
, "trace-variables");
492 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
493 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
494 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
496 ui_out_table_body (uiout
);
498 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
500 struct cleanup
*back_to2
;
504 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
506 name
= concat ("$", tsv
->name
, (char *) NULL
);
507 make_cleanup (xfree
, name
);
508 ui_out_field_string (uiout
, "name", name
);
509 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
511 if (tsv
->value_known
)
512 c
= plongest (tsv
->value
);
513 else if (ui_out_is_mi_like_p (uiout
))
514 /* For MI, we prefer not to use magic string constants, but rather
515 omit the field completely. The difference between unknown and
516 undefined does not seem important enough to represent. */
518 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
519 /* The value is/was defined, but we don't have it. */
522 /* It is not meaningful to ask about the value. */
525 ui_out_field_string (uiout
, "current", c
);
526 ui_out_text (uiout
, "\n");
528 do_cleanups (back_to2
);
531 do_cleanups (back_to
);
534 /* List all the trace state variables. */
537 tvariables_info (char *args
, int from_tty
)
539 tvariables_info_1 ();
542 /* Stash definitions of tsvs into the given file. */
545 save_trace_state_variables (struct ui_file
*fp
)
547 struct trace_state_variable
*tsv
;
550 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
552 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
553 if (tsv
->initial_value
)
554 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
555 fprintf_unfiltered (fp
, "\n");
559 /* ACTIONS functions: */
561 /* The three functions:
562 collect_pseudocommand,
563 while_stepping_pseudocommand, and
564 end_actions_pseudocommand
565 are placeholders for "commands" that are actually ONLY to be used
566 within a tracepoint action list. If the actual function is ever called,
567 it means that somebody issued the "command" at the top level,
568 which is always an error. */
571 end_actions_pseudocommand (char *args
, int from_tty
)
573 error (_("This command cannot be used at the top level."));
577 while_stepping_pseudocommand (char *args
, int from_tty
)
579 error (_("This command can only be used in a tracepoint actions list."));
583 collect_pseudocommand (char *args
, int from_tty
)
585 error (_("This command can only be used in a tracepoint actions list."));
589 teval_pseudocommand (char *args
, int from_tty
)
591 error (_("This command can only be used in a tracepoint actions list."));
594 /* Parse any collection options, such as /s for strings. */
597 decode_agent_options (char *exp
)
599 struct value_print_options opts
;
604 /* Call this to borrow the print elements default for collection
606 get_user_print_options (&opts
);
611 if (target_supports_string_tracing ())
613 /* Allow an optional decimal number giving an explicit maximum
614 string length, defaulting it to the "print elements" value;
615 so "collect/s80 mystr" gets at most 80 bytes of string. */
616 trace_string_kludge
= opts
.print_max
;
618 if (*exp
>= '0' && *exp
<= '9')
619 trace_string_kludge
= atoi (exp
);
620 while (*exp
>= '0' && *exp
<= '9')
624 error (_("Target does not support \"/s\" option for string tracing."));
627 error (_("Undefined collection format \"%c\"."), *exp
);
629 exp
= skip_spaces (exp
);
634 /* Enter a list of actions for a tracepoint. */
636 trace_actions_command (char *args
, int from_tty
)
638 struct tracepoint
*t
;
639 struct command_line
*l
;
641 t
= get_tracepoint_by_number (&args
, NULL
, 1);
645 xstrprintf ("Enter actions for tracepoint %d, one per line.",
647 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
649 l
= read_command_lines (tmpbuf
, from_tty
, 1,
650 check_tracepoint_command
, t
);
651 do_cleanups (cleanups
);
652 breakpoint_set_commands (&t
->base
, l
);
654 /* else just return */
657 /* Report the results of checking the agent expression, as errors or
661 report_agent_reqs_errors (struct agent_expr
*aexpr
)
663 /* All of the "flaws" are serious bytecode generation issues that
664 should never occur. */
665 if (aexpr
->flaw
!= agent_flaw_none
)
666 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
668 /* If analysis shows a stack underflow, GDB must have done something
669 badly wrong in its bytecode generation. */
670 if (aexpr
->min_height
< 0)
671 internal_error (__FILE__
, __LINE__
,
672 _("expression has min height < 0"));
674 /* Issue this error if the stack is predicted to get too deep. The
675 limit is rather arbitrary; a better scheme might be for the
676 target to report how much stack it will have available. The
677 depth roughly corresponds to parenthesization, so a limit of 20
678 amounts to 20 levels of expression nesting, which is actually
679 a pretty big hairy expression. */
680 if (aexpr
->max_height
> 20)
681 error (_("Expression is too complicated."));
684 /* worker function */
686 validate_actionline (char **line
, struct breakpoint
*b
)
688 struct cmd_list_element
*c
;
689 struct expression
*exp
= NULL
;
690 struct cleanup
*old_chain
= NULL
;
692 struct bp_location
*loc
;
693 struct agent_expr
*aexpr
;
694 struct tracepoint
*t
= (struct tracepoint
*) b
;
696 /* If EOF is typed, *line is NULL. */
700 for (p
= *line
; isspace ((int) *p
);)
703 /* Symbol lookup etc. */
704 if (*p
== '\0') /* empty line: just prompt for another line. */
707 if (*p
== '#') /* comment line */
710 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
712 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
714 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
716 trace_string_kludge
= 0;
718 p
= decode_agent_options (p
);
721 { /* Repeat over a comma-separated list. */
722 QUIT
; /* Allow user to bail out with ^C. */
723 while (isspace ((int) *p
))
726 if (*p
== '$') /* Look for special pseudo-symbols. */
728 if (0 == strncasecmp ("reg", p
+ 1, 3)
729 || 0 == strncasecmp ("arg", p
+ 1, 3)
730 || 0 == strncasecmp ("loc", p
+ 1, 3)
731 || 0 == strncasecmp ("_ret", p
+ 1, 4)
732 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
737 /* else fall thru, treat p as an expression and parse it! */
740 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
743 exp
= parse_exp_1 (&p
, loc
->address
,
744 block_for_pc (loc
->address
), 1);
745 old_chain
= make_cleanup (free_current_contents
, &exp
);
747 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
749 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
751 error (_("constant `%s' (value %s) "
752 "will not be collected."),
753 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
754 plongest (SYMBOL_VALUE (exp
->elts
[2].symbol
)));
756 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
757 == LOC_OPTIMIZED_OUT
)
759 error (_("`%s' is optimized away "
760 "and cannot be collected."),
761 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
765 /* We have something to collect, make sure that the expr to
766 bytecode translator can handle it and that it's not too
768 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
769 make_cleanup_free_agent_expr (aexpr
);
771 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
772 error (_("Expression is too complicated."));
776 report_agent_reqs_errors (aexpr
);
778 do_cleanups (old_chain
);
781 while (p
&& *p
++ == ',');
784 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
787 { /* Repeat over a comma-separated list. */
788 QUIT
; /* Allow user to bail out with ^C. */
789 while (isspace ((int) *p
))
793 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
796 /* Only expressions are allowed for this action. */
797 exp
= parse_exp_1 (&p
, loc
->address
,
798 block_for_pc (loc
->address
), 1);
799 old_chain
= make_cleanup (free_current_contents
, &exp
);
801 /* We have something to evaluate, make sure that the expr to
802 bytecode translator can handle it and that it's not too
804 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
805 make_cleanup_free_agent_expr (aexpr
);
807 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
808 error (_("Expression is too complicated."));
811 report_agent_reqs_errors (aexpr
);
813 do_cleanups (old_chain
);
816 while (p
&& *p
++ == ',');
819 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
821 char *steparg
; /* In case warning is necessary. */
823 while (isspace ((int) *p
))
827 if (*p
== '\0' || (t
->step_count
= strtol (p
, &p
, 0)) == 0)
828 error (_("while-stepping step count `%s' is malformed."), *line
);
831 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
835 error (_("`%s' is not a supported tracepoint action."), *line
);
839 memrange_absolute
= -1
844 int type
; /* memrange_absolute for absolute memory range,
845 else basereg number. */
846 bfd_signed_vma start
;
850 struct collection_list
852 unsigned char regs_mask
[32]; /* room for up to 256 regs */
855 struct memrange
*list
;
856 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
858 struct agent_expr
**aexpr_list
;
860 /* True is the user requested a collection of "$_sdata", "static
864 tracepoint_list
, stepping_list
;
866 /* MEMRANGE functions: */
868 static int memrange_cmp (const void *, const void *);
870 /* Compare memranges for qsort. */
872 memrange_cmp (const void *va
, const void *vb
)
874 const struct memrange
*a
= va
, *b
= vb
;
876 if (a
->type
< b
->type
)
878 if (a
->type
> b
->type
)
880 if (a
->type
== memrange_absolute
)
882 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
884 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
889 if (a
->start
< b
->start
)
891 if (a
->start
> b
->start
)
897 /* Sort the memrange list using qsort, and merge adjacent memranges. */
899 memrange_sortmerge (struct collection_list
*memranges
)
903 qsort (memranges
->list
, memranges
->next_memrange
,
904 sizeof (struct memrange
), memrange_cmp
);
905 if (memranges
->next_memrange
> 0)
907 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
909 /* If memrange b overlaps or is adjacent to memrange a,
911 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
912 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
914 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
915 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
916 continue; /* next b, same a */
920 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
921 sizeof (struct memrange
));
923 memranges
->next_memrange
= a
+ 1;
927 /* Add a register to a collection list. */
929 add_register (struct collection_list
*collection
, unsigned int regno
)
932 printf_filtered ("collect register %d\n", regno
);
933 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
934 error (_("Internal: register number %d too large for tracepoint"),
936 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
939 /* Add a memrange to a collection list. */
941 add_memrange (struct collection_list
*memranges
,
942 int type
, bfd_signed_vma base
,
947 printf_filtered ("(%d,", type
);
949 printf_filtered (",%ld)\n", len
);
952 /* type: memrange_absolute == memory, other n == basereg */
953 memranges
->list
[memranges
->next_memrange
].type
= type
;
954 /* base: addr if memory, offset if reg relative. */
955 memranges
->list
[memranges
->next_memrange
].start
= base
;
956 /* len: we actually save end (base + len) for convenience */
957 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
958 memranges
->next_memrange
++;
959 if (memranges
->next_memrange
>= memranges
->listsize
)
961 memranges
->listsize
*= 2;
962 memranges
->list
= xrealloc (memranges
->list
,
963 memranges
->listsize
);
966 if (type
!= memrange_absolute
) /* Better collect the base register! */
967 add_register (memranges
, type
);
970 /* Add a symbol to a collection list. */
972 collect_symbol (struct collection_list
*collect
,
974 struct gdbarch
*gdbarch
,
975 long frame_regno
, long frame_offset
,
980 bfd_signed_vma offset
;
981 int treat_as_expr
= 0;
983 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
984 switch (SYMBOL_CLASS (sym
))
987 printf_filtered ("%s: don't know symbol class %d\n",
988 SYMBOL_PRINT_NAME (sym
),
992 printf_filtered ("constant %s (value %s) will not be collected.\n",
993 SYMBOL_PRINT_NAME (sym
), plongest (SYMBOL_VALUE (sym
)));
996 offset
= SYMBOL_VALUE_ADDRESS (sym
);
1001 sprintf_vma (tmp
, offset
);
1002 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1003 SYMBOL_PRINT_NAME (sym
), len
,
1006 /* A struct may be a C++ class with static fields, go to general
1007 expression handling. */
1008 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
1011 add_memrange (collect
, memrange_absolute
, offset
, len
);
1014 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1016 printf_filtered ("LOC_REG[parm] %s: ",
1017 SYMBOL_PRINT_NAME (sym
));
1018 add_register (collect
, reg
);
1019 /* Check for doubles stored in two registers. */
1020 /* FIXME: how about larger types stored in 3 or more regs? */
1021 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1022 len
> register_size (gdbarch
, reg
))
1023 add_register (collect
, reg
+ 1);
1026 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1027 printf_filtered (" (will not collect %s)\n",
1028 SYMBOL_PRINT_NAME (sym
));
1032 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1035 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1036 SYMBOL_PRINT_NAME (sym
), len
);
1037 printf_vma (offset
);
1038 printf_filtered (" from frame ptr reg %d\n", reg
);
1040 add_memrange (collect
, reg
, offset
, len
);
1042 case LOC_REGPARM_ADDR
:
1043 reg
= SYMBOL_VALUE (sym
);
1047 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1048 SYMBOL_PRINT_NAME (sym
), len
);
1049 printf_vma (offset
);
1050 printf_filtered (" from reg %d\n", reg
);
1052 add_memrange (collect
, reg
, offset
, len
);
1056 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1059 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1060 SYMBOL_PRINT_NAME (sym
), len
);
1061 printf_vma (offset
);
1062 printf_filtered (" from frame ptr reg %d\n", reg
);
1064 add_memrange (collect
, reg
, offset
, len
);
1067 case LOC_UNRESOLVED
:
1071 case LOC_OPTIMIZED_OUT
:
1072 printf_filtered ("%s has been optimized out of existence.\n",
1073 SYMBOL_PRINT_NAME (sym
));
1081 /* Expressions are the most general case. */
1084 struct agent_expr
*aexpr
;
1085 struct cleanup
*old_chain1
= NULL
;
1087 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
1089 /* It can happen that the symbol is recorded as a computed
1090 location, but it's been optimized away and doesn't actually
1091 have a location expression. */
1094 printf_filtered ("%s has been optimized out of existence.\n",
1095 SYMBOL_PRINT_NAME (sym
));
1099 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1103 report_agent_reqs_errors (aexpr
);
1105 discard_cleanups (old_chain1
);
1106 add_aexpr (collect
, aexpr
);
1108 /* Take care of the registers. */
1109 if (aexpr
->reg_mask_len
> 0)
1113 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1115 QUIT
; /* Allow user to bail out with ^C. */
1116 if (aexpr
->reg_mask
[ndx1
] != 0)
1118 /* Assume chars have 8 bits. */
1119 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1120 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1121 /* It's used -- record it. */
1122 add_register (collect
, ndx1
* 8 + ndx2
);
1129 /* Data to be passed around in the calls to the locals and args
1132 struct add_local_symbols_data
1134 struct collection_list
*collect
;
1135 struct gdbarch
*gdbarch
;
1142 /* The callback for the locals and args iterators. */
1145 do_collect_symbol (const char *print_name
,
1149 struct add_local_symbols_data
*p
= cb_data
;
1151 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1152 p
->frame_offset
, p
->pc
);
1156 /* Add all locals (or args) symbols to collection list. */
1158 add_local_symbols (struct collection_list
*collect
,
1159 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1160 long frame_regno
, long frame_offset
, int type
)
1162 struct block
*block
;
1163 struct add_local_symbols_data cb_data
;
1165 cb_data
.collect
= collect
;
1166 cb_data
.gdbarch
= gdbarch
;
1168 cb_data
.frame_regno
= frame_regno
;
1169 cb_data
.frame_offset
= frame_offset
;
1174 block
= block_for_pc (pc
);
1177 warning (_("Can't collect locals; "
1178 "no symbol table info available.\n"));
1182 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1183 if (cb_data
.count
== 0)
1184 warning (_("No locals found in scope."));
1188 pc
= get_pc_function_start (pc
);
1189 block
= block_for_pc (pc
);
1192 warning (_("Can't collect args; no symbol table info available."));
1196 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1197 if (cb_data
.count
== 0)
1198 warning (_("No args found in scope."));
1203 add_static_trace_data (struct collection_list
*collection
)
1206 printf_filtered ("collect static trace data\n");
1207 collection
->strace_data
= 1;
1210 /* worker function */
1212 clear_collection_list (struct collection_list
*list
)
1216 list
->next_memrange
= 0;
1217 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1219 free_agent_expr (list
->aexpr_list
[ndx
]);
1220 list
->aexpr_list
[ndx
] = NULL
;
1222 list
->next_aexpr_elt
= 0;
1223 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1224 list
->strace_data
= 0;
1227 /* Reduce a collection list to string form (for gdb protocol). */
1229 stringify_collection_list (struct collection_list
*list
, char *string
)
1231 char temp_buf
[2048];
1235 char *(*str_list
)[];
1239 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1240 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1242 if (list
->strace_data
)
1245 printf_filtered ("\nCollecting static trace data\n");
1248 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1252 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1253 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1255 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1258 printf_filtered ("\nCollecting registers (mask): 0x");
1263 QUIT
; /* Allow user to bail out with ^C. */
1265 printf_filtered ("%02X", list
->regs_mask
[i
]);
1266 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1269 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1273 printf_filtered ("\n");
1274 if (list
->next_memrange
> 0 && info_verbose
)
1275 printf_filtered ("Collecting memranges: \n");
1276 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1278 QUIT
; /* Allow user to bail out with ^C. */
1279 sprintf_vma (tmp2
, list
->list
[i
].start
);
1282 printf_filtered ("(%d, %s, %ld)\n",
1285 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1287 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1289 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1296 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1298 /* The "%X" conversion specifier expects an unsigned argument,
1299 so passing -1 (memrange_absolute) to it directly gives you
1300 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1302 if (list
->list
[i
].type
== memrange_absolute
)
1303 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1305 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1308 count
+= strlen (end
);
1309 end
= temp_buf
+ count
;
1312 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1314 QUIT
; /* Allow user to bail out with ^C. */
1315 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1317 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1322 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1323 end
+= 10; /* 'X' + 8 hex digits + ',' */
1326 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1327 end
, list
->aexpr_list
[i
]->len
);
1328 count
+= 2 * list
->aexpr_list
[i
]->len
;
1333 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1338 (*str_list
)[ndx
] = NULL
;
1351 encode_actions_1 (struct command_line
*action
,
1352 struct breakpoint
*t
,
1353 struct bp_location
*tloc
,
1355 LONGEST frame_offset
,
1356 struct collection_list
*collect
,
1357 struct collection_list
*stepping_list
)
1360 struct expression
*exp
= NULL
;
1362 struct value
*tempval
;
1363 struct cmd_list_element
*cmd
;
1364 struct agent_expr
*aexpr
;
1366 for (; action
; action
= action
->next
)
1368 QUIT
; /* Allow user to bail out with ^C. */
1369 action_exp
= action
->line
;
1370 while (isspace ((int) *action_exp
))
1373 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1375 error (_("Bad action list item: %s"), action_exp
);
1377 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1379 trace_string_kludge
= 0;
1380 if (*action_exp
== '/')
1381 action_exp
= decode_agent_options (action_exp
);
1384 { /* Repeat over a comma-separated list. */
1385 QUIT
; /* Allow user to bail out with ^C. */
1386 while (isspace ((int) *action_exp
))
1389 if (0 == strncasecmp ("$reg", action_exp
, 4))
1391 for (i
= 0; i
< gdbarch_num_regs (tloc
->gdbarch
); i
++)
1392 add_register (collect
, i
);
1393 action_exp
= strchr (action_exp
, ','); /* more? */
1395 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1397 add_local_symbols (collect
,
1403 action_exp
= strchr (action_exp
, ','); /* more? */
1405 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1407 add_local_symbols (collect
,
1413 action_exp
= strchr (action_exp
, ','); /* more? */
1415 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1417 struct cleanup
*old_chain1
= NULL
;
1419 aexpr
= gen_trace_for_return_address (tloc
->address
,
1422 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1425 report_agent_reqs_errors (aexpr
);
1427 discard_cleanups (old_chain1
);
1428 add_aexpr (collect
, aexpr
);
1430 /* take care of the registers */
1431 if (aexpr
->reg_mask_len
> 0)
1435 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1437 QUIT
; /* allow user to bail out with ^C */
1438 if (aexpr
->reg_mask
[ndx1
] != 0)
1440 /* assume chars have 8 bits */
1441 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1442 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1443 /* it's used -- record it */
1444 add_register (collect
,
1450 action_exp
= strchr (action_exp
, ','); /* more? */
1452 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1454 add_static_trace_data (collect
);
1455 action_exp
= strchr (action_exp
, ','); /* more? */
1460 struct cleanup
*old_chain
= NULL
;
1461 struct cleanup
*old_chain1
= NULL
;
1463 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1464 block_for_pc (tloc
->address
), 1);
1465 old_chain
= make_cleanup (free_current_contents
, &exp
);
1467 switch (exp
->elts
[0].opcode
)
1471 const char *name
= &exp
->elts
[2].string
;
1473 i
= user_reg_map_name_to_regnum (tloc
->gdbarch
,
1474 name
, strlen (name
));
1476 internal_error (__FILE__
, __LINE__
,
1477 _("Register $%s not available"),
1480 printf_filtered ("OP_REGISTER: ");
1481 add_register (collect
, i
);
1486 /* Safe because we know it's a simple expression. */
1487 tempval
= evaluate_expression (exp
);
1488 addr
= value_address (tempval
);
1489 /* Initialize the TYPE_LENGTH if it is a typedef. */
1490 check_typedef (exp
->elts
[1].type
);
1491 add_memrange (collect
, memrange_absolute
, addr
,
1492 TYPE_LENGTH (exp
->elts
[1].type
));
1496 collect_symbol (collect
,
1497 exp
->elts
[2].symbol
,
1504 default: /* Full-fledged expression. */
1505 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1507 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1511 report_agent_reqs_errors (aexpr
);
1513 discard_cleanups (old_chain1
);
1514 add_aexpr (collect
, aexpr
);
1516 /* Take care of the registers. */
1517 if (aexpr
->reg_mask_len
> 0)
1522 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1524 QUIT
; /* Allow user to bail out with ^C. */
1525 if (aexpr
->reg_mask
[ndx1
] != 0)
1527 /* Assume chars have 8 bits. */
1528 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1529 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1530 /* It's used -- record it. */
1531 add_register (collect
,
1538 do_cleanups (old_chain
);
1541 while (action_exp
&& *action_exp
++ == ',');
1543 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1546 { /* Repeat over a comma-separated list. */
1547 QUIT
; /* Allow user to bail out with ^C. */
1548 while (isspace ((int) *action_exp
))
1552 struct cleanup
*old_chain
= NULL
;
1553 struct cleanup
*old_chain1
= NULL
;
1555 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1556 block_for_pc (tloc
->address
), 1);
1557 old_chain
= make_cleanup (free_current_contents
, &exp
);
1559 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1560 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1563 report_agent_reqs_errors (aexpr
);
1565 discard_cleanups (old_chain1
);
1566 /* Even though we're not officially collecting, add
1567 to the collect list anyway. */
1568 add_aexpr (collect
, aexpr
);
1570 do_cleanups (old_chain
);
1573 while (action_exp
&& *action_exp
++ == ',');
1575 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1577 /* We check against nested while-stepping when setting
1578 breakpoint action, so no way to run into nested
1580 gdb_assert (stepping_list
);
1582 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
,
1583 frame_offset
, stepping_list
, NULL
);
1586 error (_("Invalid tracepoint command '%s'"), action
->line
);
1590 /* Render all actions into gdb protocol. */
1593 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1594 char ***tdp_actions
, char ***stepping_actions
)
1596 static char tdp_buff
[2048], step_buff
[2048];
1597 char *default_collect_line
= NULL
;
1598 struct command_line
*actions
;
1599 struct command_line
*default_collect_action
= NULL
;
1601 LONGEST frame_offset
;
1602 struct cleanup
*back_to
;
1604 back_to
= make_cleanup (null_cleanup
, NULL
);
1606 clear_collection_list (&tracepoint_list
);
1607 clear_collection_list (&stepping_list
);
1609 *tdp_actions
= NULL
;
1610 *stepping_actions
= NULL
;
1612 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1613 tloc
->address
, &frame_reg
, &frame_offset
);
1615 actions
= breakpoint_commands (t
);
1617 /* If there are default expressions to collect, make up a collect
1618 action and prepend to the action list to encode. Note that since
1619 validation is per-tracepoint (local var "xyz" might be valid for
1620 one tracepoint and not another, etc), we make up the action on
1621 the fly, and don't cache it. */
1622 if (*default_collect
)
1626 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1627 make_cleanup (xfree
, default_collect_line
);
1629 line
= default_collect_line
;
1630 validate_actionline (&line
, t
);
1632 default_collect_action
= xmalloc (sizeof (struct command_line
));
1633 make_cleanup (xfree
, default_collect_action
);
1634 default_collect_action
->next
= actions
;
1635 default_collect_action
->line
= line
;
1636 actions
= default_collect_action
;
1638 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1639 &tracepoint_list
, &stepping_list
);
1641 memrange_sortmerge (&tracepoint_list
);
1642 memrange_sortmerge (&stepping_list
);
1644 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1646 *stepping_actions
= stringify_collection_list (&stepping_list
,
1649 do_cleanups (back_to
);
1653 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1655 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1657 collect
->aexpr_list
=
1658 xrealloc (collect
->aexpr_list
,
1659 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1660 collect
->aexpr_listsize
*= 2;
1662 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1663 collect
->next_aexpr_elt
++;
1667 process_tracepoint_on_disconnect (void)
1669 VEC(breakpoint_p
) *tp_vec
= NULL
;
1671 struct breakpoint
*b
;
1672 int has_pending_p
= 0;
1674 /* Check whether we still have pending tracepoint. If we have, warn the
1675 user that pending tracepoint will no longer work. */
1676 tp_vec
= all_tracepoints ();
1677 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1686 struct bp_location
*loc1
;
1688 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1690 if (loc1
->shlib_disabled
)
1701 VEC_free (breakpoint_p
, tp_vec
);
1704 warning (_("Pending tracepoints will not be resolved while"
1705 " GDB is disconnected\n"));
1710 start_tracing (char *notes
)
1712 VEC(breakpoint_p
) *tp_vec
= NULL
;
1714 struct breakpoint
*b
;
1715 struct trace_state_variable
*tsv
;
1716 int any_enabled
= 0, num_to_download
= 0;
1719 tp_vec
= all_tracepoints ();
1721 /* No point in tracing without any tracepoints... */
1722 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1724 VEC_free (breakpoint_p
, tp_vec
);
1725 error (_("No tracepoints defined, not starting trace"));
1728 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1730 struct tracepoint
*t
= (struct tracepoint
*) b
;
1731 struct bp_location
*loc
;
1733 if (b
->enable_state
== bp_enabled
)
1736 if ((b
->type
== bp_fast_tracepoint
1737 ? may_insert_fast_tracepoints
1738 : may_insert_tracepoints
))
1741 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1742 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1747 if (target_supports_enable_disable_tracepoint ())
1748 warning (_("No tracepoints enabled"));
1751 /* No point in tracing with only disabled tracepoints that
1752 cannot be re-enabled. */
1753 VEC_free (breakpoint_p
, tp_vec
);
1754 error (_("No tracepoints enabled, not starting trace"));
1758 if (num_to_download
<= 0)
1760 VEC_free (breakpoint_p
, tp_vec
);
1761 error (_("No tracepoints that may be downloaded, not starting trace"));
1764 target_trace_init ();
1766 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1768 struct tracepoint
*t
= (struct tracepoint
*) b
;
1769 struct bp_location
*loc
;
1771 /* Clear `inserted' flag. */
1772 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1775 if ((b
->type
== bp_fast_tracepoint
1776 ? !may_insert_fast_tracepoints
1777 : !may_insert_tracepoints
))
1780 t
->number_on_target
= 0;
1782 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1784 /* Since tracepoint locations are never duplicated, `inserted'
1785 flag should be zero. */
1786 gdb_assert (!loc
->inserted
);
1788 target_download_tracepoint (loc
);
1793 t
->number_on_target
= b
->number
;
1795 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1796 if (loc
->probe
!= NULL
)
1797 loc
->probe
->pops
->set_semaphore (loc
->probe
, loc
->gdbarch
);
1799 VEC_free (breakpoint_p
, tp_vec
);
1801 /* Send down all the trace state variables too. */
1802 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1804 target_download_trace_state_variable (tsv
);
1807 /* Tell target to treat text-like sections as transparent. */
1808 target_trace_set_readonly_regions ();
1809 /* Set some mode flags. */
1810 target_set_disconnected_tracing (disconnected_tracing
);
1811 target_set_circular_trace_buffer (circular_trace_buffer
);
1814 notes
= trace_notes
;
1815 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1817 if (!ret
&& (trace_user
|| notes
))
1818 warning (_("Target does not support trace user/notes, info ignored"));
1820 /* Now insert traps and begin collecting data. */
1821 target_trace_start ();
1823 /* Reset our local state. */
1824 set_traceframe_num (-1);
1825 set_tracepoint_num (-1);
1826 set_traceframe_context (NULL
);
1827 current_trace_status()->running
= 1;
1828 clear_traceframe_info ();
1831 /* The tstart command requests the target to start a new trace run.
1832 The command passes any arguments it has to the target verbatim, as
1833 an optional "trace note". This is useful as for instance a warning
1834 to other users if the trace runs disconnected, and you don't want
1835 anybody else messing with the target. */
1838 trace_start_command (char *args
, int from_tty
)
1840 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1842 if (current_trace_status ()->running
)
1845 && !query (_("A trace is running already. Start a new run? ")))
1846 error (_("New trace run not started."));
1849 start_tracing (args
);
1852 /* The tstop command stops the tracing run. The command passes any
1853 supplied arguments to the target verbatim as a "stop note"; if the
1854 target supports trace notes, then it will be reported back as part
1855 of the trace run's status. */
1858 trace_stop_command (char *args
, int from_tty
)
1860 if (!current_trace_status ()->running
)
1861 error (_("Trace is not running."));
1863 stop_tracing (args
);
1867 stop_tracing (char *note
)
1870 VEC(breakpoint_p
) *tp_vec
= NULL
;
1872 struct breakpoint
*t
;
1874 target_trace_stop ();
1876 tp_vec
= all_tracepoints ();
1877 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1879 struct bp_location
*loc
;
1881 if ((t
->type
== bp_fast_tracepoint
1882 ? !may_insert_fast_tracepoints
1883 : !may_insert_tracepoints
))
1886 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1888 /* GDB can be totally absent in some disconnected trace scenarios,
1889 but we don't really care if this semaphore goes out of sync.
1890 That's why we are decrementing it here, but not taking care
1892 if (loc
->probe
!= NULL
)
1893 loc
->probe
->pops
->clear_semaphore (loc
->probe
, loc
->gdbarch
);
1897 VEC_free (breakpoint_p
, tp_vec
);
1900 note
= trace_stop_notes
;
1901 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1904 warning (_("Target does not support trace notes, note ignored"));
1906 /* Should change in response to reply? */
1907 current_trace_status ()->running
= 0;
1910 /* tstatus command */
1912 trace_status_command (char *args
, int from_tty
)
1914 struct trace_status
*ts
= current_trace_status ();
1916 VEC(breakpoint_p
) *tp_vec
= NULL
;
1917 struct breakpoint
*t
;
1919 status
= target_get_trace_status (ts
);
1924 printf_filtered (_("Using a trace file.\n"));
1927 printf_filtered (_("Trace can not be run on this target.\n"));
1932 if (!ts
->running_known
)
1934 printf_filtered (_("Run/stop status is unknown.\n"));
1936 else if (ts
->running
)
1938 printf_filtered (_("Trace is running on the target.\n"));
1942 switch (ts
->stop_reason
)
1944 case trace_never_run
:
1945 printf_filtered (_("No trace has been run on the target.\n"));
1949 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1952 printf_filtered (_("Trace stopped by a tstop command.\n"));
1954 case trace_buffer_full
:
1955 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1957 case trace_disconnected
:
1958 printf_filtered (_("Trace stopped because of disconnection.\n"));
1960 case tracepoint_passcount
:
1961 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1962 ts
->stopping_tracepoint
);
1964 case tracepoint_error
:
1965 if (ts
->stopping_tracepoint
)
1966 printf_filtered (_("Trace stopped by an "
1967 "error (%s, tracepoint %d).\n"),
1968 ts
->stop_desc
, ts
->stopping_tracepoint
);
1970 printf_filtered (_("Trace stopped by an error (%s).\n"),
1973 case trace_stop_reason_unknown
:
1974 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1977 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1983 if (ts
->traceframes_created
>= 0
1984 && ts
->traceframe_count
!= ts
->traceframes_created
)
1986 printf_filtered (_("Buffer contains %d trace "
1987 "frames (of %d created total).\n"),
1988 ts
->traceframe_count
, ts
->traceframes_created
);
1990 else if (ts
->traceframe_count
>= 0)
1992 printf_filtered (_("Collected %d trace frames.\n"),
1993 ts
->traceframe_count
);
1996 if (ts
->buffer_free
>= 0)
1998 if (ts
->buffer_size
>= 0)
2000 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2001 ts
->buffer_free
, ts
->buffer_size
);
2002 if (ts
->buffer_size
> 0)
2003 printf_filtered (_(" (%d%% full)"),
2004 ((int) ((((long long) (ts
->buffer_size
2005 - ts
->buffer_free
)) * 100)
2006 / ts
->buffer_size
)));
2007 printf_filtered (_(".\n"));
2010 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2014 if (ts
->disconnected_tracing
)
2015 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2017 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2019 if (ts
->circular_buffer
)
2020 printf_filtered (_("Trace buffer is circular.\n"));
2022 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
2023 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
2025 if (ts
->notes
&& strlen (ts
->notes
) > 0)
2026 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
2028 /* Now report on what we're doing with tfind. */
2029 if (traceframe_number
>= 0)
2030 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2031 traceframe_number
, tracepoint_number
);
2033 printf_filtered (_("Not looking at any trace frame.\n"));
2035 /* Report start/stop times if supplied. */
2040 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
2042 /* Reporting a run time is more readable than two long numbers. */
2043 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2044 (long int) ts
->start_time
/ 1000000,
2045 (long int) ts
->start_time
% 1000000,
2046 (long int) run_time
/ 1000000,
2047 (long int) run_time
% 1000000);
2050 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2051 (long int) ts
->start_time
/ 1000000,
2052 (long int) ts
->start_time
% 1000000);
2054 else if (ts
->stop_time
)
2055 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2056 (long int) ts
->stop_time
/ 1000000,
2057 (long int) ts
->stop_time
% 1000000);
2059 /* Now report any per-tracepoint status available. */
2060 tp_vec
= all_tracepoints ();
2062 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2063 target_get_tracepoint_status (t
, NULL
);
2065 VEC_free (breakpoint_p
, tp_vec
);
2068 /* Report the trace status to uiout, in a way suitable for MI, and not
2069 suitable for CLI. If ON_STOP is true, suppress a few fields that
2070 are not meaningful in the -trace-stop response.
2072 The implementation is essentially parallel to trace_status_command, but
2073 merging them will result in unreadable code. */
2075 trace_status_mi (int on_stop
)
2077 struct ui_out
*uiout
= current_uiout
;
2078 struct trace_status
*ts
= current_trace_status ();
2081 status
= target_get_trace_status (ts
);
2083 if (status
== -1 && !ts
->from_file
)
2085 ui_out_field_string (uiout
, "supported", "0");
2090 ui_out_field_string (uiout
, "supported", "file");
2092 ui_out_field_string (uiout
, "supported", "1");
2094 gdb_assert (ts
->running_known
);
2098 ui_out_field_string (uiout
, "running", "1");
2100 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2101 Given that the frontend gets the status either on -trace-stop, or from
2102 -trace-status after re-connection, it does not seem like this
2103 information is necessary for anything. It is not necessary for either
2104 figuring the vital state of the target nor for navigation of trace
2105 frames. If the frontend wants to show the current state is some
2106 configure dialog, it can request the value when such dialog is
2107 invoked by the user. */
2111 char *stop_reason
= NULL
;
2112 int stopping_tracepoint
= -1;
2115 ui_out_field_string (uiout
, "running", "0");
2117 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2119 switch (ts
->stop_reason
)
2122 stop_reason
= "request";
2124 case trace_buffer_full
:
2125 stop_reason
= "overflow";
2127 case trace_disconnected
:
2128 stop_reason
= "disconnection";
2130 case tracepoint_passcount
:
2131 stop_reason
= "passcount";
2132 stopping_tracepoint
= ts
->stopping_tracepoint
;
2134 case tracepoint_error
:
2135 stop_reason
= "error";
2136 stopping_tracepoint
= ts
->stopping_tracepoint
;
2142 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2143 if (stopping_tracepoint
!= -1)
2144 ui_out_field_int (uiout
, "stopping-tracepoint",
2145 stopping_tracepoint
);
2146 if (ts
->stop_reason
== tracepoint_error
)
2147 ui_out_field_string (uiout
, "error-description",
2153 if (ts
->traceframe_count
!= -1)
2154 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2155 if (ts
->traceframes_created
!= -1)
2156 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2157 if (ts
->buffer_size
!= -1)
2158 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2159 if (ts
->buffer_free
!= -1)
2160 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2162 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2163 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2165 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2166 ui_out_field_string (uiout
, "notes", ts
->notes
);
2171 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2172 (long int) ts
->start_time
/ 1000000,
2173 (long int) ts
->start_time
% 1000000);
2174 ui_out_field_string (uiout
, "start-time", buf
);
2175 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2176 (long int) ts
->stop_time
/ 1000000,
2177 (long int) ts
->stop_time
% 1000000);
2178 ui_out_field_string (uiout
, "stop-time", buf
);
2182 /* This function handles the details of what to do about an ongoing
2183 tracing run if the user has asked to detach or otherwise disconnect
2186 disconnect_tracing (int from_tty
)
2188 /* It can happen that the target that was tracing went away on its
2189 own, and we didn't notice. Get a status update, and if the
2190 current target doesn't even do tracing, then assume it's not
2192 if (target_get_trace_status (current_trace_status ()) < 0)
2193 current_trace_status ()->running
= 0;
2195 /* If running interactively, give the user the option to cancel and
2196 then decide what to do differently with the run. Scripts are
2197 just going to disconnect and let the target deal with it,
2198 according to how it's been instructed previously via
2199 disconnected-tracing. */
2200 if (current_trace_status ()->running
&& from_tty
)
2202 process_tracepoint_on_disconnect ();
2204 if (current_trace_status ()->disconnected_tracing
)
2206 if (!query (_("Trace is running and will "
2207 "continue after detach; detach anyway? ")))
2208 error (_("Not confirmed."));
2212 if (!query (_("Trace is running but will "
2213 "stop on detach; detach anyway? ")))
2214 error (_("Not confirmed."));
2218 /* Also we want to be out of tfind mode, otherwise things can get
2219 confusing upon reconnection. Just use these calls instead of
2220 full tfind_1 behavior because we're in the middle of detaching,
2221 and there's no point to updating current stack frame etc. */
2222 set_current_traceframe (-1);
2223 set_tracepoint_num (-1);
2224 set_traceframe_context (NULL
);
2227 /* Worker function for the various flavors of the tfind command. */
2229 tfind_1 (enum trace_find_type type
, int num
,
2230 ULONGEST addr1
, ULONGEST addr2
,
2233 int target_frameno
= -1, target_tracept
= -1;
2234 struct frame_id old_frame_id
= null_frame_id
;
2235 struct tracepoint
*tp
;
2236 struct ui_out
*uiout
= current_uiout
;
2238 /* Only try to get the current stack frame if we have a chance of
2239 succeeding. In particular, if we're trying to get a first trace
2240 frame while all threads are running, it's not going to succeed,
2241 so leave it with a default value and let the frame comparison
2242 below (correctly) decide to print out the source location of the
2244 if (!(type
== tfind_number
&& num
== -1)
2245 && (has_stack_frames () || traceframe_number
>= 0))
2246 old_frame_id
= get_frame_id (get_current_frame ());
2248 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2251 if (type
== tfind_number
2253 && target_frameno
== -1)
2255 /* We told the target to get out of tfind mode, and it did. */
2257 else if (target_frameno
== -1)
2259 /* A request for a non-existent trace frame has failed.
2260 Our response will be different, depending on FROM_TTY:
2262 If FROM_TTY is true, meaning that this command was
2263 typed interactively by the user, then give an error
2264 and DO NOT change the state of traceframe_number etc.
2266 However if FROM_TTY is false, meaning that we're either
2267 in a script, a loop, or a user-defined command, then
2268 DON'T give an error, but DO change the state of
2269 traceframe_number etc. to invalid.
2271 The rationalle is that if you typed the command, you
2272 might just have committed a typo or something, and you'd
2273 like to NOT lose your current debugging state. However
2274 if you're in a user-defined command or especially in a
2275 loop, then you need a way to detect that the command
2276 failed WITHOUT aborting. This allows you to write
2277 scripts that search thru the trace buffer until the end,
2278 and then continue on to do something else. */
2281 error (_("Target failed to find requested trace frame."));
2285 printf_filtered ("End of trace buffer.\n");
2286 #if 0 /* dubious now? */
2287 /* The following will not recurse, since it's
2289 trace_find_command ("-1", from_tty
);
2294 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2296 reinit_frame_cache ();
2297 target_dcache_invalidate ();
2299 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2301 if (target_frameno
!= get_traceframe_number ())
2302 observer_notify_traceframe_changed (target_frameno
, tracepoint_number
);
2304 set_current_traceframe (target_frameno
);
2306 if (target_frameno
== -1)
2307 set_traceframe_context (NULL
);
2309 set_traceframe_context (get_current_frame ());
2311 if (traceframe_number
>= 0)
2313 /* Use different branches for MI and CLI to make CLI messages
2315 if (ui_out_is_mi_like_p (uiout
))
2317 ui_out_field_string (uiout
, "found", "1");
2318 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2319 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2323 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2324 traceframe_number
, tracepoint_number
);
2329 if (ui_out_is_mi_like_p (uiout
))
2330 ui_out_field_string (uiout
, "found", "0");
2331 else if (type
== tfind_number
&& num
== -1)
2332 printf_unfiltered (_("No longer looking at any trace frame\n"));
2333 else /* This case may never occur, check. */
2334 printf_unfiltered (_("No trace frame found\n"));
2337 /* If we're in nonstop mode and getting out of looking at trace
2338 frames, there won't be any current frame to go back to and
2341 && (has_stack_frames () || traceframe_number
>= 0))
2343 enum print_what print_what
;
2345 /* NOTE: in imitation of the step command, try to determine
2346 whether we have made a transition from one function to
2347 another. If so, we'll print the "stack frame" (ie. the new
2348 function and it's arguments) -- otherwise we'll just show the
2351 if (frame_id_eq (old_frame_id
,
2352 get_frame_id (get_current_frame ())))
2353 print_what
= SRC_LINE
;
2355 print_what
= SRC_AND_LOC
;
2357 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2362 /* trace_find_command takes a trace frame number n,
2363 sends "QTFrame:<n>" to the target,
2364 and accepts a reply that may contain several optional pieces
2365 of information: a frame number, a tracepoint number, and an
2366 indication of whether this is a trap frame or a stepping frame.
2368 The minimal response is just "OK" (which indicates that the
2369 target does not give us a frame number or a tracepoint number).
2370 Instead of that, the target may send us a string containing
2372 F<hexnum> (gives the selected frame number)
2373 T<hexnum> (gives the selected tracepoint number)
2378 trace_find_command (char *args
, int from_tty
)
2379 { /* This should only be called with a numeric argument. */
2382 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2383 error (_("May not look at trace frames while trace is running."));
2385 if (args
== 0 || *args
== 0)
2386 { /* TFIND with no args means find NEXT trace frame. */
2387 if (traceframe_number
== -1)
2388 frameno
= 0; /* "next" is first one. */
2390 frameno
= traceframe_number
+ 1;
2392 else if (0 == strcmp (args
, "-"))
2394 if (traceframe_number
== -1)
2395 error (_("not debugging trace buffer"));
2396 else if (from_tty
&& traceframe_number
== 0)
2397 error (_("already at start of trace buffer"));
2399 frameno
= traceframe_number
- 1;
2401 /* A hack to work around eval's need for fp to have been collected. */
2402 else if (0 == strcmp (args
, "-1"))
2405 frameno
= parse_and_eval_long (args
);
2408 error (_("invalid input (%d is less than zero)"), frameno
);
2410 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2415 trace_find_end_command (char *args
, int from_tty
)
2417 trace_find_command ("-1", from_tty
);
2422 trace_find_start_command (char *args
, int from_tty
)
2424 trace_find_command ("0", from_tty
);
2427 /* tfind pc command */
2429 trace_find_pc_command (char *args
, int from_tty
)
2433 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2434 error (_("May not look at trace frames while trace is running."));
2436 if (args
== 0 || *args
== 0)
2437 pc
= regcache_read_pc (get_current_regcache ());
2439 pc
= parse_and_eval_address (args
);
2441 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2444 /* tfind tracepoint command */
2446 trace_find_tracepoint_command (char *args
, int from_tty
)
2449 struct tracepoint
*tp
;
2451 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2452 error (_("May not look at trace frames while trace is running."));
2454 if (args
== 0 || *args
== 0)
2456 if (tracepoint_number
== -1)
2457 error (_("No current tracepoint -- please supply an argument."));
2459 tdp
= tracepoint_number
; /* Default is current TDP. */
2462 tdp
= parse_and_eval_long (args
);
2464 /* If we have the tracepoint on hand, use the number that the
2465 target knows about (which may be different if we disconnected
2466 and reconnected). */
2467 tp
= get_tracepoint (tdp
);
2469 tdp
= tp
->number_on_target
;
2471 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2474 /* TFIND LINE command:
2476 This command will take a sourceline for argument, just like BREAK
2477 or TRACE (ie. anything that "decode_line_1" can handle).
2479 With no argument, this command will find the next trace frame
2480 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2483 trace_find_line_command (char *args
, int from_tty
)
2485 static CORE_ADDR start_pc
, end_pc
;
2486 struct symtabs_and_lines sals
;
2487 struct symtab_and_line sal
;
2488 struct cleanup
*old_chain
;
2490 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2491 error (_("May not look at trace frames while trace is running."));
2493 if (args
== 0 || *args
== 0)
2495 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2497 sals
.sals
= (struct symtab_and_line
*)
2498 xmalloc (sizeof (struct symtab_and_line
));
2503 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2507 old_chain
= make_cleanup (xfree
, sals
.sals
);
2508 if (sal
.symtab
== 0)
2509 error (_("No line number information available."));
2511 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2513 if (start_pc
== end_pc
)
2515 printf_filtered ("Line %d of \"%s\"",
2516 sal
.line
, sal
.symtab
->filename
);
2518 printf_filtered (" is at address ");
2519 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2521 printf_filtered (" but contains no code.\n");
2522 sal
= find_pc_line (start_pc
, 0);
2524 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2525 && start_pc
!= end_pc
)
2526 printf_filtered ("Attempting to find line %d instead.\n",
2529 error (_("Cannot find a good line."));
2533 /* Is there any case in which we get here, and have an address
2534 which the user would want to see? If we have debugging
2535 symbols and no line numbers? */
2536 error (_("Line number %d is out of range for \"%s\"."),
2537 sal
.line
, sal
.symtab
->filename
);
2539 /* Find within range of stated line. */
2541 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2543 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2544 do_cleanups (old_chain
);
2547 /* tfind range command */
2549 trace_find_range_command (char *args
, int from_tty
)
2551 static CORE_ADDR start
, stop
;
2554 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2555 error (_("May not look at trace frames while trace is running."));
2557 if (args
== 0 || *args
== 0)
2558 { /* XXX FIXME: what should default behavior be? */
2559 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2563 if (0 != (tmp
= strchr (args
, ',')))
2565 *tmp
++ = '\0'; /* Terminate start address. */
2566 while (isspace ((int) *tmp
))
2568 start
= parse_and_eval_address (args
);
2569 stop
= parse_and_eval_address (tmp
);
2572 { /* No explicit end address? */
2573 start
= parse_and_eval_address (args
);
2574 stop
= start
+ 1; /* ??? */
2577 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2580 /* tfind outside command */
2582 trace_find_outside_command (char *args
, int from_tty
)
2584 CORE_ADDR start
, stop
;
2587 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2588 error (_("May not look at trace frames while trace is running."));
2590 if (args
== 0 || *args
== 0)
2591 { /* XXX FIXME: what should default behavior be? */
2592 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2596 if (0 != (tmp
= strchr (args
, ',')))
2598 *tmp
++ = '\0'; /* Terminate start address. */
2599 while (isspace ((int) *tmp
))
2601 start
= parse_and_eval_address (args
);
2602 stop
= parse_and_eval_address (tmp
);
2605 { /* No explicit end address? */
2606 start
= parse_and_eval_address (args
);
2607 stop
= start
+ 1; /* ??? */
2610 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2613 /* info scope command: list the locals for a scope. */
2615 scope_info (char *args
, int from_tty
)
2617 struct symtabs_and_lines sals
;
2619 struct minimal_symbol
*msym
;
2620 struct block
*block
;
2621 const char *symname
;
2622 char *save_args
= args
;
2623 struct block_iterator iter
;
2625 struct gdbarch
*gdbarch
;
2628 if (args
== 0 || *args
== 0)
2629 error (_("requires an argument (function, "
2630 "line or *addr) to define a scope"));
2632 sals
= decode_line_1 (&args
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2633 if (sals
.nelts
== 0)
2634 return; /* Presumably decode_line_1 has already warned. */
2636 /* Resolve line numbers to PC. */
2637 resolve_sal_pc (&sals
.sals
[0]);
2638 block
= block_for_pc (sals
.sals
[0].pc
);
2642 QUIT
; /* Allow user to bail out with ^C. */
2643 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2645 QUIT
; /* Allow user to bail out with ^C. */
2647 printf_filtered ("Scope for %s:\n", save_args
);
2650 symname
= SYMBOL_PRINT_NAME (sym
);
2651 if (symname
== NULL
|| *symname
== '\0')
2652 continue; /* Probably botched, certainly useless. */
2654 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2656 printf_filtered ("Symbol %s is ", symname
);
2657 switch (SYMBOL_CLASS (sym
))
2660 case LOC_UNDEF
: /* Messed up symbol? */
2661 printf_filtered ("a bogus symbol, class %d.\n",
2662 SYMBOL_CLASS (sym
));
2663 count
--; /* Don't count this one. */
2666 printf_filtered ("a constant with value %s (%s)",
2667 plongest (SYMBOL_VALUE (sym
)),
2668 hex_string (SYMBOL_VALUE (sym
)));
2670 case LOC_CONST_BYTES
:
2671 printf_filtered ("constant bytes: ");
2672 if (SYMBOL_TYPE (sym
))
2673 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2674 fprintf_filtered (gdb_stdout
, " %02x",
2675 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2678 printf_filtered ("in static storage at address ");
2679 printf_filtered ("%s", paddress (gdbarch
,
2680 SYMBOL_VALUE_ADDRESS (sym
)));
2683 /* GDBARCH is the architecture associated with the objfile
2684 the symbol is defined in; the target architecture may be
2685 different, and may provide additional registers. However,
2686 we do not know the target architecture at this point.
2687 We assume the objfile architecture will contain all the
2688 standard registers that occur in debug info in that
2690 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2693 if (SYMBOL_IS_ARGUMENT (sym
))
2694 printf_filtered ("an argument in register $%s",
2695 gdbarch_register_name (gdbarch
, regno
));
2697 printf_filtered ("a local variable in register $%s",
2698 gdbarch_register_name (gdbarch
, regno
));
2701 printf_filtered ("an argument at stack/frame offset %s",
2702 plongest (SYMBOL_VALUE (sym
)));
2705 printf_filtered ("a local variable at frame offset %s",
2706 plongest (SYMBOL_VALUE (sym
)));
2709 printf_filtered ("a reference argument at offset %s",
2710 plongest (SYMBOL_VALUE (sym
)));
2712 case LOC_REGPARM_ADDR
:
2713 /* Note comment at LOC_REGISTER. */
2714 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2716 printf_filtered ("the address of an argument, in register $%s",
2717 gdbarch_register_name (gdbarch
, regno
));
2720 printf_filtered ("a typedef.\n");
2723 printf_filtered ("a label at address ");
2724 printf_filtered ("%s", paddress (gdbarch
,
2725 SYMBOL_VALUE_ADDRESS (sym
)));
2728 printf_filtered ("a function at address ");
2729 printf_filtered ("%s",
2730 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2732 case LOC_UNRESOLVED
:
2733 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2736 printf_filtered ("Unresolved Static");
2739 printf_filtered ("static storage at address ");
2740 printf_filtered ("%s",
2741 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2744 case LOC_OPTIMIZED_OUT
:
2745 printf_filtered ("optimized out.\n");
2748 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2749 BLOCK_START (block
),
2753 if (SYMBOL_TYPE (sym
))
2754 printf_filtered (", length %d.\n",
2755 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2757 if (BLOCK_FUNCTION (block
))
2760 block
= BLOCK_SUPERBLOCK (block
);
2763 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2767 /* worker function (cleanup) */
2769 replace_comma (void *data
)
2776 /* Helper for trace_dump_command. Dump the action list starting at
2777 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2778 actions of the body of a while-stepping action. STEPPING_FRAME is
2779 set if the current traceframe was determined to be a while-stepping
2783 trace_dump_actions (struct command_line
*action
,
2784 int stepping_actions
, int stepping_frame
,
2787 char *action_exp
, *next_comma
;
2789 for (; action
!= NULL
; action
= action
->next
)
2791 struct cmd_list_element
*cmd
;
2793 QUIT
; /* Allow user to bail out with ^C. */
2794 action_exp
= action
->line
;
2795 while (isspace ((int) *action_exp
))
2798 /* The collection actions to be done while stepping are
2799 bracketed by the commands "while-stepping" and "end". */
2801 if (*action_exp
== '#') /* comment line */
2804 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2806 error (_("Bad action list item: %s"), action_exp
);
2808 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2812 for (i
= 0; i
< action
->body_count
; ++i
)
2813 trace_dump_actions (action
->body_list
[i
],
2814 1, stepping_frame
, from_tty
);
2816 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2818 /* Display the collected data.
2819 For the trap frame, display only what was collected at
2820 the trap. Likewise for stepping frames, display only
2821 what was collected while stepping. This means that the
2822 two boolean variables, STEPPING_FRAME and
2823 STEPPING_ACTIONS should be equal. */
2824 if (stepping_frame
== stepping_actions
)
2826 if (*action_exp
== '/')
2827 action_exp
= decode_agent_options (action_exp
);
2830 { /* Repeat over a comma-separated list. */
2831 QUIT
; /* Allow user to bail out with ^C. */
2832 if (*action_exp
== ',')
2834 while (isspace ((int) *action_exp
))
2837 next_comma
= strchr (action_exp
, ',');
2839 if (0 == strncasecmp (action_exp
, "$reg", 4))
2840 registers_info (NULL
, from_tty
);
2841 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2843 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2844 locals_info (NULL
, from_tty
);
2845 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2846 args_info (NULL
, from_tty
);
2851 make_cleanup (replace_comma
, next_comma
);
2854 printf_filtered ("%s = ", action_exp
);
2855 output_command (action_exp
, from_tty
);
2856 printf_filtered ("\n");
2860 action_exp
= next_comma
;
2862 while (action_exp
&& *action_exp
== ',');
2868 /* The tdump command. */
2871 trace_dump_command (char *args
, int from_tty
)
2873 struct regcache
*regcache
;
2874 struct tracepoint
*t
;
2875 int stepping_frame
= 0;
2876 struct bp_location
*loc
;
2877 char *line
, *default_collect_line
= NULL
;
2878 struct command_line
*actions
, *default_collect_action
= NULL
;
2879 struct cleanup
*old_chain
= NULL
;
2881 if (tracepoint_number
== -1)
2883 warning (_("No current trace frame."));
2887 t
= get_tracepoint (tracepoint_number
);
2890 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2893 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2894 tracepoint_number
, traceframe_number
);
2896 /* The current frame is a trap frame if the frame PC is equal
2897 to the tracepoint PC. If not, then the current frame was
2898 collected during single-stepping. */
2900 regcache
= get_current_regcache ();
2902 /* If the traceframe's address matches any of the tracepoint's
2903 locations, assume it is a direct hit rather than a while-stepping
2904 frame. (FIXME this is not reliable, should record each frame's
2907 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
2908 if (loc
->address
== regcache_read_pc (regcache
))
2911 actions
= breakpoint_commands (&t
->base
);
2913 /* If there is a default-collect list, make up a collect command,
2914 prepend to the tracepoint's commands, and pass the whole mess to
2915 the trace dump scanner. We need to validate because
2916 default-collect might have been junked since the trace run. */
2917 if (*default_collect
)
2919 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2920 old_chain
= make_cleanup (xfree
, default_collect_line
);
2921 line
= default_collect_line
;
2922 validate_actionline (&line
, &t
->base
);
2923 default_collect_action
= xmalloc (sizeof (struct command_line
));
2924 make_cleanup (xfree
, default_collect_action
);
2925 default_collect_action
->next
= actions
;
2926 default_collect_action
->line
= line
;
2927 actions
= default_collect_action
;
2930 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2932 if (*default_collect
)
2933 do_cleanups (old_chain
);
2936 /* Encode a piece of a tracepoint's source-level definition in a form
2937 that is suitable for both protocol and saving in files. */
2938 /* This version does not do multiple encodes for long strings; it should
2939 return an offset to the next piece to encode. FIXME */
2942 encode_source_string (int tpnum
, ULONGEST addr
,
2943 char *srctype
, char *src
, char *buf
, int buf_size
)
2945 if (80 + strlen (srctype
) > buf_size
)
2946 error (_("Buffer too small for source encoding"));
2947 sprintf (buf
, "%x:%s:%s:%x:%x:",
2948 tpnum
, phex_nz (addr
, sizeof (addr
)),
2949 srctype
, 0, (int) strlen (src
));
2950 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2951 error (_("Source string too long for buffer"));
2952 bin2hex (src
, buf
+ strlen (buf
), 0);
2956 extern int trace_regblock_size
;
2958 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2959 non-zero, the save is performed on the target, otherwise GDB obtains all
2960 trace data and saves it locally. */
2963 trace_save (const char *filename
, int target_does_save
)
2965 struct cleanup
*cleanup
;
2967 struct trace_status
*ts
= current_trace_status ();
2970 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2971 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2975 ULONGEST offset
= 0;
2976 #define MAX_TRACE_UPLOAD 2000
2977 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2980 /* If the target is to save the data to a file on its own, then just
2981 send the command and be done with it. */
2982 if (target_does_save
)
2984 err
= target_save_trace_data (filename
);
2986 error (_("Target failed to save trace data to '%s'."),
2991 /* Get the trace status first before opening the file, so if the
2992 target is losing, we can get out without touching files. */
2993 status
= target_get_trace_status (ts
);
2995 pathname
= tilde_expand (filename
);
2996 cleanup
= make_cleanup (xfree
, pathname
);
2998 fp
= fopen (pathname
, "wb");
3000 error (_("Unable to open file '%s' for saving trace data (%s)"),
3001 filename
, safe_strerror (errno
));
3002 make_cleanup_fclose (fp
);
3004 /* Write a file header, with a high-bit-set char to indicate a
3005 binary file, plus a hint as what this file is, and a version
3006 number in case of future needs. */
3007 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
3009 perror_with_name (pathname
);
3011 /* Write descriptive info. */
3013 /* Write out the size of a register block. */
3014 fprintf (fp
, "R %x\n", trace_regblock_size
);
3016 /* Write out status of the tracing run (aka "tstatus" info). */
3017 fprintf (fp
, "status %c;%s",
3018 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
3019 if (ts
->stop_reason
== tracepoint_error
)
3021 char *buf
= (char *) alloca (strlen (ts
->stop_desc
) * 2 + 1);
3023 bin2hex ((gdb_byte
*) ts
->stop_desc
, buf
, 0);
3024 fprintf (fp
, ":%s", buf
);
3026 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
3027 if (ts
->traceframe_count
>= 0)
3028 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
3029 if (ts
->traceframes_created
>= 0)
3030 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
3031 if (ts
->buffer_free
>= 0)
3032 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
3033 if (ts
->buffer_size
>= 0)
3034 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
3035 if (ts
->disconnected_tracing
)
3036 fprintf (fp
, ";disconn:%x", ts
->disconnected_tracing
);
3037 if (ts
->circular_buffer
)
3038 fprintf (fp
, ";circular:%x", ts
->circular_buffer
);
3041 /* Note that we want to upload tracepoints and save those, rather
3042 than simply writing out the local ones, because the user may have
3043 changed tracepoints in GDB in preparation for a future tracing
3044 run, or maybe just mass-deleted all types of breakpoints as part
3045 of cleaning up. So as not to contaminate the session, leave the
3046 data in its uploaded form, don't make into real tracepoints. */
3048 /* Get trace state variables first, they may be checked when parsing
3049 uploaded commands. */
3051 target_upload_trace_state_variables (&uploaded_tsvs
);
3053 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3059 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
3060 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
3063 fprintf (fp
, "tsv %x:%s:%x:%s\n",
3064 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
3065 utsv
->builtin
, buf
);
3071 free_uploaded_tsvs (&uploaded_tsvs
);
3073 target_upload_tracepoints (&uploaded_tps
);
3075 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3076 target_get_tracepoint_status (NULL
, utp
);
3078 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3080 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
3081 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3082 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
3083 if (utp
->type
== bp_fast_tracepoint
)
3084 fprintf (fp
, ":F%x", utp
->orig_size
);
3086 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
3089 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
3090 fprintf (fp
, "tp A%x:%s:%s\n",
3091 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3092 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
3093 fprintf (fp
, "tp S%x:%s:%s\n",
3094 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3097 encode_source_string (utp
->number
, utp
->addr
,
3098 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
3099 fprintf (fp
, "tp Z%s\n", buf
);
3101 if (utp
->cond_string
)
3103 encode_source_string (utp
->number
, utp
->addr
,
3104 "cond", utp
->cond_string
,
3105 buf
, MAX_TRACE_UPLOAD
);
3106 fprintf (fp
, "tp Z%s\n", buf
);
3108 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
3110 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
3111 buf
, MAX_TRACE_UPLOAD
);
3112 fprintf (fp
, "tp Z%s\n", buf
);
3114 fprintf (fp
, "tp V%x:%s:%x:%s\n",
3115 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3117 phex_nz (utp
->traceframe_usage
,
3118 sizeof (utp
->traceframe_usage
)));
3121 free_uploaded_tps (&uploaded_tps
);
3123 /* Mark the end of the definition section. */
3126 /* Get and write the trace data proper. We ask for big blocks, in
3127 the hopes of efficiency, but will take less if the target has
3128 packet size limitations or some such. */
3131 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
3133 error (_("Failure to get requested trace buffer data"));
3134 /* No more data is forthcoming, we're done. */
3137 written
= fwrite (buf
, gotten
, 1, fp
);
3139 perror_with_name (pathname
);
3143 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
3144 written
= fwrite (&gotten
, 4, 1, fp
);
3146 perror_with_name (pathname
);
3148 do_cleanups (cleanup
);
3152 trace_save_command (char *args
, int from_tty
)
3154 int target_does_save
= 0;
3156 char *filename
= NULL
;
3157 struct cleanup
*back_to
;
3160 error_no_arg (_("file in which to save trace data"));
3162 argv
= gdb_buildargv (args
);
3163 back_to
= make_cleanup_freeargv (argv
);
3165 for (; *argv
; ++argv
)
3167 if (strcmp (*argv
, "-r") == 0)
3168 target_does_save
= 1;
3169 else if (**argv
== '-')
3170 error (_("unknown option `%s'"), *argv
);
3176 error_no_arg (_("file in which to save trace data"));
3178 trace_save (filename
, target_does_save
);
3181 printf_filtered (_("Trace data saved to file '%s'.\n"), filename
);
3183 do_cleanups (back_to
);
3186 /* Tell the target what to do with an ongoing tracing run if GDB
3187 disconnects for some reason. */
3190 set_disconnected_tracing (char *args
, int from_tty
,
3191 struct cmd_list_element
*c
)
3193 target_set_disconnected_tracing (disconnected_tracing
);
3197 set_circular_trace_buffer (char *args
, int from_tty
,
3198 struct cmd_list_element
*c
)
3200 target_set_circular_trace_buffer (circular_trace_buffer
);
3204 set_trace_user (char *args
, int from_tty
,
3205 struct cmd_list_element
*c
)
3209 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3212 warning (_("Target does not support trace notes, user ignored"));
3216 set_trace_notes (char *args
, int from_tty
,
3217 struct cmd_list_element
*c
)
3221 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3224 warning (_("Target does not support trace notes, note ignored"));
3228 set_trace_stop_notes (char *args
, int from_tty
,
3229 struct cmd_list_element
*c
)
3233 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3236 warning (_("Target does not support trace notes, stop note ignored"));
3239 /* Convert the memory pointed to by mem into hex, placing result in buf.
3240 * Return a pointer to the last char put in buf (null)
3241 * "stolen" from sparc-stub.c
3244 static const char hexchars
[] = "0123456789abcdef";
3247 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3255 *buf
++ = hexchars
[ch
>> 4];
3256 *buf
++ = hexchars
[ch
& 0xf];
3265 get_traceframe_number (void)
3267 return traceframe_number
;
3270 /* Make the traceframe NUM be the current trace frame. Does nothing
3271 if NUM is already current. */
3274 set_current_traceframe (int num
)
3278 if (traceframe_number
== num
)
3280 /* Nothing to do. */
3284 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3287 warning (_("could not change traceframe"));
3289 set_traceframe_num (newnum
);
3291 /* Changing the traceframe changes our view of registers and of the
3293 registers_changed ();
3295 clear_traceframe_info ();
3298 /* Make the traceframe NUM be the current trace frame, and do nothing
3302 set_traceframe_number (int num
)
3304 traceframe_number
= num
;
3307 /* A cleanup used when switching away and back from tfind mode. */
3309 struct current_traceframe_cleanup
3311 /* The traceframe we were inspecting. */
3312 int traceframe_number
;
3316 do_restore_current_traceframe_cleanup (void *arg
)
3318 struct current_traceframe_cleanup
*old
= arg
;
3320 set_current_traceframe (old
->traceframe_number
);
3324 restore_current_traceframe_cleanup_dtor (void *arg
)
3326 struct current_traceframe_cleanup
*old
= arg
;
3332 make_cleanup_restore_current_traceframe (void)
3334 struct current_traceframe_cleanup
*old
;
3336 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3337 old
->traceframe_number
= traceframe_number
;
3339 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3340 restore_current_traceframe_cleanup_dtor
);
3344 make_cleanup_restore_traceframe_number (void)
3346 return make_cleanup_restore_integer (&traceframe_number
);
3349 /* Given a number and address, return an uploaded tracepoint with that
3350 number, creating if necessary. */
3352 struct uploaded_tp
*
3353 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3355 struct uploaded_tp
*utp
;
3357 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3358 if (utp
->number
== num
&& utp
->addr
== addr
)
3360 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3361 memset (utp
, 0, sizeof (struct uploaded_tp
));
3364 utp
->actions
= NULL
;
3365 utp
->step_actions
= NULL
;
3366 utp
->cmd_strings
= NULL
;
3373 free_uploaded_tps (struct uploaded_tp
**utpp
)
3375 struct uploaded_tp
*next_one
;
3379 next_one
= (*utpp
)->next
;
3385 /* Given a number and address, return an uploaded tracepoint with that
3386 number, creating if necessary. */
3388 static struct uploaded_tsv
*
3389 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3391 struct uploaded_tsv
*utsv
;
3393 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3394 if (utsv
->number
== num
)
3396 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3397 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3399 utsv
->next
= *utsvp
;
3405 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3407 struct uploaded_tsv
*next_one
;
3411 next_one
= (*utsvp
)->next
;
3417 /* FIXME this function is heuristic and will miss the cases where the
3418 conditional is semantically identical but differs in whitespace,
3419 such as "x == 0" vs "x==0". */
3422 cond_string_is_same (char *str1
, char *str2
)
3424 if (str1
== NULL
|| str2
== NULL
)
3425 return (str1
== str2
);
3427 return (strcmp (str1
, str2
) == 0);
3430 /* Look for an existing tracepoint that seems similar enough to the
3431 uploaded one. Enablement isn't compared, because the user can
3432 toggle that freely, and may have done so in anticipation of the
3433 next trace run. Return the location of matched tracepoint. */
3435 static struct bp_location
*
3436 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3438 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3440 struct breakpoint
*b
;
3441 struct bp_location
*loc
;
3443 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3445 struct tracepoint
*t
= (struct tracepoint
*) b
;
3447 if (b
->type
== utp
->type
3448 && t
->step_count
== utp
->step
3449 && t
->pass_count
== utp
->pass
3450 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3451 /* FIXME also test actions. */
3454 /* Scan the locations for an address match. */
3455 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3457 if (loc
->address
== utp
->addr
)
3465 /* Given a list of tracepoints uploaded from a target, attempt to
3466 match them up with existing tracepoints, and create new ones if not
3470 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3472 struct uploaded_tp
*utp
;
3474 /* Look for GDB tracepoints that match up with our uploaded versions. */
3475 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3477 struct bp_location
*loc
;
3478 struct tracepoint
*t
;
3480 loc
= find_matching_tracepoint_location (utp
);
3483 /* Mark this location as already inserted. */
3485 t
= (struct tracepoint
*) loc
->owner
;
3486 printf_filtered (_("Assuming tracepoint %d is same "
3487 "as target's tracepoint %d at %s.\n"),
3488 loc
->owner
->number
, utp
->number
,
3489 paddress (loc
->gdbarch
, utp
->addr
));
3493 t
= create_tracepoint_from_upload (utp
);
3495 printf_filtered (_("Created tracepoint %d for "
3496 "target's tracepoint %d at %s.\n"),
3497 t
->base
.number
, utp
->number
,
3498 paddress (get_current_arch (), utp
->addr
));
3500 printf_filtered (_("Failed to create tracepoint for target's "
3501 "tracepoint %d at %s, skipping it.\n"),
3503 paddress (get_current_arch (), utp
->addr
));
3505 /* Whether found or created, record the number used by the
3506 target, to help with mapping target tracepoints back to their
3507 counterparts here. */
3509 t
->number_on_target
= utp
->number
;
3512 free_uploaded_tps (uploaded_tps
);
3515 /* Trace state variables don't have much to identify them beyond their
3516 name, so just use that to detect matches. */
3518 static struct trace_state_variable
*
3519 find_matching_tsv (struct uploaded_tsv
*utsv
)
3524 return find_trace_state_variable (utsv
->name
);
3527 static struct trace_state_variable
*
3528 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3530 const char *namebase
;
3533 struct trace_state_variable
*tsv
;
3534 struct cleanup
*old_chain
;
3538 namebase
= utsv
->name
;
3539 buf
= xstrprintf ("%s", namebase
);
3544 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3547 /* Fish for a name that is not in use. */
3548 /* (should check against all internal vars?) */
3549 while (find_trace_state_variable (buf
))
3552 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3555 old_chain
= make_cleanup (xfree
, buf
);
3557 /* We have an available name, create the variable. */
3558 tsv
= create_trace_state_variable (buf
);
3559 tsv
->initial_value
= utsv
->initial_value
;
3560 tsv
->builtin
= utsv
->builtin
;
3562 observer_notify_tsv_created (tsv
->name
, tsv
->initial_value
);
3564 do_cleanups (old_chain
);
3569 /* Given a list of uploaded trace state variables, try to match them
3570 up with existing variables, or create additional ones. */
3573 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3576 struct uploaded_tsv
*utsv
;
3577 struct trace_state_variable
*tsv
;
3580 /* Most likely some numbers will have to be reassigned as part of
3581 the merge, so clear them all in anticipation. */
3582 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3585 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3587 tsv
= find_matching_tsv (utsv
);
3591 printf_filtered (_("Assuming trace state variable $%s "
3592 "is same as target's variable %d.\n"),
3593 tsv
->name
, utsv
->number
);
3597 tsv
= create_tsv_from_upload (utsv
);
3599 printf_filtered (_("Created trace state variable "
3600 "$%s for target's variable %d.\n"),
3601 tsv
->name
, utsv
->number
);
3603 /* Give precedence to numberings that come from the target. */
3605 tsv
->number
= utsv
->number
;
3608 /* Renumber everything that didn't get a target-assigned number. */
3610 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3611 if (tsv
->number
> highest
)
3612 highest
= tsv
->number
;
3615 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3616 if (tsv
->number
== 0)
3617 tsv
->number
= highest
++;
3619 free_uploaded_tsvs (uploaded_tsvs
);
3622 /* target tfile command */
3624 static struct target_ops tfile_ops
;
3626 /* Fill in tfile_ops with its defined operations and properties. */
3628 #define TRACE_HEADER_SIZE 8
3630 static char *trace_filename
;
3631 static int trace_fd
= -1;
3632 static off_t trace_frames_offset
;
3633 static off_t cur_offset
;
3634 static int cur_data_size
;
3635 int trace_regblock_size
;
3637 static void tfile_interp_line (char *line
,
3638 struct uploaded_tp
**utpp
,
3639 struct uploaded_tsv
**utsvp
);
3641 /* Read SIZE bytes into READBUF from the trace frame, starting at
3642 TRACE_FD's current position. Note that this call `read'
3643 underneath, hence it advances the file's seek position. Throws an
3644 error if the `read' syscall fails, or less than SIZE bytes are
3648 tfile_read (gdb_byte
*readbuf
, int size
)
3652 gotten
= read (trace_fd
, readbuf
, size
);
3654 perror_with_name (trace_filename
);
3655 else if (gotten
< size
)
3656 error (_("Premature end of file while reading trace file"));
3660 tfile_open (char *filename
, int from_tty
)
3662 volatile struct gdb_exception ex
;
3664 struct cleanup
*old_chain
;
3667 char header
[TRACE_HEADER_SIZE
];
3668 char linebuf
[1000]; /* Should be max remote packet size or so. */
3671 struct trace_status
*ts
;
3672 struct uploaded_tp
*uploaded_tps
= NULL
;
3673 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3675 target_preopen (from_tty
);
3677 error (_("No trace file specified."));
3679 filename
= tilde_expand (filename
);
3680 if (!IS_ABSOLUTE_PATH(filename
))
3682 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
3687 old_chain
= make_cleanup (xfree
, filename
);
3689 flags
= O_BINARY
| O_LARGEFILE
;
3691 scratch_chan
= open (filename
, flags
, 0);
3692 if (scratch_chan
< 0)
3693 perror_with_name (filename
);
3695 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3697 discard_cleanups (old_chain
); /* Don't free filename any more. */
3698 unpush_target (&tfile_ops
);
3700 trace_filename
= xstrdup (filename
);
3701 trace_fd
= scratch_chan
;
3704 /* Read the file header and test for validity. */
3705 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
3707 bytes
+= TRACE_HEADER_SIZE
;
3708 if (!(header
[0] == 0x7f
3709 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3710 error (_("File is not a valid trace file."));
3712 push_target (&tfile_ops
);
3714 trace_regblock_size
= 0;
3715 ts
= current_trace_status ();
3716 /* We know we're working with a file. */
3718 /* Set defaults in case there is no status line. */
3719 ts
->running_known
= 0;
3720 ts
->stop_reason
= trace_stop_reason_unknown
;
3721 ts
->traceframe_count
= -1;
3722 ts
->buffer_free
= 0;
3723 ts
->disconnected_tracing
= 0;
3724 ts
->circular_buffer
= 0;
3726 TRY_CATCH (ex
, RETURN_MASK_ALL
)
3728 /* Read through a section of newline-terminated lines that
3729 define things like tracepoints. */
3733 tfile_read (&byte
, 1);
3738 /* Empty line marks end of the definition section. */
3743 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3746 linebuf
[i
++] = byte
;
3748 error (_("Excessively long lines in trace file"));
3751 /* Record the starting offset of the binary trace data. */
3752 trace_frames_offset
= bytes
;
3754 /* If we don't have a blocksize, we can't interpret the
3756 if (trace_regblock_size
== 0)
3757 error (_("No register block size recorded in trace file"));
3761 /* Pop the partially set up target. */
3763 throw_exception (ex
);
3766 inferior_appeared (current_inferior (), TFILE_PID
);
3767 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3768 add_thread_silent (inferior_ptid
);
3770 if (ts
->traceframe_count
<= 0)
3771 warning (_("No traceframes present in this file."));
3773 /* Add the file's tracepoints and variables into the current mix. */
3775 /* Get trace state variables first, they may be checked when parsing
3776 uploaded commands. */
3777 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3779 merge_uploaded_tracepoints (&uploaded_tps
);
3781 post_create_inferior (&tfile_ops
, from_tty
);
3784 /* Interpret the given line from the definitions part of the trace
3788 tfile_interp_line (char *line
,
3789 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3793 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3796 trace_regblock_size
= strtol (p
, &p
, 16);
3798 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3800 p
+= strlen ("status ");
3801 parse_trace_status (p
, current_trace_status ());
3803 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3805 p
+= strlen ("tp ");
3806 parse_tracepoint_definition (p
, utpp
);
3808 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3810 p
+= strlen ("tsv ");
3811 parse_tsv_definition (p
, utsvp
);
3814 warning (_("Ignoring trace file definition \"%s\""), line
);
3817 /* Parse the part of trace status syntax that is shared between
3818 the remote protocol and the trace file reader. */
3821 parse_trace_status (char *line
, struct trace_status
*ts
)
3823 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
3827 ts
->running_known
= 1;
3828 ts
->running
= (*p
++ == '1');
3829 ts
->stop_reason
= trace_stop_reason_unknown
;
3830 xfree (ts
->stop_desc
);
3831 ts
->stop_desc
= NULL
;
3832 ts
->traceframe_count
= -1;
3833 ts
->traceframes_created
= -1;
3834 ts
->buffer_free
= -1;
3835 ts
->buffer_size
= -1;
3836 ts
->disconnected_tracing
= 0;
3837 ts
->circular_buffer
= 0;
3838 xfree (ts
->user_name
);
3839 ts
->user_name
= NULL
;
3842 ts
->start_time
= ts
->stop_time
= 0;
3846 p1
= strchr (p
, ':');
3848 error (_("Malformed trace status, at %s\n\
3849 Status line: '%s'\n"), p
, line
);
3850 p3
= strchr (p
, ';');
3852 p3
= p
+ strlen (p
);
3853 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3855 p
= unpack_varlen_hex (++p1
, &val
);
3856 ts
->stop_reason
= trace_buffer_full
;
3858 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3860 p
= unpack_varlen_hex (++p1
, &val
);
3861 ts
->stop_reason
= trace_never_run
;
3863 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3866 p
= unpack_varlen_hex (++p1
, &val
);
3867 ts
->stop_reason
= tracepoint_passcount
;
3868 ts
->stopping_tracepoint
= val
;
3870 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3872 p2
= strchr (++p1
, ':');
3880 ts
->stop_desc
= xmalloc (strlen (line
));
3881 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
3882 ts
->stop_desc
[end
] = '\0';
3885 ts
->stop_desc
= xstrdup ("");
3887 p
= unpack_varlen_hex (++p2
, &val
);
3888 ts
->stop_reason
= tstop_command
;
3890 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3892 p
= unpack_varlen_hex (++p1
, &val
);
3893 ts
->stop_reason
= trace_disconnected
;
3895 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3897 p2
= strchr (++p1
, ':');
3900 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3901 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
3902 ts
->stop_desc
[end
] = '\0';
3905 ts
->stop_desc
= xstrdup ("");
3907 p
= unpack_varlen_hex (++p2
, &val
);
3908 ts
->stopping_tracepoint
= val
;
3909 ts
->stop_reason
= tracepoint_error
;
3911 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3913 p
= unpack_varlen_hex (++p1
, &val
);
3914 ts
->traceframe_count
= val
;
3916 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3918 p
= unpack_varlen_hex (++p1
, &val
);
3919 ts
->traceframes_created
= val
;
3921 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3923 p
= unpack_varlen_hex (++p1
, &val
);
3924 ts
->buffer_free
= val
;
3926 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3928 p
= unpack_varlen_hex (++p1
, &val
);
3929 ts
->buffer_size
= val
;
3931 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3933 p
= unpack_varlen_hex (++p1
, &val
);
3934 ts
->disconnected_tracing
= val
;
3936 else if (strncmp (p
, "circular", p1
- p
) == 0)
3938 p
= unpack_varlen_hex (++p1
, &val
);
3939 ts
->circular_buffer
= val
;
3941 else if (strncmp (p
, "starttime", p1
- p
) == 0)
3943 p
= unpack_varlen_hex (++p1
, &val
);
3944 ts
->start_time
= val
;
3946 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
3948 p
= unpack_varlen_hex (++p1
, &val
);
3949 ts
->stop_time
= val
;
3951 else if (strncmp (p
, "username", p1
- p
) == 0)
3954 ts
->user_name
= xmalloc (strlen (p
) / 2);
3955 end
= hex2bin (p1
, ts
->user_name
, (p3
- p1
) / 2);
3956 ts
->user_name
[end
] = '\0';
3959 else if (strncmp (p
, "notes", p1
- p
) == 0)
3962 ts
->notes
= xmalloc (strlen (p
) / 2);
3963 end
= hex2bin (p1
, ts
->notes
, (p3
- p1
) / 2);
3964 ts
->notes
[end
] = '\0';
3969 /* Silently skip unknown optional info. */
3970 p_temp
= strchr (p1
+ 1, ';');
3974 /* Must be at the end. */
3981 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
3982 struct uploaded_tp
*utp
)
3985 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
3987 p
= unpack_varlen_hex (p
, &uval
);
3989 tp
->base
.hit_count
+= uval
;
3991 utp
->hit_count
+= uval
;
3992 p
= unpack_varlen_hex (p
+ 1, &uval
);
3994 tp
->traceframe_usage
+= uval
;
3996 utp
->traceframe_usage
+= uval
;
3997 /* Ignore any extra, allowing for future extensions. */
4000 /* Given a line of text defining a part of a tracepoint, parse it into
4001 an "uploaded tracepoint". */
4004 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
4008 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
4011 char *cond
, *srctype
, *buf
;
4012 struct uploaded_tp
*utp
= NULL
;
4015 /* Both tracepoint and action definitions start with the same number
4016 and address sequence. */
4018 p
= unpack_varlen_hex (p
, &num
);
4019 p
++; /* skip a colon */
4020 p
= unpack_varlen_hex (p
, &addr
);
4021 p
++; /* skip a colon */
4024 enabled
= (*p
++ == 'E');
4025 p
++; /* skip a colon */
4026 p
= unpack_varlen_hex (p
, &step
);
4027 p
++; /* skip a colon */
4028 p
= unpack_varlen_hex (p
, &pass
);
4029 type
= bp_tracepoint
;
4031 /* Thumb through optional fields. */
4034 p
++; /* skip a colon */
4037 type
= bp_fast_tracepoint
;
4039 p
= unpack_varlen_hex (p
, &orig_size
);
4043 type
= bp_static_tracepoint
;
4049 p
= unpack_varlen_hex (p
, &xlen
);
4050 p
++; /* skip a comma */
4051 cond
= (char *) xmalloc (2 * xlen
+ 1);
4052 strncpy (cond
, p
, 2 * xlen
);
4053 cond
[2 * xlen
] = '\0';
4057 warning (_("Unrecognized char '%c' in tracepoint "
4058 "definition, skipping rest"), *p
);
4060 utp
= get_uploaded_tp (num
, addr
, utpp
);
4062 utp
->enabled
= enabled
;
4067 else if (piece
== 'A')
4069 utp
= get_uploaded_tp (num
, addr
, utpp
);
4070 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
4072 else if (piece
== 'S')
4074 utp
= get_uploaded_tp (num
, addr
, utpp
);
4075 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
4077 else if (piece
== 'Z')
4079 /* Parse a chunk of source form definition. */
4080 utp
= get_uploaded_tp (num
, addr
, utpp
);
4082 p
= strchr (p
, ':');
4083 p
++; /* skip a colon */
4084 p
= unpack_varlen_hex (p
, &start
);
4085 p
++; /* skip a colon */
4086 p
= unpack_varlen_hex (p
, &xlen
);
4087 p
++; /* skip a colon */
4089 buf
= alloca (strlen (line
));
4091 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4094 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
4095 utp
->at_string
= xstrdup (buf
);
4096 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
4097 utp
->cond_string
= xstrdup (buf
);
4098 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
4099 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
4101 else if (piece
== 'V')
4103 utp
= get_uploaded_tp (num
, addr
, utpp
);
4105 parse_tracepoint_status (p
, NULL
, utp
);
4109 /* Don't error out, the target might be sending us optional
4110 info that we don't care about. */
4111 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
4115 /* Convert a textual description of a trace state variable into an
4119 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
4122 ULONGEST num
, initval
, builtin
;
4124 struct uploaded_tsv
*utsv
= NULL
;
4126 buf
= alloca (strlen (line
));
4129 p
= unpack_varlen_hex (p
, &num
);
4130 p
++; /* skip a colon */
4131 p
= unpack_varlen_hex (p
, &initval
);
4132 p
++; /* skip a colon */
4133 p
= unpack_varlen_hex (p
, &builtin
);
4134 p
++; /* skip a colon */
4135 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4138 utsv
= get_uploaded_tsv (num
, utsvp
);
4139 utsv
->initial_value
= initval
;
4140 utsv
->builtin
= builtin
;
4141 utsv
->name
= xstrdup (buf
);
4144 /* Close the trace file and generally clean up. */
4147 tfile_close (int quitting
)
4154 pid
= ptid_get_pid (inferior_ptid
);
4155 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff. */
4156 exit_inferior_silent (pid
);
4160 xfree (trace_filename
);
4161 trace_filename
= NULL
;
4165 tfile_files_info (struct target_ops
*t
)
4167 /* (it would be useful to mention the name of the file). */
4168 printf_filtered ("Looking at a trace file.\n");
4171 /* The trace status for a file is that tracing can never be run. */
4174 tfile_get_trace_status (struct trace_status
*ts
)
4176 /* Other bits of trace status were collected as part of opening the
4177 trace files, so nothing to do here. */
4183 tfile_get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
4185 /* Other bits of trace status were collected as part of opening the
4186 trace files, so nothing to do here. */
4189 /* Given the position of a traceframe in the file, figure out what
4190 address the frame was collected at. This would normally be the
4191 value of a collected PC register, but if not available, we
4195 tfile_get_traceframe_address (off_t tframe_offset
)
4199 struct tracepoint
*tp
;
4200 off_t saved_offset
= cur_offset
;
4202 /* FIXME dig pc out of collected registers. */
4204 /* Fall back to using tracepoint address. */
4205 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
4206 tfile_read ((gdb_byte
*) &tpnum
, 2);
4207 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4211 tp
= get_tracepoint_by_number_on_target (tpnum
);
4212 /* FIXME this is a poor heuristic if multiple locations. */
4213 if (tp
&& tp
->base
.loc
)
4214 addr
= tp
->base
.loc
->address
;
4216 /* Restore our seek position. */
4217 cur_offset
= saved_offset
;
4218 lseek (trace_fd
, cur_offset
, SEEK_SET
);
4222 /* Given a type of search and some parameters, scan the collection of
4223 traceframes in the file looking for a match. When found, return
4224 both the traceframe and tracepoint number, otherwise -1 for
4228 tfile_trace_find (enum trace_find_type type
, int num
,
4229 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
4232 int tfnum
= 0, found
= 0;
4233 unsigned int data_size
;
4234 struct tracepoint
*tp
;
4235 off_t offset
, tframe_offset
;
4245 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
4246 offset
= trace_frames_offset
;
4249 tframe_offset
= offset
;
4250 tfile_read ((gdb_byte
*) &tpnum
, 2);
4251 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4257 tfile_read ((gdb_byte
*) &data_size
, 4);
4258 data_size
= (unsigned int) extract_unsigned_integer
4259 ((gdb_byte
*) &data_size
, 4,
4260 gdbarch_byte_order (target_gdbarch
));
4269 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4270 if (tfaddr
== addr1
)
4274 tp
= get_tracepoint (num
);
4275 if (tp
&& tpnum
== tp
->number_on_target
)
4279 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4280 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
4284 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4285 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
4289 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
4295 cur_offset
= offset
;
4296 cur_data_size
= data_size
;
4300 /* Skip past the traceframe's data. */
4301 lseek (trace_fd
, data_size
, SEEK_CUR
);
4302 offset
+= data_size
;
4303 /* Update our own count of traceframes. */
4306 /* Did not find what we were looking for. */
4312 /* Prototype of the callback passed to tframe_walk_blocks. */
4313 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
4315 /* Callback for traceframe_walk_blocks, used to find a given block
4316 type in a traceframe. */
4319 match_blocktype (char blocktype
, void *data
)
4321 char *wantedp
= data
;
4323 if (*wantedp
== blocktype
)
4329 /* Walk over all traceframe block starting at POS offset from
4330 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4331 unmodified. If CALLBACK returns true, this returns the position in
4332 the traceframe where the block is found, relative to the start of
4333 the traceframe (cur_offset). Returns -1 if no callback call
4334 returned true, indicating that all blocks have been walked. */
4337 traceframe_walk_blocks (walk_blocks_callback_func callback
,
4338 int pos
, void *data
)
4340 /* Iterate through a traceframe's blocks, looking for a block of the
4343 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
4344 while (pos
< cur_data_size
)
4346 unsigned short mlen
;
4349 tfile_read (&block_type
, 1);
4353 if ((*callback
) (block_type
, data
))
4359 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4360 pos
+= trace_regblock_size
;
4363 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4364 tfile_read ((gdb_byte
*) &mlen
, 2);
4365 mlen
= (unsigned short)
4366 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4369 lseek (trace_fd
, mlen
, SEEK_CUR
);
4370 pos
+= (8 + 2 + mlen
);
4373 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
4377 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4378 block_type
, block_type
);
4386 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4387 position offset of a block of type TYPE_WANTED in the current trace
4388 frame, starting at POS. Returns -1 if no such block was found. */
4391 traceframe_find_block_type (char type_wanted
, int pos
)
4393 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
4396 /* Look for a block of saved registers in the traceframe, and get the
4397 requested register from it. */
4400 tfile_fetch_registers (struct target_ops
*ops
,
4401 struct regcache
*regcache
, int regno
)
4403 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4404 int offset
, regn
, regsize
, pc_regno
;
4407 /* An uninitialized reg size says we're not going to be
4408 successful at getting register blocks. */
4409 if (!trace_regblock_size
)
4412 regs
= alloca (trace_regblock_size
);
4414 if (traceframe_find_block_type ('R', 0) >= 0)
4416 tfile_read (regs
, trace_regblock_size
);
4418 /* Assume the block is laid out in GDB register number order,
4419 each register with the size that it has in GDB. */
4421 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4423 regsize
= register_size (gdbarch
, regn
);
4424 /* Make sure we stay within block bounds. */
4425 if (offset
+ regsize
>= trace_regblock_size
)
4427 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
4431 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
4434 else if (regno
== -1)
4436 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
4444 /* We get here if no register data has been found. Mark registers
4446 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4447 regcache_raw_supply (regcache
, regn
, NULL
);
4449 /* We can often usefully guess that the PC is going to be the same
4450 as the address of the tracepoint. */
4451 pc_regno
= gdbarch_pc_regnum (gdbarch
);
4452 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
4454 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
4456 if (tp
&& tp
->base
.loc
)
4458 /* But don't try to guess if tracepoint is multi-location... */
4459 if (tp
->base
.loc
->next
)
4461 warning (_("Tracepoint %d has multiple "
4462 "locations, cannot infer $pc"),
4466 /* ... or does while-stepping. */
4467 if (tp
->step_count
> 0)
4469 warning (_("Tracepoint %d does while-stepping, "
4470 "cannot infer $pc"),
4475 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
4476 gdbarch_byte_order (gdbarch
),
4477 tp
->base
.loc
->address
);
4478 regcache_raw_supply (regcache
, pc_regno
, regs
);
4484 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4485 const char *annex
, gdb_byte
*readbuf
,
4486 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
4488 /* We're only doing regular memory for now. */
4489 if (object
!= TARGET_OBJECT_MEMORY
)
4492 if (readbuf
== NULL
)
4493 error (_("tfile_xfer_partial: trace file is read-only"));
4495 if (traceframe_number
!= -1)
4499 /* Iterate through the traceframe's blocks, looking for
4501 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
4503 ULONGEST maddr
, amt
;
4504 unsigned short mlen
;
4505 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
4507 tfile_read ((gdb_byte
*) &maddr
, 8);
4508 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
4510 tfile_read ((gdb_byte
*) &mlen
, 2);
4511 mlen
= (unsigned short)
4512 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
4514 /* If the block includes the first part of the desired
4515 range, return as much it has; GDB will re-request the
4516 remainder, which might be in a different block of this
4518 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
4520 amt
= (maddr
+ mlen
) - offset
;
4524 if (maddr
!= offset
)
4525 lseek (trace_fd
, offset
- maddr
, SEEK_CUR
);
4526 tfile_read (readbuf
, amt
);
4530 /* Skip over this block. */
4531 pos
+= (8 + 2 + mlen
);
4535 /* It's unduly pedantic to refuse to look at the executable for
4536 read-only pieces; so do the equivalent of readonly regions aka
4538 /* FIXME account for relocation at some point. */
4545 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
4547 if ((s
->flags
& SEC_LOAD
) == 0
4548 || (s
->flags
& SEC_READONLY
) == 0)
4552 size
= bfd_get_section_size (s
);
4553 if (vma
<= offset
&& offset
< (vma
+ size
))
4557 amt
= (vma
+ size
) - offset
;
4561 amt
= bfd_get_section_contents (exec_bfd
, s
,
4562 readbuf
, offset
- vma
, amt
);
4568 /* Indicate failure to find the requested memory block. */
4572 /* Iterate through the blocks of a trace frame, looking for a 'V'
4573 block with a matching tsv number. */
4576 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
4581 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
4585 tfile_read ((gdb_byte
*) &vnum
, 4);
4586 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
4591 tfile_read ((gdb_byte
*) val
, 8);
4592 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
4600 /* Didn't find anything. */
4605 tfile_has_all_memory (struct target_ops
*ops
)
4611 tfile_has_memory (struct target_ops
*ops
)
4617 tfile_has_stack (struct target_ops
*ops
)
4619 return traceframe_number
!= -1;
4623 tfile_has_registers (struct target_ops
*ops
)
4625 return traceframe_number
!= -1;
4629 tfile_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
4634 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
4635 object for the tfile target's current traceframe. */
4638 build_traceframe_info (char blocktype
, void *data
)
4640 struct traceframe_info
*info
= data
;
4646 struct mem_range
*r
;
4648 unsigned short mlen
;
4650 tfile_read ((gdb_byte
*) &maddr
, 8);
4651 tfile_read ((gdb_byte
*) &mlen
, 2);
4653 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4666 warning (_("Unhandled trace block type (%d) '%c ' "
4667 "while building trace frame info."),
4668 blocktype
, blocktype
);
4675 static struct traceframe_info
*
4676 tfile_traceframe_info (void)
4678 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
4680 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
4685 init_tfile_ops (void)
4687 tfile_ops
.to_shortname
= "tfile";
4688 tfile_ops
.to_longname
= "Local trace dump file";
4690 = "Use a trace file as a target. Specify the filename of the trace file.";
4691 tfile_ops
.to_open
= tfile_open
;
4692 tfile_ops
.to_close
= tfile_close
;
4693 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
4694 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
4695 tfile_ops
.to_files_info
= tfile_files_info
;
4696 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
4697 tfile_ops
.to_get_tracepoint_status
= tfile_get_tracepoint_status
;
4698 tfile_ops
.to_trace_find
= tfile_trace_find
;
4699 tfile_ops
.to_get_trace_state_variable_value
4700 = tfile_get_trace_state_variable_value
;
4701 tfile_ops
.to_stratum
= process_stratum
;
4702 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
4703 tfile_ops
.to_has_memory
= tfile_has_memory
;
4704 tfile_ops
.to_has_stack
= tfile_has_stack
;
4705 tfile_ops
.to_has_registers
= tfile_has_registers
;
4706 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
4707 tfile_ops
.to_thread_alive
= tfile_thread_alive
;
4708 tfile_ops
.to_magic
= OPS_MAGIC
;
4712 free_current_marker (void *arg
)
4714 struct static_tracepoint_marker
**marker_p
= arg
;
4716 if (*marker_p
!= NULL
)
4718 release_static_tracepoint_marker (*marker_p
);
4725 /* Given a line of text defining a static tracepoint marker, parse it
4726 into a "static tracepoint marker" object. Throws an error is
4727 parsing fails. If PP is non-null, it points to one past the end of
4728 the parsed marker definition. */
4731 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
4732 struct static_tracepoint_marker
*marker
)
4739 p
= unpack_varlen_hex (p
, &addr
);
4740 p
++; /* skip a colon */
4742 marker
->gdbarch
= target_gdbarch
;
4743 marker
->address
= (CORE_ADDR
) addr
;
4745 endp
= strchr (p
, ':');
4747 error (_("bad marker definition: %s"), line
);
4749 marker
->str_id
= xmalloc (endp
- p
+ 1);
4750 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
4751 marker
->str_id
[end
] = '\0';
4754 p
++; /* skip a colon */
4756 marker
->extra
= xmalloc (strlen (p
) + 1);
4757 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
4758 marker
->extra
[end
] = '\0';
4764 /* Release a static tracepoint marker's contents. Note that the
4765 object itself isn't released here. There objects are usually on
4769 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
4771 xfree (marker
->str_id
);
4772 marker
->str_id
= NULL
;
4775 /* Print MARKER to gdb_stdout. */
4778 print_one_static_tracepoint_marker (int count
,
4779 struct static_tracepoint_marker
*marker
)
4781 struct command_line
*l
;
4784 char wrap_indent
[80];
4785 char extra_field_indent
[80];
4786 struct ui_out
*uiout
= current_uiout
;
4787 struct cleanup
*bkpt_chain
;
4788 VEC(breakpoint_p
) *tracepoints
;
4790 struct symtab_and_line sal
;
4794 sal
.pc
= marker
->address
;
4796 tracepoints
= static_tracepoints_here (marker
->address
);
4798 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
4800 /* A counter field to help readability. This is not a stable
4802 ui_out_field_int (uiout
, "count", count
);
4804 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
4806 ui_out_field_fmt (uiout
, "enabled", "%c",
4807 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
4808 ui_out_spaces (uiout
, 2);
4810 strcpy (wrap_indent
, " ");
4812 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
4813 strcat (wrap_indent
, " ");
4815 strcat (wrap_indent
, " ");
4817 strcpy (extra_field_indent
, " ");
4819 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
4821 sal
= find_pc_line (marker
->address
, 0);
4822 sym
= find_pc_sect_function (marker
->address
, NULL
);
4825 ui_out_text (uiout
, "in ");
4826 ui_out_field_string (uiout
, "func",
4827 SYMBOL_PRINT_NAME (sym
));
4828 ui_out_wrap_hint (uiout
, wrap_indent
);
4829 ui_out_text (uiout
, " at ");
4832 ui_out_field_skip (uiout
, "func");
4834 if (sal
.symtab
!= NULL
)
4836 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
4837 ui_out_text (uiout
, ":");
4839 if (ui_out_is_mi_like_p (uiout
))
4841 const char *fullname
= symtab_to_fullname (sal
.symtab
);
4844 ui_out_field_string (uiout
, "fullname", fullname
);
4847 ui_out_field_skip (uiout
, "fullname");
4849 ui_out_field_int (uiout
, "line", sal
.line
);
4853 ui_out_field_skip (uiout
, "fullname");
4854 ui_out_field_skip (uiout
, "line");
4857 ui_out_text (uiout
, "\n");
4858 ui_out_text (uiout
, extra_field_indent
);
4859 ui_out_text (uiout
, _("Data: \""));
4860 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
4861 ui_out_text (uiout
, "\"\n");
4863 if (!VEC_empty (breakpoint_p
, tracepoints
))
4865 struct cleanup
*cleanup_chain
;
4867 struct breakpoint
*b
;
4869 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
4872 ui_out_text (uiout
, extra_field_indent
);
4873 ui_out_text (uiout
, _("Probed by static tracepoints: "));
4874 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
4877 ui_out_text (uiout
, ", ");
4878 ui_out_text (uiout
, "#");
4879 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
4882 do_cleanups (cleanup_chain
);
4884 if (ui_out_is_mi_like_p (uiout
))
4885 ui_out_field_int (uiout
, "number-of-tracepoints",
4886 VEC_length(breakpoint_p
, tracepoints
));
4888 ui_out_text (uiout
, "\n");
4890 VEC_free (breakpoint_p
, tracepoints
);
4892 do_cleanups (bkpt_chain
);
4896 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
4898 VEC(static_tracepoint_marker_p
) *markers
;
4899 struct cleanup
*old_chain
;
4900 struct static_tracepoint_marker
*marker
;
4901 struct ui_out
*uiout
= current_uiout
;
4904 /* We don't have to check target_can_use_agent and agent's capability on
4905 static tracepoint here, in order to be compatible with older GDBserver.
4906 We don't check USE_AGENT is true or not, because static tracepoints
4907 don't work without in-process agent, so we don't bother users to type
4908 `set agent on' when to use static tracepoint. */
4911 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
4912 "StaticTracepointMarkersTable");
4914 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
4916 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
4918 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
4919 if (gdbarch_addr_bit (target_gdbarch
) <= 32)
4920 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
4922 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
4923 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
4925 ui_out_table_body (uiout
);
4927 markers
= target_static_tracepoint_markers_by_strid (NULL
);
4928 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
4931 VEC_iterate (static_tracepoint_marker_p
,
4932 markers
, i
, marker
);
4935 print_one_static_tracepoint_marker (i
+ 1, marker
);
4936 release_static_tracepoint_marker (marker
);
4939 do_cleanups (old_chain
);
4942 /* The $_sdata convenience variable is a bit special. We don't know
4943 for sure type of the value until we actually have a chance to fetch
4944 the data --- the size of the object depends on what has been
4945 collected. We solve this by making $_sdata be an internalvar that
4946 creates a new value on access. */
4948 /* Return a new value with the correct type for the sdata object of
4949 the current trace frame. Return a void value if there's no object
4952 static struct value
*
4953 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
4959 /* We need to read the whole object before we know its size. */
4960 size
= target_read_alloc (¤t_target
,
4961 TARGET_OBJECT_STATIC_TRACE_DATA
,
4968 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
4970 v
= allocate_value (type
);
4971 memcpy (value_contents_raw (v
), buf
, size
);
4976 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
4979 #if !defined(HAVE_LIBEXPAT)
4981 struct traceframe_info
*
4982 parse_traceframe_info (const char *tframe_info
)
4984 static int have_warned
;
4989 warning (_("Can not parse XML trace frame info; XML support "
4990 "was disabled at compile time"));
4996 #else /* HAVE_LIBEXPAT */
4998 #include "xml-support.h"
5000 /* Handle the start of a <memory> element. */
5003 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
5004 const struct gdb_xml_element
*element
,
5005 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
5007 struct traceframe_info
*info
= user_data
;
5008 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5009 ULONGEST
*start_p
, *length_p
;
5011 start_p
= xml_find_attribute (attributes
, "start")->value
;
5012 length_p
= xml_find_attribute (attributes
, "length")->value
;
5014 r
->start
= *start_p
;
5015 r
->length
= *length_p
;
5018 /* Discard the constructed trace frame info (if an error occurs). */
5021 free_result (void *p
)
5023 struct traceframe_info
*result
= p
;
5025 free_traceframe_info (result
);
5028 /* The allowed elements and attributes for an XML memory map. */
5030 static const struct gdb_xml_attribute memory_attributes
[] = {
5031 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5032 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5033 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5036 static const struct gdb_xml_element traceframe_info_children
[] = {
5037 { "memory", memory_attributes
, NULL
,
5038 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5039 traceframe_info_start_memory
, NULL
},
5040 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5043 static const struct gdb_xml_element traceframe_info_elements
[] = {
5044 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
5046 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5049 /* Parse a traceframe-info XML document. */
5051 struct traceframe_info
*
5052 parse_traceframe_info (const char *tframe_info
)
5054 struct traceframe_info
*result
;
5055 struct cleanup
*back_to
;
5057 result
= XCNEW (struct traceframe_info
);
5058 back_to
= make_cleanup (free_result
, result
);
5060 if (gdb_xml_parse_quick (_("trace frame info"),
5061 "traceframe-info.dtd", traceframe_info_elements
,
5062 tframe_info
, result
) == 0)
5064 /* Parsed successfully, keep the result. */
5065 discard_cleanups (back_to
);
5070 do_cleanups (back_to
);
5074 #endif /* HAVE_LIBEXPAT */
5076 /* Returns the traceframe_info object for the current traceframe.
5077 This is where we avoid re-fetching the object from the target if we
5078 already have it cached. */
5080 static struct traceframe_info
*
5081 get_traceframe_info (void)
5083 if (traceframe_info
== NULL
)
5084 traceframe_info
= target_traceframe_info ();
5086 return traceframe_info
;
5089 /* If the target supports the query, return in RESULT the set of
5090 collected memory in the current traceframe, found within the LEN
5091 bytes range starting at MEMADDR. Returns true if the target
5092 supports the query, otherwise returns false, and RESULT is left
5096 traceframe_available_memory (VEC(mem_range_s
) **result
,
5097 CORE_ADDR memaddr
, ULONGEST len
)
5099 struct traceframe_info
*info
= get_traceframe_info ();
5103 struct mem_range
*r
;
5108 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
5109 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
5111 ULONGEST lo1
, hi1
, lo2
, hi2
;
5112 struct mem_range
*nr
;
5115 hi1
= memaddr
+ len
;
5118 hi2
= r
->start
+ r
->length
;
5120 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
5122 nr
->start
= max (lo1
, lo2
);
5123 nr
->length
= min (hi1
, hi2
) - nr
->start
;
5126 normalize_mem_ranges (*result
);
5133 /* Implementation of `sdata' variable. */
5135 static const struct internalvar_funcs sdata_funcs
=
5142 /* module initialization */
5144 _initialize_tracepoint (void)
5146 struct cmd_list_element
*c
;
5148 /* Explicitly create without lookup, since that tries to create a
5149 value with a void typed value, and when we get here, gdbarch
5150 isn't initialized yet. At this point, we're quite sure there
5151 isn't another convenience variable of the same name. */
5152 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
5154 traceframe_number
= -1;
5155 tracepoint_number
= -1;
5157 if (tracepoint_list
.list
== NULL
)
5159 tracepoint_list
.listsize
= 128;
5160 tracepoint_list
.list
= xmalloc
5161 (tracepoint_list
.listsize
* sizeof (struct memrange
));
5163 if (tracepoint_list
.aexpr_list
== NULL
)
5165 tracepoint_list
.aexpr_listsize
= 128;
5166 tracepoint_list
.aexpr_list
= xmalloc
5167 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5170 if (stepping_list
.list
== NULL
)
5172 stepping_list
.listsize
= 128;
5173 stepping_list
.list
= xmalloc
5174 (stepping_list
.listsize
* sizeof (struct memrange
));
5177 if (stepping_list
.aexpr_list
== NULL
)
5179 stepping_list
.aexpr_listsize
= 128;
5180 stepping_list
.aexpr_list
= xmalloc
5181 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5184 add_info ("scope", scope_info
,
5185 _("List the variables local to a scope"));
5187 add_cmd ("tracepoints", class_trace
, NULL
,
5188 _("Tracing of program execution without stopping the program."),
5191 add_com ("tdump", class_trace
, trace_dump_command
,
5192 _("Print everything collected at the current tracepoint."));
5194 add_com ("tsave", class_trace
, trace_save_command
, _("\
5195 Save the trace data to a file.\n\
5196 Use the '-r' option to direct the target to save directly to the file,\n\
5197 using its own filesystem."));
5199 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
5200 Define a trace state variable.\n\
5201 Argument is a $-prefixed name, optionally followed\n\
5202 by '=' and an expression that sets the initial value\n\
5203 at the start of tracing."));
5204 set_cmd_completer (c
, expression_completer
);
5206 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
5207 Delete one or more trace state variables.\n\
5208 Arguments are the names of the variables to delete.\n\
5209 If no arguments are supplied, delete all variables."), &deletelist
);
5210 /* FIXME add a trace variable completer. */
5212 add_info ("tvariables", tvariables_info
, _("\
5213 Status of trace state variables and their values.\n\
5216 add_info ("static-tracepoint-markers",
5217 info_static_tracepoint_markers_command
, _("\
5218 List target static tracepoints markers.\n\
5221 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
5222 Select a trace frame;\n\
5223 No argument means forward by one frame; '-' means backward by one frame."),
5224 &tfindlist
, "tfind ", 1, &cmdlist
);
5226 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
5227 Select a trace frame whose PC is outside the given range (exclusive).\n\
5228 Usage: tfind outside addr1, addr2"),
5231 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
5232 Select a trace frame whose PC is in the given range (inclusive).\n\
5233 Usage: tfind range addr1,addr2"),
5236 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
5237 Select a trace frame by source line.\n\
5238 Argument can be a line number (with optional source file),\n\
5239 a function name, or '*' followed by an address.\n\
5240 Default argument is 'the next source line that was traced'."),
5243 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
5244 Select a trace frame by tracepoint number.\n\
5245 Default is the tracepoint for the current trace frame."),
5248 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
5249 Select a trace frame by PC.\n\
5250 Default is the current PC, or the PC of the current trace frame."),
5253 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
5254 De-select any trace frame and resume 'live' debugging."),
5257 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
5259 add_cmd ("start", class_trace
, trace_find_start_command
,
5260 _("Select the first trace frame in the trace buffer."),
5263 add_com ("tstatus", class_trace
, trace_status_command
,
5264 _("Display the status of the current trace data collection."));
5266 add_com ("tstop", class_trace
, trace_stop_command
, _("\
5267 Stop trace data collection.\n\
5268 Usage: tstop [ <notes> ... ]\n\
5269 Any arguments supplied are recorded with the trace as a stop reason and\n\
5270 reported by tstatus (if the target supports trace notes)."));
5272 add_com ("tstart", class_trace
, trace_start_command
, _("\
5273 Start trace data collection.\n\
5274 Usage: tstart [ <notes> ... ]\n\
5275 Any arguments supplied are recorded with the trace as a note and\n\
5276 reported by tstatus (if the target supports trace notes)."));
5278 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
5279 Ends a list of commands or actions.\n\
5280 Several GDB commands allow you to enter a list of commands or actions.\n\
5281 Entering \"end\" on a line by itself is the normal way to terminate\n\
5283 Note: the \"end\" command cannot be used at the gdb prompt."));
5285 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
5286 Specify single-stepping behavior at a tracepoint.\n\
5287 Argument is number of instructions to trace in single-step mode\n\
5288 following the tracepoint. This command is normally followed by\n\
5289 one or more \"collect\" commands, to specify what to collect\n\
5290 while single-stepping.\n\n\
5291 Note: this command can only be used in a tracepoint \"actions\" list."));
5293 add_com_alias ("ws", "while-stepping", class_alias
, 0);
5294 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
5296 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
5297 Specify one or more data items to be collected at a tracepoint.\n\
5298 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5299 collect all data (variables, registers) referenced by that expression.\n\
5300 Also accepts the following special arguments:\n\
5301 $regs -- all registers.\n\
5302 $args -- all function arguments.\n\
5303 $locals -- all variables local to the block/function scope.\n\
5304 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5305 Note: this command can only be used in a tracepoint \"actions\" list."));
5307 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
5308 Specify one or more expressions to be evaluated at a tracepoint.\n\
5309 Accepts a comma-separated list of (one or more) expressions.\n\
5310 The result of each evaluation will be discarded.\n\
5311 Note: this command can only be used in a tracepoint \"actions\" list."));
5313 add_com ("actions", class_trace
, trace_actions_command
, _("\
5314 Specify the actions to be taken at a tracepoint.\n\
5315 Tracepoint actions may include collecting of specified data,\n\
5316 single-stepping, or enabling/disabling other tracepoints,\n\
5317 depending on target's capabilities."));
5319 default_collect
= xstrdup ("");
5320 add_setshow_string_cmd ("default-collect", class_trace
,
5321 &default_collect
, _("\
5322 Set the list of expressions to collect by default"), _("\
5323 Show the list of expressions to collect by default"), NULL
,
5325 &setlist
, &showlist
);
5327 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
5328 &disconnected_tracing
, _("\
5329 Set whether tracing continues after GDB disconnects."), _("\
5330 Show whether tracing continues after GDB disconnects."), _("\
5331 Use this to continue a tracing run even if GDB disconnects\n\
5332 or detaches from the target. You can reconnect later and look at\n\
5333 trace data collected in the meantime."),
5334 set_disconnected_tracing
,
5339 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
5340 &circular_trace_buffer
, _("\
5341 Set target's use of circular trace buffer."), _("\
5342 Show target's use of circular trace buffer."), _("\
5343 Use this to make the trace buffer into a circular buffer,\n\
5344 which will discard traceframes (oldest first) instead of filling\n\
5345 up and stopping the trace run."),
5346 set_circular_trace_buffer
,
5351 add_setshow_string_cmd ("trace-user", class_trace
,
5353 Set the user name to use for current and future trace runs"), _("\
5354 Show the user name to use for current and future trace runs"), NULL
,
5355 set_trace_user
, NULL
,
5356 &setlist
, &showlist
);
5358 add_setshow_string_cmd ("trace-notes", class_trace
,
5360 Set notes string to use for current and future trace runs"), _("\
5361 Show the notes string to use for current and future trace runs"), NULL
,
5362 set_trace_notes
, NULL
,
5363 &setlist
, &showlist
);
5365 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
5366 &trace_stop_notes
, _("\
5367 Set notes string to use for future tstop commands"), _("\
5368 Show the notes string to use for future tstop commands"), NULL
,
5369 set_trace_stop_notes
, NULL
,
5370 &setlist
, &showlist
);
5374 add_target (&tfile_ops
);