1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
4 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "arch-utils.h"
26 #include "expression.h"
31 #include "gdb_string.h"
33 #include "breakpoint.h"
34 #include "tracepoint.h"
37 #include "completer.h"
39 #include "dictionary.h"
41 #include "user-regs.h"
45 #include "filenames.h"
46 #include "gdbthread.h"
54 #include "exceptions.h"
55 #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
);
365 warning (_("No trace variable named \"$%s\", not deleting"), name
);
368 /* The 'tvariable' command collects a name and optional expression to
369 evaluate into an initial value. */
372 trace_variable_command (char *args
, int from_tty
)
374 struct expression
*expr
;
375 struct cleanup
*old_chain
;
376 struct internalvar
*intvar
= NULL
;
378 struct trace_state_variable
*tsv
;
381 error_no_arg (_("trace state variable name"));
383 /* All the possible valid arguments are expressions. */
384 expr
= parse_expression (args
);
385 old_chain
= make_cleanup (free_current_contents
, &expr
);
387 if (expr
->nelts
== 0)
388 error (_("No expression?"));
390 /* Only allow two syntaxes; "$name" and "$name=value". */
391 if (expr
->elts
[0].opcode
== OP_INTERNALVAR
)
393 intvar
= expr
->elts
[1].internalvar
;
395 else if (expr
->elts
[0].opcode
== BINOP_ASSIGN
396 && expr
->elts
[1].opcode
== OP_INTERNALVAR
)
398 intvar
= expr
->elts
[2].internalvar
;
399 initval
= value_as_long (evaluate_subexpression_type (expr
, 4));
402 error (_("Syntax must be $NAME [ = EXPR ]"));
405 error (_("No name given"));
407 if (strlen (internalvar_name (intvar
)) <= 0)
408 error (_("Must supply a non-empty variable name"));
410 /* If the variable already exists, just change its initial value. */
411 tsv
= find_trace_state_variable (internalvar_name (intvar
));
414 tsv
->initial_value
= initval
;
415 printf_filtered (_("Trace state variable $%s "
416 "now has initial value %s.\n"),
417 tsv
->name
, plongest (tsv
->initial_value
));
418 do_cleanups (old_chain
);
422 /* Create a new variable. */
423 tsv
= create_trace_state_variable (internalvar_name (intvar
));
424 tsv
->initial_value
= initval
;
426 printf_filtered (_("Trace state variable $%s "
427 "created, with initial value %s.\n"),
428 tsv
->name
, plongest (tsv
->initial_value
));
430 do_cleanups (old_chain
);
434 delete_trace_variable_command (char *args
, int from_tty
)
438 struct cleanup
*back_to
;
442 if (query (_("Delete all trace state variables? ")))
443 VEC_free (tsv_s
, tvariables
);
448 argv
= gdb_buildargv (args
);
449 back_to
= make_cleanup_freeargv (argv
);
451 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
453 if (*argv
[ix
] == '$')
454 delete_trace_state_variable (argv
[ix
] + 1);
456 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
459 do_cleanups (back_to
);
465 tvariables_info_1 (void)
467 struct trace_state_variable
*tsv
;
470 struct cleanup
*back_to
;
471 struct ui_out
*uiout
= current_uiout
;
473 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
475 printf_filtered (_("No trace state variables.\n"));
479 /* Try to acquire values from the target. */
480 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
481 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
484 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
485 count
, "trace-variables");
486 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
487 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
488 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
490 ui_out_table_body (uiout
);
492 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
494 struct cleanup
*back_to2
;
498 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
500 name
= concat ("$", tsv
->name
, (char *) NULL
);
501 make_cleanup (xfree
, name
);
502 ui_out_field_string (uiout
, "name", name
);
503 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
505 if (tsv
->value_known
)
506 c
= plongest (tsv
->value
);
507 else if (ui_out_is_mi_like_p (uiout
))
508 /* For MI, we prefer not to use magic string constants, but rather
509 omit the field completely. The difference between unknown and
510 undefined does not seem important enough to represent. */
512 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
513 /* The value is/was defined, but we don't have it. */
516 /* It is not meaningful to ask about the value. */
519 ui_out_field_string (uiout
, "current", c
);
520 ui_out_text (uiout
, "\n");
522 do_cleanups (back_to2
);
525 do_cleanups (back_to
);
528 /* List all the trace state variables. */
531 tvariables_info (char *args
, int from_tty
)
533 tvariables_info_1 ();
536 /* Stash definitions of tsvs into the given file. */
539 save_trace_state_variables (struct ui_file
*fp
)
541 struct trace_state_variable
*tsv
;
544 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
546 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
547 if (tsv
->initial_value
)
548 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
549 fprintf_unfiltered (fp
, "\n");
553 /* ACTIONS functions: */
555 /* The three functions:
556 collect_pseudocommand,
557 while_stepping_pseudocommand, and
558 end_actions_pseudocommand
559 are placeholders for "commands" that are actually ONLY to be used
560 within a tracepoint action list. If the actual function is ever called,
561 it means that somebody issued the "command" at the top level,
562 which is always an error. */
565 end_actions_pseudocommand (char *args
, int from_tty
)
567 error (_("This command cannot be used at the top level."));
571 while_stepping_pseudocommand (char *args
, int from_tty
)
573 error (_("This command can only be used in a tracepoint actions list."));
577 collect_pseudocommand (char *args
, int from_tty
)
579 error (_("This command can only be used in a tracepoint actions list."));
583 teval_pseudocommand (char *args
, int from_tty
)
585 error (_("This command can only be used in a tracepoint actions list."));
588 /* Parse any collection options, such as /s for strings. */
591 decode_agent_options (char *exp
)
593 struct value_print_options opts
;
598 /* Call this to borrow the print elements default for collection
600 get_user_print_options (&opts
);
605 if (target_supports_string_tracing ())
607 /* Allow an optional decimal number giving an explicit maximum
608 string length, defaulting it to the "print elements" value;
609 so "collect/s80 mystr" gets at most 80 bytes of string. */
610 trace_string_kludge
= opts
.print_max
;
612 if (*exp
>= '0' && *exp
<= '9')
613 trace_string_kludge
= atoi (exp
);
614 while (*exp
>= '0' && *exp
<= '9')
618 error (_("Target does not support \"/s\" option for string tracing."));
621 error (_("Undefined collection format \"%c\"."), *exp
);
623 exp
= skip_spaces (exp
);
628 /* Enter a list of actions for a tracepoint. */
630 trace_actions_command (char *args
, int from_tty
)
632 struct tracepoint
*t
;
633 struct command_line
*l
;
635 t
= get_tracepoint_by_number (&args
, NULL
, 1);
639 xstrprintf ("Enter actions for tracepoint %d, one per line.",
641 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
643 l
= read_command_lines (tmpbuf
, from_tty
, 1,
644 check_tracepoint_command
, t
);
645 do_cleanups (cleanups
);
646 breakpoint_set_commands (&t
->base
, l
);
648 /* else just return */
651 /* Report the results of checking the agent expression, as errors or
655 report_agent_reqs_errors (struct agent_expr
*aexpr
)
657 /* All of the "flaws" are serious bytecode generation issues that
658 should never occur. */
659 if (aexpr
->flaw
!= agent_flaw_none
)
660 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
662 /* If analysis shows a stack underflow, GDB must have done something
663 badly wrong in its bytecode generation. */
664 if (aexpr
->min_height
< 0)
665 internal_error (__FILE__
, __LINE__
,
666 _("expression has min height < 0"));
668 /* Issue this error if the stack is predicted to get too deep. The
669 limit is rather arbitrary; a better scheme might be for the
670 target to report how much stack it will have available. The
671 depth roughly corresponds to parenthesization, so a limit of 20
672 amounts to 20 levels of expression nesting, which is actually
673 a pretty big hairy expression. */
674 if (aexpr
->max_height
> 20)
675 error (_("Expression is too complicated."));
678 /* worker function */
680 validate_actionline (char **line
, struct breakpoint
*b
)
682 struct cmd_list_element
*c
;
683 struct expression
*exp
= NULL
;
684 struct cleanup
*old_chain
= NULL
;
686 struct bp_location
*loc
;
687 struct agent_expr
*aexpr
;
688 struct tracepoint
*t
= (struct tracepoint
*) b
;
690 /* If EOF is typed, *line is NULL. */
694 for (p
= *line
; isspace ((int) *p
);)
697 /* Symbol lookup etc. */
698 if (*p
== '\0') /* empty line: just prompt for another line. */
701 if (*p
== '#') /* comment line */
704 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
706 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
708 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
710 trace_string_kludge
= 0;
712 p
= decode_agent_options (p
);
715 { /* Repeat over a comma-separated list. */
716 QUIT
; /* Allow user to bail out with ^C. */
717 while (isspace ((int) *p
))
720 if (*p
== '$') /* Look for special pseudo-symbols. */
722 if (0 == strncasecmp ("reg", p
+ 1, 3)
723 || 0 == strncasecmp ("arg", p
+ 1, 3)
724 || 0 == strncasecmp ("loc", p
+ 1, 3)
725 || 0 == strncasecmp ("_ret", p
+ 1, 4)
726 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
731 /* else fall thru, treat p as an expression and parse it! */
734 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
737 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
738 old_chain
= make_cleanup (free_current_contents
, &exp
);
740 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
742 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
744 error (_("constant `%s' (value %ld) "
745 "will not be collected."),
746 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
747 SYMBOL_VALUE (exp
->elts
[2].symbol
));
749 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
750 == LOC_OPTIMIZED_OUT
)
752 error (_("`%s' is optimized away "
753 "and cannot be collected."),
754 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
758 /* We have something to collect, make sure that the expr to
759 bytecode translator can handle it and that it's not too
761 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
762 make_cleanup_free_agent_expr (aexpr
);
764 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
765 error (_("Expression is too complicated."));
769 report_agent_reqs_errors (aexpr
);
771 do_cleanups (old_chain
);
774 while (p
&& *p
++ == ',');
777 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
780 { /* Repeat over a comma-separated list. */
781 QUIT
; /* Allow user to bail out with ^C. */
782 while (isspace ((int) *p
))
786 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
789 /* Only expressions are allowed for this action. */
790 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
791 old_chain
= make_cleanup (free_current_contents
, &exp
);
793 /* We have something to evaluate, make sure that the expr to
794 bytecode translator can handle it and that it's not too
796 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
797 make_cleanup_free_agent_expr (aexpr
);
799 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
800 error (_("Expression is too complicated."));
803 report_agent_reqs_errors (aexpr
);
805 do_cleanups (old_chain
);
808 while (p
&& *p
++ == ',');
811 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
813 char *steparg
; /* In case warning is necessary. */
815 while (isspace ((int) *p
))
819 if (*p
== '\0' || (t
->step_count
= strtol (p
, &p
, 0)) == 0)
820 error (_("while-stepping step count `%s' is malformed."), *line
);
823 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
827 error (_("`%s' is not a supported tracepoint action."), *line
);
831 memrange_absolute
= -1
836 int type
; /* memrange_absolute for absolute memory range,
837 else basereg number. */
838 bfd_signed_vma start
;
842 struct collection_list
844 unsigned char regs_mask
[32]; /* room for up to 256 regs */
847 struct memrange
*list
;
848 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
850 struct agent_expr
**aexpr_list
;
852 /* True is the user requested a collection of "$_sdata", "static
856 tracepoint_list
, stepping_list
;
858 /* MEMRANGE functions: */
860 static int memrange_cmp (const void *, const void *);
862 /* Compare memranges for qsort. */
864 memrange_cmp (const void *va
, const void *vb
)
866 const struct memrange
*a
= va
, *b
= vb
;
868 if (a
->type
< b
->type
)
870 if (a
->type
> b
->type
)
872 if (a
->type
== memrange_absolute
)
874 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
876 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
881 if (a
->start
< b
->start
)
883 if (a
->start
> b
->start
)
889 /* Sort the memrange list using qsort, and merge adjacent memranges. */
891 memrange_sortmerge (struct collection_list
*memranges
)
895 qsort (memranges
->list
, memranges
->next_memrange
,
896 sizeof (struct memrange
), memrange_cmp
);
897 if (memranges
->next_memrange
> 0)
899 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
901 /* If memrange b overlaps or is adjacent to memrange a,
903 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
904 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
906 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
907 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
908 continue; /* next b, same a */
912 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
913 sizeof (struct memrange
));
915 memranges
->next_memrange
= a
+ 1;
919 /* Add a register to a collection list. */
921 add_register (struct collection_list
*collection
, unsigned int regno
)
924 printf_filtered ("collect register %d\n", regno
);
925 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
926 error (_("Internal: register number %d too large for tracepoint"),
928 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
931 /* Add a memrange to a collection list. */
933 add_memrange (struct collection_list
*memranges
,
934 int type
, bfd_signed_vma base
,
939 printf_filtered ("(%d,", type
);
941 printf_filtered (",%ld)\n", len
);
944 /* type: memrange_absolute == memory, other n == basereg */
945 memranges
->list
[memranges
->next_memrange
].type
= type
;
946 /* base: addr if memory, offset if reg relative. */
947 memranges
->list
[memranges
->next_memrange
].start
= base
;
948 /* len: we actually save end (base + len) for convenience */
949 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
950 memranges
->next_memrange
++;
951 if (memranges
->next_memrange
>= memranges
->listsize
)
953 memranges
->listsize
*= 2;
954 memranges
->list
= xrealloc (memranges
->list
,
955 memranges
->listsize
);
958 if (type
!= memrange_absolute
) /* Better collect the base register! */
959 add_register (memranges
, type
);
962 /* Add a symbol to a collection list. */
964 collect_symbol (struct collection_list
*collect
,
966 struct gdbarch
*gdbarch
,
967 long frame_regno
, long frame_offset
,
972 bfd_signed_vma offset
;
973 int treat_as_expr
= 0;
975 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
976 switch (SYMBOL_CLASS (sym
))
979 printf_filtered ("%s: don't know symbol class %d\n",
980 SYMBOL_PRINT_NAME (sym
),
984 printf_filtered ("constant %s (value %ld) will not be collected.\n",
985 SYMBOL_PRINT_NAME (sym
), SYMBOL_VALUE (sym
));
988 offset
= SYMBOL_VALUE_ADDRESS (sym
);
993 sprintf_vma (tmp
, offset
);
994 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
995 SYMBOL_PRINT_NAME (sym
), len
,
998 /* A struct may be a C++ class with static fields, go to general
999 expression handling. */
1000 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
1003 add_memrange (collect
, memrange_absolute
, offset
, len
);
1006 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1008 printf_filtered ("LOC_REG[parm] %s: ",
1009 SYMBOL_PRINT_NAME (sym
));
1010 add_register (collect
, reg
);
1011 /* Check for doubles stored in two registers. */
1012 /* FIXME: how about larger types stored in 3 or more regs? */
1013 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1014 len
> register_size (gdbarch
, reg
))
1015 add_register (collect
, reg
+ 1);
1018 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1019 printf_filtered (" (will not collect %s)\n",
1020 SYMBOL_PRINT_NAME (sym
));
1024 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1027 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1028 SYMBOL_PRINT_NAME (sym
), len
);
1029 printf_vma (offset
);
1030 printf_filtered (" from frame ptr reg %d\n", reg
);
1032 add_memrange (collect
, reg
, offset
, len
);
1034 case LOC_REGPARM_ADDR
:
1035 reg
= SYMBOL_VALUE (sym
);
1039 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1040 SYMBOL_PRINT_NAME (sym
), len
);
1041 printf_vma (offset
);
1042 printf_filtered (" from reg %d\n", reg
);
1044 add_memrange (collect
, reg
, offset
, len
);
1048 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1051 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1052 SYMBOL_PRINT_NAME (sym
), len
);
1053 printf_vma (offset
);
1054 printf_filtered (" from frame ptr reg %d\n", reg
);
1056 add_memrange (collect
, reg
, offset
, len
);
1059 case LOC_UNRESOLVED
:
1063 case LOC_OPTIMIZED_OUT
:
1064 printf_filtered ("%s has been optimized out of existence.\n",
1065 SYMBOL_PRINT_NAME (sym
));
1073 /* Expressions are the most general case. */
1076 struct agent_expr
*aexpr
;
1077 struct cleanup
*old_chain1
= NULL
;
1079 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
1081 /* It can happen that the symbol is recorded as a computed
1082 location, but it's been optimized away and doesn't actually
1083 have a location expression. */
1086 printf_filtered ("%s has been optimized out of existence.\n",
1087 SYMBOL_PRINT_NAME (sym
));
1091 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1095 report_agent_reqs_errors (aexpr
);
1097 discard_cleanups (old_chain1
);
1098 add_aexpr (collect
, aexpr
);
1100 /* Take care of the registers. */
1101 if (aexpr
->reg_mask_len
> 0)
1105 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1107 QUIT
; /* Allow user to bail out with ^C. */
1108 if (aexpr
->reg_mask
[ndx1
] != 0)
1110 /* Assume chars have 8 bits. */
1111 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1112 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1113 /* It's used -- record it. */
1114 add_register (collect
, ndx1
* 8 + ndx2
);
1121 /* Data to be passed around in the calls to the locals and args
1124 struct add_local_symbols_data
1126 struct collection_list
*collect
;
1127 struct gdbarch
*gdbarch
;
1134 /* The callback for the locals and args iterators. */
1137 do_collect_symbol (const char *print_name
,
1141 struct add_local_symbols_data
*p
= cb_data
;
1143 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1144 p
->frame_offset
, p
->pc
);
1148 /* Add all locals (or args) symbols to collection list. */
1150 add_local_symbols (struct collection_list
*collect
,
1151 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1152 long frame_regno
, long frame_offset
, int type
)
1154 struct block
*block
;
1155 struct add_local_symbols_data cb_data
;
1157 cb_data
.collect
= collect
;
1158 cb_data
.gdbarch
= gdbarch
;
1160 cb_data
.frame_regno
= frame_regno
;
1161 cb_data
.frame_offset
= frame_offset
;
1166 block
= block_for_pc (pc
);
1169 warning (_("Can't collect locals; "
1170 "no symbol table info available.\n"));
1174 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1175 if (cb_data
.count
== 0)
1176 warning (_("No locals found in scope."));
1180 pc
= get_pc_function_start (pc
);
1181 block
= block_for_pc (pc
);
1184 warning (_("Can't collect args; no symbol table info available."));
1188 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1189 if (cb_data
.count
== 0)
1190 warning (_("No args found in scope."));
1195 add_static_trace_data (struct collection_list
*collection
)
1198 printf_filtered ("collect static trace data\n");
1199 collection
->strace_data
= 1;
1202 /* worker function */
1204 clear_collection_list (struct collection_list
*list
)
1208 list
->next_memrange
= 0;
1209 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1211 free_agent_expr (list
->aexpr_list
[ndx
]);
1212 list
->aexpr_list
[ndx
] = NULL
;
1214 list
->next_aexpr_elt
= 0;
1215 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1216 list
->strace_data
= 0;
1219 /* Reduce a collection list to string form (for gdb protocol). */
1221 stringify_collection_list (struct collection_list
*list
, char *string
)
1223 char temp_buf
[2048];
1227 char *(*str_list
)[];
1231 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1232 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1234 if (list
->strace_data
)
1237 printf_filtered ("\nCollecting static trace data\n");
1240 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1244 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1245 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1247 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1250 printf_filtered ("\nCollecting registers (mask): 0x");
1255 QUIT
; /* Allow user to bail out with ^C. */
1257 printf_filtered ("%02X", list
->regs_mask
[i
]);
1258 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1261 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1265 printf_filtered ("\n");
1266 if (list
->next_memrange
> 0 && info_verbose
)
1267 printf_filtered ("Collecting memranges: \n");
1268 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1270 QUIT
; /* Allow user to bail out with ^C. */
1271 sprintf_vma (tmp2
, list
->list
[i
].start
);
1274 printf_filtered ("(%d, %s, %ld)\n",
1277 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1279 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1281 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1288 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1290 /* The "%X" conversion specifier expects an unsigned argument,
1291 so passing -1 (memrange_absolute) to it directly gives you
1292 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1294 if (list
->list
[i
].type
== memrange_absolute
)
1295 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1297 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1300 count
+= strlen (end
);
1301 end
= temp_buf
+ count
;
1304 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1306 QUIT
; /* Allow user to bail out with ^C. */
1307 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1309 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1314 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1315 end
+= 10; /* 'X' + 8 hex digits + ',' */
1318 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1319 end
, list
->aexpr_list
[i
]->len
);
1320 count
+= 2 * list
->aexpr_list
[i
]->len
;
1325 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1330 (*str_list
)[ndx
] = NULL
;
1343 encode_actions_1 (struct command_line
*action
,
1344 struct breakpoint
*t
,
1345 struct bp_location
*tloc
,
1347 LONGEST frame_offset
,
1348 struct collection_list
*collect
,
1349 struct collection_list
*stepping_list
)
1352 struct expression
*exp
= NULL
;
1354 struct value
*tempval
;
1355 struct cmd_list_element
*cmd
;
1356 struct agent_expr
*aexpr
;
1358 for (; action
; action
= action
->next
)
1360 QUIT
; /* Allow user to bail out with ^C. */
1361 action_exp
= action
->line
;
1362 while (isspace ((int) *action_exp
))
1365 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1367 error (_("Bad action list item: %s"), action_exp
);
1369 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1371 trace_string_kludge
= 0;
1372 if (*action_exp
== '/')
1373 action_exp
= decode_agent_options (action_exp
);
1376 { /* Repeat over a comma-separated list. */
1377 QUIT
; /* Allow user to bail out with ^C. */
1378 while (isspace ((int) *action_exp
))
1381 if (0 == strncasecmp ("$reg", action_exp
, 4))
1383 for (i
= 0; i
< gdbarch_num_regs (tloc
->gdbarch
); i
++)
1384 add_register (collect
, i
);
1385 action_exp
= strchr (action_exp
, ','); /* more? */
1387 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1389 add_local_symbols (collect
,
1395 action_exp
= strchr (action_exp
, ','); /* more? */
1397 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1399 add_local_symbols (collect
,
1405 action_exp
= strchr (action_exp
, ','); /* more? */
1407 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1409 struct cleanup
*old_chain1
= NULL
;
1411 aexpr
= gen_trace_for_return_address (tloc
->address
,
1414 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1417 report_agent_reqs_errors (aexpr
);
1419 discard_cleanups (old_chain1
);
1420 add_aexpr (collect
, aexpr
);
1422 /* take care of the registers */
1423 if (aexpr
->reg_mask_len
> 0)
1427 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1429 QUIT
; /* allow user to bail out with ^C */
1430 if (aexpr
->reg_mask
[ndx1
] != 0)
1432 /* assume chars have 8 bits */
1433 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1434 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1435 /* it's used -- record it */
1436 add_register (collect
,
1442 action_exp
= strchr (action_exp
, ','); /* more? */
1444 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1446 add_static_trace_data (collect
);
1447 action_exp
= strchr (action_exp
, ','); /* more? */
1451 unsigned long addr
, len
;
1452 struct cleanup
*old_chain
= NULL
;
1453 struct cleanup
*old_chain1
= NULL
;
1455 exp
= parse_exp_1 (&action_exp
,
1456 block_for_pc (tloc
->address
), 1);
1457 old_chain
= make_cleanup (free_current_contents
, &exp
);
1459 switch (exp
->elts
[0].opcode
)
1463 const char *name
= &exp
->elts
[2].string
;
1465 i
= user_reg_map_name_to_regnum (tloc
->gdbarch
,
1466 name
, strlen (name
));
1468 internal_error (__FILE__
, __LINE__
,
1469 _("Register $%s not available"),
1472 printf_filtered ("OP_REGISTER: ");
1473 add_register (collect
, i
);
1478 /* Safe because we know it's a simple expression. */
1479 tempval
= evaluate_expression (exp
);
1480 addr
= value_address (tempval
);
1481 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1482 add_memrange (collect
, memrange_absolute
, addr
, len
);
1486 collect_symbol (collect
,
1487 exp
->elts
[2].symbol
,
1494 default: /* Full-fledged expression. */
1495 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1497 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1501 report_agent_reqs_errors (aexpr
);
1503 discard_cleanups (old_chain1
);
1504 add_aexpr (collect
, aexpr
);
1506 /* Take care of the registers. */
1507 if (aexpr
->reg_mask_len
> 0)
1512 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1514 QUIT
; /* Allow user to bail out with ^C. */
1515 if (aexpr
->reg_mask
[ndx1
] != 0)
1517 /* Assume chars have 8 bits. */
1518 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1519 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1520 /* It's used -- record it. */
1521 add_register (collect
,
1528 do_cleanups (old_chain
);
1531 while (action_exp
&& *action_exp
++ == ',');
1533 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1536 { /* Repeat over a comma-separated list. */
1537 QUIT
; /* Allow user to bail out with ^C. */
1538 while (isspace ((int) *action_exp
))
1542 struct cleanup
*old_chain
= NULL
;
1543 struct cleanup
*old_chain1
= NULL
;
1545 exp
= parse_exp_1 (&action_exp
,
1546 block_for_pc (tloc
->address
), 1);
1547 old_chain
= make_cleanup (free_current_contents
, &exp
);
1549 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1550 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1553 report_agent_reqs_errors (aexpr
);
1555 discard_cleanups (old_chain1
);
1556 /* Even though we're not officially collecting, add
1557 to the collect list anyway. */
1558 add_aexpr (collect
, aexpr
);
1560 do_cleanups (old_chain
);
1563 while (action_exp
&& *action_exp
++ == ',');
1565 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1567 /* We check against nested while-stepping when setting
1568 breakpoint action, so no way to run into nested
1570 gdb_assert (stepping_list
);
1572 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
,
1573 frame_offset
, stepping_list
, NULL
);
1576 error (_("Invalid tracepoint command '%s'"), action
->line
);
1580 /* Render all actions into gdb protocol. */
1582 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1583 char ***tdp_actions
, char ***stepping_actions
)
1585 static char tdp_buff
[2048], step_buff
[2048];
1586 char *default_collect_line
= NULL
;
1587 struct command_line
*actions
;
1588 struct command_line
*default_collect_action
= NULL
;
1590 LONGEST frame_offset
;
1591 struct cleanup
*back_to
;
1593 back_to
= make_cleanup (null_cleanup
, NULL
);
1595 clear_collection_list (&tracepoint_list
);
1596 clear_collection_list (&stepping_list
);
1598 *tdp_actions
= NULL
;
1599 *stepping_actions
= NULL
;
1601 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1602 tloc
->address
, &frame_reg
, &frame_offset
);
1604 actions
= breakpoint_commands (t
);
1606 /* If there are default expressions to collect, make up a collect
1607 action and prepend to the action list to encode. Note that since
1608 validation is per-tracepoint (local var "xyz" might be valid for
1609 one tracepoint and not another, etc), we make up the action on
1610 the fly, and don't cache it. */
1611 if (*default_collect
)
1615 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1616 make_cleanup (xfree
, default_collect_line
);
1618 line
= default_collect_line
;
1619 validate_actionline (&line
, t
);
1621 default_collect_action
= xmalloc (sizeof (struct command_line
));
1622 make_cleanup (xfree
, default_collect_action
);
1623 default_collect_action
->next
= actions
;
1624 default_collect_action
->line
= line
;
1625 actions
= default_collect_action
;
1627 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1628 &tracepoint_list
, &stepping_list
);
1630 memrange_sortmerge (&tracepoint_list
);
1631 memrange_sortmerge (&stepping_list
);
1633 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1635 *stepping_actions
= stringify_collection_list (&stepping_list
,
1638 do_cleanups (back_to
);
1642 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1644 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1646 collect
->aexpr_list
=
1647 xrealloc (collect
->aexpr_list
,
1648 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1649 collect
->aexpr_listsize
*= 2;
1651 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1652 collect
->next_aexpr_elt
++;
1656 process_tracepoint_on_disconnect (void)
1658 VEC(breakpoint_p
) *tp_vec
= NULL
;
1660 struct breakpoint
*b
;
1661 int has_pending_p
= 0;
1663 /* Check whether we still have pending tracepoint. If we have, warn the
1664 user that pending tracepoint will no longer work. */
1665 tp_vec
= all_tracepoints ();
1666 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1675 struct bp_location
*loc1
;
1677 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1679 if (loc1
->shlib_disabled
)
1690 VEC_free (breakpoint_p
, tp_vec
);
1693 warning (_("Pending tracepoints will not be resolved while"
1694 " GDB is disconnected\n"));
1699 start_tracing (char *notes
)
1701 VEC(breakpoint_p
) *tp_vec
= NULL
;
1703 struct breakpoint
*b
;
1704 struct trace_state_variable
*tsv
;
1705 int any_enabled
= 0, num_to_download
= 0;
1708 tp_vec
= all_tracepoints ();
1710 /* No point in tracing without any tracepoints... */
1711 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1713 VEC_free (breakpoint_p
, tp_vec
);
1714 error (_("No tracepoints defined, not starting trace"));
1717 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1719 struct tracepoint
*t
= (struct tracepoint
*) b
;
1721 if (b
->enable_state
== bp_enabled
)
1724 if ((b
->type
== bp_fast_tracepoint
1725 ? may_insert_fast_tracepoints
1726 : may_insert_tracepoints
))
1729 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1730 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1735 if (target_supports_enable_disable_tracepoint ())
1736 warning (_("No tracepoints enabled"));
1739 /* No point in tracing with only disabled tracepoints that
1740 cannot be re-enabled. */
1741 VEC_free (breakpoint_p
, tp_vec
);
1742 error (_("No tracepoints enabled, not starting trace"));
1746 if (num_to_download
<= 0)
1748 VEC_free (breakpoint_p
, tp_vec
);
1749 error (_("No tracepoints that may be downloaded, not starting trace"));
1752 target_trace_init ();
1754 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1756 struct tracepoint
*t
= (struct tracepoint
*) b
;
1757 struct bp_location
*loc
;
1759 if ((b
->type
== bp_fast_tracepoint
1760 ? !may_insert_fast_tracepoints
1761 : !may_insert_tracepoints
))
1764 t
->number_on_target
= 0;
1766 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1768 /* Since tracepoint locations are never duplicated, `inserted'
1769 flag should be zero. */
1770 gdb_assert (!loc
->inserted
);
1772 target_download_tracepoint (loc
);
1777 t
->number_on_target
= b
->number
;
1779 VEC_free (breakpoint_p
, tp_vec
);
1781 /* Send down all the trace state variables too. */
1782 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1784 target_download_trace_state_variable (tsv
);
1787 /* Tell target to treat text-like sections as transparent. */
1788 target_trace_set_readonly_regions ();
1789 /* Set some mode flags. */
1790 target_set_disconnected_tracing (disconnected_tracing
);
1791 target_set_circular_trace_buffer (circular_trace_buffer
);
1794 notes
= trace_notes
;
1795 ret
= target_set_trace_notes (trace_user
, notes
, NULL
);
1797 if (!ret
&& (trace_user
|| notes
))
1798 warning ("Target does not support trace user/notes, info ignored");
1800 /* Now insert traps and begin collecting data. */
1801 target_trace_start ();
1803 /* Reset our local state. */
1804 set_traceframe_num (-1);
1805 set_tracepoint_num (-1);
1806 set_traceframe_context (NULL
);
1807 current_trace_status()->running
= 1;
1808 clear_traceframe_info ();
1811 /* The tstart command requests the target to start a new trace run.
1812 The command passes any arguments it has to the target verbatim, as
1813 an optional "trace note". This is useful as for instance a warning
1814 to other users if the trace runs disconnected, and you don't want
1815 anybody else messing with the target. */
1818 trace_start_command (char *args
, int from_tty
)
1820 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1822 if (current_trace_status ()->running
)
1825 && !query (_("A trace is running already. Start a new run? ")))
1826 error (_("New trace run not started."));
1829 start_tracing (args
);
1832 /* The tstop command stops the tracing run. The command passes any
1833 supplied arguments to the target verbatim as a "stop note"; if the
1834 target supports trace notes, then it will be reported back as part
1835 of the trace run's status. */
1838 trace_stop_command (char *args
, int from_tty
)
1840 if (!current_trace_status ()->running
)
1841 error (_("Trace is not running."));
1843 stop_tracing (args
);
1847 stop_tracing (char *note
)
1851 target_trace_stop ();
1854 note
= trace_stop_notes
;
1855 ret
= target_set_trace_notes (NULL
, NULL
, note
);
1858 warning ("Target does not support trace notes, note ignored");
1860 /* Should change in response to reply? */
1861 current_trace_status ()->running
= 0;
1864 /* tstatus command */
1866 trace_status_command (char *args
, int from_tty
)
1868 struct trace_status
*ts
= current_trace_status ();
1870 VEC(breakpoint_p
) *tp_vec
= NULL
;
1871 struct breakpoint
*t
;
1873 status
= target_get_trace_status (ts
);
1878 printf_filtered (_("Using a trace file.\n"));
1881 printf_filtered (_("Trace can not be run on this target.\n"));
1886 if (!ts
->running_known
)
1888 printf_filtered (_("Run/stop status is unknown.\n"));
1890 else if (ts
->running
)
1892 printf_filtered (_("Trace is running on the target.\n"));
1896 switch (ts
->stop_reason
)
1898 case trace_never_run
:
1899 printf_filtered (_("No trace has been run on the target.\n"));
1903 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1906 printf_filtered (_("Trace stopped by a tstop command.\n"));
1908 case trace_buffer_full
:
1909 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1911 case trace_disconnected
:
1912 printf_filtered (_("Trace stopped because of disconnection.\n"));
1914 case tracepoint_passcount
:
1915 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1916 ts
->stopping_tracepoint
);
1918 case tracepoint_error
:
1919 if (ts
->stopping_tracepoint
)
1920 printf_filtered (_("Trace stopped by an "
1921 "error (%s, tracepoint %d).\n"),
1922 ts
->stop_desc
, ts
->stopping_tracepoint
);
1924 printf_filtered (_("Trace stopped by an error (%s).\n"),
1927 case trace_stop_reason_unknown
:
1928 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1931 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1937 if (ts
->traceframes_created
>= 0
1938 && ts
->traceframe_count
!= ts
->traceframes_created
)
1940 printf_filtered (_("Buffer contains %d trace "
1941 "frames (of %d created total).\n"),
1942 ts
->traceframe_count
, ts
->traceframes_created
);
1944 else if (ts
->traceframe_count
>= 0)
1946 printf_filtered (_("Collected %d trace frames.\n"),
1947 ts
->traceframe_count
);
1950 if (ts
->buffer_free
>= 0)
1952 if (ts
->buffer_size
>= 0)
1954 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1955 ts
->buffer_free
, ts
->buffer_size
);
1956 if (ts
->buffer_size
> 0)
1957 printf_filtered (_(" (%d%% full)"),
1958 ((int) ((((long long) (ts
->buffer_size
1959 - ts
->buffer_free
)) * 100)
1960 / ts
->buffer_size
)));
1961 printf_filtered (_(".\n"));
1964 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1968 if (ts
->disconnected_tracing
)
1969 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1971 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1973 if (ts
->circular_buffer
)
1974 printf_filtered (_("Trace buffer is circular.\n"));
1976 if (ts
->user_name
&& strlen (ts
->user_name
) > 0)
1977 printf_filtered (_("Trace user is %s.\n"), ts
->user_name
);
1979 if (ts
->notes
&& strlen (ts
->notes
) > 0)
1980 printf_filtered (_("Trace notes: %s.\n"), ts
->notes
);
1982 /* Now report on what we're doing with tfind. */
1983 if (traceframe_number
>= 0)
1984 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1985 traceframe_number
, tracepoint_number
);
1987 printf_filtered (_("Not looking at any trace frame.\n"));
1989 /* Report start/stop times if supplied. */
1994 LONGEST run_time
= ts
->stop_time
- ts
->start_time
;
1996 /* Reporting a run time is more readable than two long numbers. */
1997 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
1998 ts
->start_time
/ 1000000, ts
->start_time
% 1000000,
1999 run_time
/ 1000000, run_time
% 1000000);
2002 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2003 ts
->start_time
/ 1000000, ts
->start_time
% 1000000);
2005 else if (ts
->stop_time
)
2006 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2007 ts
->stop_time
/ 1000000, ts
->stop_time
% 1000000);
2009 /* Now report any per-tracepoint status available. */
2010 tp_vec
= all_tracepoints ();
2012 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2013 target_get_tracepoint_status (t
, NULL
);
2015 VEC_free (breakpoint_p
, tp_vec
);
2018 /* Report the trace status to uiout, in a way suitable for MI, and not
2019 suitable for CLI. If ON_STOP is true, suppress a few fields that
2020 are not meaningful in the -trace-stop response.
2022 The implementation is essentially parallel to trace_status_command, but
2023 merging them will result in unreadable code. */
2025 trace_status_mi (int on_stop
)
2027 struct ui_out
*uiout
= current_uiout
;
2028 struct trace_status
*ts
= current_trace_status ();
2031 status
= target_get_trace_status (ts
);
2033 if (status
== -1 && !ts
->from_file
)
2035 ui_out_field_string (uiout
, "supported", "0");
2040 ui_out_field_string (uiout
, "supported", "file");
2042 ui_out_field_string (uiout
, "supported", "1");
2044 gdb_assert (ts
->running_known
);
2048 ui_out_field_string (uiout
, "running", "1");
2050 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2051 Given that the frontend gets the status either on -trace-stop, or from
2052 -trace-status after re-connection, it does not seem like this
2053 information is necessary for anything. It is not necessary for either
2054 figuring the vital state of the target nor for navigation of trace
2055 frames. If the frontend wants to show the current state is some
2056 configure dialog, it can request the value when such dialog is
2057 invoked by the user. */
2061 char *stop_reason
= NULL
;
2062 int stopping_tracepoint
= -1;
2065 ui_out_field_string (uiout
, "running", "0");
2067 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
2069 switch (ts
->stop_reason
)
2072 stop_reason
= "request";
2074 case trace_buffer_full
:
2075 stop_reason
= "overflow";
2077 case trace_disconnected
:
2078 stop_reason
= "disconnection";
2080 case tracepoint_passcount
:
2081 stop_reason
= "passcount";
2082 stopping_tracepoint
= ts
->stopping_tracepoint
;
2084 case tracepoint_error
:
2085 stop_reason
= "error";
2086 stopping_tracepoint
= ts
->stopping_tracepoint
;
2092 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2093 if (stopping_tracepoint
!= -1)
2094 ui_out_field_int (uiout
, "stopping-tracepoint",
2095 stopping_tracepoint
);
2096 if (ts
->stop_reason
== tracepoint_error
)
2097 ui_out_field_string (uiout
, "error-description",
2103 if (ts
->traceframe_count
!= -1)
2104 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2105 if (ts
->traceframes_created
!= -1)
2106 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2107 if (ts
->buffer_size
!= -1)
2108 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2109 if (ts
->buffer_free
!= -1)
2110 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2112 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2113 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2115 ui_out_field_string (uiout
, "user-name", ts
->user_name
);
2116 ui_out_field_string (uiout
, "notes", ts
->notes
);
2121 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2122 ts
->start_time
/ 1000000, ts
->start_time
% 1000000);
2123 ui_out_field_string (uiout
, "start-time", buf
);
2124 xsnprintf (buf
, sizeof buf
, "%ld.%06ld",
2125 ts
->stop_time
/ 1000000, ts
->stop_time
% 1000000);
2126 ui_out_field_string (uiout
, "stop-time", buf
);
2130 /* This function handles the details of what to do about an ongoing
2131 tracing run if the user has asked to detach or otherwise disconnect
2134 disconnect_tracing (int from_tty
)
2136 /* It can happen that the target that was tracing went away on its
2137 own, and we didn't notice. Get a status update, and if the
2138 current target doesn't even do tracing, then assume it's not
2140 if (target_get_trace_status (current_trace_status ()) < 0)
2141 current_trace_status ()->running
= 0;
2143 /* If running interactively, give the user the option to cancel and
2144 then decide what to do differently with the run. Scripts are
2145 just going to disconnect and let the target deal with it,
2146 according to how it's been instructed previously via
2147 disconnected-tracing. */
2148 if (current_trace_status ()->running
&& from_tty
)
2150 process_tracepoint_on_disconnect ();
2152 if (current_trace_status ()->disconnected_tracing
)
2154 if (!query (_("Trace is running and will "
2155 "continue after detach; detach anyway? ")))
2156 error (_("Not confirmed."));
2160 if (!query (_("Trace is running but will "
2161 "stop on detach; detach anyway? ")))
2162 error (_("Not confirmed."));
2166 /* Also we want to be out of tfind mode, otherwise things can get
2167 confusing upon reconnection. Just use these calls instead of
2168 full tfind_1 behavior because we're in the middle of detaching,
2169 and there's no point to updating current stack frame etc. */
2170 set_current_traceframe (-1);
2171 set_traceframe_context (NULL
);
2174 /* Worker function for the various flavors of the tfind command. */
2176 tfind_1 (enum trace_find_type type
, int num
,
2177 ULONGEST addr1
, ULONGEST addr2
,
2180 int target_frameno
= -1, target_tracept
= -1;
2181 struct frame_id old_frame_id
= null_frame_id
;
2182 struct tracepoint
*tp
;
2183 struct ui_out
*uiout
= current_uiout
;
2185 /* Only try to get the current stack frame if we have a chance of
2186 succeeding. In particular, if we're trying to get a first trace
2187 frame while all threads are running, it's not going to succeed,
2188 so leave it with a default value and let the frame comparison
2189 below (correctly) decide to print out the source location of the
2191 if (!(type
== tfind_number
&& num
== -1)
2192 && (has_stack_frames () || traceframe_number
>= 0))
2193 old_frame_id
= get_frame_id (get_current_frame ());
2195 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2198 if (type
== tfind_number
2200 && target_frameno
== -1)
2202 /* We told the target to get out of tfind mode, and it did. */
2204 else if (target_frameno
== -1)
2206 /* A request for a non-existent trace frame has failed.
2207 Our response will be different, depending on FROM_TTY:
2209 If FROM_TTY is true, meaning that this command was
2210 typed interactively by the user, then give an error
2211 and DO NOT change the state of traceframe_number etc.
2213 However if FROM_TTY is false, meaning that we're either
2214 in a script, a loop, or a user-defined command, then
2215 DON'T give an error, but DO change the state of
2216 traceframe_number etc. to invalid.
2218 The rationalle is that if you typed the command, you
2219 might just have committed a typo or something, and you'd
2220 like to NOT lose your current debugging state. However
2221 if you're in a user-defined command or especially in a
2222 loop, then you need a way to detect that the command
2223 failed WITHOUT aborting. This allows you to write
2224 scripts that search thru the trace buffer until the end,
2225 and then continue on to do something else. */
2228 error (_("Target failed to find requested trace frame."));
2232 printf_filtered ("End of trace buffer.\n");
2233 #if 0 /* dubious now? */
2234 /* The following will not recurse, since it's
2236 trace_find_command ("-1", from_tty
);
2241 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2243 reinit_frame_cache ();
2244 registers_changed ();
2245 target_dcache_invalidate ();
2246 set_traceframe_num (target_frameno
);
2247 clear_traceframe_info ();
2248 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2249 if (target_frameno
== -1)
2250 set_traceframe_context (NULL
);
2252 set_traceframe_context (get_current_frame ());
2254 if (traceframe_number
>= 0)
2256 /* Use different branches for MI and CLI to make CLI messages
2258 if (ui_out_is_mi_like_p (uiout
))
2260 ui_out_field_string (uiout
, "found", "1");
2261 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2262 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2266 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2267 traceframe_number
, tracepoint_number
);
2272 if (ui_out_is_mi_like_p (uiout
))
2273 ui_out_field_string (uiout
, "found", "0");
2274 else if (type
== tfind_number
&& num
== -1)
2275 printf_unfiltered (_("No longer looking at any trace frame\n"));
2276 else /* This case may never occur, check. */
2277 printf_unfiltered (_("No trace frame found\n"));
2280 /* If we're in nonstop mode and getting out of looking at trace
2281 frames, there won't be any current frame to go back to and
2284 && (has_stack_frames () || traceframe_number
>= 0))
2286 enum print_what print_what
;
2288 /* NOTE: in imitation of the step command, try to determine
2289 whether we have made a transition from one function to
2290 another. If so, we'll print the "stack frame" (ie. the new
2291 function and it's arguments) -- otherwise we'll just show the
2294 if (frame_id_eq (old_frame_id
,
2295 get_frame_id (get_current_frame ())))
2296 print_what
= SRC_LINE
;
2298 print_what
= SRC_AND_LOC
;
2300 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2305 /* trace_find_command takes a trace frame number n,
2306 sends "QTFrame:<n>" to the target,
2307 and accepts a reply that may contain several optional pieces
2308 of information: a frame number, a tracepoint number, and an
2309 indication of whether this is a trap frame or a stepping frame.
2311 The minimal response is just "OK" (which indicates that the
2312 target does not give us a frame number or a tracepoint number).
2313 Instead of that, the target may send us a string containing
2315 F<hexnum> (gives the selected frame number)
2316 T<hexnum> (gives the selected tracepoint number)
2321 trace_find_command (char *args
, int from_tty
)
2322 { /* This should only be called with a numeric argument. */
2325 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2326 error (_("May not look at trace frames while trace is running."));
2328 if (args
== 0 || *args
== 0)
2329 { /* TFIND with no args means find NEXT trace frame. */
2330 if (traceframe_number
== -1)
2331 frameno
= 0; /* "next" is first one. */
2333 frameno
= traceframe_number
+ 1;
2335 else if (0 == strcmp (args
, "-"))
2337 if (traceframe_number
== -1)
2338 error (_("not debugging trace buffer"));
2339 else if (from_tty
&& traceframe_number
== 0)
2340 error (_("already at start of trace buffer"));
2342 frameno
= traceframe_number
- 1;
2344 /* A hack to work around eval's need for fp to have been collected. */
2345 else if (0 == strcmp (args
, "-1"))
2348 frameno
= parse_and_eval_long (args
);
2351 error (_("invalid input (%d is less than zero)"), frameno
);
2353 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2358 trace_find_end_command (char *args
, int from_tty
)
2360 trace_find_command ("-1", from_tty
);
2365 trace_find_none_command (char *args
, int from_tty
)
2367 trace_find_command ("-1", from_tty
);
2372 trace_find_start_command (char *args
, int from_tty
)
2374 trace_find_command ("0", from_tty
);
2377 /* tfind pc command */
2379 trace_find_pc_command (char *args
, int from_tty
)
2383 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2384 error (_("May not look at trace frames while trace is running."));
2386 if (args
== 0 || *args
== 0)
2387 pc
= regcache_read_pc (get_current_regcache ());
2389 pc
= parse_and_eval_address (args
);
2391 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2394 /* tfind tracepoint command */
2396 trace_find_tracepoint_command (char *args
, int from_tty
)
2399 struct tracepoint
*tp
;
2401 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2402 error (_("May not look at trace frames while trace is running."));
2404 if (args
== 0 || *args
== 0)
2406 if (tracepoint_number
== -1)
2407 error (_("No current tracepoint -- please supply an argument."));
2409 tdp
= tracepoint_number
; /* Default is current TDP. */
2412 tdp
= parse_and_eval_long (args
);
2414 /* If we have the tracepoint on hand, use the number that the
2415 target knows about (which may be different if we disconnected
2416 and reconnected). */
2417 tp
= get_tracepoint (tdp
);
2419 tdp
= tp
->number_on_target
;
2421 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2424 /* TFIND LINE command:
2426 This command will take a sourceline for argument, just like BREAK
2427 or TRACE (ie. anything that "decode_line_1" can handle).
2429 With no argument, this command will find the next trace frame
2430 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2433 trace_find_line_command (char *args
, int from_tty
)
2435 static CORE_ADDR start_pc
, end_pc
;
2436 struct symtabs_and_lines sals
;
2437 struct symtab_and_line sal
;
2438 struct cleanup
*old_chain
;
2440 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2441 error (_("May not look at trace frames while trace is running."));
2443 if (args
== 0 || *args
== 0)
2445 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2447 sals
.sals
= (struct symtab_and_line
*)
2448 xmalloc (sizeof (struct symtab_and_line
));
2453 sals
= decode_line_spec (args
, 1);
2457 old_chain
= make_cleanup (xfree
, sals
.sals
);
2458 if (sal
.symtab
== 0)
2459 error (_("No line number information available."));
2461 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2463 if (start_pc
== end_pc
)
2465 printf_filtered ("Line %d of \"%s\"",
2466 sal
.line
, sal
.symtab
->filename
);
2468 printf_filtered (" is at address ");
2469 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2471 printf_filtered (" but contains no code.\n");
2472 sal
= find_pc_line (start_pc
, 0);
2474 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2475 && start_pc
!= end_pc
)
2476 printf_filtered ("Attempting to find line %d instead.\n",
2479 error (_("Cannot find a good line."));
2483 /* Is there any case in which we get here, and have an address
2484 which the user would want to see? If we have debugging
2485 symbols and no line numbers? */
2486 error (_("Line number %d is out of range for \"%s\"."),
2487 sal
.line
, sal
.symtab
->filename
);
2489 /* Find within range of stated line. */
2491 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2493 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2494 do_cleanups (old_chain
);
2497 /* tfind range command */
2499 trace_find_range_command (char *args
, int from_tty
)
2501 static CORE_ADDR start
, stop
;
2504 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2505 error (_("May not look at trace frames while trace is running."));
2507 if (args
== 0 || *args
== 0)
2508 { /* XXX FIXME: what should default behavior be? */
2509 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2513 if (0 != (tmp
= strchr (args
, ',')))
2515 *tmp
++ = '\0'; /* Terminate start address. */
2516 while (isspace ((int) *tmp
))
2518 start
= parse_and_eval_address (args
);
2519 stop
= parse_and_eval_address (tmp
);
2522 { /* No explicit end address? */
2523 start
= parse_and_eval_address (args
);
2524 stop
= start
+ 1; /* ??? */
2527 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2530 /* tfind outside command */
2532 trace_find_outside_command (char *args
, int from_tty
)
2534 CORE_ADDR start
, stop
;
2537 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2538 error (_("May not look at trace frames while trace is running."));
2540 if (args
== 0 || *args
== 0)
2541 { /* XXX FIXME: what should default behavior be? */
2542 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2546 if (0 != (tmp
= strchr (args
, ',')))
2548 *tmp
++ = '\0'; /* Terminate start address. */
2549 while (isspace ((int) *tmp
))
2551 start
= parse_and_eval_address (args
);
2552 stop
= parse_and_eval_address (tmp
);
2555 { /* No explicit end address? */
2556 start
= parse_and_eval_address (args
);
2557 stop
= start
+ 1; /* ??? */
2560 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2563 /* info scope command: list the locals for a scope. */
2565 scope_info (char *args
, int from_tty
)
2567 struct symtabs_and_lines sals
;
2569 struct minimal_symbol
*msym
;
2570 struct block
*block
;
2571 char *symname
, *save_args
= args
;
2572 struct dict_iterator iter
;
2574 struct gdbarch
*gdbarch
;
2577 if (args
== 0 || *args
== 0)
2578 error (_("requires an argument (function, "
2579 "line or *addr) to define a scope"));
2581 sals
= decode_line_1 (&args
, 1, NULL
, 0, NULL
);
2582 if (sals
.nelts
== 0)
2583 return; /* Presumably decode_line_1 has already warned. */
2585 /* Resolve line numbers to PC. */
2586 resolve_sal_pc (&sals
.sals
[0]);
2587 block
= block_for_pc (sals
.sals
[0].pc
);
2591 QUIT
; /* Allow user to bail out with ^C. */
2592 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2594 QUIT
; /* Allow user to bail out with ^C. */
2596 printf_filtered ("Scope for %s:\n", save_args
);
2599 symname
= SYMBOL_PRINT_NAME (sym
);
2600 if (symname
== NULL
|| *symname
== '\0')
2601 continue; /* Probably botched, certainly useless. */
2603 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2605 printf_filtered ("Symbol %s is ", symname
);
2606 switch (SYMBOL_CLASS (sym
))
2609 case LOC_UNDEF
: /* Messed up symbol? */
2610 printf_filtered ("a bogus symbol, class %d.\n",
2611 SYMBOL_CLASS (sym
));
2612 count
--; /* Don't count this one. */
2615 printf_filtered ("a constant with value %ld (0x%lx)",
2616 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2618 case LOC_CONST_BYTES
:
2619 printf_filtered ("constant bytes: ");
2620 if (SYMBOL_TYPE (sym
))
2621 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2622 fprintf_filtered (gdb_stdout
, " %02x",
2623 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2626 printf_filtered ("in static storage at address ");
2627 printf_filtered ("%s", paddress (gdbarch
,
2628 SYMBOL_VALUE_ADDRESS (sym
)));
2631 /* GDBARCH is the architecture associated with the objfile
2632 the symbol is defined in; the target architecture may be
2633 different, and may provide additional registers. However,
2634 we do not know the target architecture at this point.
2635 We assume the objfile architecture will contain all the
2636 standard registers that occur in debug info in that
2638 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2641 if (SYMBOL_IS_ARGUMENT (sym
))
2642 printf_filtered ("an argument in register $%s",
2643 gdbarch_register_name (gdbarch
, regno
));
2645 printf_filtered ("a local variable in register $%s",
2646 gdbarch_register_name (gdbarch
, regno
));
2649 printf_filtered ("an argument at stack/frame offset %ld",
2650 SYMBOL_VALUE (sym
));
2653 printf_filtered ("a local variable at frame offset %ld",
2654 SYMBOL_VALUE (sym
));
2657 printf_filtered ("a reference argument at offset %ld",
2658 SYMBOL_VALUE (sym
));
2660 case LOC_REGPARM_ADDR
:
2661 /* Note comment at LOC_REGISTER. */
2662 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2664 printf_filtered ("the address of an argument, in register $%s",
2665 gdbarch_register_name (gdbarch
, regno
));
2668 printf_filtered ("a typedef.\n");
2671 printf_filtered ("a label at address ");
2672 printf_filtered ("%s", paddress (gdbarch
,
2673 SYMBOL_VALUE_ADDRESS (sym
)));
2676 printf_filtered ("a function at address ");
2677 printf_filtered ("%s",
2678 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2680 case LOC_UNRESOLVED
:
2681 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2684 printf_filtered ("Unresolved Static");
2687 printf_filtered ("static storage at address ");
2688 printf_filtered ("%s",
2689 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2692 case LOC_OPTIMIZED_OUT
:
2693 printf_filtered ("optimized out.\n");
2696 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2697 BLOCK_START (block
),
2701 if (SYMBOL_TYPE (sym
))
2702 printf_filtered (", length %d.\n",
2703 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2705 if (BLOCK_FUNCTION (block
))
2708 block
= BLOCK_SUPERBLOCK (block
);
2711 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2715 /* worker function (cleanup) */
2717 replace_comma (void *data
)
2724 /* Helper for trace_dump_command. Dump the action list starting at
2725 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2726 actions of the body of a while-stepping action. STEPPING_FRAME is
2727 set if the current traceframe was determined to be a while-stepping
2731 trace_dump_actions (struct command_line
*action
,
2732 int stepping_actions
, int stepping_frame
,
2735 char *action_exp
, *next_comma
;
2737 for (; action
!= NULL
; action
= action
->next
)
2739 struct cmd_list_element
*cmd
;
2741 QUIT
; /* Allow user to bail out with ^C. */
2742 action_exp
= action
->line
;
2743 while (isspace ((int) *action_exp
))
2746 /* The collection actions to be done while stepping are
2747 bracketed by the commands "while-stepping" and "end". */
2749 if (*action_exp
== '#') /* comment line */
2752 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2754 error (_("Bad action list item: %s"), action_exp
);
2756 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2760 for (i
= 0; i
< action
->body_count
; ++i
)
2761 trace_dump_actions (action
->body_list
[i
],
2762 1, stepping_frame
, from_tty
);
2764 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2766 /* Display the collected data.
2767 For the trap frame, display only what was collected at
2768 the trap. Likewise for stepping frames, display only
2769 what was collected while stepping. This means that the
2770 two boolean variables, STEPPING_FRAME and
2771 STEPPING_ACTIONS should be equal. */
2772 if (stepping_frame
== stepping_actions
)
2774 if (*action_exp
== '/')
2775 action_exp
= decode_agent_options (action_exp
);
2778 { /* Repeat over a comma-separated list. */
2779 QUIT
; /* Allow user to bail out with ^C. */
2780 if (*action_exp
== ',')
2782 while (isspace ((int) *action_exp
))
2785 next_comma
= strchr (action_exp
, ',');
2787 if (0 == strncasecmp (action_exp
, "$reg", 4))
2788 registers_info (NULL
, from_tty
);
2789 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2791 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2792 locals_info (NULL
, from_tty
);
2793 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2794 args_info (NULL
, from_tty
);
2799 make_cleanup (replace_comma
, next_comma
);
2802 printf_filtered ("%s = ", action_exp
);
2803 output_command (action_exp
, from_tty
);
2804 printf_filtered ("\n");
2808 action_exp
= next_comma
;
2810 while (action_exp
&& *action_exp
== ',');
2816 /* The tdump command. */
2819 trace_dump_command (char *args
, int from_tty
)
2821 struct regcache
*regcache
;
2822 struct tracepoint
*t
;
2823 int stepping_frame
= 0;
2824 struct bp_location
*loc
;
2825 char *line
, *default_collect_line
= NULL
;
2826 struct command_line
*actions
, *default_collect_action
= NULL
;
2827 struct cleanup
*old_chain
= NULL
;
2829 if (tracepoint_number
== -1)
2831 warning (_("No current trace frame."));
2835 t
= get_tracepoint (tracepoint_number
);
2838 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2841 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2842 tracepoint_number
, traceframe_number
);
2844 /* The current frame is a trap frame if the frame PC is equal
2845 to the tracepoint PC. If not, then the current frame was
2846 collected during single-stepping. */
2848 regcache
= get_current_regcache ();
2850 /* If the traceframe's address matches any of the tracepoint's
2851 locations, assume it is a direct hit rather than a while-stepping
2852 frame. (FIXME this is not reliable, should record each frame's
2855 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
2856 if (loc
->address
== regcache_read_pc (regcache
))
2859 actions
= breakpoint_commands (&t
->base
);
2861 /* If there is a default-collect list, make up a collect command,
2862 prepend to the tracepoint's commands, and pass the whole mess to
2863 the trace dump scanner. We need to validate because
2864 default-collect might have been junked since the trace run. */
2865 if (*default_collect
)
2867 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2868 old_chain
= make_cleanup (xfree
, default_collect_line
);
2869 line
= default_collect_line
;
2870 validate_actionline (&line
, &t
->base
);
2871 default_collect_action
= xmalloc (sizeof (struct command_line
));
2872 make_cleanup (xfree
, default_collect_action
);
2873 default_collect_action
->next
= actions
;
2874 default_collect_action
->line
= line
;
2875 actions
= default_collect_action
;
2878 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2880 if (*default_collect
)
2881 do_cleanups (old_chain
);
2884 /* Encode a piece of a tracepoint's source-level definition in a form
2885 that is suitable for both protocol and saving in files. */
2886 /* This version does not do multiple encodes for long strings; it should
2887 return an offset to the next piece to encode. FIXME */
2890 encode_source_string (int tpnum
, ULONGEST addr
,
2891 char *srctype
, char *src
, char *buf
, int buf_size
)
2893 if (80 + strlen (srctype
) > buf_size
)
2894 error (_("Buffer too small for source encoding"));
2895 sprintf (buf
, "%x:%s:%s:%x:%x:",
2896 tpnum
, phex_nz (addr
, sizeof (addr
)),
2897 srctype
, 0, (int) strlen (src
));
2898 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2899 error (_("Source string too long for buffer"));
2900 bin2hex (src
, buf
+ strlen (buf
), 0);
2904 extern int trace_regblock_size
;
2906 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2907 non-zero, the save is performed on the target, otherwise GDB obtains all
2908 trace data and saves it locally. */
2911 trace_save (const char *filename
, int target_does_save
)
2913 struct cleanup
*cleanup
;
2915 struct trace_status
*ts
= current_trace_status ();
2918 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2919 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2923 ULONGEST offset
= 0;
2924 #define MAX_TRACE_UPLOAD 2000
2925 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2928 /* If the target is to save the data to a file on its own, then just
2929 send the command and be done with it. */
2930 if (target_does_save
)
2932 err
= target_save_trace_data (filename
);
2934 error (_("Target failed to save trace data to '%s'."),
2939 /* Get the trace status first before opening the file, so if the
2940 target is losing, we can get out without touching files. */
2941 status
= target_get_trace_status (ts
);
2943 pathname
= tilde_expand (filename
);
2944 cleanup
= make_cleanup (xfree
, pathname
);
2946 fp
= fopen (pathname
, "wb");
2948 error (_("Unable to open file '%s' for saving trace data (%s)"),
2949 filename
, safe_strerror (errno
));
2950 make_cleanup_fclose (fp
);
2952 /* Write a file header, with a high-bit-set char to indicate a
2953 binary file, plus a hint as what this file is, and a version
2954 number in case of future needs. */
2955 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2957 perror_with_name (pathname
);
2959 /* Write descriptive info. */
2961 /* Write out the size of a register block. */
2962 fprintf (fp
, "R %x\n", trace_regblock_size
);
2964 /* Write out status of the tracing run (aka "tstatus" info). */
2965 fprintf (fp
, "status %c;%s",
2966 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
2967 if (ts
->stop_reason
== tracepoint_error
)
2969 char *buf
= (char *) alloca (strlen (ts
->stop_desc
) * 2 + 1);
2971 bin2hex ((gdb_byte
*) ts
->stop_desc
, buf
, 0);
2972 fprintf (fp
, ":%s", buf
);
2974 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
2975 if (ts
->traceframe_count
>= 0)
2976 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
2977 if (ts
->traceframes_created
>= 0)
2978 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
2979 if (ts
->buffer_free
>= 0)
2980 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
2981 if (ts
->buffer_size
>= 0)
2982 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
2983 if (ts
->disconnected_tracing
)
2984 fprintf (fp
, ";disconn:%x", ts
->disconnected_tracing
);
2985 if (ts
->circular_buffer
)
2986 fprintf (fp
, ";circular:%x", ts
->circular_buffer
);
2989 /* Note that we want to upload tracepoints and save those, rather
2990 than simply writing out the local ones, because the user may have
2991 changed tracepoints in GDB in preparation for a future tracing
2992 run, or maybe just mass-deleted all types of breakpoints as part
2993 of cleaning up. So as not to contaminate the session, leave the
2994 data in its uploaded form, don't make into real tracepoints. */
2996 /* Get trace state variables first, they may be checked when parsing
2997 uploaded commands. */
2999 target_upload_trace_state_variables (&uploaded_tsvs
);
3001 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3007 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
3008 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
3011 fprintf (fp
, "tsv %x:%s:%x:%s\n",
3012 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
3013 utsv
->builtin
, buf
);
3019 free_uploaded_tsvs (&uploaded_tsvs
);
3021 target_upload_tracepoints (&uploaded_tps
);
3023 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3024 target_get_tracepoint_status (NULL
, utp
);
3026 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
3028 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
3029 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3030 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
3031 if (utp
->type
== bp_fast_tracepoint
)
3032 fprintf (fp
, ":F%x", utp
->orig_size
);
3034 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
3037 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
3038 fprintf (fp
, "tp A%x:%s:%s\n",
3039 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3040 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
3041 fprintf (fp
, "tp S%x:%s:%s\n",
3042 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
3045 encode_source_string (utp
->number
, utp
->addr
,
3046 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
3047 fprintf (fp
, "tp Z%s\n", buf
);
3049 if (utp
->cond_string
)
3051 encode_source_string (utp
->number
, utp
->addr
,
3052 "cond", utp
->cond_string
,
3053 buf
, MAX_TRACE_UPLOAD
);
3054 fprintf (fp
, "tp Z%s\n", buf
);
3056 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
3058 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
3059 buf
, MAX_TRACE_UPLOAD
);
3060 fprintf (fp
, "tp Z%s\n", buf
);
3062 fprintf (fp
, "tp V%x:%s:%x:%s\n",
3063 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
3065 phex_nz (utp
->traceframe_usage
,
3066 sizeof (utp
->traceframe_usage
)));
3069 free_uploaded_tps (&uploaded_tps
);
3071 /* Mark the end of the definition section. */
3074 /* Get and write the trace data proper. We ask for big blocks, in
3075 the hopes of efficiency, but will take less if the target has
3076 packet size limitations or some such. */
3079 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
3081 error (_("Failure to get requested trace buffer data"));
3082 /* No more data is forthcoming, we're done. */
3085 written
= fwrite (buf
, gotten
, 1, fp
);
3087 perror_with_name (pathname
);
3091 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
3092 written
= fwrite (&gotten
, 4, 1, fp
);
3094 perror_with_name (pathname
);
3096 do_cleanups (cleanup
);
3100 trace_save_command (char *args
, int from_tty
)
3102 int target_does_save
= 0;
3104 char *filename
= NULL
;
3105 struct cleanup
*back_to
;
3108 error_no_arg (_("file in which to save trace data"));
3110 argv
= gdb_buildargv (args
);
3111 back_to
= make_cleanup_freeargv (argv
);
3113 for (; *argv
; ++argv
)
3115 if (strcmp (*argv
, "-r") == 0)
3116 target_does_save
= 1;
3117 else if (**argv
== '-')
3118 error (_("unknown option `%s'"), *argv
);
3124 error_no_arg (_("file in which to save trace data"));
3126 trace_save (filename
, target_does_save
);
3129 printf_filtered (_("Trace data saved to file '%s'.\n"), filename
);
3131 do_cleanups (back_to
);
3134 /* Tell the target what to do with an ongoing tracing run if GDB
3135 disconnects for some reason. */
3138 set_disconnected_tracing (char *args
, int from_tty
,
3139 struct cmd_list_element
*c
)
3141 target_set_disconnected_tracing (disconnected_tracing
);
3145 set_circular_trace_buffer (char *args
, int from_tty
,
3146 struct cmd_list_element
*c
)
3148 target_set_circular_trace_buffer (circular_trace_buffer
);
3152 set_trace_user (char *args
, int from_tty
,
3153 struct cmd_list_element
*c
)
3157 ret
= target_set_trace_notes (trace_user
, NULL
, NULL
);
3160 warning ("Target does not support trace notes, user ignored");
3164 set_trace_notes (char *args
, int from_tty
,
3165 struct cmd_list_element
*c
)
3169 ret
= target_set_trace_notes (NULL
, trace_notes
, NULL
);
3172 warning ("Target does not support trace notes, note ignored");
3176 set_trace_stop_notes (char *args
, int from_tty
,
3177 struct cmd_list_element
*c
)
3181 ret
= target_set_trace_notes (NULL
, NULL
, trace_stop_notes
);
3184 warning ("Target does not support trace notes, stop note ignored");
3187 /* Convert the memory pointed to by mem into hex, placing result in buf.
3188 * Return a pointer to the last char put in buf (null)
3189 * "stolen" from sparc-stub.c
3192 static const char hexchars
[] = "0123456789abcdef";
3195 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3203 *buf
++ = hexchars
[ch
>> 4];
3204 *buf
++ = hexchars
[ch
& 0xf];
3213 get_traceframe_number (void)
3215 return traceframe_number
;
3218 /* Make the traceframe NUM be the current trace frame. Does nothing
3219 if NUM is already current. */
3222 set_current_traceframe (int num
)
3226 if (traceframe_number
== num
)
3228 /* Nothing to do. */
3232 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3235 warning (_("could not change traceframe"));
3237 traceframe_number
= newnum
;
3239 /* Changing the traceframe changes our view of registers and of the
3241 registers_changed ();
3243 clear_traceframe_info ();
3246 /* Make the traceframe NUM be the current trace frame, and do nothing
3250 set_traceframe_number (int num
)
3252 traceframe_number
= num
;
3255 /* A cleanup used when switching away and back from tfind mode. */
3257 struct current_traceframe_cleanup
3259 /* The traceframe we were inspecting. */
3260 int traceframe_number
;
3264 do_restore_current_traceframe_cleanup (void *arg
)
3266 struct current_traceframe_cleanup
*old
= arg
;
3268 set_current_traceframe (old
->traceframe_number
);
3272 restore_current_traceframe_cleanup_dtor (void *arg
)
3274 struct current_traceframe_cleanup
*old
= arg
;
3280 make_cleanup_restore_current_traceframe (void)
3282 struct current_traceframe_cleanup
*old
;
3284 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3285 old
->traceframe_number
= traceframe_number
;
3287 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3288 restore_current_traceframe_cleanup_dtor
);
3292 make_cleanup_restore_traceframe_number (void)
3294 return make_cleanup_restore_integer (&traceframe_number
);
3297 /* Given a number and address, return an uploaded tracepoint with that
3298 number, creating if necessary. */
3300 struct uploaded_tp
*
3301 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3303 struct uploaded_tp
*utp
;
3305 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3306 if (utp
->number
== num
&& utp
->addr
== addr
)
3308 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3309 memset (utp
, 0, sizeof (struct uploaded_tp
));
3312 utp
->actions
= NULL
;
3313 utp
->step_actions
= NULL
;
3314 utp
->cmd_strings
= NULL
;
3321 free_uploaded_tps (struct uploaded_tp
**utpp
)
3323 struct uploaded_tp
*next_one
;
3327 next_one
= (*utpp
)->next
;
3333 /* Given a number and address, return an uploaded tracepoint with that
3334 number, creating if necessary. */
3336 struct uploaded_tsv
*
3337 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3339 struct uploaded_tsv
*utsv
;
3341 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3342 if (utsv
->number
== num
)
3344 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3345 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3347 utsv
->next
= *utsvp
;
3353 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3355 struct uploaded_tsv
*next_one
;
3359 next_one
= (*utsvp
)->next
;
3365 /* FIXME this function is heuristic and will miss the cases where the
3366 conditional is semantically identical but differs in whitespace,
3367 such as "x == 0" vs "x==0". */
3370 cond_string_is_same (char *str1
, char *str2
)
3372 if (str1
== NULL
|| str2
== NULL
)
3373 return (str1
== str2
);
3375 return (strcmp (str1
, str2
) == 0);
3378 /* Look for an existing tracepoint that seems similar enough to the
3379 uploaded one. Enablement isn't compared, because the user can
3380 toggle that freely, and may have done so in anticipation of the
3381 next trace run. Return the location of matched tracepoint. */
3383 struct bp_location
*
3384 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3386 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3388 struct breakpoint
*b
;
3389 struct bp_location
*loc
;
3391 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3393 struct tracepoint
*t
= (struct tracepoint
*) b
;
3395 if (b
->type
== utp
->type
3396 && t
->step_count
== utp
->step
3397 && t
->pass_count
== utp
->pass
3398 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3399 /* FIXME also test actions. */
3402 /* Scan the locations for an address match. */
3403 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3405 if (loc
->address
== utp
->addr
)
3413 /* Given a list of tracepoints uploaded from a target, attempt to
3414 match them up with existing tracepoints, and create new ones if not
3418 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3420 struct uploaded_tp
*utp
;
3422 /* Look for GDB tracepoints that match up with our uploaded versions. */
3423 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3425 struct bp_location
*loc
;
3426 struct tracepoint
*t
;
3428 loc
= find_matching_tracepoint_location (utp
);
3431 /* Mark this location as already inserted. */
3433 t
= (struct tracepoint
*) loc
->owner
;
3434 printf_filtered (_("Assuming tracepoint %d is same "
3435 "as target's tracepoint %d at %s.\n"),
3436 loc
->owner
->number
, utp
->number
,
3437 paddress (loc
->gdbarch
, utp
->addr
));
3441 t
= create_tracepoint_from_upload (utp
);
3443 printf_filtered (_("Created tracepoint %d for "
3444 "target's tracepoint %d at %s.\n"),
3445 t
->base
.number
, utp
->number
,
3446 paddress (get_current_arch (), utp
->addr
));
3448 printf_filtered (_("Failed to create tracepoint for target's "
3449 "tracepoint %d at %s, skipping it.\n"),
3451 paddress (get_current_arch (), utp
->addr
));
3453 /* Whether found or created, record the number used by the
3454 target, to help with mapping target tracepoints back to their
3455 counterparts here. */
3457 t
->number_on_target
= utp
->number
;
3460 free_uploaded_tps (uploaded_tps
);
3463 /* Trace state variables don't have much to identify them beyond their
3464 name, so just use that to detect matches. */
3466 struct trace_state_variable
*
3467 find_matching_tsv (struct uploaded_tsv
*utsv
)
3472 return find_trace_state_variable (utsv
->name
);
3475 struct trace_state_variable
*
3476 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3478 const char *namebase
;
3481 struct trace_state_variable
*tsv
;
3485 namebase
= utsv
->name
;
3486 sprintf (buf
, "%s", namebase
);
3491 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3494 /* Fish for a name that is not in use. */
3495 /* (should check against all internal vars?) */
3496 while (find_trace_state_variable (buf
))
3497 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3499 /* We have an available name, create the variable. */
3500 tsv
= create_trace_state_variable (buf
);
3501 tsv
->initial_value
= utsv
->initial_value
;
3502 tsv
->builtin
= utsv
->builtin
;
3507 /* Given a list of uploaded trace state variables, try to match them
3508 up with existing variables, or create additional ones. */
3511 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3514 struct uploaded_tsv
*utsv
;
3515 struct trace_state_variable
*tsv
;
3518 /* Most likely some numbers will have to be reassigned as part of
3519 the merge, so clear them all in anticipation. */
3520 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3523 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3525 tsv
= find_matching_tsv (utsv
);
3529 printf_filtered (_("Assuming trace state variable $%s "
3530 "is same as target's variable %d.\n"),
3531 tsv
->name
, utsv
->number
);
3535 tsv
= create_tsv_from_upload (utsv
);
3537 printf_filtered (_("Created trace state variable "
3538 "$%s for target's variable %d.\n"),
3539 tsv
->name
, utsv
->number
);
3541 /* Give precedence to numberings that come from the target. */
3543 tsv
->number
= utsv
->number
;
3546 /* Renumber everything that didn't get a target-assigned number. */
3548 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3549 if (tsv
->number
> highest
)
3550 highest
= tsv
->number
;
3553 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3554 if (tsv
->number
== 0)
3555 tsv
->number
= highest
++;
3557 free_uploaded_tsvs (uploaded_tsvs
);
3560 /* target tfile command */
3562 struct target_ops tfile_ops
;
3564 /* Fill in tfile_ops with its defined operations and properties. */
3566 #define TRACE_HEADER_SIZE 8
3568 char *trace_filename
;
3570 off_t trace_frames_offset
;
3572 int cur_traceframe_number
;
3574 int trace_regblock_size
;
3576 static void tfile_interp_line (char *line
,
3577 struct uploaded_tp
**utpp
,
3578 struct uploaded_tsv
**utsvp
);
3580 /* Read SIZE bytes into READBUF from the trace frame, starting at
3581 TRACE_FD's current position. Note that this call `read'
3582 underneath, hence it advances the file's seek position. Throws an
3583 error if the `read' syscall fails, or less than SIZE bytes are
3587 tfile_read (gdb_byte
*readbuf
, int size
)
3591 gotten
= read (trace_fd
, readbuf
, size
);
3593 perror_with_name (trace_filename
);
3594 else if (gotten
< size
)
3595 error (_("Premature end of file while reading trace file"));
3599 tfile_open (char *filename
, int from_tty
)
3601 volatile struct gdb_exception ex
;
3603 struct cleanup
*old_chain
;
3606 char header
[TRACE_HEADER_SIZE
];
3607 char linebuf
[1000]; /* Should be max remote packet size or so. */
3610 struct trace_status
*ts
;
3611 struct uploaded_tp
*uploaded_tps
= NULL
;
3612 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3614 target_preopen (from_tty
);
3616 error (_("No trace file specified."));
3618 filename
= tilde_expand (filename
);
3619 if (!IS_ABSOLUTE_PATH(filename
))
3621 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
3626 old_chain
= make_cleanup (xfree
, filename
);
3628 flags
= O_BINARY
| O_LARGEFILE
;
3630 scratch_chan
= open (filename
, flags
, 0);
3631 if (scratch_chan
< 0)
3632 perror_with_name (filename
);
3634 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3636 discard_cleanups (old_chain
); /* Don't free filename any more. */
3637 unpush_target (&tfile_ops
);
3639 trace_filename
= xstrdup (filename
);
3640 trace_fd
= scratch_chan
;
3643 /* Read the file header and test for validity. */
3644 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
3646 bytes
+= TRACE_HEADER_SIZE
;
3647 if (!(header
[0] == 0x7f
3648 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3649 error (_("File is not a valid trace file."));
3651 push_target (&tfile_ops
);
3653 trace_regblock_size
= 0;
3654 ts
= current_trace_status ();
3655 /* We know we're working with a file. */
3657 /* Set defaults in case there is no status line. */
3658 ts
->running_known
= 0;
3659 ts
->stop_reason
= trace_stop_reason_unknown
;
3660 ts
->traceframe_count
= -1;
3661 ts
->buffer_free
= 0;
3662 ts
->disconnected_tracing
= 0;
3663 ts
->circular_buffer
= 0;
3665 cur_traceframe_number
= -1;
3667 TRY_CATCH (ex
, RETURN_MASK_ALL
)
3669 /* Read through a section of newline-terminated lines that
3670 define things like tracepoints. */
3674 tfile_read (&byte
, 1);
3679 /* Empty line marks end of the definition section. */
3684 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3687 linebuf
[i
++] = byte
;
3689 error (_("Excessively long lines in trace file"));
3692 /* Record the starting offset of the binary trace data. */
3693 trace_frames_offset
= bytes
;
3695 /* If we don't have a blocksize, we can't interpret the
3697 if (trace_regblock_size
== 0)
3698 error (_("No register block size recorded in trace file"));
3702 /* Pop the partially set up target. */
3704 throw_exception (ex
);
3707 inferior_appeared (current_inferior (), TFILE_PID
);
3708 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3709 add_thread_silent (inferior_ptid
);
3711 if (ts
->traceframe_count
<= 0)
3712 warning (_("No traceframes present in this file."));
3714 /* Add the file's tracepoints and variables into the current mix. */
3716 /* Get trace state variables first, they may be checked when parsing
3717 uploaded commands. */
3718 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3720 merge_uploaded_tracepoints (&uploaded_tps
);
3722 post_create_inferior (&tfile_ops
, from_tty
);
3725 /* Interpret the given line from the definitions part of the trace
3729 tfile_interp_line (char *line
,
3730 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3734 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3737 trace_regblock_size
= strtol (p
, &p
, 16);
3739 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3741 p
+= strlen ("status ");
3742 parse_trace_status (p
, current_trace_status ());
3744 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3746 p
+= strlen ("tp ");
3747 parse_tracepoint_definition (p
, utpp
);
3749 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3751 p
+= strlen ("tsv ");
3752 parse_tsv_definition (p
, utsvp
);
3755 warning (_("Ignoring trace file definition \"%s\""), line
);
3758 /* Parse the part of trace status syntax that is shared between
3759 the remote protocol and the trace file reader. */
3762 parse_trace_status (char *line
, struct trace_status
*ts
)
3764 char *p
= line
, *p1
, *p2
, *p3
, *p_temp
;
3768 ts
->running_known
= 1;
3769 ts
->running
= (*p
++ == '1');
3770 ts
->stop_reason
= trace_stop_reason_unknown
;
3771 xfree (ts
->stop_desc
);
3772 ts
->stop_desc
= NULL
;
3773 ts
->traceframe_count
= -1;
3774 ts
->traceframes_created
= -1;
3775 ts
->buffer_free
= -1;
3776 ts
->buffer_size
= -1;
3777 ts
->disconnected_tracing
= 0;
3778 ts
->circular_buffer
= 0;
3779 xfree (ts
->user_name
);
3780 ts
->user_name
= NULL
;
3783 ts
->start_time
= ts
->stop_time
= 0;
3787 p1
= strchr (p
, ':');
3789 error (_("Malformed trace status, at %s\n\
3790 Status line: '%s'\n"), p
, line
);
3791 p3
= strchr (p
, ';');
3793 p3
= p
+ strlen (p
);
3794 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3796 p
= unpack_varlen_hex (++p1
, &val
);
3797 ts
->stop_reason
= trace_buffer_full
;
3799 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3801 p
= unpack_varlen_hex (++p1
, &val
);
3802 ts
->stop_reason
= trace_never_run
;
3804 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3807 p
= unpack_varlen_hex (++p1
, &val
);
3808 ts
->stop_reason
= tracepoint_passcount
;
3809 ts
->stopping_tracepoint
= val
;
3811 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3813 p2
= strchr (++p1
, ':');
3821 ts
->stop_desc
= xmalloc (strlen (line
));
3822 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
3823 ts
->stop_desc
[end
] = '\0';
3826 ts
->stop_desc
= xstrdup ("");
3828 p
= unpack_varlen_hex (++p2
, &val
);
3829 ts
->stop_reason
= tstop_command
;
3831 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3833 p
= unpack_varlen_hex (++p1
, &val
);
3834 ts
->stop_reason
= trace_disconnected
;
3836 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3838 p2
= strchr (++p1
, ':');
3841 ts
->stop_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3842 end
= hex2bin (p1
, ts
->stop_desc
, (p2
- p1
) / 2);
3843 ts
->stop_desc
[end
] = '\0';
3846 ts
->stop_desc
= xstrdup ("");
3848 p
= unpack_varlen_hex (++p2
, &val
);
3849 ts
->stopping_tracepoint
= val
;
3850 ts
->stop_reason
= tracepoint_error
;
3852 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3854 p
= unpack_varlen_hex (++p1
, &val
);
3855 ts
->traceframe_count
= val
;
3857 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3859 p
= unpack_varlen_hex (++p1
, &val
);
3860 ts
->traceframes_created
= val
;
3862 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3864 p
= unpack_varlen_hex (++p1
, &val
);
3865 ts
->buffer_free
= val
;
3867 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3869 p
= unpack_varlen_hex (++p1
, &val
);
3870 ts
->buffer_size
= val
;
3872 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3874 p
= unpack_varlen_hex (++p1
, &val
);
3875 ts
->disconnected_tracing
= val
;
3877 else if (strncmp (p
, "circular", p1
- p
) == 0)
3879 p
= unpack_varlen_hex (++p1
, &val
);
3880 ts
->circular_buffer
= val
;
3882 else if (strncmp (p
, "starttime", p1
- p
) == 0)
3884 p
= unpack_varlen_hex (++p1
, &val
);
3885 ts
->start_time
= val
;
3887 else if (strncmp (p
, "stoptime", p1
- p
) == 0)
3889 p
= unpack_varlen_hex (++p1
, &val
);
3890 ts
->stop_time
= val
;
3892 else if (strncmp (p
, "username", p1
- p
) == 0)
3895 ts
->user_name
= xmalloc (strlen (p
) / 2);
3896 end
= hex2bin (p1
, ts
->user_name
, (p3
- p1
) / 2);
3897 ts
->user_name
[end
] = '\0';
3900 else if (strncmp (p
, "notes", p1
- p
) == 0)
3903 ts
->notes
= xmalloc (strlen (p
) / 2);
3904 end
= hex2bin (p1
, ts
->notes
, (p3
- p1
) / 2);
3905 ts
->notes
[end
] = '\0';
3910 /* Silently skip unknown optional info. */
3911 p_temp
= strchr (p1
+ 1, ';');
3915 /* Must be at the end. */
3922 parse_tracepoint_status (char *p
, struct breakpoint
*bp
,
3923 struct uploaded_tp
*utp
)
3926 struct tracepoint
*tp
= (struct tracepoint
*) bp
;
3928 p
= unpack_varlen_hex (p
, &uval
);
3930 tp
->base
.hit_count
+= uval
;
3932 utp
->hit_count
+= uval
;
3933 p
= unpack_varlen_hex (p
+ 1, &uval
);
3935 tp
->traceframe_usage
+= uval
;
3937 utp
->traceframe_usage
+= uval
;
3938 /* Ignore any extra, allowing for future extensions. */
3941 /* Given a line of text defining a part of a tracepoint, parse it into
3942 an "uploaded tracepoint". */
3945 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3949 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3952 char *cond
, *srctype
, *buf
;
3953 struct uploaded_tp
*utp
= NULL
;
3956 /* Both tracepoint and action definitions start with the same number
3957 and address sequence. */
3959 p
= unpack_varlen_hex (p
, &num
);
3960 p
++; /* skip a colon */
3961 p
= unpack_varlen_hex (p
, &addr
);
3962 p
++; /* skip a colon */
3965 enabled
= (*p
++ == 'E');
3966 p
++; /* skip a colon */
3967 p
= unpack_varlen_hex (p
, &step
);
3968 p
++; /* skip a colon */
3969 p
= unpack_varlen_hex (p
, &pass
);
3970 type
= bp_tracepoint
;
3972 /* Thumb through optional fields. */
3975 p
++; /* skip a colon */
3978 type
= bp_fast_tracepoint
;
3980 p
= unpack_varlen_hex (p
, &orig_size
);
3984 type
= bp_static_tracepoint
;
3990 p
= unpack_varlen_hex (p
, &xlen
);
3991 p
++; /* skip a comma */
3992 cond
= (char *) xmalloc (2 * xlen
+ 1);
3993 strncpy (cond
, p
, 2 * xlen
);
3994 cond
[2 * xlen
] = '\0';
3998 warning (_("Unrecognized char '%c' in tracepoint "
3999 "definition, skipping rest"), *p
);
4001 utp
= get_uploaded_tp (num
, addr
, utpp
);
4003 utp
->enabled
= enabled
;
4008 else if (piece
== 'A')
4010 utp
= get_uploaded_tp (num
, addr
, utpp
);
4011 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
4013 else if (piece
== 'S')
4015 utp
= get_uploaded_tp (num
, addr
, utpp
);
4016 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
4018 else if (piece
== 'Z')
4020 /* Parse a chunk of source form definition. */
4021 utp
= get_uploaded_tp (num
, addr
, utpp
);
4023 p
= strchr (p
, ':');
4024 p
++; /* skip a colon */
4025 p
= unpack_varlen_hex (p
, &start
);
4026 p
++; /* skip a colon */
4027 p
= unpack_varlen_hex (p
, &xlen
);
4028 p
++; /* skip a colon */
4030 buf
= alloca (strlen (line
));
4032 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4035 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
4036 utp
->at_string
= xstrdup (buf
);
4037 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
4038 utp
->cond_string
= xstrdup (buf
);
4039 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
4040 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
4042 else if (piece
== 'V')
4044 utp
= get_uploaded_tp (num
, addr
, utpp
);
4046 parse_tracepoint_status (p
, NULL
, utp
);
4050 /* Don't error out, the target might be sending us optional
4051 info that we don't care about. */
4052 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
4056 /* Convert a textual description of a trace state variable into an
4060 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
4063 ULONGEST num
, initval
, builtin
;
4065 struct uploaded_tsv
*utsv
= NULL
;
4067 buf
= alloca (strlen (line
));
4070 p
= unpack_varlen_hex (p
, &num
);
4071 p
++; /* skip a colon */
4072 p
= unpack_varlen_hex (p
, &initval
);
4073 p
++; /* skip a colon */
4074 p
= unpack_varlen_hex (p
, &builtin
);
4075 p
++; /* skip a colon */
4076 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
4079 utsv
= get_uploaded_tsv (num
, utsvp
);
4080 utsv
->initial_value
= initval
;
4081 utsv
->builtin
= builtin
;
4082 utsv
->name
= xstrdup (buf
);
4085 /* Close the trace file and generally clean up. */
4088 tfile_close (int quitting
)
4095 pid
= ptid_get_pid (inferior_ptid
);
4096 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff. */
4097 exit_inferior_silent (pid
);
4101 xfree (trace_filename
);
4102 trace_filename
= NULL
;
4106 tfile_files_info (struct target_ops
*t
)
4108 /* (it would be useful to mention the name of the file). */
4109 printf_filtered ("Looking at a trace file.\n");
4112 /* The trace status for a file is that tracing can never be run. */
4115 tfile_get_trace_status (struct trace_status
*ts
)
4117 /* Other bits of trace status were collected as part of opening the
4118 trace files, so nothing to do here. */
4124 tfile_get_tracepoint_status (struct breakpoint
*tp
, struct uploaded_tp
*utp
)
4126 /* Other bits of trace status were collected as part of opening the
4127 trace files, so nothing to do here. */
4130 /* Given the position of a traceframe in the file, figure out what
4131 address the frame was collected at. This would normally be the
4132 value of a collected PC register, but if not available, we
4136 tfile_get_traceframe_address (off_t tframe_offset
)
4140 struct tracepoint
*tp
;
4141 off_t saved_offset
= cur_offset
;
4143 /* FIXME dig pc out of collected registers. */
4145 /* Fall back to using tracepoint address. */
4146 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
4147 tfile_read ((gdb_byte
*) &tpnum
, 2);
4148 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4152 tp
= get_tracepoint_by_number_on_target (tpnum
);
4153 /* FIXME this is a poor heuristic if multiple locations. */
4154 if (tp
&& tp
->base
.loc
)
4155 addr
= tp
->base
.loc
->address
;
4157 /* Restore our seek position. */
4158 cur_offset
= saved_offset
;
4159 lseek (trace_fd
, cur_offset
, SEEK_SET
);
4163 /* Make tfile's selected traceframe match GDB's selected
4167 set_tfile_traceframe (void)
4171 if (cur_traceframe_number
== get_traceframe_number ())
4174 /* Avoid recursion, tfile_trace_find calls us again. */
4175 cur_traceframe_number
= get_traceframe_number ();
4177 newnum
= target_trace_find (tfind_number
,
4178 get_traceframe_number (), 0, 0, NULL
);
4180 /* Should not happen. If it does, all bets are off. */
4181 if (newnum
!= get_traceframe_number ())
4182 warning (_("could not set tfile's traceframe"));
4185 /* Given a type of search and some parameters, scan the collection of
4186 traceframes in the file looking for a match. When found, return
4187 both the traceframe and tracepoint number, otherwise -1 for
4191 tfile_trace_find (enum trace_find_type type
, int num
,
4192 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
4195 int tfnum
= 0, found
= 0;
4196 unsigned int data_size
;
4197 struct tracepoint
*tp
;
4198 off_t offset
, tframe_offset
;
4201 /* Lookups other than by absolute frame number depend on the current
4202 trace selected, so make sure it is correct on the tfile end
4204 if (type
!= tfind_number
)
4205 set_tfile_traceframe ();
4213 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
4214 offset
= trace_frames_offset
;
4217 tframe_offset
= offset
;
4218 tfile_read ((gdb_byte
*) &tpnum
, 2);
4219 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4225 tfile_read ((gdb_byte
*) &data_size
, 4);
4226 data_size
= (unsigned int) extract_unsigned_integer
4227 ((gdb_byte
*) &data_size
, 4,
4228 gdbarch_byte_order (target_gdbarch
));
4237 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4238 if (tfaddr
== addr1
)
4242 tp
= get_tracepoint (num
);
4243 if (tp
&& tpnum
== tp
->number_on_target
)
4247 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4248 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
4252 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4253 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
4257 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
4263 cur_offset
= offset
;
4264 cur_data_size
= data_size
;
4265 cur_traceframe_number
= tfnum
;
4268 /* Skip past the traceframe's data. */
4269 lseek (trace_fd
, data_size
, SEEK_CUR
);
4270 offset
+= data_size
;
4271 /* Update our own count of traceframes. */
4274 /* Did not find what we were looking for. */
4280 /* Prototype of the callback passed to tframe_walk_blocks. */
4281 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
4283 /* Callback for traceframe_walk_blocks, used to find a given block
4284 type in a traceframe. */
4287 match_blocktype (char blocktype
, void *data
)
4289 char *wantedp
= data
;
4291 if (*wantedp
== blocktype
)
4297 /* Walk over all traceframe block starting at POS offset from
4298 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4299 unmodified. If CALLBACK returns true, this returns the position in
4300 the traceframe where the block is found, relative to the start of
4301 the traceframe (cur_offset). Returns -1 if no callback call
4302 returned true, indicating that all blocks have been walked. */
4305 traceframe_walk_blocks (walk_blocks_callback_func callback
,
4306 int pos
, void *data
)
4308 /* Iterate through a traceframe's blocks, looking for a block of the
4311 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
4312 while (pos
< cur_data_size
)
4314 unsigned short mlen
;
4317 tfile_read (&block_type
, 1);
4321 if ((*callback
) (block_type
, data
))
4327 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4328 pos
+= trace_regblock_size
;
4331 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4332 tfile_read ((gdb_byte
*) &mlen
, 2);
4333 mlen
= (unsigned short)
4334 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4337 lseek (trace_fd
, mlen
, SEEK_CUR
);
4338 pos
+= (8 + 2 + mlen
);
4341 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
4345 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4346 block_type
, block_type
);
4354 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4355 position offset of a block of type TYPE_WANTED in the current trace
4356 frame, starting at POS. Returns -1 if no such block was found. */
4359 traceframe_find_block_type (char type_wanted
, int pos
)
4361 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
4364 /* Look for a block of saved registers in the traceframe, and get the
4365 requested register from it. */
4368 tfile_fetch_registers (struct target_ops
*ops
,
4369 struct regcache
*regcache
, int regno
)
4371 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4373 int pos
, offset
, regn
, regsize
, pc_regno
;
4374 unsigned short mlen
;
4377 /* An uninitialized reg size says we're not going to be
4378 successful at getting register blocks. */
4379 if (!trace_regblock_size
)
4382 set_tfile_traceframe ();
4384 regs
= alloca (trace_regblock_size
);
4386 if (traceframe_find_block_type ('R', 0) >= 0)
4388 tfile_read (regs
, trace_regblock_size
);
4390 /* Assume the block is laid out in GDB register number order,
4391 each register with the size that it has in GDB. */
4393 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4395 regsize
= register_size (gdbarch
, regn
);
4396 /* Make sure we stay within block bounds. */
4397 if (offset
+ regsize
>= trace_regblock_size
)
4399 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
4403 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
4406 else if (regno
== -1)
4408 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
4416 /* We get here if no register data has been found. Mark registers
4418 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4419 regcache_raw_supply (regcache
, regn
, NULL
);
4421 /* We can often usefully guess that the PC is going to be the same
4422 as the address of the tracepoint. */
4423 pc_regno
= gdbarch_pc_regnum (gdbarch
);
4424 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
4426 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
4428 if (tp
&& tp
->base
.loc
)
4430 /* But don't try to guess if tracepoint is multi-location... */
4431 if (tp
->base
.loc
->next
)
4433 warning (_("Tracepoint %d has multiple "
4434 "locations, cannot infer $pc"),
4438 /* ... or does while-stepping. */
4439 if (tp
->step_count
> 0)
4441 warning (_("Tracepoint %d does while-stepping, "
4442 "cannot infer $pc"),
4447 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
4448 gdbarch_byte_order (gdbarch
),
4449 tp
->base
.loc
->address
);
4450 regcache_raw_supply (regcache
, pc_regno
, regs
);
4456 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4457 const char *annex
, gdb_byte
*readbuf
,
4458 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
4460 /* We're only doing regular memory for now. */
4461 if (object
!= TARGET_OBJECT_MEMORY
)
4464 if (readbuf
== NULL
)
4465 error (_("tfile_xfer_partial: trace file is read-only"));
4467 set_tfile_traceframe ();
4469 if (traceframe_number
!= -1)
4473 /* Iterate through the traceframe's blocks, looking for
4475 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
4477 ULONGEST maddr
, amt
;
4478 unsigned short mlen
;
4479 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
4481 tfile_read ((gdb_byte
*) &maddr
, 8);
4482 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
4484 tfile_read ((gdb_byte
*) &mlen
, 2);
4485 mlen
= (unsigned short)
4486 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
4488 /* If the block includes the first part of the desired
4489 range, return as much it has; GDB will re-request the
4490 remainder, which might be in a different block of this
4492 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
4494 amt
= (maddr
+ mlen
) - offset
;
4498 tfile_read (readbuf
, amt
);
4502 /* Skip over this block. */
4503 pos
+= (8 + 2 + mlen
);
4507 /* It's unduly pedantic to refuse to look at the executable for
4508 read-only pieces; so do the equivalent of readonly regions aka
4510 /* FIXME account for relocation at some point. */
4517 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
4519 if ((s
->flags
& SEC_LOAD
) == 0
4520 || (s
->flags
& SEC_READONLY
) == 0)
4524 size
= bfd_get_section_size (s
);
4525 if (vma
<= offset
&& offset
< (vma
+ size
))
4529 amt
= (vma
+ size
) - offset
;
4533 amt
= bfd_get_section_contents (exec_bfd
, s
,
4534 readbuf
, offset
- vma
, amt
);
4540 /* Indicate failure to find the requested memory block. */
4544 /* Iterate through the blocks of a trace frame, looking for a 'V'
4545 block with a matching tsv number. */
4548 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
4552 set_tfile_traceframe ();
4555 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
4559 tfile_read ((gdb_byte
*) &vnum
, 4);
4560 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
4565 tfile_read ((gdb_byte
*) val
, 8);
4566 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
4574 /* Didn't find anything. */
4579 tfile_has_all_memory (struct target_ops
*ops
)
4585 tfile_has_memory (struct target_ops
*ops
)
4591 tfile_has_stack (struct target_ops
*ops
)
4593 return traceframe_number
!= -1;
4597 tfile_has_registers (struct target_ops
*ops
)
4599 return traceframe_number
!= -1;
4603 tfile_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
4608 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
4609 object for the tfile target's current traceframe. */
4612 build_traceframe_info (char blocktype
, void *data
)
4614 struct traceframe_info
*info
= data
;
4620 struct mem_range
*r
;
4622 unsigned short mlen
;
4624 tfile_read ((gdb_byte
*) &maddr
, 8);
4625 tfile_read ((gdb_byte
*) &mlen
, 2);
4627 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4640 warning (_("Unhandled trace block type (%d) '%c ' "
4641 "while building trace frame info."),
4642 blocktype
, blocktype
);
4649 static struct traceframe_info
*
4650 tfile_traceframe_info (void)
4652 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
4654 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
4659 init_tfile_ops (void)
4661 tfile_ops
.to_shortname
= "tfile";
4662 tfile_ops
.to_longname
= "Local trace dump file";
4664 = "Use a trace file as a target. Specify the filename of the trace file.";
4665 tfile_ops
.to_open
= tfile_open
;
4666 tfile_ops
.to_close
= tfile_close
;
4667 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
4668 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
4669 tfile_ops
.to_files_info
= tfile_files_info
;
4670 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
4671 tfile_ops
.to_get_tracepoint_status
= tfile_get_tracepoint_status
;
4672 tfile_ops
.to_trace_find
= tfile_trace_find
;
4673 tfile_ops
.to_get_trace_state_variable_value
4674 = tfile_get_trace_state_variable_value
;
4675 tfile_ops
.to_stratum
= process_stratum
;
4676 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
4677 tfile_ops
.to_has_memory
= tfile_has_memory
;
4678 tfile_ops
.to_has_stack
= tfile_has_stack
;
4679 tfile_ops
.to_has_registers
= tfile_has_registers
;
4680 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
4681 tfile_ops
.to_thread_alive
= tfile_thread_alive
;
4682 tfile_ops
.to_magic
= OPS_MAGIC
;
4685 /* Given a line of text defining a static tracepoint marker, parse it
4686 into a "static tracepoint marker" object. Throws an error is
4687 parsing fails. If PP is non-null, it points to one past the end of
4688 the parsed marker definition. */
4691 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
4692 struct static_tracepoint_marker
*marker
)
4699 p
= unpack_varlen_hex (p
, &addr
);
4700 p
++; /* skip a colon */
4702 marker
->gdbarch
= target_gdbarch
;
4703 marker
->address
= (CORE_ADDR
) addr
;
4705 endp
= strchr (p
, ':');
4707 error (_("bad marker definition: %s"), line
);
4709 marker
->str_id
= xmalloc (endp
- p
+ 1);
4710 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
4711 marker
->str_id
[end
] = '\0';
4714 p
++; /* skip a colon */
4716 marker
->extra
= xmalloc (strlen (p
) + 1);
4717 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
4718 marker
->extra
[end
] = '\0';
4724 /* Release a static tracepoint marker's contents. Note that the
4725 object itself isn't released here. There objects are usually on
4729 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
4731 xfree (marker
->str_id
);
4732 marker
->str_id
= NULL
;
4735 /* Print MARKER to gdb_stdout. */
4738 print_one_static_tracepoint_marker (int count
,
4739 struct static_tracepoint_marker
*marker
)
4741 struct command_line
*l
;
4744 char wrap_indent
[80];
4745 char extra_field_indent
[80];
4746 struct ui_out
*uiout
= current_uiout
;
4747 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
4748 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4749 struct cleanup
*bkpt_chain
;
4750 VEC(breakpoint_p
) *tracepoints
;
4752 struct symtab_and_line sal
;
4756 sal
.pc
= marker
->address
;
4758 tracepoints
= static_tracepoints_here (marker
->address
);
4760 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
4762 /* A counter field to help readability. This is not a stable
4764 ui_out_field_int (uiout
, "count", count
);
4766 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
4768 ui_out_field_fmt (uiout
, "enabled", "%c",
4769 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
4770 ui_out_spaces (uiout
, 2);
4772 strcpy (wrap_indent
, " ");
4774 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
4775 strcat (wrap_indent
, " ");
4777 strcat (wrap_indent
, " ");
4779 strcpy (extra_field_indent
, " ");
4781 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
4783 sal
= find_pc_line (marker
->address
, 0);
4784 sym
= find_pc_sect_function (marker
->address
, NULL
);
4787 ui_out_text (uiout
, "in ");
4788 ui_out_field_string (uiout
, "func",
4789 SYMBOL_PRINT_NAME (sym
));
4790 ui_out_wrap_hint (uiout
, wrap_indent
);
4791 ui_out_text (uiout
, " at ");
4794 ui_out_field_skip (uiout
, "func");
4796 if (sal
.symtab
!= NULL
)
4798 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
4799 ui_out_text (uiout
, ":");
4801 if (ui_out_is_mi_like_p (uiout
))
4803 char *fullname
= symtab_to_fullname (sal
.symtab
);
4806 ui_out_field_string (uiout
, "fullname", fullname
);
4809 ui_out_field_skip (uiout
, "fullname");
4811 ui_out_field_int (uiout
, "line", sal
.line
);
4815 ui_out_field_skip (uiout
, "fullname");
4816 ui_out_field_skip (uiout
, "line");
4819 ui_out_text (uiout
, "\n");
4820 ui_out_text (uiout
, extra_field_indent
);
4821 ui_out_text (uiout
, _("Data: \""));
4822 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
4823 ui_out_text (uiout
, "\"\n");
4825 if (!VEC_empty (breakpoint_p
, tracepoints
))
4827 struct cleanup
*cleanup_chain
;
4829 struct breakpoint
*b
;
4831 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
4834 ui_out_text (uiout
, extra_field_indent
);
4835 ui_out_text (uiout
, _("Probed by static tracepoints: "));
4836 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
4839 ui_out_text (uiout
, ", ");
4840 ui_out_text (uiout
, "#");
4841 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
4844 do_cleanups (cleanup_chain
);
4846 if (ui_out_is_mi_like_p (uiout
))
4847 ui_out_field_int (uiout
, "number-of-tracepoints",
4848 VEC_length(breakpoint_p
, tracepoints
));
4850 ui_out_text (uiout
, "\n");
4852 VEC_free (breakpoint_p
, tracepoints
);
4854 do_cleanups (bkpt_chain
);
4855 do_cleanups (old_chain
);
4859 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
4861 VEC(static_tracepoint_marker_p
) *markers
;
4862 struct cleanup
*old_chain
;
4863 struct static_tracepoint_marker
*marker
;
4864 struct ui_out
*uiout
= current_uiout
;
4868 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
4869 "StaticTracepointMarkersTable");
4871 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
4873 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
4875 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
4876 if (gdbarch_addr_bit (target_gdbarch
) <= 32)
4877 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
4879 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
4880 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
4882 ui_out_table_body (uiout
);
4884 markers
= target_static_tracepoint_markers_by_strid (NULL
);
4885 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
4888 VEC_iterate (static_tracepoint_marker_p
,
4889 markers
, i
, marker
);
4892 print_one_static_tracepoint_marker (i
+ 1, marker
);
4893 release_static_tracepoint_marker (marker
);
4896 do_cleanups (old_chain
);
4899 /* The $_sdata convenience variable is a bit special. We don't know
4900 for sure type of the value until we actually have a chance to fetch
4901 the data --- the size of the object depends on what has been
4902 collected. We solve this by making $_sdata be an internalvar that
4903 creates a new value on access. */
4905 /* Return a new value with the correct type for the sdata object of
4906 the current trace frame. Return a void value if there's no object
4909 static struct value
*
4910 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
)
4915 /* We need to read the whole object before we know its size. */
4916 size
= target_read_alloc (¤t_target
,
4917 TARGET_OBJECT_STATIC_TRACE_DATA
,
4924 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
4926 v
= allocate_value (type
);
4927 memcpy (value_contents_raw (v
), buf
, size
);
4932 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
4935 #if !defined(HAVE_LIBEXPAT)
4937 struct traceframe_info
*
4938 parse_traceframe_info (const char *tframe_info
)
4940 static int have_warned
;
4945 warning (_("Can not parse XML trace frame info; XML support "
4946 "was disabled at compile time"));
4952 #else /* HAVE_LIBEXPAT */
4954 #include "xml-support.h"
4956 /* Handle the start of a <memory> element. */
4959 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
4960 const struct gdb_xml_element
*element
,
4961 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
4963 struct traceframe_info
*info
= user_data
;
4964 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4965 ULONGEST
*start_p
, *length_p
;
4967 start_p
= xml_find_attribute (attributes
, "start")->value
;
4968 length_p
= xml_find_attribute (attributes
, "length")->value
;
4970 r
->start
= *start_p
;
4971 r
->length
= *length_p
;
4974 /* Discard the constructed trace frame info (if an error occurs). */
4977 free_result (void *p
)
4979 struct traceframe_info
*result
= p
;
4981 free_traceframe_info (result
);
4984 /* The allowed elements and attributes for an XML memory map. */
4986 static const struct gdb_xml_attribute memory_attributes
[] = {
4987 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
4988 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
4989 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
4992 static const struct gdb_xml_element traceframe_info_children
[] = {
4993 { "memory", memory_attributes
, NULL
,
4994 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
4995 traceframe_info_start_memory
, NULL
},
4996 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
4999 static const struct gdb_xml_element traceframe_info_elements
[] = {
5000 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
5002 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
5005 /* Parse a traceframe-info XML document. */
5007 struct traceframe_info
*
5008 parse_traceframe_info (const char *tframe_info
)
5010 struct traceframe_info
*result
;
5011 struct cleanup
*back_to
;
5013 result
= XCNEW (struct traceframe_info
);
5014 back_to
= make_cleanup (free_result
, result
);
5016 if (gdb_xml_parse_quick (_("trace frame info"),
5017 "traceframe-info.dtd", traceframe_info_elements
,
5018 tframe_info
, result
) == 0)
5020 /* Parsed successfully, keep the result. */
5021 discard_cleanups (back_to
);
5026 do_cleanups (back_to
);
5030 #endif /* HAVE_LIBEXPAT */
5032 /* Returns the traceframe_info object for the current traceframe.
5033 This is where we avoid re-fetching the object from the target if we
5034 already have it cached. */
5036 struct traceframe_info
*
5037 get_traceframe_info (void)
5039 if (traceframe_info
== NULL
)
5040 traceframe_info
= target_traceframe_info ();
5042 return traceframe_info
;
5045 /* If the target supports the query, return in RESULT the set of
5046 collected memory in the current traceframe, found within the LEN
5047 bytes range starting at MEMADDR. Returns true if the target
5048 supports the query, otherwise returns false, and RESULT is left
5052 traceframe_available_memory (VEC(mem_range_s
) **result
,
5053 CORE_ADDR memaddr
, ULONGEST len
)
5055 struct traceframe_info
*info
= get_traceframe_info ();
5059 struct mem_range
*r
;
5064 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
5065 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
5067 ULONGEST lo1
, hi1
, lo2
, hi2
;
5068 struct mem_range
*nr
;
5071 hi1
= memaddr
+ len
;
5074 hi2
= r
->start
+ r
->length
;
5076 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
5078 nr
->start
= max (lo1
, lo2
);
5079 nr
->length
= min (hi1
, hi2
) - nr
->start
;
5082 normalize_mem_ranges (*result
);
5089 /* module initialization */
5091 _initialize_tracepoint (void)
5093 struct cmd_list_element
*c
;
5095 /* Explicitly create without lookup, since that tries to create a
5096 value with a void typed value, and when we get here, gdbarch
5097 isn't initialized yet. At this point, we're quite sure there
5098 isn't another convenience variable of the same name. */
5099 create_internalvar_type_lazy ("_sdata", sdata_make_value
);
5101 traceframe_number
= -1;
5102 tracepoint_number
= -1;
5104 if (tracepoint_list
.list
== NULL
)
5106 tracepoint_list
.listsize
= 128;
5107 tracepoint_list
.list
= xmalloc
5108 (tracepoint_list
.listsize
* sizeof (struct memrange
));
5110 if (tracepoint_list
.aexpr_list
== NULL
)
5112 tracepoint_list
.aexpr_listsize
= 128;
5113 tracepoint_list
.aexpr_list
= xmalloc
5114 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5117 if (stepping_list
.list
== NULL
)
5119 stepping_list
.listsize
= 128;
5120 stepping_list
.list
= xmalloc
5121 (stepping_list
.listsize
* sizeof (struct memrange
));
5124 if (stepping_list
.aexpr_list
== NULL
)
5126 stepping_list
.aexpr_listsize
= 128;
5127 stepping_list
.aexpr_list
= xmalloc
5128 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
5131 add_info ("scope", scope_info
,
5132 _("List the variables local to a scope"));
5134 add_cmd ("tracepoints", class_trace
, NULL
,
5135 _("Tracing of program execution without stopping the program."),
5138 add_com ("tdump", class_trace
, trace_dump_command
,
5139 _("Print everything collected at the current tracepoint."));
5141 add_com ("tsave", class_trace
, trace_save_command
, _("\
5142 Save the trace data to a file.\n\
5143 Use the '-r' option to direct the target to save directly to the file,\n\
5144 using its own filesystem."));
5146 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
5147 Define a trace state variable.\n\
5148 Argument is a $-prefixed name, optionally followed\n\
5149 by '=' and an expression that sets the initial value\n\
5150 at the start of tracing."));
5151 set_cmd_completer (c
, expression_completer
);
5153 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
5154 Delete one or more trace state variables.\n\
5155 Arguments are the names of the variables to delete.\n\
5156 If no arguments are supplied, delete all variables."), &deletelist
);
5157 /* FIXME add a trace variable completer. */
5159 add_info ("tvariables", tvariables_info
, _("\
5160 Status of trace state variables and their values.\n\
5163 add_info ("static-tracepoint-markers",
5164 info_static_tracepoint_markers_command
, _("\
5165 List target static tracepoints markers.\n\
5168 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
5169 Select a trace frame;\n\
5170 No argument means forward by one frame; '-' means backward by one frame."),
5171 &tfindlist
, "tfind ", 1, &cmdlist
);
5173 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
5174 Select a trace frame whose PC is outside the given range (exclusive).\n\
5175 Usage: tfind outside addr1, addr2"),
5178 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
5179 Select a trace frame whose PC is in the given range (inclusive).\n\
5180 Usage: tfind range addr1,addr2"),
5183 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
5184 Select a trace frame by source line.\n\
5185 Argument can be a line number (with optional source file),\n\
5186 a function name, or '*' followed by an address.\n\
5187 Default argument is 'the next source line that was traced'."),
5190 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
5191 Select a trace frame by tracepoint number.\n\
5192 Default is the tracepoint for the current trace frame."),
5195 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
5196 Select a trace frame by PC.\n\
5197 Default is the current PC, or the PC of the current trace frame."),
5200 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
5201 Synonym for 'none'.\n\
5202 De-select any trace frame and resume 'live' debugging."),
5205 add_cmd ("none", class_trace
, trace_find_none_command
,
5206 _("De-select any trace frame and resume 'live' debugging."),
5209 add_cmd ("start", class_trace
, trace_find_start_command
,
5210 _("Select the first trace frame in the trace buffer."),
5213 add_com ("tstatus", class_trace
, trace_status_command
,
5214 _("Display the status of the current trace data collection."));
5216 add_com ("tstop", class_trace
, trace_stop_command
, _("\
5217 Stop trace data collection.\n\
5218 Usage: tstop [ <notes> ... ]\n\
5219 Any arguments supplied are recorded with the trace as a stop reason and\n\
5220 reported by tstatus (if the target supports trace notes)."));
5222 add_com ("tstart", class_trace
, trace_start_command
, _("\
5223 Start trace data collection.\n\
5224 Usage: tstart [ <notes> ... ]\n\
5225 Any arguments supplied are recorded with the trace as a note and\n\
5226 reported by tstatus (if the target supports trace notes)."));
5228 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
5229 Ends a list of commands or actions.\n\
5230 Several GDB commands allow you to enter a list of commands or actions.\n\
5231 Entering \"end\" on a line by itself is the normal way to terminate\n\
5233 Note: the \"end\" command cannot be used at the gdb prompt."));
5235 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
5236 Specify single-stepping behavior at a tracepoint.\n\
5237 Argument is number of instructions to trace in single-step mode\n\
5238 following the tracepoint. This command is normally followed by\n\
5239 one or more \"collect\" commands, to specify what to collect\n\
5240 while single-stepping.\n\n\
5241 Note: this command can only be used in a tracepoint \"actions\" list."));
5243 add_com_alias ("ws", "while-stepping", class_alias
, 0);
5244 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
5246 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
5247 Specify one or more data items to be collected at a tracepoint.\n\
5248 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5249 collect all data (variables, registers) referenced by that expression.\n\
5250 Also accepts the following special arguments:\n\
5251 $regs -- all registers.\n\
5252 $args -- all function arguments.\n\
5253 $locals -- all variables local to the block/function scope.\n\
5254 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5255 Note: this command can only be used in a tracepoint \"actions\" list."));
5257 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
5258 Specify one or more expressions to be evaluated at a tracepoint.\n\
5259 Accepts a comma-separated list of (one or more) expressions.\n\
5260 The result of each evaluation will be discarded.\n\
5261 Note: this command can only be used in a tracepoint \"actions\" list."));
5263 add_com ("actions", class_trace
, trace_actions_command
, _("\
5264 Specify the actions to be taken at a tracepoint.\n\
5265 Tracepoint actions may include collecting of specified data,\n\
5266 single-stepping, or enabling/disabling other tracepoints,\n\
5267 depending on target's capabilities."));
5269 default_collect
= xstrdup ("");
5270 add_setshow_string_cmd ("default-collect", class_trace
,
5271 &default_collect
, _("\
5272 Set the list of expressions to collect by default"), _("\
5273 Show the list of expressions to collect by default"), NULL
,
5275 &setlist
, &showlist
);
5277 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
5278 &disconnected_tracing
, _("\
5279 Set whether tracing continues after GDB disconnects."), _("\
5280 Show whether tracing continues after GDB disconnects."), _("\
5281 Use this to continue a tracing run even if GDB disconnects\n\
5282 or detaches from the target. You can reconnect later and look at\n\
5283 trace data collected in the meantime."),
5284 set_disconnected_tracing
,
5289 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
5290 &circular_trace_buffer
, _("\
5291 Set target's use of circular trace buffer."), _("\
5292 Show target's use of circular trace buffer."), _("\
5293 Use this to make the trace buffer into a circular buffer,\n\
5294 which will discard traceframes (oldest first) instead of filling\n\
5295 up and stopping the trace run."),
5296 set_circular_trace_buffer
,
5301 add_setshow_string_cmd ("trace-user", class_trace
,
5303 Set the user name to use for current and future trace runs"), _("\
5304 Show the user name to use for current and future trace runs"), NULL
,
5305 set_trace_user
, NULL
,
5306 &setlist
, &showlist
);
5308 add_setshow_string_cmd ("trace-notes", class_trace
,
5310 Set notes string to use for current and future trace runs"), _("\
5311 Show the notes string to use for current and future trace runs"), NULL
,
5312 set_trace_notes
, NULL
,
5313 &setlist
, &showlist
);
5315 add_setshow_string_cmd ("trace-stop-notes", class_trace
,
5316 &trace_stop_notes
, _("\
5317 Set notes string to use for future tstop commands"), _("\
5318 Show the notes string to use for future tstop commands"), NULL
,
5319 set_trace_stop_notes
, NULL
,
5320 &setlist
, &showlist
);
5324 add_target (&tfile_ops
);