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? */
1459 unsigned long addr
, len
;
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 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1490 add_memrange (collect
, memrange_absolute
, addr
, len
);
1494 collect_symbol (collect
,
1495 exp
->elts
[2].symbol
,
1502 default: /* Full-fledged expression. */
1503 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1505 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1509 report_agent_reqs_errors (aexpr
);
1511 discard_cleanups (old_chain1
);
1512 add_aexpr (collect
, aexpr
);
1514 /* Take care of the registers. */
1515 if (aexpr
->reg_mask_len
> 0)
1520 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1522 QUIT
; /* Allow user to bail out with ^C. */
1523 if (aexpr
->reg_mask
[ndx1
] != 0)
1525 /* Assume chars have 8 bits. */
1526 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1527 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1528 /* It's used -- record it. */
1529 add_register (collect
,
1536 do_cleanups (old_chain
);
1539 while (action_exp
&& *action_exp
++ == ',');
1541 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1544 { /* Repeat over a comma-separated list. */
1545 QUIT
; /* Allow user to bail out with ^C. */
1546 while (isspace ((int) *action_exp
))
1550 struct cleanup
*old_chain
= NULL
;
1551 struct cleanup
*old_chain1
= NULL
;
1553 exp
= parse_exp_1 (&action_exp
, tloc
->address
,
1554 block_for_pc (tloc
->address
), 1);
1555 old_chain
= make_cleanup (free_current_contents
, &exp
);
1557 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1558 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1561 report_agent_reqs_errors (aexpr
);
1563 discard_cleanups (old_chain1
);
1564 /* Even though we're not officially collecting, add
1565 to the collect list anyway. */
1566 add_aexpr (collect
, aexpr
);
1568 do_cleanups (old_chain
);
1571 while (action_exp
&& *action_exp
++ == ',');
1573 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1575 /* We check against nested while-stepping when setting
1576 breakpoint action, so no way to run into nested
1578 gdb_assert (stepping_list
);
1580 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
,
1581 frame_offset
, stepping_list
, NULL
);
1584 error (_("Invalid tracepoint command '%s'"), action
->line
);
1588 /* Render all actions into gdb protocol. */
1591 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1592 char ***tdp_actions
, char ***stepping_actions
)
1594 static char tdp_buff
[2048], step_buff
[2048];
1595 char *default_collect_line
= NULL
;
1596 struct command_line
*actions
;
1597 struct command_line
*default_collect_action
= NULL
;
1599 LONGEST frame_offset
;
1600 struct cleanup
*back_to
;
1602 back_to
= make_cleanup (null_cleanup
, NULL
);
1604 clear_collection_list (&tracepoint_list
);
1605 clear_collection_list (&stepping_list
);
1607 *tdp_actions
= NULL
;
1608 *stepping_actions
= NULL
;
1610 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1611 tloc
->address
, &frame_reg
, &frame_offset
);
1613 actions
= breakpoint_commands (t
);
1615 /* If there are default expressions to collect, make up a collect
1616 action and prepend to the action list to encode. Note that since
1617 validation is per-tracepoint (local var "xyz" might be valid for
1618 one tracepoint and not another, etc), we make up the action on
1619 the fly, and don't cache it. */
1620 if (*default_collect
)
1624 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1625 make_cleanup (xfree
, default_collect_line
);
1627 line
= default_collect_line
;
1628 validate_actionline (&line
, t
);
1630 default_collect_action
= xmalloc (sizeof (struct command_line
));
1631 make_cleanup (xfree
, default_collect_action
);
1632 default_collect_action
->next
= actions
;
1633 default_collect_action
->line
= line
;
1634 actions
= default_collect_action
;
1636 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1637 &tracepoint_list
, &stepping_list
);
1639 memrange_sortmerge (&tracepoint_list
);
1640 memrange_sortmerge (&stepping_list
);
1642 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1644 *stepping_actions
= stringify_collection_list (&stepping_list
,
1647 do_cleanups (back_to
);
1651 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1653 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1655 collect
->aexpr_list
=
1656 xrealloc (collect
->aexpr_list
,
1657 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1658 collect
->aexpr_listsize
*= 2;
1660 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1661 collect
->next_aexpr_elt
++;
1665 process_tracepoint_on_disconnect (void)
1667 VEC(breakpoint_p
) *tp_vec
= NULL
;
1669 struct breakpoint
*b
;
1670 int has_pending_p
= 0;
1672 /* Check whether we still have pending tracepoint. If we have, warn the
1673 user that pending tracepoint will no longer work. */
1674 tp_vec
= all_tracepoints ();
1675 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1684 struct bp_location
*loc1
;
1686 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1688 if (loc1
->shlib_disabled
)
1699 VEC_free (breakpoint_p
, tp_vec
);
1702 warning (_("Pending tracepoints will not be resolved while"
1703 " GDB is disconnected\n"));
1708 start_tracing (char *notes
)
1710 VEC(breakpoint_p
) *tp_vec
= NULL
;
1712 struct breakpoint
*b
;
1713 struct trace_state_variable
*tsv
;
1714 int any_enabled
= 0, num_to_download
= 0;
1717 tp_vec
= all_tracepoints ();
1719 /* No point in tracing without any tracepoints... */
1720 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1722 VEC_free (breakpoint_p
, tp_vec
);
1723 error (_("No tracepoints defined, not starting trace"));
1726 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1728 struct tracepoint
*t
= (struct tracepoint
*) b
;
1729 struct bp_location
*loc
;
1731 if (b
->enable_state
== bp_enabled
)
1734 if ((b
->type
== bp_fast_tracepoint
1735 ? may_insert_fast_tracepoints
1736 : may_insert_tracepoints
))
1739 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1740 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1745 if (target_supports_enable_disable_tracepoint ())
1746 warning (_("No tracepoints enabled"));
1749 /* No point in tracing with only disabled tracepoints that
1750 cannot be re-enabled. */
1751 VEC_free (breakpoint_p
, tp_vec
);
1752 error (_("No tracepoints enabled, not starting trace"));
1756 if (num_to_download
<= 0)
1758 VEC_free (breakpoint_p
, tp_vec
);
1759 error (_("No tracepoints that may be downloaded, not starting trace"));
1762 target_trace_init ();
1764 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1766 struct tracepoint
*t
= (struct tracepoint
*) b
;
1767 struct bp_location
*loc
;
1769 /* Clear `inserted' flag. */
1770 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1773 if ((b
->type
== bp_fast_tracepoint
1774 ? !may_insert_fast_tracepoints
1775 : !may_insert_tracepoints
))
1778 t
->number_on_target
= 0;
1780 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1782 /* Since tracepoint locations are never duplicated, `inserted'
1783 flag should be zero. */
1784 gdb_assert (!loc
->inserted
);
1786 target_download_tracepoint (loc
);
1791 t
->number_on_target
= b
->number
;
1793 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1794 if (loc
->probe
!= NULL
)
1795 loc
->probe
->pops
->set_semaphore (loc
->probe
, loc
->gdbarch
);
1797 VEC_free (breakpoint_p
, tp_vec
);
1799 /* Send down all the trace state variables too. */
1800 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1802 target_download_trace_state_variable (tsv
);
1805 /* Tell target to treat text-like sections as transparent. */
1806 target_trace_set_readonly_regions ();
1807 /* Set some mode flags. */
1808 target_set_disconnected_tracing (disconnected_tracing
);
1809 target_set_circular_trace_buffer (circular_trace_buffer
);
1812 notes
= trace_notes
;
1813 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1815 if (!ret
&& (trace_user
|| notes
))
1816 warning (_("Target does not support trace user/notes, info ignored"));
1818 /* Now insert traps and begin collecting data. */
1819 target_trace_start ();
1821 /* Reset our local state. */
1822 set_traceframe_num (-1);
1823 set_tracepoint_num (-1);
1824 set_traceframe_context (NULL
);
1825 current_trace_status()->running
= 1;
1826 clear_traceframe_info ();
1829 /* The tstart command requests the target to start a new trace run.
1830 The command passes any arguments it has to the target verbatim, as
1831 an optional "trace note". This is useful as for instance a warning
1832 to other users if the trace runs disconnected, and you don't want
1833 anybody else messing with the target. */
1836 trace_start_command (char *args
, int from_tty
)
1838 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1840 if (current_trace_status ()->running
)
1843 && !query (_("A trace is running already. Start a new run? ")))
1844 error (_("New trace run not started."));
1847 start_tracing (args
);
1850 /* The tstop command stops the tracing run. The command passes any
1851 supplied arguments to the target verbatim as a "stop note"; if the
1852 target supports trace notes, then it will be reported back as part
1853 of the trace run's status. */
1856 trace_stop_command (char *args
, int from_tty
)
1858 if (!current_trace_status ()->running
)
1859 error (_("Trace is not running."));
1861 stop_tracing (args
);
1865 stop_tracing (char *note
)
1868 VEC(breakpoint_p
) *tp_vec
= NULL
;
1870 struct breakpoint
*t
;
1872 target_trace_stop ();
1874 tp_vec
= all_tracepoints ();
1875 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1877 struct bp_location
*loc
;
1879 if ((t
->type
== bp_fast_tracepoint
1880 ? !may_insert_fast_tracepoints
1881 : !may_insert_tracepoints
))
1884 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
1886 /* GDB can be totally absent in some disconnected trace scenarios,
1887 but we don't really care if this semaphore goes out of sync.
1888 That's why we are decrementing it here, but not taking care
1890 if (loc
->probe
!= NULL
)
1891 loc
->probe
->pops
->clear_semaphore (loc
->probe
, loc
->gdbarch
);
1895 VEC_free (breakpoint_p
, tp_vec
);
1898 note
= trace_stop_notes
;
1899 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1902 warning (_("Target does not support trace notes, note ignored"));
1904 /* Should change in response to reply? */
1905 current_trace_status ()->running
= 0;
1908 /* tstatus command */
1910 trace_status_command (char *args
, int from_tty
)
1912 struct trace_status
*ts
= current_trace_status ();
1914 VEC(breakpoint_p
) *tp_vec
= NULL
;
1915 struct breakpoint
*t
;
1917 status
= target_get_trace_status (ts
);
1922 printf_filtered (_("Using a trace file.\n"));
1925 printf_filtered (_("Trace can not be run on this target.\n"));
1930 if (!ts
->running_known
)
1932 printf_filtered (_("Run/stop status is unknown.\n"));
1934 else if (ts
->running
)
1936 printf_filtered (_("Trace is running on the target.\n"));
1940 switch (ts
->stop_reason
)
1942 case trace_never_run
:
1943 printf_filtered (_("No trace has been run on the target.\n"));
1947 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1950 printf_filtered (_("Trace stopped by a tstop command.\n"));
1952 case trace_buffer_full
:
1953 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1955 case trace_disconnected
:
1956 printf_filtered (_("Trace stopped because of disconnection.\n"));
1958 case tracepoint_passcount
:
1959 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1960 ts
->stopping_tracepoint
);
1962 case tracepoint_error
:
1963 if (ts
->stopping_tracepoint
)
1964 printf_filtered (_("Trace stopped by an "
1965 "error (%s, tracepoint %d).\n"),
1966 ts
->stop_desc
, ts
->stopping_tracepoint
);
1968 printf_filtered (_("Trace stopped by an error (%s).\n"),
1971 case trace_stop_reason_unknown
:
1972 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1975 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1981 if (ts
->traceframes_created
>= 0
1982 && ts
->traceframe_count
!= ts
->traceframes_created
)
1984 printf_filtered (_("Buffer contains %d trace "
1985 "frames (of %d created total).\n"),
1986 ts
->traceframe_count
, ts
->traceframes_created
);
1988 else if (ts
->traceframe_count
>= 0)
1990 printf_filtered (_("Collected %d trace frames.\n"),
1991 ts
->traceframe_count
);
1994 if (ts
->buffer_free
>= 0)
1996 if (ts
->buffer_size
>= 0)
1998 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1999 ts
->buffer_free
, ts
->buffer_size
);
2000 if (ts
->buffer_size
> 0)
2001 printf_filtered (_(" (%d%% full)"),
2002 ((int) ((((long long) (ts
->buffer_size
2003 - ts
->buffer_free
)) * 100)
2004 / ts
->buffer_size
)));
2005 printf_filtered (_(".\n"));
2008 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2012 if (ts
->disconnected_tracing
)
2013 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2015 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2017 if (ts
->circular_buffer
)
2018 printf_filtered (_("Trace buffer is circular.\n"));
2020 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
2021 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
2023 if (ts
->notes
&& strlen (ts
->notes
) > 0)
2024 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
2026 /* Now report on what we're doing with tfind. */
2027 if (traceframe_number
>= 0)
2028 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2029 traceframe_number
, tracepoint_number
);
2031 printf_filtered (_("Not looking at any trace frame.\n"));
2033 /* Report start/stop times if supplied. */
2038 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
2040 /* Reporting a run time is more readable than two long numbers. */
2041 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2042 (long int) ts
->start_time
/ 1000000,
2043 (long int) ts
->start_time
% 1000000,
2044 (long int) run_time
/ 1000000,
2045 (long int) run_time
% 1000000);
2048 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2049 (long int) ts
->start_time
/ 1000000,
2050 (long int) ts
->start_time
% 1000000);
2052 else if (ts
->stop_time
)
2053 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2054 (long int) ts
->stop_time
/ 1000000,
2055 (long int) ts
->stop_time
% 1000000);
2057 /* Now report any per-tracepoint status available. */
2058 tp_vec
= all_tracepoints ();
2060 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2061 target_get_tracepoint_status (t
, NULL
);
2063 VEC_free (breakpoint_p
, tp_vec
);
2066 /* Report the trace status to uiout, in a way suitable for MI, and not
2067 suitable for CLI. If ON_STOP is true, suppress a few fields that
2068 are not meaningful in the -trace-stop response.
2070 The implementation is essentially parallel to trace_status_command, but
2071 merging them will result in unreadable code. */
2073 trace_status_mi (int on_stop
)
2075 struct ui_out
*uiout
= current_uiout
;
2076 struct trace_status
*ts
= current_trace_status ();
2079 status
= target_get_trace_status (ts
);
2081 if (status
== -1 && !ts
->from_file
)
2083 ui_out_field_string (uiout
, "supported", "0");
2088 ui_out_field_string (uiout
, "supported", "file");
2090 ui_out_field_string (uiout
, "supported", "1");
2092 gdb_assert (ts
->running_known
);
2096 ui_out_field_string (uiout
, "running", "1");
2098 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2099 Given that the frontend gets the status either on -trace-stop, or from
2100 -trace-status after re-connection, it does not seem like this
2101 information is necessary for anything. It is not necessary for either
2102 figuring the vital state of the target nor for navigation of trace
2103 frames. If the frontend wants to show the current state is some
2104 configure dialog, it can request the value when such dialog is
2105 invoked by the user. */
2109 char *stop_reason
= NULL
;
2110 int stopping_tracepoint
= -1;
2113 ui_out_field_string (uiout
, "running", "0");
2115 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2117 switch (ts
->stop_reason
)
2120 stop_reason
= "request";
2122 case trace_buffer_full
:
2123 stop_reason
= "overflow";
2125 case trace_disconnected
:
2126 stop_reason
= "disconnection";
2128 case tracepoint_passcount
:
2129 stop_reason
= "passcount";
2130 stopping_tracepoint
= ts
->stopping_tracepoint
;
2132 case tracepoint_error
:
2133 stop_reason
= "error";
2134 stopping_tracepoint
= ts
->stopping_tracepoint
;
2140 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2141 if (stopping_tracepoint
!= -1)
2142 ui_out_field_int (uiout
, "stopping-tracepoint",
2143 stopping_tracepoint
);
2144 if (ts
->stop_reason
== tracepoint_error
)
2145 ui_out_field_string (uiout
, "error-description",
2151 if (ts
->traceframe_count
!= -1)
2152 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2153 if (ts
->traceframes_created
!= -1)
2154 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2155 if (ts
->buffer_size
!= -1)
2156 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2157 if (ts
->buffer_free
!= -1)
2158 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2160 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2161 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2163 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2164 ui_out_field_string (uiout
, "notes", ts
->notes
);
2169 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2170 (long int) ts
->start_time
/ 1000000,
2171 (long int) ts
->start_time
% 1000000);
2172 ui_out_field_string (uiout
, "start-time", buf
);
2173 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2174 (long int) ts
->stop_time
/ 1000000,
2175 (long int) ts
->stop_time
% 1000000);
2176 ui_out_field_string (uiout
, "stop-time", buf
);
2180 /* This function handles the details of what to do about an ongoing
2181 tracing run if the user has asked to detach or otherwise disconnect
2184 disconnect_tracing (int from_tty
)
2186 /* It can happen that the target that was tracing went away on its
2187 own, and we didn't notice. Get a status update, and if the
2188 current target doesn't even do tracing, then assume it's not
2190 if (target_get_trace_status (current_trace_status ()) < 0)
2191 current_trace_status ()->running
= 0;
2193 /* If running interactively, give the user the option to cancel and
2194 then decide what to do differently with the run. Scripts are
2195 just going to disconnect and let the target deal with it,
2196 according to how it's been instructed previously via
2197 disconnected-tracing. */
2198 if (current_trace_status ()->running
&& from_tty
)
2200 process_tracepoint_on_disconnect ();
2202 if (current_trace_status ()->disconnected_tracing
)
2204 if (!query (_("Trace is running and will "
2205 "continue after detach; detach anyway? ")))
2206 error (_("Not confirmed."));
2210 if (!query (_("Trace is running but will "
2211 "stop on detach; detach anyway? ")))
2212 error (_("Not confirmed."));
2216 /* Also we want to be out of tfind mode, otherwise things can get
2217 confusing upon reconnection. Just use these calls instead of
2218 full tfind_1 behavior because we're in the middle of detaching,
2219 and there's no point to updating current stack frame etc. */
2220 set_current_traceframe (-1);
2221 set_tracepoint_num (-1);
2222 set_traceframe_context (NULL
);
2225 /* Worker function for the various flavors of the tfind command. */
2227 tfind_1 (enum trace_find_type type
, int num
,
2228 ULONGEST addr1
, ULONGEST addr2
,
2231 int target_frameno
= -1, target_tracept
= -1;
2232 struct frame_id old_frame_id
= null_frame_id
;
2233 struct tracepoint
*tp
;
2234 struct ui_out
*uiout
= current_uiout
;
2236 /* Only try to get the current stack frame if we have a chance of
2237 succeeding. In particular, if we're trying to get a first trace
2238 frame while all threads are running, it's not going to succeed,
2239 so leave it with a default value and let the frame comparison
2240 below (correctly) decide to print out the source location of the
2242 if (!(type
== tfind_number
&& num
== -1)
2243 && (has_stack_frames () || traceframe_number
>= 0))
2244 old_frame_id
= get_frame_id (get_current_frame ());
2246 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2249 if (type
== tfind_number
2251 && target_frameno
== -1)
2253 /* We told the target to get out of tfind mode, and it did. */
2255 else if (target_frameno
== -1)
2257 /* A request for a non-existent trace frame has failed.
2258 Our response will be different, depending on FROM_TTY:
2260 If FROM_TTY is true, meaning that this command was
2261 typed interactively by the user, then give an error
2262 and DO NOT change the state of traceframe_number etc.
2264 However if FROM_TTY is false, meaning that we're either
2265 in a script, a loop, or a user-defined command, then
2266 DON'T give an error, but DO change the state of
2267 traceframe_number etc. to invalid.
2269 The rationalle is that if you typed the command, you
2270 might just have committed a typo or something, and you'd
2271 like to NOT lose your current debugging state. However
2272 if you're in a user-defined command or especially in a
2273 loop, then you need a way to detect that the command
2274 failed WITHOUT aborting. This allows you to write
2275 scripts that search thru the trace buffer until the end,
2276 and then continue on to do something else. */
2279 error (_("Target failed to find requested trace frame."));
2283 printf_filtered ("End of trace buffer.\n");
2284 #if 0 /* dubious now? */
2285 /* The following will not recurse, since it's
2287 trace_find_command ("-1", from_tty
);
2292 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2294 reinit_frame_cache ();
2295 target_dcache_invalidate ();
2297 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2299 if (target_frameno
!= get_traceframe_number ())
2300 observer_notify_traceframe_changed (target_frameno
, tracepoint_number
);
2302 set_current_traceframe (target_frameno
);
2304 if (target_frameno
== -1)
2305 set_traceframe_context (NULL
);
2307 set_traceframe_context (get_current_frame ());
2309 if (traceframe_number
>= 0)
2311 /* Use different branches for MI and CLI to make CLI messages
2313 if (ui_out_is_mi_like_p (uiout
))
2315 ui_out_field_string (uiout
, "found", "1");
2316 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2317 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2321 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2322 traceframe_number
, tracepoint_number
);
2327 if (ui_out_is_mi_like_p (uiout
))
2328 ui_out_field_string (uiout
, "found", "0");
2329 else if (type
== tfind_number
&& num
== -1)
2330 printf_unfiltered (_("No longer looking at any trace frame\n"));
2331 else /* This case may never occur, check. */
2332 printf_unfiltered (_("No trace frame found\n"));
2335 /* If we're in nonstop mode and getting out of looking at trace
2336 frames, there won't be any current frame to go back to and
2339 && (has_stack_frames () || traceframe_number
>= 0))
2341 enum print_what print_what
;
2343 /* NOTE: in imitation of the step command, try to determine
2344 whether we have made a transition from one function to
2345 another. If so, we'll print the "stack frame" (ie. the new
2346 function and it's arguments) -- otherwise we'll just show the
2349 if (frame_id_eq (old_frame_id
,
2350 get_frame_id (get_current_frame ())))
2351 print_what
= SRC_LINE
;
2353 print_what
= SRC_AND_LOC
;
2355 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2360 /* trace_find_command takes a trace frame number n,
2361 sends "QTFrame:<n>" to the target,
2362 and accepts a reply that may contain several optional pieces
2363 of information: a frame number, a tracepoint number, and an
2364 indication of whether this is a trap frame or a stepping frame.
2366 The minimal response is just "OK" (which indicates that the
2367 target does not give us a frame number or a tracepoint number).
2368 Instead of that, the target may send us a string containing
2370 F<hexnum> (gives the selected frame number)
2371 T<hexnum> (gives the selected tracepoint number)
2376 trace_find_command (char *args
, int from_tty
)
2377 { /* This should only be called with a numeric argument. */
2380 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2381 error (_("May not look at trace frames while trace is running."));
2383 if (args
== 0 || *args
== 0)
2384 { /* TFIND with no args means find NEXT trace frame. */
2385 if (traceframe_number
== -1)
2386 frameno
= 0; /* "next" is first one. */
2388 frameno
= traceframe_number
+ 1;
2390 else if (0 == strcmp (args
, "-"))
2392 if (traceframe_number
== -1)
2393 error (_("not debugging trace buffer"));
2394 else if (from_tty
&& traceframe_number
== 0)
2395 error (_("already at start of trace buffer"));
2397 frameno
= traceframe_number
- 1;
2399 /* A hack to work around eval's need for fp to have been collected. */
2400 else if (0 == strcmp (args
, "-1"))
2403 frameno
= parse_and_eval_long (args
);
2406 error (_("invalid input (%d is less than zero)"), frameno
);
2408 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2413 trace_find_end_command (char *args
, int from_tty
)
2415 trace_find_command ("-1", from_tty
);
2420 trace_find_start_command (char *args
, int from_tty
)
2422 trace_find_command ("0", from_tty
);
2425 /* tfind pc command */
2427 trace_find_pc_command (char *args
, int from_tty
)
2431 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2432 error (_("May not look at trace frames while trace is running."));
2434 if (args
== 0 || *args
== 0)
2435 pc
= regcache_read_pc (get_current_regcache ());
2437 pc
= parse_and_eval_address (args
);
2439 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2442 /* tfind tracepoint command */
2444 trace_find_tracepoint_command (char *args
, int from_tty
)
2447 struct tracepoint
*tp
;
2449 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2450 error (_("May not look at trace frames while trace is running."));
2452 if (args
== 0 || *args
== 0)
2454 if (tracepoint_number
== -1)
2455 error (_("No current tracepoint -- please supply an argument."));
2457 tdp
= tracepoint_number
; /* Default is current TDP. */
2460 tdp
= parse_and_eval_long (args
);
2462 /* If we have the tracepoint on hand, use the number that the
2463 target knows about (which may be different if we disconnected
2464 and reconnected). */
2465 tp
= get_tracepoint (tdp
);
2467 tdp
= tp
->number_on_target
;
2469 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2472 /* TFIND LINE command:
2474 This command will take a sourceline for argument, just like BREAK
2475 or TRACE (ie. anything that "decode_line_1" can handle).
2477 With no argument, this command will find the next trace frame
2478 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2481 trace_find_line_command (char *args
, int from_tty
)
2483 static CORE_ADDR start_pc
, end_pc
;
2484 struct symtabs_and_lines sals
;
2485 struct symtab_and_line sal
;
2486 struct cleanup
*old_chain
;
2488 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2489 error (_("May not look at trace frames while trace is running."));
2491 if (args
== 0 || *args
== 0)
2493 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2495 sals
.sals
= (struct symtab_and_line
*)
2496 xmalloc (sizeof (struct symtab_and_line
));
2501 sals
= decode_line_with_current_source (args
, DECODE_LINE_FUNFIRSTLINE
);
2505 old_chain
= make_cleanup (xfree
, sals
.sals
);
2506 if (sal
.symtab
== 0)
2507 error (_("No line number information available."));
2509 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2511 if (start_pc
== end_pc
)
2513 printf_filtered ("Line %d of \"%s\"",
2514 sal
.line
, sal
.symtab
->filename
);
2516 printf_filtered (" is at address ");
2517 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2519 printf_filtered (" but contains no code.\n");
2520 sal
= find_pc_line (start_pc
, 0);
2522 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2523 && start_pc
!= end_pc
)
2524 printf_filtered ("Attempting to find line %d instead.\n",
2527 error (_("Cannot find a good line."));
2531 /* Is there any case in which we get here, and have an address
2532 which the user would want to see? If we have debugging
2533 symbols and no line numbers? */
2534 error (_("Line number %d is out of range for \"%s\"."),
2535 sal
.line
, sal
.symtab
->filename
);
2537 /* Find within range of stated line. */
2539 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2541 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2542 do_cleanups (old_chain
);
2545 /* tfind range command */
2547 trace_find_range_command (char *args
, int from_tty
)
2549 static CORE_ADDR start
, stop
;
2552 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2553 error (_("May not look at trace frames while trace is running."));
2555 if (args
== 0 || *args
== 0)
2556 { /* XXX FIXME: what should default behavior be? */
2557 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2561 if (0 != (tmp
= strchr (args
, ',')))
2563 *tmp
++ = '\0'; /* Terminate start address. */
2564 while (isspace ((int) *tmp
))
2566 start
= parse_and_eval_address (args
);
2567 stop
= parse_and_eval_address (tmp
);
2570 { /* No explicit end address? */
2571 start
= parse_and_eval_address (args
);
2572 stop
= start
+ 1; /* ??? */
2575 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2578 /* tfind outside command */
2580 trace_find_outside_command (char *args
, int from_tty
)
2582 CORE_ADDR start
, stop
;
2585 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2586 error (_("May not look at trace frames while trace is running."));
2588 if (args
== 0 || *args
== 0)
2589 { /* XXX FIXME: what should default behavior be? */
2590 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2594 if (0 != (tmp
= strchr (args
, ',')))
2596 *tmp
++ = '\0'; /* Terminate start address. */
2597 while (isspace ((int) *tmp
))
2599 start
= parse_and_eval_address (args
);
2600 stop
= parse_and_eval_address (tmp
);
2603 { /* No explicit end address? */
2604 start
= parse_and_eval_address (args
);
2605 stop
= start
+ 1; /* ??? */
2608 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2611 /* info scope command: list the locals for a scope. */
2613 scope_info (char *args
, int from_tty
)
2615 struct symtabs_and_lines sals
;
2617 struct minimal_symbol
*msym
;
2618 struct block
*block
;
2619 const char *symname
;
2620 char *save_args
= args
;
2621 struct block_iterator iter
;
2623 struct gdbarch
*gdbarch
;
2626 if (args
== 0 || *args
== 0)
2627 error (_("requires an argument (function, "
2628 "line or *addr) to define a scope"));
2630 sals
= decode_line_1 (&args
, DECODE_LINE_FUNFIRSTLINE
, NULL
, 0);
2631 if (sals
.nelts
== 0)
2632 return; /* Presumably decode_line_1 has already warned. */
2634 /* Resolve line numbers to PC. */
2635 resolve_sal_pc (&sals
.sals
[0]);
2636 block
= block_for_pc (sals
.sals
[0].pc
);
2640 QUIT
; /* Allow user to bail out with ^C. */
2641 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2643 QUIT
; /* Allow user to bail out with ^C. */
2645 printf_filtered ("Scope for %s:\n", save_args
);
2648 symname
= SYMBOL_PRINT_NAME (sym
);
2649 if (symname
== NULL
|| *symname
== '\0')
2650 continue; /* Probably botched, certainly useless. */
2652 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2654 printf_filtered ("Symbol %s is ", symname
);
2655 switch (SYMBOL_CLASS (sym
))
2658 case LOC_UNDEF
: /* Messed up symbol? */
2659 printf_filtered ("a bogus symbol, class %d.\n",
2660 SYMBOL_CLASS (sym
));
2661 count
--; /* Don't count this one. */
2664 printf_filtered ("a constant with value %s (%s)",
2665 plongest (SYMBOL_VALUE (sym
)),
2666 hex_string (SYMBOL_VALUE (sym
)));
2668 case LOC_CONST_BYTES
:
2669 printf_filtered ("constant bytes: ");
2670 if (SYMBOL_TYPE (sym
))
2671 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2672 fprintf_filtered (gdb_stdout
, " %02x",
2673 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2676 printf_filtered ("in static storage at address ");
2677 printf_filtered ("%s", paddress (gdbarch
,
2678 SYMBOL_VALUE_ADDRESS (sym
)));
2681 /* GDBARCH is the architecture associated with the objfile
2682 the symbol is defined in; the target architecture may be
2683 different, and may provide additional registers. However,
2684 we do not know the target architecture at this point.
2685 We assume the objfile architecture will contain all the
2686 standard registers that occur in debug info in that
2688 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2691 if (SYMBOL_IS_ARGUMENT (sym
))
2692 printf_filtered ("an argument in register $%s",
2693 gdbarch_register_name (gdbarch
, regno
));
2695 printf_filtered ("a local variable in register $%s",
2696 gdbarch_register_name (gdbarch
, regno
));
2699 printf_filtered ("an argument at stack/frame offset %s",
2700 plongest (SYMBOL_VALUE (sym
)));
2703 printf_filtered ("a local variable at frame offset %s",
2704 plongest (SYMBOL_VALUE (sym
)));
2707 printf_filtered ("a reference argument at offset %s",
2708 plongest (SYMBOL_VALUE (sym
)));
2710 case LOC_REGPARM_ADDR
:
2711 /* Note comment at LOC_REGISTER. */
2712 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2714 printf_filtered ("the address of an argument, in register $%s",
2715 gdbarch_register_name (gdbarch
, regno
));
2718 printf_filtered ("a typedef.\n");
2721 printf_filtered ("a label at address ");
2722 printf_filtered ("%s", paddress (gdbarch
,
2723 SYMBOL_VALUE_ADDRESS (sym
)));
2726 printf_filtered ("a function at address ");
2727 printf_filtered ("%s",
2728 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2730 case LOC_UNRESOLVED
:
2731 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2734 printf_filtered ("Unresolved Static");
2737 printf_filtered ("static storage at address ");
2738 printf_filtered ("%s",
2739 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2742 case LOC_OPTIMIZED_OUT
:
2743 printf_filtered ("optimized out.\n");
2746 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2747 BLOCK_START (block
),
2751 if (SYMBOL_TYPE (sym
))
2752 printf_filtered (", length %d.\n",
2753 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2755 if (BLOCK_FUNCTION (block
))
2758 block
= BLOCK_SUPERBLOCK (block
);
2761 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2765 /* worker function (cleanup) */
2767 replace_comma (void *data
)
2774 /* Helper for trace_dump_command. Dump the action list starting at
2775 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2776 actions of the body of a while-stepping action. STEPPING_FRAME is
2777 set if the current traceframe was determined to be a while-stepping
2781 trace_dump_actions (struct command_line
*action
,
2782 int stepping_actions
, int stepping_frame
,
2785 char *action_exp
, *next_comma
;
2787 for (; action
!= NULL
; action
= action
->next
)
2789 struct cmd_list_element
*cmd
;
2791 QUIT
; /* Allow user to bail out with ^C. */
2792 action_exp
= action
->line
;
2793 while (isspace ((int) *action_exp
))
2796 /* The collection actions to be done while stepping are
2797 bracketed by the commands "while-stepping" and "end". */
2799 if (*action_exp
== '#') /* comment line */
2802 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2804 error (_("Bad action list item: %s"), action_exp
);
2806 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2810 for (i
= 0; i
< action
->body_count
; ++i
)
2811 trace_dump_actions (action
->body_list
[i
],
2812 1, stepping_frame
, from_tty
);
2814 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2816 /* Display the collected data.
2817 For the trap frame, display only what was collected at
2818 the trap. Likewise for stepping frames, display only
2819 what was collected while stepping. This means that the
2820 two boolean variables, STEPPING_FRAME and
2821 STEPPING_ACTIONS should be equal. */
2822 if (stepping_frame
== stepping_actions
)
2824 if (*action_exp
== '/')
2825 action_exp
= decode_agent_options (action_exp
);
2828 { /* Repeat over a comma-separated list. */
2829 QUIT
; /* Allow user to bail out with ^C. */
2830 if (*action_exp
== ',')
2832 while (isspace ((int) *action_exp
))
2835 next_comma
= strchr (action_exp
, ',');
2837 if (0 == strncasecmp (action_exp
, "$reg", 4))
2838 registers_info (NULL
, from_tty
);
2839 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2841 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2842 locals_info (NULL
, from_tty
);
2843 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2844 args_info (NULL
, from_tty
);
2849 make_cleanup (replace_comma
, next_comma
);
2852 printf_filtered ("%s = ", action_exp
);
2853 output_command (action_exp
, from_tty
);
2854 printf_filtered ("\n");
2858 action_exp
= next_comma
;
2860 while (action_exp
&& *action_exp
== ',');
2866 /* The tdump command. */
2869 trace_dump_command (char *args
, int from_tty
)
2871 struct regcache
*regcache
;
2872 struct tracepoint
*t
;
2873 int stepping_frame
= 0;
2874 struct bp_location
*loc
;
2875 char *line
, *default_collect_line
= NULL
;
2876 struct command_line
*actions
, *default_collect_action
= NULL
;
2877 struct cleanup
*old_chain
= NULL
;
2879 if (tracepoint_number
== -1)
2881 warning (_("No current trace frame."));
2885 t
= get_tracepoint (tracepoint_number
);
2888 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2891 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2892 tracepoint_number
, traceframe_number
);
2894 /* The current frame is a trap frame if the frame PC is equal
2895 to the tracepoint PC. If not, then the current frame was
2896 collected during single-stepping. */
2898 regcache
= get_current_regcache ();
2900 /* If the traceframe's address matches any of the tracepoint's
2901 locations, assume it is a direct hit rather than a while-stepping
2902 frame. (FIXME this is not reliable, should record each frame's
2905 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
2906 if (loc
->address
== regcache_read_pc (regcache
))
2909 actions
= breakpoint_commands (&t
->base
);
2911 /* If there is a default-collect list, make up a collect command,
2912 prepend to the tracepoint's commands, and pass the whole mess to
2913 the trace dump scanner. We need to validate because
2914 default-collect might have been junked since the trace run. */
2915 if (*default_collect
)
2917 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2918 old_chain
= make_cleanup (xfree
, default_collect_line
);
2919 line
= default_collect_line
;
2920 validate_actionline (&line
, &t
->base
);
2921 default_collect_action
= xmalloc (sizeof (struct command_line
));
2922 make_cleanup (xfree
, default_collect_action
);
2923 default_collect_action
->next
= actions
;
2924 default_collect_action
->line
= line
;
2925 actions
= default_collect_action
;
2928 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2930 if (*default_collect
)
2931 do_cleanups (old_chain
);
2934 /* Encode a piece of a tracepoint's source-level definition in a form
2935 that is suitable for both protocol and saving in files. */
2936 /* This version does not do multiple encodes for long strings; it should
2937 return an offset to the next piece to encode. FIXME */
2940 encode_source_string (int tpnum
, ULONGEST addr
,
2941 char *srctype
, char *src
, char *buf
, int buf_size
)
2943 if (80 + strlen (srctype
) > buf_size
)
2944 error (_("Buffer too small for source encoding"));
2945 sprintf (buf
, "%x:%s:%s:%x:%x:",
2946 tpnum
, phex_nz (addr
, sizeof (addr
)),
2947 srctype
, 0, (int) strlen (src
));
2948 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2949 error (_("Source string too long for buffer"));
2950 bin2hex (src
, buf
+ strlen (buf
), 0);
2954 extern int trace_regblock_size
;
2956 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2957 non-zero, the save is performed on the target, otherwise GDB obtains all
2958 trace data and saves it locally. */
2961 trace_save (const char *filename
, int target_does_save
)
2963 struct cleanup
*cleanup
;
2965 struct trace_status
*ts
= current_trace_status ();
2968 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2969 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2973 ULONGEST offset
= 0;
2974 #define MAX_TRACE_UPLOAD 2000
2975 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2978 /* If the target is to save the data to a file on its own, then just
2979 send the command and be done with it. */
2980 if (target_does_save
)
2982 err
= target_save_trace_data (filename
);
2984 error (_("Target failed to save trace data to '%s'."),
2989 /* Get the trace status first before opening the file, so if the
2990 target is losing, we can get out without touching files. */
2991 status
= target_get_trace_status (ts
);
2993 pathname
= tilde_expand (filename
);
2994 cleanup
= make_cleanup (xfree
, pathname
);
2996 fp
= fopen (pathname
, "wb");
2998 error (_("Unable to open file '%s' for saving trace data (%s)"),
2999 filename
, safe_strerror (errno
));
3000 make_cleanup_fclose (fp
);
3002 /* Write a file header, with a high-bit-set char to indicate a
3003 binary file, plus a hint as what this file is, and a version
3004 number in case of future needs. */
3005 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
3007 perror_with_name (pathname
);
3009 /* Write descriptive info. */
3011 /* Write out the size of a register block. */
3012 fprintf (fp
, "R %x\n", trace_regblock_size
);
3014 /* Write out status of the tracing run (aka "tstatus" info). */
3015 fprintf (fp
, "status %c;%s",
3016 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
3017 if (ts
->stop_reason
== tracepoint_error
)
3019 char *buf
= (char *) alloca (strlen (ts
->stop_desc
) * 2 + 1);
3021 bin2hex ((gdb_byte
*) ts
->stop_desc
, buf
, 0);
3022 fprintf (fp
, ":%s", buf
);
3024 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
3025 if (ts
->traceframe_count
>= 0)
3026 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
3027 if (ts
->traceframes_created
>= 0)
3028 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
3029 if (ts
->buffer_free
>= 0)
3030 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
3031 if (ts
->buffer_size
>= 0)
3032 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
3033 if (ts
->disconnected_tracing
)
3034 fprintf (fp
, ";disconn:%x", ts
->disconnected_tracing
);
3035 if (ts
->circular_buffer
)
3036 fprintf (fp
, ";circular:%x", ts
->circular_buffer
);
3039 /* Note that we want to upload tracepoints and save those, rather
3040 than simply writing out the local ones, because the user may have
3041 changed tracepoints in GDB in preparation for a future tracing
3042 run, or maybe just mass-deleted all types of breakpoints as part
3043 of cleaning up. So as not to contaminate the session, leave the
3044 data in its uploaded form, don't make into real tracepoints. */
3046 /* Get trace state variables first, they may be checked when parsing
3047 uploaded commands. */
3049 target_upload_trace_state_variables (&uploaded_tsvs
);
3051 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3057 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
3058 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
3061 fprintf (fp
, "tsv %x:%s:%x:%s\n",
3062 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
3063 utsv
->builtin
, buf
);
3069 free_uploaded_tsvs (&uploaded_tsvs
);
3071 target_upload_tracepoints (&uploaded_tps
);
3073 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3074 target_get_tracepoint_status (NULL
, utp
);
3076 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3078 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
3079 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3080 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
3081 if (utp
->type
== bp_fast_tracepoint
)
3082 fprintf (fp
, ":F%x", utp
->orig_size
);
3084 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
3087 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
3088 fprintf (fp
, "tp A%x:%s:%s\n",
3089 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3090 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
3091 fprintf (fp
, "tp S%x:%s:%s\n",
3092 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3095 encode_source_string (utp
->number
, utp
->addr
,
3096 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
3097 fprintf (fp
, "tp Z%s\n", buf
);
3099 if (utp
->cond_string
)
3101 encode_source_string (utp
->number
, utp
->addr
,
3102 "cond", utp
->cond_string
,
3103 buf
, MAX_TRACE_UPLOAD
);
3104 fprintf (fp
, "tp Z%s\n", buf
);
3106 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
3108 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
3109 buf
, MAX_TRACE_UPLOAD
);
3110 fprintf (fp
, "tp Z%s\n", buf
);
3112 fprintf (fp
, "tp V%x:%s:%x:%s\n",
3113 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3115 phex_nz (utp
->traceframe_usage
,
3116 sizeof (utp
->traceframe_usage
)));
3119 free_uploaded_tps (&uploaded_tps
);
3121 /* Mark the end of the definition section. */
3124 /* Get and write the trace data proper. We ask for big blocks, in
3125 the hopes of efficiency, but will take less if the target has
3126 packet size limitations or some such. */
3129 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
3131 error (_("Failure to get requested trace buffer data"));
3132 /* No more data is forthcoming, we're done. */
3135 written
= fwrite (buf
, gotten
, 1, fp
);
3137 perror_with_name (pathname
);
3141 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
3142 written
= fwrite (&gotten
, 4, 1, fp
);
3144 perror_with_name (pathname
);
3146 do_cleanups (cleanup
);
3150 trace_save_command (char *args
, int from_tty
)
3152 int target_does_save
= 0;
3154 char *filename
= NULL
;
3155 struct cleanup
*back_to
;
3158 error_no_arg (_("file in which to save trace data"));
3160 argv
= gdb_buildargv (args
);
3161 back_to
= make_cleanup_freeargv (argv
);
3163 for (; *argv
; ++argv
)
3165 if (strcmp (*argv
, "-r") == 0)
3166 target_does_save
= 1;
3167 else if (**argv
== '-')
3168 error (_("unknown option `%s'"), *argv
);
3174 error_no_arg (_("file in which to save trace data"));
3176 trace_save (filename
, target_does_save
);
3179 printf_filtered (_("Trace data saved to file '%s'.\n"), filename
);
3181 do_cleanups (back_to
);
3184 /* Tell the target what to do with an ongoing tracing run if GDB
3185 disconnects for some reason. */
3188 set_disconnected_tracing (char *args
, int from_tty
,
3189 struct cmd_list_element
*c
)
3191 target_set_disconnected_tracing (disconnected_tracing
);
3195 set_circular_trace_buffer (char *args
, int from_tty
,
3196 struct cmd_list_element
*c
)
3198 target_set_circular_trace_buffer (circular_trace_buffer
);
3202 set_trace_user (char *args
, int from_tty
,
3203 struct cmd_list_element
*c
)
3207 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3210 warning (_("Target does not support trace notes, user ignored"));
3214 set_trace_notes (char *args
, int from_tty
,
3215 struct cmd_list_element
*c
)
3219 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3222 warning (_("Target does not support trace notes, note ignored"));
3226 set_trace_stop_notes (char *args
, int from_tty
,
3227 struct cmd_list_element
*c
)
3231 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3234 warning (_("Target does not support trace notes, stop note ignored"));
3237 /* Convert the memory pointed to by mem into hex, placing result in buf.
3238 * Return a pointer to the last char put in buf (null)
3239 * "stolen" from sparc-stub.c
3242 static const char hexchars
[] = "0123456789abcdef";
3245 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3253 *buf
++ = hexchars
[ch
>> 4];
3254 *buf
++ = hexchars
[ch
& 0xf];
3263 get_traceframe_number (void)
3265 return traceframe_number
;
3268 /* Make the traceframe NUM be the current trace frame. Does nothing
3269 if NUM is already current. */
3272 set_current_traceframe (int num
)
3276 if (traceframe_number
== num
)
3278 /* Nothing to do. */
3282 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3285 warning (_("could not change traceframe"));
3287 set_traceframe_num (newnum
);
3289 /* Changing the traceframe changes our view of registers and of the
3291 registers_changed ();
3293 clear_traceframe_info ();
3296 /* Make the traceframe NUM be the current trace frame, and do nothing
3300 set_traceframe_number (int num
)
3302 traceframe_number
= num
;
3305 /* A cleanup used when switching away and back from tfind mode. */
3307 struct current_traceframe_cleanup
3309 /* The traceframe we were inspecting. */
3310 int traceframe_number
;
3314 do_restore_current_traceframe_cleanup (void *arg
)
3316 struct current_traceframe_cleanup
*old
= arg
;
3318 set_current_traceframe (old
->traceframe_number
);
3322 restore_current_traceframe_cleanup_dtor (void *arg
)
3324 struct current_traceframe_cleanup
*old
= arg
;
3330 make_cleanup_restore_current_traceframe (void)
3332 struct current_traceframe_cleanup
*old
;
3334 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3335 old
->traceframe_number
= traceframe_number
;
3337 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3338 restore_current_traceframe_cleanup_dtor
);
3342 make_cleanup_restore_traceframe_number (void)
3344 return make_cleanup_restore_integer (&traceframe_number
);
3347 /* Given a number and address, return an uploaded tracepoint with that
3348 number, creating if necessary. */
3350 struct uploaded_tp
*
3351 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3353 struct uploaded_tp
*utp
;
3355 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3356 if (utp
->number
== num
&& utp
->addr
== addr
)
3358 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3359 memset (utp
, 0, sizeof (struct uploaded_tp
));
3362 utp
->actions
= NULL
;
3363 utp
->step_actions
= NULL
;
3364 utp
->cmd_strings
= NULL
;
3371 free_uploaded_tps (struct uploaded_tp
**utpp
)
3373 struct uploaded_tp
*next_one
;
3377 next_one
= (*utpp
)->next
;
3383 /* Given a number and address, return an uploaded tracepoint with that
3384 number, creating if necessary. */
3386 static struct uploaded_tsv
*
3387 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3389 struct uploaded_tsv
*utsv
;
3391 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3392 if (utsv
->number
== num
)
3394 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3395 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3397 utsv
->next
= *utsvp
;
3403 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3405 struct uploaded_tsv
*next_one
;
3409 next_one
= (*utsvp
)->next
;
3415 /* FIXME this function is heuristic and will miss the cases where the
3416 conditional is semantically identical but differs in whitespace,
3417 such as "x == 0" vs "x==0". */
3420 cond_string_is_same (char *str1
, char *str2
)
3422 if (str1
== NULL
|| str2
== NULL
)
3423 return (str1
== str2
);
3425 return (strcmp (str1
, str2
) == 0);
3428 /* Look for an existing tracepoint that seems similar enough to the
3429 uploaded one. Enablement isn't compared, because the user can
3430 toggle that freely, and may have done so in anticipation of the
3431 next trace run. Return the location of matched tracepoint. */
3433 static struct bp_location
*
3434 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3436 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3438 struct breakpoint
*b
;
3439 struct bp_location
*loc
;
3441 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3443 struct tracepoint
*t
= (struct tracepoint
*) b
;
3445 if (b
->type
== utp
->type
3446 && t
->step_count
== utp
->step
3447 && t
->pass_count
== utp
->pass
3448 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3449 /* FIXME also test actions. */
3452 /* Scan the locations for an address match. */
3453 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3455 if (loc
->address
== utp
->addr
)
3463 /* Given a list of tracepoints uploaded from a target, attempt to
3464 match them up with existing tracepoints, and create new ones if not
3468 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3470 struct uploaded_tp
*utp
;
3472 /* Look for GDB tracepoints that match up with our uploaded versions. */
3473 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3475 struct bp_location
*loc
;
3476 struct tracepoint
*t
;
3478 loc
= find_matching_tracepoint_location (utp
);
3481 /* Mark this location as already inserted. */
3483 t
= (struct tracepoint
*) loc
->owner
;
3484 printf_filtered (_("Assuming tracepoint %d is same "
3485 "as target's tracepoint %d at %s.\n"),
3486 loc
->owner
->number
, utp
->number
,
3487 paddress (loc
->gdbarch
, utp
->addr
));
3491 t
= create_tracepoint_from_upload (utp
);
3493 printf_filtered (_("Created tracepoint %d for "
3494 "target's tracepoint %d at %s.\n"),
3495 t
->base
.number
, utp
->number
,
3496 paddress (get_current_arch (), utp
->addr
));
3498 printf_filtered (_("Failed to create tracepoint for target's "
3499 "tracepoint %d at %s, skipping it.\n"),
3501 paddress (get_current_arch (), utp
->addr
));
3503 /* Whether found or created, record the number used by the
3504 target, to help with mapping target tracepoints back to their
3505 counterparts here. */
3507 t
->number_on_target
= utp
->number
;
3510 free_uploaded_tps (uploaded_tps
);
3513 /* Trace state variables don't have much to identify them beyond their
3514 name, so just use that to detect matches. */
3516 static struct trace_state_variable
*
3517 find_matching_tsv (struct uploaded_tsv
*utsv
)
3522 return find_trace_state_variable (utsv
->name
);
3525 static struct trace_state_variable
*
3526 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3528 const char *namebase
;
3531 struct trace_state_variable
*tsv
;
3532 struct cleanup
*old_chain
;
3536 namebase
= utsv
->name
;
3537 buf
= xstrprintf ("%s", namebase
);
3542 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3545 /* Fish for a name that is not in use. */
3546 /* (should check against all internal vars?) */
3547 while (find_trace_state_variable (buf
))
3550 buf
= xstrprintf ("%s_%d", namebase
, try_num
++);
3553 old_chain
= make_cleanup (xfree
, buf
);
3555 /* We have an available name, create the variable. */
3556 tsv
= create_trace_state_variable (buf
);
3557 tsv
->initial_value
= utsv
->initial_value
;
3558 tsv
->builtin
= utsv
->builtin
;
3560 observer_notify_tsv_created (tsv
->name
, tsv
->initial_value
);
3562 do_cleanups (old_chain
);
3567 /* Given a list of uploaded trace state variables, try to match them
3568 up with existing variables, or create additional ones. */
3571 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3574 struct uploaded_tsv
*utsv
;
3575 struct trace_state_variable
*tsv
;
3578 /* Most likely some numbers will have to be reassigned as part of
3579 the merge, so clear them all in anticipation. */
3580 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3583 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3585 tsv
= find_matching_tsv (utsv
);
3589 printf_filtered (_("Assuming trace state variable $%s "
3590 "is same as target's variable %d.\n"),
3591 tsv
->name
, utsv
->number
);
3595 tsv
= create_tsv_from_upload (utsv
);
3597 printf_filtered (_("Created trace state variable "
3598 "$%s for target's variable %d.\n"),
3599 tsv
->name
, utsv
->number
);
3601 /* Give precedence to numberings that come from the target. */
3603 tsv
->number
= utsv
->number
;
3606 /* Renumber everything that didn't get a target-assigned number. */
3608 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3609 if (tsv
->number
> highest
)
3610 highest
= tsv
->number
;
3613 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3614 if (tsv
->number
== 0)
3615 tsv
->number
= highest
++;
3617 free_uploaded_tsvs (uploaded_tsvs
);
3620 /* target tfile command */
3622 static struct target_ops tfile_ops
;
3624 /* Fill in tfile_ops with its defined operations and properties. */
3626 #define TRACE_HEADER_SIZE 8
3628 static char *trace_filename
;
3629 static int trace_fd
= -1;
3630 static off_t trace_frames_offset
;
3631 static off_t cur_offset
;
3632 static int cur_data_size
;
3633 int trace_regblock_size
;
3635 static void tfile_interp_line (char *line
,
3636 struct uploaded_tp
**utpp
,
3637 struct uploaded_tsv
**utsvp
);
3639 /* Read SIZE bytes into READBUF from the trace frame, starting at
3640 TRACE_FD's current position. Note that this call `read'
3641 underneath, hence it advances the file's seek position. Throws an
3642 error if the `read' syscall fails, or less than SIZE bytes are
3646 tfile_read (gdb_byte
*readbuf
, int size
)
3650 gotten
= read (trace_fd
, readbuf
, size
);
3652 perror_with_name (trace_filename
);
3653 else if (gotten
< size
)
3654 error (_("Premature end of file while reading trace file"));
3658 tfile_open (char *filename
, int from_tty
)
3660 volatile struct gdb_exception ex
;
3662 struct cleanup
*old_chain
;
3665 char header
[TRACE_HEADER_SIZE
];
3666 char linebuf
[1000]; /* Should be max remote packet size or so. */
3669 struct trace_status
*ts
;
3670 struct uploaded_tp
*uploaded_tps
= NULL
;
3671 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3673 target_preopen (from_tty
);
3675 error (_("No trace file specified."));
3677 filename
= tilde_expand (filename
);
3678 if (!IS_ABSOLUTE_PATH(filename
))
3680 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
3685 old_chain
= make_cleanup (xfree
, filename
);
3687 flags
= O_BINARY
| O_LARGEFILE
;
3689 scratch_chan
= open (filename
, flags
, 0);
3690 if (scratch_chan
< 0)
3691 perror_with_name (filename
);
3693 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3695 discard_cleanups (old_chain
); /* Don't free filename any more. */
3696 unpush_target (&tfile_ops
);
3698 trace_filename
= xstrdup (filename
);
3699 trace_fd
= scratch_chan
;
3702 /* Read the file header and test for validity. */
3703 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
3705 bytes
+= TRACE_HEADER_SIZE
;
3706 if (!(header
[0] == 0x7f
3707 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3708 error (_("File is not a valid trace file."));
3710 push_target (&tfile_ops
);
3712 trace_regblock_size
= 0;
3713 ts
= current_trace_status ();
3714 /* We know we're working with a file. */
3716 /* Set defaults in case there is no status line. */
3717 ts
->running_known
= 0;
3718 ts
->stop_reason
= trace_stop_reason_unknown
;
3719 ts
->traceframe_count
= -1;
3720 ts
->buffer_free
= 0;
3721 ts
->disconnected_tracing
= 0;
3722 ts
->circular_buffer
= 0;
3724 TRY_CATCH (ex
, RETURN_MASK_ALL
)
3726 /* Read through a section of newline-terminated lines that
3727 define things like tracepoints. */
3731 tfile_read (&byte
, 1);
3736 /* Empty line marks end of the definition section. */
3741 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3744 linebuf
[i
++] = byte
;
3746 error (_("Excessively long lines in trace file"));
3749 /* Record the starting offset of the binary trace data. */
3750 trace_frames_offset
= bytes
;
3752 /* If we don't have a blocksize, we can't interpret the
3754 if (trace_regblock_size
== 0)
3755 error (_("No register block size recorded in trace file"));
3759 /* Pop the partially set up target. */
3761 throw_exception (ex
);
3764 inferior_appeared (current_inferior (), TFILE_PID
);
3765 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3766 add_thread_silent (inferior_ptid
);
3768 if (ts
->traceframe_count
<= 0)
3769 warning (_("No traceframes present in this file."));
3771 /* Add the file's tracepoints and variables into the current mix. */
3773 /* Get trace state variables first, they may be checked when parsing
3774 uploaded commands. */
3775 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3777 merge_uploaded_tracepoints (&uploaded_tps
);
3779 post_create_inferior (&tfile_ops
, from_tty
);
3782 /* Interpret the given line from the definitions part of the trace
3786 tfile_interp_line (char *line
,
3787 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3791 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3794 trace_regblock_size
= strtol (p
, &p
, 16);
3796 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3798 p
+= strlen ("status ");
3799 parse_trace_status (p
, current_trace_status ());
3801 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3803 p
+= strlen ("tp ");
3804 parse_tracepoint_definition (p
, utpp
);
3806 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3808 p
+= strlen ("tsv ");
3809 parse_tsv_definition (p
, utsvp
);
3812 warning (_("Ignoring trace file definition \"%s\""), line
);
3815 /* Parse the part of trace status syntax that is shared between
3816 the remote protocol and the trace file reader. */
3819 parse_trace_status (char *line
, struct trace_status
*ts
)
3821 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
3825 ts
->running_known
= 1;
3826 ts
->running
= (*p
++ == '1');
3827 ts
->stop_reason
= trace_stop_reason_unknown
;
3828 xfree (ts
->stop_desc
);
3829 ts
->stop_desc
= NULL
;
3830 ts
->traceframe_count
= -1;
3831 ts
->traceframes_created
= -1;
3832 ts
->buffer_free
= -1;
3833 ts
->buffer_size
= -1;
3834 ts
->disconnected_tracing
= 0;
3835 ts
->circular_buffer
= 0;
3836 xfree (ts
->user_name
);
3837 ts
->user_name
= NULL
;
3840 ts
->start_time
= ts
->stop_time
= 0;
3844 p1
= strchr (p
, ':');
3846 error (_("Malformed trace status, at %s\n\
3847 Status line: '%s'\n"), p
, line
);
3848 p3
= strchr (p
, ';');
3850 p3
= p
+ strlen (p
);
3851 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3853 p
= unpack_varlen_hex (++p1
, &val
);
3854 ts
->stop_reason
= trace_buffer_full
;
3856 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3858 p
= unpack_varlen_hex (++p1
, &val
);
3859 ts
->stop_reason
= trace_never_run
;
3861 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3864 p
= unpack_varlen_hex (++p1
, &val
);
3865 ts
->stop_reason
= tracepoint_passcount
;
3866 ts
->stopping_tracepoint
= val
;
3868 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3870 p2
= strchr (++p1
, ':');
3878 ts
->stop_desc
= xmalloc (strlen (line
));
3879 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
3880 ts
->stop_desc
[end
] = '\0';
3883 ts
->stop_desc
= xstrdup ("");
3885 p
= unpack_varlen_hex (++p2
, &val
);
3886 ts
->stop_reason
= tstop_command
;
3888 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3890 p
= unpack_varlen_hex (++p1
, &val
);
3891 ts
->stop_reason
= trace_disconnected
;
3893 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3895 p2
= strchr (++p1
, ':');
3898 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3899 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
3900 ts
->stop_desc
[end
] = '\0';
3903 ts
->stop_desc
= xstrdup ("");
3905 p
= unpack_varlen_hex (++p2
, &val
);
3906 ts
->stopping_tracepoint
= val
;
3907 ts
->stop_reason
= tracepoint_error
;
3909 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3911 p
= unpack_varlen_hex (++p1
, &val
);
3912 ts
->traceframe_count
= val
;
3914 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3916 p
= unpack_varlen_hex (++p1
, &val
);
3917 ts
->traceframes_created
= val
;
3919 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3921 p
= unpack_varlen_hex (++p1
, &val
);
3922 ts
->buffer_free
= val
;
3924 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3926 p
= unpack_varlen_hex (++p1
, &val
);
3927 ts
->buffer_size
= val
;
3929 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3931 p
= unpack_varlen_hex (++p1
, &val
);
3932 ts
->disconnected_tracing
= val
;
3934 else if (strncmp (p
, "circular", p1
- p
) == 0)
3936 p
= unpack_varlen_hex (++p1
, &val
);
3937 ts
->circular_buffer
= val
;
3939 else if (strncmp (p
, "starttime", p1
- p
) == 0)
3941 p
= unpack_varlen_hex (++p1
, &val
);
3942 ts
->start_time
= val
;
3944 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
3946 p
= unpack_varlen_hex (++p1
, &val
);
3947 ts
->stop_time
= val
;
3949 else if (strncmp (p
, "username", p1
- p
) == 0)
3952 ts
->user_name
= xmalloc (strlen (p
) / 2);
3953 end
= hex2bin (p1
, ts
->user_name
, (p3
- p1
) / 2);
3954 ts
->user_name
[end
] = '\0';
3957 else if (strncmp (p
, "notes", p1
- p
) == 0)
3960 ts
->notes
= xmalloc (strlen (p
) / 2);
3961 end
= hex2bin (p1
, ts
->notes
, (p3
- p1
) / 2);
3962 ts
->notes
[end
] = '\0';
3967 /* Silently skip unknown optional info. */
3968 p_temp
= strchr (p1
+ 1, ';');
3972 /* Must be at the end. */
3979 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
3980 struct uploaded_tp
*utp
)
3983 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
3985 p
= unpack_varlen_hex (p
, &uval
);
3987 tp
->base
.hit_count
+= uval
;
3989 utp
->hit_count
+= uval
;
3990 p
= unpack_varlen_hex (p
+ 1, &uval
);
3992 tp
->traceframe_usage
+= uval
;
3994 utp
->traceframe_usage
+= uval
;
3995 /* Ignore any extra, allowing for future extensions. */
3998 /* Given a line of text defining a part of a tracepoint, parse it into
3999 an "uploaded tracepoint". */
4002 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
4006 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
4009 char *cond
, *srctype
, *buf
;
4010 struct uploaded_tp
*utp
= NULL
;
4013 /* Both tracepoint and action definitions start with the same number
4014 and address sequence. */
4016 p
= unpack_varlen_hex (p
, &num
);
4017 p
++; /* skip a colon */
4018 p
= unpack_varlen_hex (p
, &addr
);
4019 p
++; /* skip a colon */
4022 enabled
= (*p
++ == 'E');
4023 p
++; /* skip a colon */
4024 p
= unpack_varlen_hex (p
, &step
);
4025 p
++; /* skip a colon */
4026 p
= unpack_varlen_hex (p
, &pass
);
4027 type
= bp_tracepoint
;
4029 /* Thumb through optional fields. */
4032 p
++; /* skip a colon */
4035 type
= bp_fast_tracepoint
;
4037 p
= unpack_varlen_hex (p
, &orig_size
);
4041 type
= bp_static_tracepoint
;
4047 p
= unpack_varlen_hex (p
, &xlen
);
4048 p
++; /* skip a comma */
4049 cond
= (char *) xmalloc (2 * xlen
+ 1);
4050 strncpy (cond
, p
, 2 * xlen
);
4051 cond
[2 * xlen
] = '\0';
4055 warning (_("Unrecognized char '%c' in tracepoint "
4056 "definition, skipping rest"), *p
);
4058 utp
= get_uploaded_tp (num
, addr
, utpp
);
4060 utp
->enabled
= enabled
;
4065 else if (piece
== 'A')
4067 utp
= get_uploaded_tp (num
, addr
, utpp
);
4068 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
4070 else if (piece
== 'S')
4072 utp
= get_uploaded_tp (num
, addr
, utpp
);
4073 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
4075 else if (piece
== 'Z')
4077 /* Parse a chunk of source form definition. */
4078 utp
= get_uploaded_tp (num
, addr
, utpp
);
4080 p
= strchr (p
, ':');
4081 p
++; /* skip a colon */
4082 p
= unpack_varlen_hex (p
, &start
);
4083 p
++; /* skip a colon */
4084 p
= unpack_varlen_hex (p
, &xlen
);
4085 p
++; /* skip a colon */
4087 buf
= alloca (strlen (line
));
4089 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4092 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
4093 utp
->at_string
= xstrdup (buf
);
4094 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
4095 utp
->cond_string
= xstrdup (buf
);
4096 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
4097 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
4099 else if (piece
== 'V')
4101 utp
= get_uploaded_tp (num
, addr
, utpp
);
4103 parse_tracepoint_status (p
, NULL
, utp
);
4107 /* Don't error out, the target might be sending us optional
4108 info that we don't care about. */
4109 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
4113 /* Convert a textual description of a trace state variable into an
4117 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
4120 ULONGEST num
, initval
, builtin
;
4122 struct uploaded_tsv
*utsv
= NULL
;
4124 buf
= alloca (strlen (line
));
4127 p
= unpack_varlen_hex (p
, &num
);
4128 p
++; /* skip a colon */
4129 p
= unpack_varlen_hex (p
, &initval
);
4130 p
++; /* skip a colon */
4131 p
= unpack_varlen_hex (p
, &builtin
);
4132 p
++; /* skip a colon */
4133 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4136 utsv
= get_uploaded_tsv (num
, utsvp
);
4137 utsv
->initial_value
= initval
;
4138 utsv
->builtin
= builtin
;
4139 utsv
->name
= xstrdup (buf
);
4142 /* Close the trace file and generally clean up. */
4145 tfile_close (int quitting
)
4152 pid
= ptid_get_pid (inferior_ptid
);
4153 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff. */
4154 exit_inferior_silent (pid
);
4158 xfree (trace_filename
);
4159 trace_filename
= NULL
;
4163 tfile_files_info (struct target_ops
*t
)
4165 /* (it would be useful to mention the name of the file). */
4166 printf_filtered ("Looking at a trace file.\n");
4169 /* The trace status for a file is that tracing can never be run. */
4172 tfile_get_trace_status (struct trace_status
*ts
)
4174 /* Other bits of trace status were collected as part of opening the
4175 trace files, so nothing to do here. */
4181 tfile_get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
4183 /* Other bits of trace status were collected as part of opening the
4184 trace files, so nothing to do here. */
4187 /* Given the position of a traceframe in the file, figure out what
4188 address the frame was collected at. This would normally be the
4189 value of a collected PC register, but if not available, we
4193 tfile_get_traceframe_address (off_t tframe_offset
)
4197 struct tracepoint
*tp
;
4198 off_t saved_offset
= cur_offset
;
4200 /* FIXME dig pc out of collected registers. */
4202 /* Fall back to using tracepoint address. */
4203 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
4204 tfile_read ((gdb_byte
*) &tpnum
, 2);
4205 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4209 tp
= get_tracepoint_by_number_on_target (tpnum
);
4210 /* FIXME this is a poor heuristic if multiple locations. */
4211 if (tp
&& tp
->base
.loc
)
4212 addr
= tp
->base
.loc
->address
;
4214 /* Restore our seek position. */
4215 cur_offset
= saved_offset
;
4216 lseek (trace_fd
, cur_offset
, SEEK_SET
);
4220 /* Given a type of search and some parameters, scan the collection of
4221 traceframes in the file looking for a match. When found, return
4222 both the traceframe and tracepoint number, otherwise -1 for
4226 tfile_trace_find (enum trace_find_type type
, int num
,
4227 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
4230 int tfnum
= 0, found
= 0;
4231 unsigned int data_size
;
4232 struct tracepoint
*tp
;
4233 off_t offset
, tframe_offset
;
4243 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
4244 offset
= trace_frames_offset
;
4247 tframe_offset
= offset
;
4248 tfile_read ((gdb_byte
*) &tpnum
, 2);
4249 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4255 tfile_read ((gdb_byte
*) &data_size
, 4);
4256 data_size
= (unsigned int) extract_unsigned_integer
4257 ((gdb_byte
*) &data_size
, 4,
4258 gdbarch_byte_order (target_gdbarch
));
4267 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4268 if (tfaddr
== addr1
)
4272 tp
= get_tracepoint (num
);
4273 if (tp
&& tpnum
== tp
->number_on_target
)
4277 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4278 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
4282 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4283 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
4287 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
4293 cur_offset
= offset
;
4294 cur_data_size
= data_size
;
4298 /* Skip past the traceframe's data. */
4299 lseek (trace_fd
, data_size
, SEEK_CUR
);
4300 offset
+= data_size
;
4301 /* Update our own count of traceframes. */
4304 /* Did not find what we were looking for. */
4310 /* Prototype of the callback passed to tframe_walk_blocks. */
4311 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
4313 /* Callback for traceframe_walk_blocks, used to find a given block
4314 type in a traceframe. */
4317 match_blocktype (char blocktype
, void *data
)
4319 char *wantedp
= data
;
4321 if (*wantedp
== blocktype
)
4327 /* Walk over all traceframe block starting at POS offset from
4328 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4329 unmodified. If CALLBACK returns true, this returns the position in
4330 the traceframe where the block is found, relative to the start of
4331 the traceframe (cur_offset). Returns -1 if no callback call
4332 returned true, indicating that all blocks have been walked. */
4335 traceframe_walk_blocks (walk_blocks_callback_func callback
,
4336 int pos
, void *data
)
4338 /* Iterate through a traceframe's blocks, looking for a block of the
4341 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
4342 while (pos
< cur_data_size
)
4344 unsigned short mlen
;
4347 tfile_read (&block_type
, 1);
4351 if ((*callback
) (block_type
, data
))
4357 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4358 pos
+= trace_regblock_size
;
4361 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4362 tfile_read ((gdb_byte
*) &mlen
, 2);
4363 mlen
= (unsigned short)
4364 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4367 lseek (trace_fd
, mlen
, SEEK_CUR
);
4368 pos
+= (8 + 2 + mlen
);
4371 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
4375 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4376 block_type
, block_type
);
4384 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4385 position offset of a block of type TYPE_WANTED in the current trace
4386 frame, starting at POS. Returns -1 if no such block was found. */
4389 traceframe_find_block_type (char type_wanted
, int pos
)
4391 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
4394 /* Look for a block of saved registers in the traceframe, and get the
4395 requested register from it. */
4398 tfile_fetch_registers (struct target_ops
*ops
,
4399 struct regcache
*regcache
, int regno
)
4401 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4402 int offset
, regn
, regsize
, pc_regno
;
4405 /* An uninitialized reg size says we're not going to be
4406 successful at getting register blocks. */
4407 if (!trace_regblock_size
)
4410 regs
= alloca (trace_regblock_size
);
4412 if (traceframe_find_block_type ('R', 0) >= 0)
4414 tfile_read (regs
, trace_regblock_size
);
4416 /* Assume the block is laid out in GDB register number order,
4417 each register with the size that it has in GDB. */
4419 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4421 regsize
= register_size (gdbarch
, regn
);
4422 /* Make sure we stay within block bounds. */
4423 if (offset
+ regsize
>= trace_regblock_size
)
4425 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
4429 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
4432 else if (regno
== -1)
4434 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
4442 /* We get here if no register data has been found. Mark registers
4444 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4445 regcache_raw_supply (regcache
, regn
, NULL
);
4447 /* We can often usefully guess that the PC is going to be the same
4448 as the address of the tracepoint. */
4449 pc_regno
= gdbarch_pc_regnum (gdbarch
);
4450 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
4452 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
4454 if (tp
&& tp
->base
.loc
)
4456 /* But don't try to guess if tracepoint is multi-location... */
4457 if (tp
->base
.loc
->next
)
4459 warning (_("Tracepoint %d has multiple "
4460 "locations, cannot infer $pc"),
4464 /* ... or does while-stepping. */
4465 if (tp
->step_count
> 0)
4467 warning (_("Tracepoint %d does while-stepping, "
4468 "cannot infer $pc"),
4473 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
4474 gdbarch_byte_order (gdbarch
),
4475 tp
->base
.loc
->address
);
4476 regcache_raw_supply (regcache
, pc_regno
, regs
);
4482 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4483 const char *annex
, gdb_byte
*readbuf
,
4484 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
4486 /* We're only doing regular memory for now. */
4487 if (object
!= TARGET_OBJECT_MEMORY
)
4490 if (readbuf
== NULL
)
4491 error (_("tfile_xfer_partial: trace file is read-only"));
4493 if (traceframe_number
!= -1)
4497 /* Iterate through the traceframe's blocks, looking for
4499 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
4501 ULONGEST maddr
, amt
;
4502 unsigned short mlen
;
4503 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
4505 tfile_read ((gdb_byte
*) &maddr
, 8);
4506 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
4508 tfile_read ((gdb_byte
*) &mlen
, 2);
4509 mlen
= (unsigned short)
4510 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
4512 /* If the block includes the first part of the desired
4513 range, return as much it has; GDB will re-request the
4514 remainder, which might be in a different block of this
4516 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
4518 amt
= (maddr
+ mlen
) - offset
;
4522 if (maddr
!= offset
)
4523 lseek (trace_fd
, offset
- maddr
, SEEK_CUR
);
4524 tfile_read (readbuf
, amt
);
4528 /* Skip over this block. */
4529 pos
+= (8 + 2 + mlen
);
4533 /* It's unduly pedantic to refuse to look at the executable for
4534 read-only pieces; so do the equivalent of readonly regions aka
4536 /* FIXME account for relocation at some point. */
4543 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
4545 if ((s
->flags
& SEC_LOAD
) == 0
4546 || (s
->flags
& SEC_READONLY
) == 0)
4550 size
= bfd_get_section_size (s
);
4551 if (vma
<= offset
&& offset
< (vma
+ size
))
4555 amt
= (vma
+ size
) - offset
;
4559 amt
= bfd_get_section_contents (exec_bfd
, s
,
4560 readbuf
, offset
- vma
, amt
);
4566 /* Indicate failure to find the requested memory block. */
4570 /* Iterate through the blocks of a trace frame, looking for a 'V'
4571 block with a matching tsv number. */
4574 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
4579 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
4583 tfile_read ((gdb_byte
*) &vnum
, 4);
4584 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
4589 tfile_read ((gdb_byte
*) val
, 8);
4590 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
4598 /* Didn't find anything. */
4603 tfile_has_all_memory (struct target_ops
*ops
)
4609 tfile_has_memory (struct target_ops
*ops
)
4615 tfile_has_stack (struct target_ops
*ops
)
4617 return traceframe_number
!= -1;
4621 tfile_has_registers (struct target_ops
*ops
)
4623 return traceframe_number
!= -1;
4627 tfile_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
4632 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
4633 object for the tfile target's current traceframe. */
4636 build_traceframe_info (char blocktype
, void *data
)
4638 struct traceframe_info
*info
= data
;
4644 struct mem_range
*r
;
4646 unsigned short mlen
;
4648 tfile_read ((gdb_byte
*) &maddr
, 8);
4649 tfile_read ((gdb_byte
*) &mlen
, 2);
4651 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4664 warning (_("Unhandled trace block type (%d) '%c ' "
4665 "while building trace frame info."),
4666 blocktype
, blocktype
);
4673 static struct traceframe_info
*
4674 tfile_traceframe_info (void)
4676 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
4678 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
4683 init_tfile_ops (void)
4685 tfile_ops
.to_shortname
= "tfile";
4686 tfile_ops
.to_longname
= "Local trace dump file";
4688 = "Use a trace file as a target. Specify the filename of the trace file.";
4689 tfile_ops
.to_open
= tfile_open
;
4690 tfile_ops
.to_close
= tfile_close
;
4691 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
4692 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
4693 tfile_ops
.to_files_info
= tfile_files_info
;
4694 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
4695 tfile_ops
.to_get_tracepoint_status
= tfile_get_tracepoint_status
;
4696 tfile_ops
.to_trace_find
= tfile_trace_find
;
4697 tfile_ops
.to_get_trace_state_variable_value
4698 = tfile_get_trace_state_variable_value
;
4699 tfile_ops
.to_stratum
= process_stratum
;
4700 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
4701 tfile_ops
.to_has_memory
= tfile_has_memory
;
4702 tfile_ops
.to_has_stack
= tfile_has_stack
;
4703 tfile_ops
.to_has_registers
= tfile_has_registers
;
4704 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
4705 tfile_ops
.to_thread_alive
= tfile_thread_alive
;
4706 tfile_ops
.to_magic
= OPS_MAGIC
;
4710 free_current_marker (void *arg
)
4712 struct static_tracepoint_marker
**marker_p
= arg
;
4714 if (*marker_p
!= NULL
)
4716 release_static_tracepoint_marker (*marker_p
);
4723 /* Given a line of text defining a static tracepoint marker, parse it
4724 into a "static tracepoint marker" object. Throws an error is
4725 parsing fails. If PP is non-null, it points to one past the end of
4726 the parsed marker definition. */
4729 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
4730 struct static_tracepoint_marker
*marker
)
4737 p
= unpack_varlen_hex (p
, &addr
);
4738 p
++; /* skip a colon */
4740 marker
->gdbarch
= target_gdbarch
;
4741 marker
->address
= (CORE_ADDR
) addr
;
4743 endp
= strchr (p
, ':');
4745 error (_("bad marker definition: %s"), line
);
4747 marker
->str_id
= xmalloc (endp
- p
+ 1);
4748 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
4749 marker
->str_id
[end
] = '\0';
4752 p
++; /* skip a colon */
4754 marker
->extra
= xmalloc (strlen (p
) + 1);
4755 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
4756 marker
->extra
[end
] = '\0';
4762 /* Release a static tracepoint marker's contents. Note that the
4763 object itself isn't released here. There objects are usually on
4767 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
4769 xfree (marker
->str_id
);
4770 marker
->str_id
= NULL
;
4773 /* Print MARKER to gdb_stdout. */
4776 print_one_static_tracepoint_marker (int count
,
4777 struct static_tracepoint_marker
*marker
)
4779 struct command_line
*l
;
4782 char wrap_indent
[80];
4783 char extra_field_indent
[80];
4784 struct ui_out
*uiout
= current_uiout
;
4785 struct cleanup
*bkpt_chain
;
4786 VEC(breakpoint_p
) *tracepoints
;
4788 struct symtab_and_line sal
;
4792 sal
.pc
= marker
->address
;
4794 tracepoints
= static_tracepoints_here (marker
->address
);
4796 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
4798 /* A counter field to help readability. This is not a stable
4800 ui_out_field_int (uiout
, "count", count
);
4802 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
4804 ui_out_field_fmt (uiout
, "enabled", "%c",
4805 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
4806 ui_out_spaces (uiout
, 2);
4808 strcpy (wrap_indent
, " ");
4810 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
4811 strcat (wrap_indent
, " ");
4813 strcat (wrap_indent
, " ");
4815 strcpy (extra_field_indent
, " ");
4817 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
4819 sal
= find_pc_line (marker
->address
, 0);
4820 sym
= find_pc_sect_function (marker
->address
, NULL
);
4823 ui_out_text (uiout
, "in ");
4824 ui_out_field_string (uiout
, "func",
4825 SYMBOL_PRINT_NAME (sym
));
4826 ui_out_wrap_hint (uiout
, wrap_indent
);
4827 ui_out_text (uiout
, " at ");
4830 ui_out_field_skip (uiout
, "func");
4832 if (sal
.symtab
!= NULL
)
4834 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
4835 ui_out_text (uiout
, ":");
4837 if (ui_out_is_mi_like_p (uiout
))
4839 char *fullname
= symtab_to_fullname (sal
.symtab
);
4842 ui_out_field_string (uiout
, "fullname", fullname
);
4845 ui_out_field_skip (uiout
, "fullname");
4847 ui_out_field_int (uiout
, "line", sal
.line
);
4851 ui_out_field_skip (uiout
, "fullname");
4852 ui_out_field_skip (uiout
, "line");
4855 ui_out_text (uiout
, "\n");
4856 ui_out_text (uiout
, extra_field_indent
);
4857 ui_out_text (uiout
, _("Data: \""));
4858 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
4859 ui_out_text (uiout
, "\"\n");
4861 if (!VEC_empty (breakpoint_p
, tracepoints
))
4863 struct cleanup
*cleanup_chain
;
4865 struct breakpoint
*b
;
4867 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
4870 ui_out_text (uiout
, extra_field_indent
);
4871 ui_out_text (uiout
, _("Probed by static tracepoints: "));
4872 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
4875 ui_out_text (uiout
, ", ");
4876 ui_out_text (uiout
, "#");
4877 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
4880 do_cleanups (cleanup_chain
);
4882 if (ui_out_is_mi_like_p (uiout
))
4883 ui_out_field_int (uiout
, "number-of-tracepoints",
4884 VEC_length(breakpoint_p
, tracepoints
));
4886 ui_out_text (uiout
, "\n");
4888 VEC_free (breakpoint_p
, tracepoints
);
4890 do_cleanups (bkpt_chain
);
4894 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
4896 VEC(static_tracepoint_marker_p
) *markers
;
4897 struct cleanup
*old_chain
;
4898 struct static_tracepoint_marker
*marker
;
4899 struct ui_out
*uiout
= current_uiout
;
4902 /* We don't have to check target_can_use_agent and agent's capability on
4903 static tracepoint here, in order to be compatible with older GDBserver.
4904 We don't check USE_AGENT is true or not, because static tracepoints
4905 don't work without in-process agent, so we don't bother users to type
4906 `set agent on' when to use static tracepoint. */
4909 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
4910 "StaticTracepointMarkersTable");
4912 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
4914 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
4916 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
4917 if (gdbarch_addr_bit (target_gdbarch
) <= 32)
4918 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
4920 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
4921 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
4923 ui_out_table_body (uiout
);
4925 markers
= target_static_tracepoint_markers_by_strid (NULL
);
4926 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
4929 VEC_iterate (static_tracepoint_marker_p
,
4930 markers
, i
, marker
);
4933 print_one_static_tracepoint_marker (i
+ 1, marker
);
4934 release_static_tracepoint_marker (marker
);
4937 do_cleanups (old_chain
);
4940 /* The $_sdata convenience variable is a bit special. We don't know
4941 for sure type of the value until we actually have a chance to fetch
4942 the data --- the size of the object depends on what has been
4943 collected. We solve this by making $_sdata be an internalvar that
4944 creates a new value on access. */
4946 /* Return a new value with the correct type for the sdata object of
4947 the current trace frame. Return a void value if there's no object
4950 static struct value
*
4951 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
,
4957 /* We need to read the whole object before we know its size. */
4958 size
= target_read_alloc (¤t_target
,
4959 TARGET_OBJECT_STATIC_TRACE_DATA
,
4966 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
4968 v
= allocate_value (type
);
4969 memcpy (value_contents_raw (v
), buf
, size
);
4974 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
4977 #if !defined(HAVE_LIBEXPAT)
4979 struct traceframe_info
*
4980 parse_traceframe_info (const char *tframe_info
)
4982 static int have_warned
;
4987 warning (_("Can not parse XML trace frame info; XML support "
4988 "was disabled at compile time"));
4994 #else /* HAVE_LIBEXPAT */
4996 #include "xml-support.h"
4998 /* Handle the start of a <memory> element. */
5001 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
5002 const struct gdb_xml_element
*element
,
5003 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
5005 struct traceframe_info
*info
= user_data
;
5006 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
5007 ULONGEST
*start_p
, *length_p
;
5009 start_p
= xml_find_attribute (attributes
, "start")->value
;
5010 length_p
= xml_find_attribute (attributes
, "length")->value
;
5012 r
->start
= *start_p
;
5013 r
->length
= *length_p
;
5016 /* Discard the constructed trace frame info (if an error occurs). */
5019 free_result (void *p
)
5021 struct traceframe_info
*result
= p
;
5023 free_traceframe_info (result
);
5026 /* The allowed elements and attributes for an XML memory map. */
5028 static const struct gdb_xml_attribute memory_attributes
[] = {
5029 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5030 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
5031 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
5034 static const struct gdb_xml_element traceframe_info_children
[] = {
5035 { "memory", memory_attributes
, NULL
,
5036 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
5037 traceframe_info_start_memory
, NULL
},
5038 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5041 static const struct gdb_xml_element traceframe_info_elements
[] = {
5042 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
5044 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5047 /* Parse a traceframe-info XML document. */
5049 struct traceframe_info
*
5050 parse_traceframe_info (const char *tframe_info
)
5052 struct traceframe_info
*result
;
5053 struct cleanup
*back_to
;
5055 result
= XCNEW (struct traceframe_info
);
5056 back_to
= make_cleanup (free_result
, result
);
5058 if (gdb_xml_parse_quick (_("trace frame info"),
5059 "traceframe-info.dtd", traceframe_info_elements
,
5060 tframe_info
, result
) == 0)
5062 /* Parsed successfully, keep the result. */
5063 discard_cleanups (back_to
);
5068 do_cleanups (back_to
);
5072 #endif /* HAVE_LIBEXPAT */
5074 /* Returns the traceframe_info object for the current traceframe.
5075 This is where we avoid re-fetching the object from the target if we
5076 already have it cached. */
5078 static struct traceframe_info
*
5079 get_traceframe_info (void)
5081 if (traceframe_info
== NULL
)
5082 traceframe_info
= target_traceframe_info ();
5084 return traceframe_info
;
5087 /* If the target supports the query, return in RESULT the set of
5088 collected memory in the current traceframe, found within the LEN
5089 bytes range starting at MEMADDR. Returns true if the target
5090 supports the query, otherwise returns false, and RESULT is left
5094 traceframe_available_memory (VEC(mem_range_s
) **result
,
5095 CORE_ADDR memaddr
, ULONGEST len
)
5097 struct traceframe_info
*info
= get_traceframe_info ();
5101 struct mem_range
*r
;
5106 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
5107 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
5109 ULONGEST lo1
, hi1
, lo2
, hi2
;
5110 struct mem_range
*nr
;
5113 hi1
= memaddr
+ len
;
5116 hi2
= r
->start
+ r
->length
;
5118 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
5120 nr
->start
= max (lo1
, lo2
);
5121 nr
->length
= min (hi1
, hi2
) - nr
->start
;
5124 normalize_mem_ranges (*result
);
5131 /* Implementation of `sdata' variable. */
5133 static const struct internalvar_funcs sdata_funcs
=
5140 /* module initialization */
5142 _initialize_tracepoint (void)
5144 struct cmd_list_element
*c
;
5146 /* Explicitly create without lookup, since that tries to create a
5147 value with a void typed value, and when we get here, gdbarch
5148 isn't initialized yet. At this point, we're quite sure there
5149 isn't another convenience variable of the same name. */
5150 create_internalvar_type_lazy ("_sdata", &sdata_funcs
, NULL
);
5152 traceframe_number
= -1;
5153 tracepoint_number
= -1;
5155 if (tracepoint_list
.list
== NULL
)
5157 tracepoint_list
.listsize
= 128;
5158 tracepoint_list
.list
= xmalloc
5159 (tracepoint_list
.listsize
* sizeof (struct memrange
));
5161 if (tracepoint_list
.aexpr_list
== NULL
)
5163 tracepoint_list
.aexpr_listsize
= 128;
5164 tracepoint_list
.aexpr_list
= xmalloc
5165 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5168 if (stepping_list
.list
== NULL
)
5170 stepping_list
.listsize
= 128;
5171 stepping_list
.list
= xmalloc
5172 (stepping_list
.listsize
* sizeof (struct memrange
));
5175 if (stepping_list
.aexpr_list
== NULL
)
5177 stepping_list
.aexpr_listsize
= 128;
5178 stepping_list
.aexpr_list
= xmalloc
5179 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5182 add_info ("scope", scope_info
,
5183 _("List the variables local to a scope"));
5185 add_cmd ("tracepoints", class_trace
, NULL
,
5186 _("Tracing of program execution without stopping the program."),
5189 add_com ("tdump", class_trace
, trace_dump_command
,
5190 _("Print everything collected at the current tracepoint."));
5192 add_com ("tsave", class_trace
, trace_save_command
, _("\
5193 Save the trace data to a file.\n\
5194 Use the '-r' option to direct the target to save directly to the file,\n\
5195 using its own filesystem."));
5197 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
5198 Define a trace state variable.\n\
5199 Argument is a $-prefixed name, optionally followed\n\
5200 by '=' and an expression that sets the initial value\n\
5201 at the start of tracing."));
5202 set_cmd_completer (c
, expression_completer
);
5204 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
5205 Delete one or more trace state variables.\n\
5206 Arguments are the names of the variables to delete.\n\
5207 If no arguments are supplied, delete all variables."), &deletelist
);
5208 /* FIXME add a trace variable completer. */
5210 add_info ("tvariables", tvariables_info
, _("\
5211 Status of trace state variables and their values.\n\
5214 add_info ("static-tracepoint-markers",
5215 info_static_tracepoint_markers_command
, _("\
5216 List target static tracepoints markers.\n\
5219 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
5220 Select a trace frame;\n\
5221 No argument means forward by one frame; '-' means backward by one frame."),
5222 &tfindlist
, "tfind ", 1, &cmdlist
);
5224 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
5225 Select a trace frame whose PC is outside the given range (exclusive).\n\
5226 Usage: tfind outside addr1, addr2"),
5229 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
5230 Select a trace frame whose PC is in the given range (inclusive).\n\
5231 Usage: tfind range addr1,addr2"),
5234 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
5235 Select a trace frame by source line.\n\
5236 Argument can be a line number (with optional source file),\n\
5237 a function name, or '*' followed by an address.\n\
5238 Default argument is 'the next source line that was traced'."),
5241 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
5242 Select a trace frame by tracepoint number.\n\
5243 Default is the tracepoint for the current trace frame."),
5246 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
5247 Select a trace frame by PC.\n\
5248 Default is the current PC, or the PC of the current trace frame."),
5251 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
5252 De-select any trace frame and resume 'live' debugging."),
5255 add_alias_cmd ("none", "end", class_trace
, 0, &tfindlist
);
5257 add_cmd ("start", class_trace
, trace_find_start_command
,
5258 _("Select the first trace frame in the trace buffer."),
5261 add_com ("tstatus", class_trace
, trace_status_command
,
5262 _("Display the status of the current trace data collection."));
5264 add_com ("tstop", class_trace
, trace_stop_command
, _("\
5265 Stop trace data collection.\n\
5266 Usage: tstop [ <notes> ... ]\n\
5267 Any arguments supplied are recorded with the trace as a stop reason and\n\
5268 reported by tstatus (if the target supports trace notes)."));
5270 add_com ("tstart", class_trace
, trace_start_command
, _("\
5271 Start trace data collection.\n\
5272 Usage: tstart [ <notes> ... ]\n\
5273 Any arguments supplied are recorded with the trace as a note and\n\
5274 reported by tstatus (if the target supports trace notes)."));
5276 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
5277 Ends a list of commands or actions.\n\
5278 Several GDB commands allow you to enter a list of commands or actions.\n\
5279 Entering \"end\" on a line by itself is the normal way to terminate\n\
5281 Note: the \"end\" command cannot be used at the gdb prompt."));
5283 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
5284 Specify single-stepping behavior at a tracepoint.\n\
5285 Argument is number of instructions to trace in single-step mode\n\
5286 following the tracepoint. This command is normally followed by\n\
5287 one or more \"collect\" commands, to specify what to collect\n\
5288 while single-stepping.\n\n\
5289 Note: this command can only be used in a tracepoint \"actions\" list."));
5291 add_com_alias ("ws", "while-stepping", class_alias
, 0);
5292 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
5294 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
5295 Specify one or more data items to be collected at a tracepoint.\n\
5296 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5297 collect all data (variables, registers) referenced by that expression.\n\
5298 Also accepts the following special arguments:\n\
5299 $regs -- all registers.\n\
5300 $args -- all function arguments.\n\
5301 $locals -- all variables local to the block/function scope.\n\
5302 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5303 Note: this command can only be used in a tracepoint \"actions\" list."));
5305 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
5306 Specify one or more expressions to be evaluated at a tracepoint.\n\
5307 Accepts a comma-separated list of (one or more) expressions.\n\
5308 The result of each evaluation will be discarded.\n\
5309 Note: this command can only be used in a tracepoint \"actions\" list."));
5311 add_com ("actions", class_trace
, trace_actions_command
, _("\
5312 Specify the actions to be taken at a tracepoint.\n\
5313 Tracepoint actions may include collecting of specified data,\n\
5314 single-stepping, or enabling/disabling other tracepoints,\n\
5315 depending on target's capabilities."));
5317 default_collect
= xstrdup ("");
5318 add_setshow_string_cmd ("default-collect", class_trace
,
5319 &default_collect
, _("\
5320 Set the list of expressions to collect by default"), _("\
5321 Show the list of expressions to collect by default"), NULL
,
5323 &setlist
, &showlist
);
5325 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
5326 &disconnected_tracing
, _("\
5327 Set whether tracing continues after GDB disconnects."), _("\
5328 Show whether tracing continues after GDB disconnects."), _("\
5329 Use this to continue a tracing run even if GDB disconnects\n\
5330 or detaches from the target. You can reconnect later and look at\n\
5331 trace data collected in the meantime."),
5332 set_disconnected_tracing
,
5337 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
5338 &circular_trace_buffer
, _("\
5339 Set target's use of circular trace buffer."), _("\
5340 Show target's use of circular trace buffer."), _("\
5341 Use this to make the trace buffer into a circular buffer,\n\
5342 which will discard traceframes (oldest first) instead of filling\n\
5343 up and stopping the trace run."),
5344 set_circular_trace_buffer
,
5349 add_setshow_string_cmd ("trace-user", class_trace
,
5351 Set the user name to use for current and future trace runs"), _("\
5352 Show the user name to use for current and future trace runs"), NULL
,
5353 set_trace_user
, NULL
,
5354 &setlist
, &showlist
);
5356 add_setshow_string_cmd ("trace-notes", class_trace
,
5358 Set notes string to use for current and future trace runs"), _("\
5359 Show the notes string to use for current and future trace runs"), NULL
,
5360 set_trace_notes
, NULL
,
5361 &setlist
, &showlist
);
5363 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
5364 &trace_stop_notes
, _("\
5365 Set notes string to use for future tstop commands"), _("\
5366 Show the notes string to use for future tstop commands"), NULL
,
5367 set_trace_stop_notes
, NULL
,
5368 &setlist
, &showlist
);
5372 add_target (&tfile_ops
);