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 /* ======= Important command functions: ======= */
182 static void trace_actions_command (char *, int);
183 static void trace_start_command (char *, int);
184 static void trace_stop_command (char *, int);
185 static void trace_status_command (char *, int);
186 static void trace_find_command (char *, int);
187 static void trace_find_pc_command (char *, int);
188 static void trace_find_tracepoint_command (char *, int);
189 static void trace_find_line_command (char *, int);
190 static void trace_find_range_command (char *, int);
191 static void trace_find_outside_command (char *, int);
192 static void trace_dump_command (char *, int);
194 /* support routines */
196 struct collection_list
;
197 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
198 static char *mem2hex (gdb_byte
*, char *, int);
199 static void add_register (struct collection_list
*collection
,
202 extern void send_disconnected_tracing_value (int value
);
204 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
205 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
208 extern void _initialize_tracepoint (void);
210 static struct trace_status trace_status
;
212 char *stop_reason_names
[] = {
222 struct trace_status
*
223 current_trace_status (void)
225 return &trace_status
;
231 free_traceframe_info (struct traceframe_info
*info
)
235 VEC_free (mem_range_s
, info
->memory
);
241 /* Free and clear the traceframe info cache of the current
245 clear_traceframe_info (void)
247 free_traceframe_info (traceframe_info
);
248 traceframe_info
= NULL
;
251 /* Set traceframe number to NUM. */
253 set_traceframe_num (int num
)
255 traceframe_number
= num
;
256 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
259 /* Set tracepoint number to NUM. */
261 set_tracepoint_num (int num
)
263 tracepoint_number
= num
;
264 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
267 /* Set externally visible debug variables for querying/printing
268 the traceframe context (line, function, file). */
271 set_traceframe_context (struct frame_info
*trace_frame
)
275 /* Save as globals for internal use. */
276 if (trace_frame
!= NULL
277 && get_frame_pc_if_available (trace_frame
, &trace_pc
))
279 traceframe_sal
= find_pc_line (trace_pc
, 0);
280 traceframe_fun
= find_pc_function (trace_pc
);
282 /* Save linenumber as "$trace_line", a debugger variable visible to
284 set_internalvar_integer (lookup_internalvar ("trace_line"),
285 traceframe_sal
.line
);
289 init_sal (&traceframe_sal
);
290 traceframe_fun
= NULL
;
291 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
294 /* Save func name as "$trace_func", a debugger variable visible to
296 if (traceframe_fun
== NULL
297 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
298 clear_internalvar (lookup_internalvar ("trace_func"));
300 set_internalvar_string (lookup_internalvar ("trace_func"),
301 SYMBOL_LINKAGE_NAME (traceframe_fun
));
303 /* Save file name as "$trace_file", a debugger variable visible to
305 if (traceframe_sal
.symtab
== NULL
306 || traceframe_sal
.symtab
->filename
== NULL
)
307 clear_internalvar (lookup_internalvar ("trace_file"));
309 set_internalvar_string (lookup_internalvar ("trace_file"),
310 traceframe_sal
.symtab
->filename
);
313 /* Create a new trace state variable with the given name. */
315 struct trace_state_variable
*
316 create_trace_state_variable (const char *name
)
318 struct trace_state_variable tsv
;
320 memset (&tsv
, 0, sizeof (tsv
));
321 tsv
.name
= xstrdup (name
);
322 tsv
.number
= next_tsv_number
++;
323 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
326 /* Look for a trace state variable of the given name. */
328 struct trace_state_variable
*
329 find_trace_state_variable (const char *name
)
331 struct trace_state_variable
*tsv
;
334 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
335 if (strcmp (name
, tsv
->name
) == 0)
342 delete_trace_state_variable (const char *name
)
344 struct trace_state_variable
*tsv
;
347 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
348 if (strcmp (name
, tsv
->name
) == 0)
350 xfree ((void *)tsv
->name
);
351 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
355 warning (_("No trace variable named \"$%s\", not deleting"), name
);
358 /* The 'tvariable' command collects a name and optional expression to
359 evaluate into an initial value. */
362 trace_variable_command (char *args
, int from_tty
)
364 struct expression
*expr
;
365 struct cleanup
*old_chain
;
366 struct internalvar
*intvar
= NULL
;
368 struct trace_state_variable
*tsv
;
371 error_no_arg (_("trace state variable name"));
373 /* All the possible valid arguments are expressions. */
374 expr
= parse_expression (args
);
375 old_chain
= make_cleanup (free_current_contents
, &expr
);
377 if (expr
->nelts
== 0)
378 error (_("No expression?"));
380 /* Only allow two syntaxes; "$name" and "$name=value". */
381 if (expr
->elts
[0].opcode
== OP_INTERNALVAR
)
383 intvar
= expr
->elts
[1].internalvar
;
385 else if (expr
->elts
[0].opcode
== BINOP_ASSIGN
386 && expr
->elts
[1].opcode
== OP_INTERNALVAR
)
388 intvar
= expr
->elts
[2].internalvar
;
389 initval
= value_as_long (evaluate_subexpression_type (expr
, 4));
392 error (_("Syntax must be $NAME [ = EXPR ]"));
395 error (_("No name given"));
397 if (strlen (internalvar_name (intvar
)) <= 0)
398 error (_("Must supply a non-empty variable name"));
400 /* If the variable already exists, just change its initial value. */
401 tsv
= find_trace_state_variable (internalvar_name (intvar
));
404 tsv
->initial_value
= initval
;
405 printf_filtered (_("Trace state variable $%s "
406 "now has initial value %s.\n"),
407 tsv
->name
, plongest (tsv
->initial_value
));
408 do_cleanups (old_chain
);
412 /* Create a new variable. */
413 tsv
= create_trace_state_variable (internalvar_name (intvar
));
414 tsv
->initial_value
= initval
;
416 printf_filtered (_("Trace state variable $%s "
417 "created, with initial value %s.\n"),
418 tsv
->name
, plongest (tsv
->initial_value
));
420 do_cleanups (old_chain
);
424 delete_trace_variable_command (char *args
, int from_tty
)
428 struct cleanup
*back_to
;
432 if (query (_("Delete all trace state variables? ")))
433 VEC_free (tsv_s
, tvariables
);
438 argv
= gdb_buildargv (args
);
439 back_to
= make_cleanup_freeargv (argv
);
441 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
443 if (*argv
[ix
] == '$')
444 delete_trace_state_variable (argv
[ix
] + 1);
446 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
449 do_cleanups (back_to
);
455 tvariables_info_1 (void)
457 struct trace_state_variable
*tsv
;
460 struct cleanup
*back_to
;
461 struct ui_out
*uiout
= current_uiout
;
463 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
465 printf_filtered (_("No trace state variables.\n"));
469 /* Try to acquire values from the target. */
470 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
471 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
474 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
475 count
, "trace-variables");
476 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
477 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
478 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
480 ui_out_table_body (uiout
);
482 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
484 struct cleanup
*back_to2
;
488 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
490 name
= concat ("$", tsv
->name
, (char *) NULL
);
491 make_cleanup (xfree
, name
);
492 ui_out_field_string (uiout
, "name", name
);
493 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
495 if (tsv
->value_known
)
496 c
= plongest (tsv
->value
);
497 else if (ui_out_is_mi_like_p (uiout
))
498 /* For MI, we prefer not to use magic string constants, but rather
499 omit the field completely. The difference between unknown and
500 undefined does not seem important enough to represent. */
502 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
503 /* The value is/was defined, but we don't have it. */
506 /* It is not meaningful to ask about the value. */
509 ui_out_field_string (uiout
, "current", c
);
510 ui_out_text (uiout
, "\n");
512 do_cleanups (back_to2
);
515 do_cleanups (back_to
);
518 /* List all the trace state variables. */
521 tvariables_info (char *args
, int from_tty
)
523 tvariables_info_1 ();
526 /* Stash definitions of tsvs into the given file. */
529 save_trace_state_variables (struct ui_file
*fp
)
531 struct trace_state_variable
*tsv
;
534 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
536 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
537 if (tsv
->initial_value
)
538 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
539 fprintf_unfiltered (fp
, "\n");
543 /* ACTIONS functions: */
545 /* The three functions:
546 collect_pseudocommand,
547 while_stepping_pseudocommand, and
548 end_actions_pseudocommand
549 are placeholders for "commands" that are actually ONLY to be used
550 within a tracepoint action list. If the actual function is ever called,
551 it means that somebody issued the "command" at the top level,
552 which is always an error. */
555 end_actions_pseudocommand (char *args
, int from_tty
)
557 error (_("This command cannot be used at the top level."));
561 while_stepping_pseudocommand (char *args
, int from_tty
)
563 error (_("This command can only be used in a tracepoint actions list."));
567 collect_pseudocommand (char *args
, int from_tty
)
569 error (_("This command can only be used in a tracepoint actions list."));
573 teval_pseudocommand (char *args
, int from_tty
)
575 error (_("This command can only be used in a tracepoint actions list."));
578 /* Parse any collection options, such as /s for strings. */
581 decode_agent_options (char *exp
)
583 struct value_print_options opts
;
588 /* Call this to borrow the print elements default for collection
590 get_user_print_options (&opts
);
595 if (target_supports_string_tracing ())
597 /* Allow an optional decimal number giving an explicit maximum
598 string length, defaulting it to the "print elements" value;
599 so "collect/s80 mystr" gets at most 80 bytes of string. */
600 trace_string_kludge
= opts
.print_max
;
602 if (*exp
>= '0' && *exp
<= '9')
603 trace_string_kludge
= atoi (exp
);
604 while (*exp
>= '0' && *exp
<= '9')
608 error (_("Target does not support \"/s\" option for string tracing."));
611 error (_("Undefined collection format \"%c\"."), *exp
);
613 exp
= skip_spaces (exp
);
618 /* Enter a list of actions for a tracepoint. */
620 trace_actions_command (char *args
, int from_tty
)
622 struct tracepoint
*t
;
623 struct command_line
*l
;
625 t
= get_tracepoint_by_number (&args
, NULL
, 1);
629 xstrprintf ("Enter actions for tracepoint %d, one per line.",
631 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
633 l
= read_command_lines (tmpbuf
, from_tty
, 1,
634 check_tracepoint_command
, t
);
635 do_cleanups (cleanups
);
636 breakpoint_set_commands (&t
->base
, l
);
638 /* else just return */
641 /* Report the results of checking the agent expression, as errors or
645 report_agent_reqs_errors (struct agent_expr
*aexpr
)
647 /* All of the "flaws" are serious bytecode generation issues that
648 should never occur. */
649 if (aexpr
->flaw
!= agent_flaw_none
)
650 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
652 /* If analysis shows a stack underflow, GDB must have done something
653 badly wrong in its bytecode generation. */
654 if (aexpr
->min_height
< 0)
655 internal_error (__FILE__
, __LINE__
,
656 _("expression has min height < 0"));
658 /* Issue this error if the stack is predicted to get too deep. The
659 limit is rather arbitrary; a better scheme might be for the
660 target to report how much stack it will have available. The
661 depth roughly corresponds to parenthesization, so a limit of 20
662 amounts to 20 levels of expression nesting, which is actually
663 a pretty big hairy expression. */
664 if (aexpr
->max_height
> 20)
665 error (_("Expression is too complicated."));
668 /* worker function */
670 validate_actionline (char **line
, struct breakpoint
*b
)
672 struct cmd_list_element
*c
;
673 struct expression
*exp
= NULL
;
674 struct cleanup
*old_chain
= NULL
;
676 struct bp_location
*loc
;
677 struct agent_expr
*aexpr
;
678 struct tracepoint
*t
= (struct tracepoint
*) b
;
680 /* If EOF is typed, *line is NULL. */
684 for (p
= *line
; isspace ((int) *p
);)
687 /* Symbol lookup etc. */
688 if (*p
== '\0') /* empty line: just prompt for another line. */
691 if (*p
== '#') /* comment line */
694 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
696 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
698 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
700 trace_string_kludge
= 0;
702 p
= decode_agent_options (p
);
705 { /* Repeat over a comma-separated list. */
706 QUIT
; /* Allow user to bail out with ^C. */
707 while (isspace ((int) *p
))
710 if (*p
== '$') /* Look for special pseudo-symbols. */
712 if (0 == strncasecmp ("reg", p
+ 1, 3)
713 || 0 == strncasecmp ("arg", p
+ 1, 3)
714 || 0 == strncasecmp ("loc", p
+ 1, 3)
715 || 0 == strncasecmp ("_ret", p
+ 1, 4)
716 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
721 /* else fall thru, treat p as an expression and parse it! */
724 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
727 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
728 old_chain
= make_cleanup (free_current_contents
, &exp
);
730 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
732 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
734 error (_("constant `%s' (value %ld) "
735 "will not be collected."),
736 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
737 SYMBOL_VALUE (exp
->elts
[2].symbol
));
739 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
)
740 == LOC_OPTIMIZED_OUT
)
742 error (_("`%s' is optimized away "
743 "and cannot be collected."),
744 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
748 /* We have something to collect, make sure that the expr to
749 bytecode translator can handle it and that it's not too
751 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
752 make_cleanup_free_agent_expr (aexpr
);
754 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
755 error (_("Expression is too complicated."));
759 report_agent_reqs_errors (aexpr
);
761 do_cleanups (old_chain
);
764 while (p
&& *p
++ == ',');
767 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
770 { /* Repeat over a comma-separated list. */
771 QUIT
; /* Allow user to bail out with ^C. */
772 while (isspace ((int) *p
))
776 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
779 /* Only expressions are allowed for this action. */
780 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
781 old_chain
= make_cleanup (free_current_contents
, &exp
);
783 /* We have something to evaluate, make sure that the expr to
784 bytecode translator can handle it and that it's not too
786 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
787 make_cleanup_free_agent_expr (aexpr
);
789 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
790 error (_("Expression is too complicated."));
793 report_agent_reqs_errors (aexpr
);
795 do_cleanups (old_chain
);
798 while (p
&& *p
++ == ',');
801 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
803 char *steparg
; /* In case warning is necessary. */
805 while (isspace ((int) *p
))
809 if (*p
== '\0' || (t
->step_count
= strtol (p
, &p
, 0)) == 0)
810 error (_("while-stepping step count `%s' is malformed."), *line
);
813 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
817 error (_("`%s' is not a supported tracepoint action."), *line
);
821 memrange_absolute
= -1
826 int type
; /* memrange_absolute for absolute memory range,
827 else basereg number. */
828 bfd_signed_vma start
;
832 struct collection_list
834 unsigned char regs_mask
[32]; /* room for up to 256 regs */
837 struct memrange
*list
;
838 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
840 struct agent_expr
**aexpr_list
;
842 /* True is the user requested a collection of "$_sdata", "static
846 tracepoint_list
, stepping_list
;
848 /* MEMRANGE functions: */
850 static int memrange_cmp (const void *, const void *);
852 /* Compare memranges for qsort. */
854 memrange_cmp (const void *va
, const void *vb
)
856 const struct memrange
*a
= va
, *b
= vb
;
858 if (a
->type
< b
->type
)
860 if (a
->type
> b
->type
)
862 if (a
->type
== memrange_absolute
)
864 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
866 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
871 if (a
->start
< b
->start
)
873 if (a
->start
> b
->start
)
879 /* Sort the memrange list using qsort, and merge adjacent memranges. */
881 memrange_sortmerge (struct collection_list
*memranges
)
885 qsort (memranges
->list
, memranges
->next_memrange
,
886 sizeof (struct memrange
), memrange_cmp
);
887 if (memranges
->next_memrange
> 0)
889 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
891 /* If memrange b overlaps or is adjacent to memrange a,
893 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
894 && memranges
->list
[b
].start
<= memranges
->list
[a
].end
)
896 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
897 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
898 continue; /* next b, same a */
902 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
903 sizeof (struct memrange
));
905 memranges
->next_memrange
= a
+ 1;
909 /* Add a register to a collection list. */
911 add_register (struct collection_list
*collection
, unsigned int regno
)
914 printf_filtered ("collect register %d\n", regno
);
915 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
916 error (_("Internal: register number %d too large for tracepoint"),
918 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
921 /* Add a memrange to a collection list. */
923 add_memrange (struct collection_list
*memranges
,
924 int type
, bfd_signed_vma base
,
929 printf_filtered ("(%d,", type
);
931 printf_filtered (",%ld)\n", len
);
934 /* type: memrange_absolute == memory, other n == basereg */
935 memranges
->list
[memranges
->next_memrange
].type
= type
;
936 /* base: addr if memory, offset if reg relative. */
937 memranges
->list
[memranges
->next_memrange
].start
= base
;
938 /* len: we actually save end (base + len) for convenience */
939 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
940 memranges
->next_memrange
++;
941 if (memranges
->next_memrange
>= memranges
->listsize
)
943 memranges
->listsize
*= 2;
944 memranges
->list
= xrealloc (memranges
->list
,
945 memranges
->listsize
);
948 if (type
!= memrange_absolute
) /* Better collect the base register! */
949 add_register (memranges
, type
);
952 /* Add a symbol to a collection list. */
954 collect_symbol (struct collection_list
*collect
,
956 struct gdbarch
*gdbarch
,
957 long frame_regno
, long frame_offset
,
962 bfd_signed_vma offset
;
963 int treat_as_expr
= 0;
965 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
966 switch (SYMBOL_CLASS (sym
))
969 printf_filtered ("%s: don't know symbol class %d\n",
970 SYMBOL_PRINT_NAME (sym
),
974 printf_filtered ("constant %s (value %ld) will not be collected.\n",
975 SYMBOL_PRINT_NAME (sym
), SYMBOL_VALUE (sym
));
978 offset
= SYMBOL_VALUE_ADDRESS (sym
);
983 sprintf_vma (tmp
, offset
);
984 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
985 SYMBOL_PRINT_NAME (sym
), len
,
988 /* A struct may be a C++ class with static fields, go to general
989 expression handling. */
990 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
993 add_memrange (collect
, memrange_absolute
, offset
, len
);
996 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
998 printf_filtered ("LOC_REG[parm] %s: ",
999 SYMBOL_PRINT_NAME (sym
));
1000 add_register (collect
, reg
);
1001 /* Check for doubles stored in two registers. */
1002 /* FIXME: how about larger types stored in 3 or more regs? */
1003 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1004 len
> register_size (gdbarch
, reg
))
1005 add_register (collect
, reg
+ 1);
1008 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1009 printf_filtered (" (will not collect %s)\n",
1010 SYMBOL_PRINT_NAME (sym
));
1014 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1017 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1018 SYMBOL_PRINT_NAME (sym
), len
);
1019 printf_vma (offset
);
1020 printf_filtered (" from frame ptr reg %d\n", reg
);
1022 add_memrange (collect
, reg
, offset
, len
);
1024 case LOC_REGPARM_ADDR
:
1025 reg
= SYMBOL_VALUE (sym
);
1029 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1030 SYMBOL_PRINT_NAME (sym
), len
);
1031 printf_vma (offset
);
1032 printf_filtered (" from reg %d\n", reg
);
1034 add_memrange (collect
, reg
, offset
, len
);
1038 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1041 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1042 SYMBOL_PRINT_NAME (sym
), len
);
1043 printf_vma (offset
);
1044 printf_filtered (" from frame ptr reg %d\n", reg
);
1046 add_memrange (collect
, reg
, offset
, len
);
1049 case LOC_UNRESOLVED
:
1053 case LOC_OPTIMIZED_OUT
:
1054 printf_filtered ("%s has been optimized out of existence.\n",
1055 SYMBOL_PRINT_NAME (sym
));
1063 /* Expressions are the most general case. */
1066 struct agent_expr
*aexpr
;
1067 struct cleanup
*old_chain1
= NULL
;
1069 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
1071 /* It can happen that the symbol is recorded as a computed
1072 location, but it's been optimized away and doesn't actually
1073 have a location expression. */
1076 printf_filtered ("%s has been optimized out of existence.\n",
1077 SYMBOL_PRINT_NAME (sym
));
1081 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1085 report_agent_reqs_errors (aexpr
);
1087 discard_cleanups (old_chain1
);
1088 add_aexpr (collect
, aexpr
);
1090 /* Take care of the registers. */
1091 if (aexpr
->reg_mask_len
> 0)
1095 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1097 QUIT
; /* Allow user to bail out with ^C. */
1098 if (aexpr
->reg_mask
[ndx1
] != 0)
1100 /* Assume chars have 8 bits. */
1101 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1102 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1103 /* It's used -- record it. */
1104 add_register (collect
, ndx1
* 8 + ndx2
);
1111 /* Data to be passed around in the calls to the locals and args
1114 struct add_local_symbols_data
1116 struct collection_list
*collect
;
1117 struct gdbarch
*gdbarch
;
1124 /* The callback for the locals and args iterators. */
1127 do_collect_symbol (const char *print_name
,
1131 struct add_local_symbols_data
*p
= cb_data
;
1133 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1134 p
->frame_offset
, p
->pc
);
1138 /* Add all locals (or args) symbols to collection list. */
1140 add_local_symbols (struct collection_list
*collect
,
1141 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1142 long frame_regno
, long frame_offset
, int type
)
1144 struct block
*block
;
1145 struct add_local_symbols_data cb_data
;
1147 cb_data
.collect
= collect
;
1148 cb_data
.gdbarch
= gdbarch
;
1150 cb_data
.frame_regno
= frame_regno
;
1151 cb_data
.frame_offset
= frame_offset
;
1156 block
= block_for_pc (pc
);
1159 warning (_("Can't collect locals; "
1160 "no symbol table info available.\n"));
1164 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1165 if (cb_data
.count
== 0)
1166 warning (_("No locals found in scope."));
1170 pc
= get_pc_function_start (pc
);
1171 block
= block_for_pc (pc
);
1174 warning (_("Can't collect args; no symbol table info available."));
1178 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1179 if (cb_data
.count
== 0)
1180 warning (_("No args found in scope."));
1185 add_static_trace_data (struct collection_list
*collection
)
1188 printf_filtered ("collect static trace data\n");
1189 collection
->strace_data
= 1;
1192 /* worker function */
1194 clear_collection_list (struct collection_list
*list
)
1198 list
->next_memrange
= 0;
1199 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1201 free_agent_expr (list
->aexpr_list
[ndx
]);
1202 list
->aexpr_list
[ndx
] = NULL
;
1204 list
->next_aexpr_elt
= 0;
1205 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1206 list
->strace_data
= 0;
1209 /* Reduce a collection list to string form (for gdb protocol). */
1211 stringify_collection_list (struct collection_list
*list
, char *string
)
1213 char temp_buf
[2048];
1217 char *(*str_list
)[];
1221 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1222 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1224 if (list
->strace_data
)
1227 printf_filtered ("\nCollecting static trace data\n");
1230 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1234 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1235 if (list
->regs_mask
[i
] != 0) /* Skip leading zeroes in regs_mask. */
1237 if (list
->regs_mask
[i
] != 0) /* Prepare to send regs_mask to the stub. */
1240 printf_filtered ("\nCollecting registers (mask): 0x");
1245 QUIT
; /* Allow user to bail out with ^C. */
1247 printf_filtered ("%02X", list
->regs_mask
[i
]);
1248 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1251 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1255 printf_filtered ("\n");
1256 if (list
->next_memrange
> 0 && info_verbose
)
1257 printf_filtered ("Collecting memranges: \n");
1258 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1260 QUIT
; /* Allow user to bail out with ^C. */
1261 sprintf_vma (tmp2
, list
->list
[i
].start
);
1264 printf_filtered ("(%d, %s, %ld)\n",
1267 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1269 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1271 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1278 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1280 /* The "%X" conversion specifier expects an unsigned argument,
1281 so passing -1 (memrange_absolute) to it directly gives you
1282 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1284 if (list
->list
[i
].type
== memrange_absolute
)
1285 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1287 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1290 count
+= strlen (end
);
1291 end
= temp_buf
+ count
;
1294 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1296 QUIT
; /* Allow user to bail out with ^C. */
1297 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1299 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1304 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1305 end
+= 10; /* 'X' + 8 hex digits + ',' */
1308 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1309 end
, list
->aexpr_list
[i
]->len
);
1310 count
+= 2 * list
->aexpr_list
[i
]->len
;
1315 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1320 (*str_list
)[ndx
] = NULL
;
1333 encode_actions_1 (struct command_line
*action
,
1334 struct breakpoint
*t
,
1335 struct bp_location
*tloc
,
1337 LONGEST frame_offset
,
1338 struct collection_list
*collect
,
1339 struct collection_list
*stepping_list
)
1342 struct expression
*exp
= NULL
;
1344 struct value
*tempval
;
1345 struct cmd_list_element
*cmd
;
1346 struct agent_expr
*aexpr
;
1348 for (; action
; action
= action
->next
)
1350 QUIT
; /* Allow user to bail out with ^C. */
1351 action_exp
= action
->line
;
1352 while (isspace ((int) *action_exp
))
1355 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1357 error (_("Bad action list item: %s"), action_exp
);
1359 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1361 trace_string_kludge
= 0;
1362 if (*action_exp
== '/')
1363 action_exp
= decode_agent_options (action_exp
);
1366 { /* Repeat over a comma-separated list. */
1367 QUIT
; /* Allow user to bail out with ^C. */
1368 while (isspace ((int) *action_exp
))
1371 if (0 == strncasecmp ("$reg", action_exp
, 4))
1373 for (i
= 0; i
< gdbarch_num_regs (tloc
->gdbarch
); i
++)
1374 add_register (collect
, i
);
1375 action_exp
= strchr (action_exp
, ','); /* more? */
1377 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1379 add_local_symbols (collect
,
1385 action_exp
= strchr (action_exp
, ','); /* more? */
1387 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1389 add_local_symbols (collect
,
1395 action_exp
= strchr (action_exp
, ','); /* more? */
1397 else if (0 == strncasecmp ("$_ret", action_exp
, 5))
1399 struct cleanup
*old_chain1
= NULL
;
1401 aexpr
= gen_trace_for_return_address (tloc
->address
,
1404 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1407 report_agent_reqs_errors (aexpr
);
1409 discard_cleanups (old_chain1
);
1410 add_aexpr (collect
, aexpr
);
1412 /* take care of the registers */
1413 if (aexpr
->reg_mask_len
> 0)
1417 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1419 QUIT
; /* allow user to bail out with ^C */
1420 if (aexpr
->reg_mask
[ndx1
] != 0)
1422 /* assume chars have 8 bits */
1423 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1424 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1425 /* it's used -- record it */
1426 add_register (collect
,
1432 action_exp
= strchr (action_exp
, ','); /* more? */
1434 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1436 add_static_trace_data (collect
);
1437 action_exp
= strchr (action_exp
, ','); /* more? */
1441 unsigned long addr
, len
;
1442 struct cleanup
*old_chain
= NULL
;
1443 struct cleanup
*old_chain1
= NULL
;
1445 exp
= parse_exp_1 (&action_exp
,
1446 block_for_pc (tloc
->address
), 1);
1447 old_chain
= make_cleanup (free_current_contents
, &exp
);
1449 switch (exp
->elts
[0].opcode
)
1453 const char *name
= &exp
->elts
[2].string
;
1455 i
= user_reg_map_name_to_regnum (tloc
->gdbarch
,
1456 name
, strlen (name
));
1458 internal_error (__FILE__
, __LINE__
,
1459 _("Register $%s not available"),
1462 printf_filtered ("OP_REGISTER: ");
1463 add_register (collect
, i
);
1468 /* Safe because we know it's a simple expression. */
1469 tempval
= evaluate_expression (exp
);
1470 addr
= value_address (tempval
);
1471 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1472 add_memrange (collect
, memrange_absolute
, addr
, len
);
1476 collect_symbol (collect
,
1477 exp
->elts
[2].symbol
,
1484 default: /* Full-fledged expression. */
1485 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1487 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1491 report_agent_reqs_errors (aexpr
);
1493 discard_cleanups (old_chain1
);
1494 add_aexpr (collect
, aexpr
);
1496 /* Take care of the registers. */
1497 if (aexpr
->reg_mask_len
> 0)
1502 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1504 QUIT
; /* Allow user to bail out with ^C. */
1505 if (aexpr
->reg_mask
[ndx1
] != 0)
1507 /* Assume chars have 8 bits. */
1508 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1509 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1510 /* It's used -- record it. */
1511 add_register (collect
,
1518 do_cleanups (old_chain
);
1521 while (action_exp
&& *action_exp
++ == ',');
1523 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1526 { /* Repeat over a comma-separated list. */
1527 QUIT
; /* Allow user to bail out with ^C. */
1528 while (isspace ((int) *action_exp
))
1532 struct cleanup
*old_chain
= NULL
;
1533 struct cleanup
*old_chain1
= NULL
;
1535 exp
= parse_exp_1 (&action_exp
,
1536 block_for_pc (tloc
->address
), 1);
1537 old_chain
= make_cleanup (free_current_contents
, &exp
);
1539 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1540 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1543 report_agent_reqs_errors (aexpr
);
1545 discard_cleanups (old_chain1
);
1546 /* Even though we're not officially collecting, add
1547 to the collect list anyway. */
1548 add_aexpr (collect
, aexpr
);
1550 do_cleanups (old_chain
);
1553 while (action_exp
&& *action_exp
++ == ',');
1555 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1557 /* We check against nested while-stepping when setting
1558 breakpoint action, so no way to run into nested
1560 gdb_assert (stepping_list
);
1562 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
,
1563 frame_offset
, stepping_list
, NULL
);
1566 error (_("Invalid tracepoint command '%s'"), action
->line
);
1570 /* Render all actions into gdb protocol. */
1572 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1573 char ***tdp_actions
, char ***stepping_actions
)
1575 static char tdp_buff
[2048], step_buff
[2048];
1576 char *default_collect_line
= NULL
;
1577 struct command_line
*actions
;
1578 struct command_line
*default_collect_action
= NULL
;
1580 LONGEST frame_offset
;
1581 struct cleanup
*back_to
;
1583 back_to
= make_cleanup (null_cleanup
, NULL
);
1585 clear_collection_list (&tracepoint_list
);
1586 clear_collection_list (&stepping_list
);
1588 *tdp_actions
= NULL
;
1589 *stepping_actions
= NULL
;
1591 gdbarch_virtual_frame_pointer (tloc
->gdbarch
,
1592 tloc
->address
, &frame_reg
, &frame_offset
);
1594 actions
= breakpoint_commands (t
);
1596 /* If there are default expressions to collect, make up a collect
1597 action and prepend to the action list to encode. Note that since
1598 validation is per-tracepoint (local var "xyz" might be valid for
1599 one tracepoint and not another, etc), we make up the action on
1600 the fly, and don't cache it. */
1601 if (*default_collect
)
1605 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1606 make_cleanup (xfree
, default_collect_line
);
1608 line
= default_collect_line
;
1609 validate_actionline (&line
, t
);
1611 default_collect_action
= xmalloc (sizeof (struct command_line
));
1612 make_cleanup (xfree
, default_collect_action
);
1613 default_collect_action
->next
= actions
;
1614 default_collect_action
->line
= line
;
1615 actions
= default_collect_action
;
1617 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1618 &tracepoint_list
, &stepping_list
);
1620 memrange_sortmerge (&tracepoint_list
);
1621 memrange_sortmerge (&stepping_list
);
1623 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1625 *stepping_actions
= stringify_collection_list (&stepping_list
,
1628 do_cleanups (back_to
);
1632 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1634 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1636 collect
->aexpr_list
=
1637 xrealloc (collect
->aexpr_list
,
1638 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1639 collect
->aexpr_listsize
*= 2;
1641 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1642 collect
->next_aexpr_elt
++;
1646 process_tracepoint_on_disconnect (void)
1648 VEC(breakpoint_p
) *tp_vec
= NULL
;
1650 struct breakpoint
*b
;
1651 int has_pending_p
= 0;
1653 /* Check whether we still have pending tracepoint. If we have, warn the
1654 user that pending tracepoint will no longer work. */
1655 tp_vec
= all_tracepoints ();
1656 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1665 struct bp_location
*loc1
;
1667 for (loc1
= b
->loc
; loc1
; loc1
= loc1
->next
)
1669 if (loc1
->shlib_disabled
)
1680 VEC_free (breakpoint_p
, tp_vec
);
1683 warning (_("Pending tracepoints will not be resolved while"
1684 " GDB is disconnected\n"));
1689 start_tracing (void)
1691 VEC(breakpoint_p
) *tp_vec
= NULL
;
1693 struct breakpoint
*b
;
1694 struct trace_state_variable
*tsv
;
1695 int any_enabled
= 0, num_to_download
= 0;
1697 tp_vec
= all_tracepoints ();
1699 /* No point in tracing without any tracepoints... */
1700 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1702 VEC_free (breakpoint_p
, tp_vec
);
1703 error (_("No tracepoints defined, not starting trace"));
1706 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1708 struct tracepoint
*t
= (struct tracepoint
*) b
;
1710 if (b
->enable_state
== bp_enabled
)
1713 if ((b
->type
== bp_fast_tracepoint
1714 ? may_insert_fast_tracepoints
1715 : may_insert_tracepoints
))
1718 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1719 (b
->type
== bp_fast_tracepoint
? "fast " : ""), b
->number
);
1724 if (target_supports_enable_disable_tracepoint ())
1725 warning (_("No tracepoints enabled"));
1728 /* No point in tracing with only disabled tracepoints that
1729 cannot be re-enabled. */
1730 VEC_free (breakpoint_p
, tp_vec
);
1731 error (_("No tracepoints enabled, not starting trace"));
1735 if (num_to_download
<= 0)
1737 VEC_free (breakpoint_p
, tp_vec
);
1738 error (_("No tracepoints that may be downloaded, not starting trace"));
1741 target_trace_init ();
1743 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
1745 struct tracepoint
*t
= (struct tracepoint
*) b
;
1746 struct bp_location
*loc
;
1748 if ((b
->type
== bp_fast_tracepoint
1749 ? !may_insert_fast_tracepoints
1750 : !may_insert_tracepoints
))
1753 t
->number_on_target
= 0;
1755 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
1757 /* Since tracepoint locations are never duplicated, `inserted'
1758 flag should be zero. */
1759 gdb_assert (!loc
->inserted
);
1761 target_download_tracepoint (loc
);
1766 t
->number_on_target
= b
->number
;
1768 VEC_free (breakpoint_p
, tp_vec
);
1770 /* Send down all the trace state variables too. */
1771 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1773 target_download_trace_state_variable (tsv
);
1776 /* Tell target to treat text-like sections as transparent. */
1777 target_trace_set_readonly_regions ();
1778 /* Set some mode flags. */
1779 target_set_disconnected_tracing (disconnected_tracing
);
1780 target_set_circular_trace_buffer (circular_trace_buffer
);
1782 /* Now insert traps and begin collecting data. */
1783 target_trace_start ();
1785 /* Reset our local state. */
1786 set_traceframe_num (-1);
1787 set_tracepoint_num (-1);
1788 set_traceframe_context (NULL
);
1789 current_trace_status()->running
= 1;
1790 clear_traceframe_info ();
1795 Tell target to clear any previous trace experiment.
1796 Walk the list of tracepoints, and send them (and their actions)
1797 to the target. If no errors,
1798 Tell target to start a new trace experiment. */
1801 trace_start_command (char *args
, int from_tty
)
1803 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1805 if (current_trace_status ()->running
)
1808 && !query (_("A trace is running already. Start a new run? ")))
1809 error (_("New trace run not started."));
1817 trace_stop_command (char *args
, int from_tty
)
1819 if (!current_trace_status ()->running
)
1820 error (_("Trace is not running."));
1828 target_trace_stop ();
1829 /* Should change in response to reply? */
1830 current_trace_status ()->running
= 0;
1833 /* tstatus command */
1835 trace_status_command (char *args
, int from_tty
)
1837 struct trace_status
*ts
= current_trace_status ();
1840 status
= target_get_trace_status (ts
);
1845 printf_filtered (_("Using a trace file.\n"));
1848 printf_filtered (_("Trace can not be run on this target.\n"));
1853 if (!ts
->running_known
)
1855 printf_filtered (_("Run/stop status is unknown.\n"));
1857 else if (ts
->running
)
1859 printf_filtered (_("Trace is running on the target.\n"));
1863 switch (ts
->stop_reason
)
1865 case trace_never_run
:
1866 printf_filtered (_("No trace has been run on the target.\n"));
1869 printf_filtered (_("Trace stopped by a tstop command.\n"));
1871 case trace_buffer_full
:
1872 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1874 case trace_disconnected
:
1875 printf_filtered (_("Trace stopped because of disconnection.\n"));
1877 case tracepoint_passcount
:
1878 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1879 ts
->stopping_tracepoint
);
1881 case tracepoint_error
:
1882 if (ts
->stopping_tracepoint
)
1883 printf_filtered (_("Trace stopped by an "
1884 "error (%s, tracepoint %d).\n"),
1885 ts
->error_desc
, ts
->stopping_tracepoint
);
1887 printf_filtered (_("Trace stopped by an error (%s).\n"),
1890 case trace_stop_reason_unknown
:
1891 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1894 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1900 if (ts
->traceframes_created
>= 0
1901 && ts
->traceframe_count
!= ts
->traceframes_created
)
1903 printf_filtered (_("Buffer contains %d trace "
1904 "frames (of %d created total).\n"),
1905 ts
->traceframe_count
, ts
->traceframes_created
);
1907 else if (ts
->traceframe_count
>= 0)
1909 printf_filtered (_("Collected %d trace frames.\n"),
1910 ts
->traceframe_count
);
1913 if (ts
->buffer_free
>= 0)
1915 if (ts
->buffer_size
>= 0)
1917 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1918 ts
->buffer_free
, ts
->buffer_size
);
1919 if (ts
->buffer_size
> 0)
1920 printf_filtered (_(" (%d%% full)"),
1921 ((int) ((((long long) (ts
->buffer_size
1922 - ts
->buffer_free
)) * 100)
1923 / ts
->buffer_size
)));
1924 printf_filtered (_(".\n"));
1927 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1931 if (ts
->disconnected_tracing
)
1932 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1934 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1936 if (ts
->circular_buffer
)
1937 printf_filtered (_("Trace buffer is circular.\n"));
1939 /* Now report on what we're doing with tfind. */
1940 if (traceframe_number
>= 0)
1941 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1942 traceframe_number
, tracepoint_number
);
1944 printf_filtered (_("Not looking at any trace frame.\n"));
1947 /* Report the trace status to uiout, in a way suitable for MI, and not
1948 suitable for CLI. If ON_STOP is true, suppress a few fields that
1949 are not meaningful in the -trace-stop response.
1951 The implementation is essentially parallel to trace_status_command, but
1952 merging them will result in unreadable code. */
1954 trace_status_mi (int on_stop
)
1956 struct ui_out
*uiout
= current_uiout
;
1957 struct trace_status
*ts
= current_trace_status ();
1960 status
= target_get_trace_status (ts
);
1962 if (status
== -1 && !ts
->from_file
)
1964 ui_out_field_string (uiout
, "supported", "0");
1969 ui_out_field_string (uiout
, "supported", "file");
1971 ui_out_field_string (uiout
, "supported", "1");
1973 gdb_assert (ts
->running_known
);
1977 ui_out_field_string (uiout
, "running", "1");
1979 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1980 Given that the frontend gets the status either on -trace-stop, or from
1981 -trace-status after re-connection, it does not seem like this
1982 information is necessary for anything. It is not necessary for either
1983 figuring the vital state of the target nor for navigation of trace
1984 frames. If the frontend wants to show the current state is some
1985 configure dialog, it can request the value when such dialog is
1986 invoked by the user. */
1990 char *stop_reason
= NULL
;
1991 int stopping_tracepoint
= -1;
1994 ui_out_field_string (uiout
, "running", "0");
1996 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
1998 switch (ts
->stop_reason
)
2001 stop_reason
= "request";
2003 case trace_buffer_full
:
2004 stop_reason
= "overflow";
2006 case trace_disconnected
:
2007 stop_reason
= "disconnection";
2009 case tracepoint_passcount
:
2010 stop_reason
= "passcount";
2011 stopping_tracepoint
= ts
->stopping_tracepoint
;
2013 case tracepoint_error
:
2014 stop_reason
= "error";
2015 stopping_tracepoint
= ts
->stopping_tracepoint
;
2021 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
2022 if (stopping_tracepoint
!= -1)
2023 ui_out_field_int (uiout
, "stopping-tracepoint",
2024 stopping_tracepoint
);
2025 if (ts
->stop_reason
== tracepoint_error
)
2026 ui_out_field_string (uiout
, "error-description",
2032 if (ts
->traceframe_count
!= -1)
2033 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
2034 if (ts
->traceframes_created
!= -1)
2035 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
2036 if (ts
->buffer_size
!= -1)
2037 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
2038 if (ts
->buffer_free
!= -1)
2039 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
2041 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
2042 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
2045 /* This function handles the details of what to do about an ongoing
2046 tracing run if the user has asked to detach or otherwise disconnect
2049 disconnect_tracing (int from_tty
)
2051 /* It can happen that the target that was tracing went away on its
2052 own, and we didn't notice. Get a status update, and if the
2053 current target doesn't even do tracing, then assume it's not
2055 if (target_get_trace_status (current_trace_status ()) < 0)
2056 current_trace_status ()->running
= 0;
2058 /* If running interactively, give the user the option to cancel and
2059 then decide what to do differently with the run. Scripts are
2060 just going to disconnect and let the target deal with it,
2061 according to how it's been instructed previously via
2062 disconnected-tracing. */
2063 if (current_trace_status ()->running
&& from_tty
)
2065 process_tracepoint_on_disconnect ();
2067 if (current_trace_status ()->disconnected_tracing
)
2069 if (!query (_("Trace is running and will "
2070 "continue after detach; detach anyway? ")))
2071 error (_("Not confirmed."));
2075 if (!query (_("Trace is running but will "
2076 "stop on detach; detach anyway? ")))
2077 error (_("Not confirmed."));
2081 /* Also we want to be out of tfind mode, otherwise things can get
2082 confusing upon reconnection. Just use these calls instead of
2083 full tfind_1 behavior because we're in the middle of detaching,
2084 and there's no point to updating current stack frame etc. */
2085 set_current_traceframe (-1);
2086 set_traceframe_context (NULL
);
2089 /* Worker function for the various flavors of the tfind command. */
2091 tfind_1 (enum trace_find_type type
, int num
,
2092 ULONGEST addr1
, ULONGEST addr2
,
2095 int target_frameno
= -1, target_tracept
= -1;
2096 struct frame_id old_frame_id
= null_frame_id
;
2097 struct tracepoint
*tp
;
2098 struct ui_out
*uiout
= current_uiout
;
2100 /* Only try to get the current stack frame if we have a chance of
2101 succeeding. In particular, if we're trying to get a first trace
2102 frame while all threads are running, it's not going to succeed,
2103 so leave it with a default value and let the frame comparison
2104 below (correctly) decide to print out the source location of the
2106 if (!(type
== tfind_number
&& num
== -1)
2107 && (has_stack_frames () || traceframe_number
>= 0))
2108 old_frame_id
= get_frame_id (get_current_frame ());
2110 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
2113 if (type
== tfind_number
2115 && target_frameno
== -1)
2117 /* We told the target to get out of tfind mode, and it did. */
2119 else if (target_frameno
== -1)
2121 /* A request for a non-existent trace frame has failed.
2122 Our response will be different, depending on FROM_TTY:
2124 If FROM_TTY is true, meaning that this command was
2125 typed interactively by the user, then give an error
2126 and DO NOT change the state of traceframe_number etc.
2128 However if FROM_TTY is false, meaning that we're either
2129 in a script, a loop, or a user-defined command, then
2130 DON'T give an error, but DO change the state of
2131 traceframe_number etc. to invalid.
2133 The rationalle is that if you typed the command, you
2134 might just have committed a typo or something, and you'd
2135 like to NOT lose your current debugging state. However
2136 if you're in a user-defined command or especially in a
2137 loop, then you need a way to detect that the command
2138 failed WITHOUT aborting. This allows you to write
2139 scripts that search thru the trace buffer until the end,
2140 and then continue on to do something else. */
2143 error (_("Target failed to find requested trace frame."));
2147 printf_filtered ("End of trace buffer.\n");
2148 #if 0 /* dubious now? */
2149 /* The following will not recurse, since it's
2151 trace_find_command ("-1", from_tty
);
2156 tp
= get_tracepoint_by_number_on_target (target_tracept
);
2158 reinit_frame_cache ();
2159 registers_changed ();
2160 target_dcache_invalidate ();
2161 set_traceframe_num (target_frameno
);
2162 clear_traceframe_info ();
2163 set_tracepoint_num (tp
? tp
->base
.number
: target_tracept
);
2164 if (target_frameno
== -1)
2165 set_traceframe_context (NULL
);
2167 set_traceframe_context (get_current_frame ());
2169 if (traceframe_number
>= 0)
2171 /* Use different branches for MI and CLI to make CLI messages
2173 if (ui_out_is_mi_like_p (uiout
))
2175 ui_out_field_string (uiout
, "found", "1");
2176 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
2177 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
2181 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2182 traceframe_number
, tracepoint_number
);
2187 if (ui_out_is_mi_like_p (uiout
))
2188 ui_out_field_string (uiout
, "found", "0");
2189 else if (type
== tfind_number
&& num
== -1)
2190 printf_unfiltered (_("No longer looking at any trace frame\n"));
2191 else /* This case may never occur, check. */
2192 printf_unfiltered (_("No trace frame found\n"));
2195 /* If we're in nonstop mode and getting out of looking at trace
2196 frames, there won't be any current frame to go back to and
2199 && (has_stack_frames () || traceframe_number
>= 0))
2201 enum print_what print_what
;
2203 /* NOTE: in imitation of the step command, try to determine
2204 whether we have made a transition from one function to
2205 another. If so, we'll print the "stack frame" (ie. the new
2206 function and it's arguments) -- otherwise we'll just show the
2209 if (frame_id_eq (old_frame_id
,
2210 get_frame_id (get_current_frame ())))
2211 print_what
= SRC_LINE
;
2213 print_what
= SRC_AND_LOC
;
2215 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2220 /* trace_find_command takes a trace frame number n,
2221 sends "QTFrame:<n>" to the target,
2222 and accepts a reply that may contain several optional pieces
2223 of information: a frame number, a tracepoint number, and an
2224 indication of whether this is a trap frame or a stepping frame.
2226 The minimal response is just "OK" (which indicates that the
2227 target does not give us a frame number or a tracepoint number).
2228 Instead of that, the target may send us a string containing
2230 F<hexnum> (gives the selected frame number)
2231 T<hexnum> (gives the selected tracepoint number)
2236 trace_find_command (char *args
, int from_tty
)
2237 { /* This should only be called with a numeric argument. */
2240 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2241 error (_("May not look at trace frames while trace is running."));
2243 if (args
== 0 || *args
== 0)
2244 { /* TFIND with no args means find NEXT trace frame. */
2245 if (traceframe_number
== -1)
2246 frameno
= 0; /* "next" is first one. */
2248 frameno
= traceframe_number
+ 1;
2250 else if (0 == strcmp (args
, "-"))
2252 if (traceframe_number
== -1)
2253 error (_("not debugging trace buffer"));
2254 else if (from_tty
&& traceframe_number
== 0)
2255 error (_("already at start of trace buffer"));
2257 frameno
= traceframe_number
- 1;
2259 /* A hack to work around eval's need for fp to have been collected. */
2260 else if (0 == strcmp (args
, "-1"))
2263 frameno
= parse_and_eval_long (args
);
2266 error (_("invalid input (%d is less than zero)"), frameno
);
2268 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2273 trace_find_end_command (char *args
, int from_tty
)
2275 trace_find_command ("-1", from_tty
);
2280 trace_find_none_command (char *args
, int from_tty
)
2282 trace_find_command ("-1", from_tty
);
2287 trace_find_start_command (char *args
, int from_tty
)
2289 trace_find_command ("0", from_tty
);
2292 /* tfind pc command */
2294 trace_find_pc_command (char *args
, int from_tty
)
2298 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2299 error (_("May not look at trace frames while trace is running."));
2301 if (args
== 0 || *args
== 0)
2302 pc
= regcache_read_pc (get_current_regcache ());
2304 pc
= parse_and_eval_address (args
);
2306 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2309 /* tfind tracepoint command */
2311 trace_find_tracepoint_command (char *args
, int from_tty
)
2314 struct tracepoint
*tp
;
2316 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2317 error (_("May not look at trace frames while trace is running."));
2319 if (args
== 0 || *args
== 0)
2321 if (tracepoint_number
== -1)
2322 error (_("No current tracepoint -- please supply an argument."));
2324 tdp
= tracepoint_number
; /* Default is current TDP. */
2327 tdp
= parse_and_eval_long (args
);
2329 /* If we have the tracepoint on hand, use the number that the
2330 target knows about (which may be different if we disconnected
2331 and reconnected). */
2332 tp
= get_tracepoint (tdp
);
2334 tdp
= tp
->number_on_target
;
2336 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2339 /* TFIND LINE command:
2341 This command will take a sourceline for argument, just like BREAK
2342 or TRACE (ie. anything that "decode_line_1" can handle).
2344 With no argument, this command will find the next trace frame
2345 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2348 trace_find_line_command (char *args
, int from_tty
)
2350 static CORE_ADDR start_pc
, end_pc
;
2351 struct symtabs_and_lines sals
;
2352 struct symtab_and_line sal
;
2353 struct cleanup
*old_chain
;
2355 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2356 error (_("May not look at trace frames while trace is running."));
2358 if (args
== 0 || *args
== 0)
2360 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2362 sals
.sals
= (struct symtab_and_line
*)
2363 xmalloc (sizeof (struct symtab_and_line
));
2368 sals
= decode_line_spec (args
, 1);
2372 old_chain
= make_cleanup (xfree
, sals
.sals
);
2373 if (sal
.symtab
== 0)
2374 error (_("No line number information available."));
2376 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2378 if (start_pc
== end_pc
)
2380 printf_filtered ("Line %d of \"%s\"",
2381 sal
.line
, sal
.symtab
->filename
);
2383 printf_filtered (" is at address ");
2384 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2386 printf_filtered (" but contains no code.\n");
2387 sal
= find_pc_line (start_pc
, 0);
2389 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2390 && start_pc
!= end_pc
)
2391 printf_filtered ("Attempting to find line %d instead.\n",
2394 error (_("Cannot find a good line."));
2398 /* Is there any case in which we get here, and have an address
2399 which the user would want to see? If we have debugging
2400 symbols and no line numbers? */
2401 error (_("Line number %d is out of range for \"%s\"."),
2402 sal
.line
, sal
.symtab
->filename
);
2404 /* Find within range of stated line. */
2406 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2408 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2409 do_cleanups (old_chain
);
2412 /* tfind range command */
2414 trace_find_range_command (char *args
, int from_tty
)
2416 static CORE_ADDR start
, stop
;
2419 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2420 error (_("May not look at trace frames while trace is running."));
2422 if (args
== 0 || *args
== 0)
2423 { /* XXX FIXME: what should default behavior be? */
2424 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2428 if (0 != (tmp
= strchr (args
, ',')))
2430 *tmp
++ = '\0'; /* Terminate start address. */
2431 while (isspace ((int) *tmp
))
2433 start
= parse_and_eval_address (args
);
2434 stop
= parse_and_eval_address (tmp
);
2437 { /* No explicit end address? */
2438 start
= parse_and_eval_address (args
);
2439 stop
= start
+ 1; /* ??? */
2442 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2445 /* tfind outside command */
2447 trace_find_outside_command (char *args
, int from_tty
)
2449 CORE_ADDR start
, stop
;
2452 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2453 error (_("May not look at trace frames while trace is running."));
2455 if (args
== 0 || *args
== 0)
2456 { /* XXX FIXME: what should default behavior be? */
2457 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2461 if (0 != (tmp
= strchr (args
, ',')))
2463 *tmp
++ = '\0'; /* Terminate start address. */
2464 while (isspace ((int) *tmp
))
2466 start
= parse_and_eval_address (args
);
2467 stop
= parse_and_eval_address (tmp
);
2470 { /* No explicit end address? */
2471 start
= parse_and_eval_address (args
);
2472 stop
= start
+ 1; /* ??? */
2475 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2478 /* info scope command: list the locals for a scope. */
2480 scope_info (char *args
, int from_tty
)
2482 struct symtabs_and_lines sals
;
2484 struct minimal_symbol
*msym
;
2485 struct block
*block
;
2486 char *symname
, *save_args
= args
;
2487 struct dict_iterator iter
;
2489 struct gdbarch
*gdbarch
;
2492 if (args
== 0 || *args
== 0)
2493 error (_("requires an argument (function, "
2494 "line or *addr) to define a scope"));
2496 sals
= decode_line_1 (&args
, 1, NULL
, 0, NULL
);
2497 if (sals
.nelts
== 0)
2498 return; /* Presumably decode_line_1 has already warned. */
2500 /* Resolve line numbers to PC. */
2501 resolve_sal_pc (&sals
.sals
[0]);
2502 block
= block_for_pc (sals
.sals
[0].pc
);
2506 QUIT
; /* Allow user to bail out with ^C. */
2507 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2509 QUIT
; /* Allow user to bail out with ^C. */
2511 printf_filtered ("Scope for %s:\n", save_args
);
2514 symname
= SYMBOL_PRINT_NAME (sym
);
2515 if (symname
== NULL
|| *symname
== '\0')
2516 continue; /* Probably botched, certainly useless. */
2518 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2520 printf_filtered ("Symbol %s is ", symname
);
2521 switch (SYMBOL_CLASS (sym
))
2524 case LOC_UNDEF
: /* Messed up symbol? */
2525 printf_filtered ("a bogus symbol, class %d.\n",
2526 SYMBOL_CLASS (sym
));
2527 count
--; /* Don't count this one. */
2530 printf_filtered ("a constant with value %ld (0x%lx)",
2531 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2533 case LOC_CONST_BYTES
:
2534 printf_filtered ("constant bytes: ");
2535 if (SYMBOL_TYPE (sym
))
2536 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2537 fprintf_filtered (gdb_stdout
, " %02x",
2538 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2541 printf_filtered ("in static storage at address ");
2542 printf_filtered ("%s", paddress (gdbarch
,
2543 SYMBOL_VALUE_ADDRESS (sym
)));
2546 /* GDBARCH is the architecture associated with the objfile
2547 the symbol is defined in; the target architecture may be
2548 different, and may provide additional registers. However,
2549 we do not know the target architecture at this point.
2550 We assume the objfile architecture will contain all the
2551 standard registers that occur in debug info in that
2553 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2556 if (SYMBOL_IS_ARGUMENT (sym
))
2557 printf_filtered ("an argument in register $%s",
2558 gdbarch_register_name (gdbarch
, regno
));
2560 printf_filtered ("a local variable in register $%s",
2561 gdbarch_register_name (gdbarch
, regno
));
2564 printf_filtered ("an argument at stack/frame offset %ld",
2565 SYMBOL_VALUE (sym
));
2568 printf_filtered ("a local variable at frame offset %ld",
2569 SYMBOL_VALUE (sym
));
2572 printf_filtered ("a reference argument at offset %ld",
2573 SYMBOL_VALUE (sym
));
2575 case LOC_REGPARM_ADDR
:
2576 /* Note comment at LOC_REGISTER. */
2577 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
,
2579 printf_filtered ("the address of an argument, in register $%s",
2580 gdbarch_register_name (gdbarch
, regno
));
2583 printf_filtered ("a typedef.\n");
2586 printf_filtered ("a label at address ");
2587 printf_filtered ("%s", paddress (gdbarch
,
2588 SYMBOL_VALUE_ADDRESS (sym
)));
2591 printf_filtered ("a function at address ");
2592 printf_filtered ("%s",
2593 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2595 case LOC_UNRESOLVED
:
2596 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2599 printf_filtered ("Unresolved Static");
2602 printf_filtered ("static storage at address ");
2603 printf_filtered ("%s",
2604 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2607 case LOC_OPTIMIZED_OUT
:
2608 printf_filtered ("optimized out.\n");
2611 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2612 BLOCK_START (block
),
2616 if (SYMBOL_TYPE (sym
))
2617 printf_filtered (", length %d.\n",
2618 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2620 if (BLOCK_FUNCTION (block
))
2623 block
= BLOCK_SUPERBLOCK (block
);
2626 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2630 /* worker function (cleanup) */
2632 replace_comma (void *data
)
2639 /* Helper for trace_dump_command. Dump the action list starting at
2640 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2641 actions of the body of a while-stepping action. STEPPING_FRAME is
2642 set if the current traceframe was determined to be a while-stepping
2646 trace_dump_actions (struct command_line
*action
,
2647 int stepping_actions
, int stepping_frame
,
2650 char *action_exp
, *next_comma
;
2652 for (; action
!= NULL
; action
= action
->next
)
2654 struct cmd_list_element
*cmd
;
2656 QUIT
; /* Allow user to bail out with ^C. */
2657 action_exp
= action
->line
;
2658 while (isspace ((int) *action_exp
))
2661 /* The collection actions to be done while stepping are
2662 bracketed by the commands "while-stepping" and "end". */
2664 if (*action_exp
== '#') /* comment line */
2667 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2669 error (_("Bad action list item: %s"), action_exp
);
2671 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2675 for (i
= 0; i
< action
->body_count
; ++i
)
2676 trace_dump_actions (action
->body_list
[i
],
2677 1, stepping_frame
, from_tty
);
2679 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2681 /* Display the collected data.
2682 For the trap frame, display only what was collected at
2683 the trap. Likewise for stepping frames, display only
2684 what was collected while stepping. This means that the
2685 two boolean variables, STEPPING_FRAME and
2686 STEPPING_ACTIONS should be equal. */
2687 if (stepping_frame
== stepping_actions
)
2689 if (*action_exp
== '/')
2690 action_exp
= decode_agent_options (action_exp
);
2693 { /* Repeat over a comma-separated list. */
2694 QUIT
; /* Allow user to bail out with ^C. */
2695 if (*action_exp
== ',')
2697 while (isspace ((int) *action_exp
))
2700 next_comma
= strchr (action_exp
, ',');
2702 if (0 == strncasecmp (action_exp
, "$reg", 4))
2703 registers_info (NULL
, from_tty
);
2704 else if (0 == strncasecmp (action_exp
, "$_ret", 5))
2706 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2707 locals_info (NULL
, from_tty
);
2708 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2709 args_info (NULL
, from_tty
);
2714 make_cleanup (replace_comma
, next_comma
);
2717 printf_filtered ("%s = ", action_exp
);
2718 output_command (action_exp
, from_tty
);
2719 printf_filtered ("\n");
2723 action_exp
= next_comma
;
2725 while (action_exp
&& *action_exp
== ',');
2731 /* The tdump command. */
2734 trace_dump_command (char *args
, int from_tty
)
2736 struct regcache
*regcache
;
2737 struct tracepoint
*t
;
2738 int stepping_frame
= 0;
2739 struct bp_location
*loc
;
2740 char *line
, *default_collect_line
= NULL
;
2741 struct command_line
*actions
, *default_collect_action
= NULL
;
2742 struct cleanup
*old_chain
= NULL
;
2744 if (tracepoint_number
== -1)
2746 warning (_("No current trace frame."));
2750 t
= get_tracepoint (tracepoint_number
);
2753 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2756 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2757 tracepoint_number
, traceframe_number
);
2759 /* The current frame is a trap frame if the frame PC is equal
2760 to the tracepoint PC. If not, then the current frame was
2761 collected during single-stepping. */
2763 regcache
= get_current_regcache ();
2765 /* If the traceframe's address matches any of the tracepoint's
2766 locations, assume it is a direct hit rather than a while-stepping
2767 frame. (FIXME this is not reliable, should record each frame's
2770 for (loc
= t
->base
.loc
; loc
; loc
= loc
->next
)
2771 if (loc
->address
== regcache_read_pc (regcache
))
2774 actions
= breakpoint_commands (&t
->base
);
2776 /* If there is a default-collect list, make up a collect command,
2777 prepend to the tracepoint's commands, and pass the whole mess to
2778 the trace dump scanner. We need to validate because
2779 default-collect might have been junked since the trace run. */
2780 if (*default_collect
)
2782 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2783 old_chain
= make_cleanup (xfree
, default_collect_line
);
2784 line
= default_collect_line
;
2785 validate_actionline (&line
, &t
->base
);
2786 default_collect_action
= xmalloc (sizeof (struct command_line
));
2787 make_cleanup (xfree
, default_collect_action
);
2788 default_collect_action
->next
= actions
;
2789 default_collect_action
->line
= line
;
2790 actions
= default_collect_action
;
2793 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2795 if (*default_collect
)
2796 do_cleanups (old_chain
);
2799 /* Encode a piece of a tracepoint's source-level definition in a form
2800 that is suitable for both protocol and saving in files. */
2801 /* This version does not do multiple encodes for long strings; it should
2802 return an offset to the next piece to encode. FIXME */
2805 encode_source_string (int tpnum
, ULONGEST addr
,
2806 char *srctype
, char *src
, char *buf
, int buf_size
)
2808 if (80 + strlen (srctype
) > buf_size
)
2809 error (_("Buffer too small for source encoding"));
2810 sprintf (buf
, "%x:%s:%s:%x:%x:",
2811 tpnum
, phex_nz (addr
, sizeof (addr
)),
2812 srctype
, 0, (int) strlen (src
));
2813 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2814 error (_("Source string too long for buffer"));
2815 bin2hex (src
, buf
+ strlen (buf
), 0);
2819 extern int trace_regblock_size
;
2821 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2822 non-zero, the save is performed on the target, otherwise GDB obtains all
2823 trace data and saves it locally. */
2826 trace_save (const char *filename
, int target_does_save
)
2828 struct cleanup
*cleanup
;
2830 struct trace_status
*ts
= current_trace_status ();
2833 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2834 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2838 ULONGEST offset
= 0;
2839 #define MAX_TRACE_UPLOAD 2000
2840 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2843 /* If the target is to save the data to a file on its own, then just
2844 send the command and be done with it. */
2845 if (target_does_save
)
2847 err
= target_save_trace_data (filename
);
2849 error (_("Target failed to save trace data to '%s'."),
2854 /* Get the trace status first before opening the file, so if the
2855 target is losing, we can get out without touching files. */
2856 status
= target_get_trace_status (ts
);
2858 pathname
= tilde_expand (filename
);
2859 cleanup
= make_cleanup (xfree
, pathname
);
2861 fp
= fopen (pathname
, "wb");
2863 error (_("Unable to open file '%s' for saving trace data (%s)"),
2864 filename
, safe_strerror (errno
));
2865 make_cleanup_fclose (fp
);
2867 /* Write a file header, with a high-bit-set char to indicate a
2868 binary file, plus a hint as what this file is, and a version
2869 number in case of future needs. */
2870 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2872 perror_with_name (pathname
);
2874 /* Write descriptive info. */
2876 /* Write out the size of a register block. */
2877 fprintf (fp
, "R %x\n", trace_regblock_size
);
2879 /* Write out status of the tracing run (aka "tstatus" info). */
2880 fprintf (fp
, "status %c;%s",
2881 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
2882 if (ts
->stop_reason
== tracepoint_error
)
2884 char *buf
= (char *) alloca (strlen (ts
->error_desc
) * 2 + 1);
2886 bin2hex ((gdb_byte
*) ts
->error_desc
, buf
, 0);
2887 fprintf (fp
, ":%s", buf
);
2889 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
2890 if (ts
->traceframe_count
>= 0)
2891 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
2892 if (ts
->traceframes_created
>= 0)
2893 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
2894 if (ts
->buffer_free
>= 0)
2895 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
2896 if (ts
->buffer_size
>= 0)
2897 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
2898 if (ts
->disconnected_tracing
)
2899 fprintf (fp
, ";disconn:%x", ts
->disconnected_tracing
);
2900 if (ts
->circular_buffer
)
2901 fprintf (fp
, ";circular:%x", ts
->circular_buffer
);
2904 /* Note that we want to upload tracepoints and save those, rather
2905 than simply writing out the local ones, because the user may have
2906 changed tracepoints in GDB in preparation for a future tracing
2907 run, or maybe just mass-deleted all types of breakpoints as part
2908 of cleaning up. So as not to contaminate the session, leave the
2909 data in its uploaded form, don't make into real tracepoints. */
2911 /* Get trace state variables first, they may be checked when parsing
2912 uploaded commands. */
2914 target_upload_trace_state_variables (&uploaded_tsvs
);
2916 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2922 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
2923 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
2926 fprintf (fp
, "tsv %x:%s:%x:%s\n",
2927 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
2928 utsv
->builtin
, buf
);
2934 free_uploaded_tsvs (&uploaded_tsvs
);
2936 target_upload_tracepoints (&uploaded_tps
);
2938 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
2940 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
2941 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2942 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
2943 if (utp
->type
== bp_fast_tracepoint
)
2944 fprintf (fp
, ":F%x", utp
->orig_size
);
2946 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
2949 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
2950 fprintf (fp
, "tp A%x:%s:%s\n",
2951 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
2952 for (a
= 0; VEC_iterate (char_ptr
, utp
->step_actions
, a
, act
); ++a
)
2953 fprintf (fp
, "tp S%x:%s:%s\n",
2954 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
2957 encode_source_string (utp
->number
, utp
->addr
,
2958 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
2959 fprintf (fp
, "tp Z%s\n", buf
);
2961 if (utp
->cond_string
)
2963 encode_source_string (utp
->number
, utp
->addr
,
2964 "cond", utp
->cond_string
,
2965 buf
, MAX_TRACE_UPLOAD
);
2966 fprintf (fp
, "tp Z%s\n", buf
);
2968 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
2970 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
2971 buf
, MAX_TRACE_UPLOAD
);
2972 fprintf (fp
, "tp Z%s\n", buf
);
2976 free_uploaded_tps (&uploaded_tps
);
2978 /* Mark the end of the definition section. */
2981 /* Get and write the trace data proper. We ask for big blocks, in
2982 the hopes of efficiency, but will take less if the target has
2983 packet size limitations or some such. */
2986 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
2988 error (_("Failure to get requested trace buffer data"));
2989 /* No more data is forthcoming, we're done. */
2992 written
= fwrite (buf
, gotten
, 1, fp
);
2994 perror_with_name (pathname
);
2998 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
2999 written
= fwrite (&gotten
, 4, 1, fp
);
3001 perror_with_name (pathname
);
3003 do_cleanups (cleanup
);
3007 trace_save_command (char *args
, int from_tty
)
3009 int target_does_save
= 0;
3011 char *filename
= NULL
;
3012 struct cleanup
*back_to
;
3015 error_no_arg (_("file in which to save trace data"));
3017 argv
= gdb_buildargv (args
);
3018 back_to
= make_cleanup_freeargv (argv
);
3020 for (; *argv
; ++argv
)
3022 if (strcmp (*argv
, "-r") == 0)
3023 target_does_save
= 1;
3024 else if (**argv
== '-')
3025 error (_("unknown option `%s'"), *argv
);
3031 error_no_arg (_("file in which to save trace data"));
3033 trace_save (filename
, target_does_save
);
3036 printf_filtered (_("Trace data saved to file '%s'.\n"), filename
);
3038 do_cleanups (back_to
);
3041 /* Tell the target what to do with an ongoing tracing run if GDB
3042 disconnects for some reason. */
3045 send_disconnected_tracing_value (int value
)
3047 target_set_disconnected_tracing (value
);
3051 set_disconnected_tracing (char *args
, int from_tty
,
3052 struct cmd_list_element
*c
)
3054 send_disconnected_tracing_value (disconnected_tracing
);
3058 set_circular_trace_buffer (char *args
, int from_tty
,
3059 struct cmd_list_element
*c
)
3061 target_set_circular_trace_buffer (circular_trace_buffer
);
3064 /* Convert the memory pointed to by mem into hex, placing result in buf.
3065 * Return a pointer to the last char put in buf (null)
3066 * "stolen" from sparc-stub.c
3069 static const char hexchars
[] = "0123456789abcdef";
3072 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
3080 *buf
++ = hexchars
[ch
>> 4];
3081 *buf
++ = hexchars
[ch
& 0xf];
3090 get_traceframe_number (void)
3092 return traceframe_number
;
3095 /* Make the traceframe NUM be the current trace frame. Does nothing
3096 if NUM is already current. */
3099 set_current_traceframe (int num
)
3103 if (traceframe_number
== num
)
3105 /* Nothing to do. */
3109 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
3112 warning (_("could not change traceframe"));
3114 traceframe_number
= newnum
;
3116 /* Changing the traceframe changes our view of registers and of the
3118 registers_changed ();
3120 clear_traceframe_info ();
3123 /* Make the traceframe NUM be the current trace frame, and do nothing
3127 set_traceframe_number (int num
)
3129 traceframe_number
= num
;
3132 /* A cleanup used when switching away and back from tfind mode. */
3134 struct current_traceframe_cleanup
3136 /* The traceframe we were inspecting. */
3137 int traceframe_number
;
3141 do_restore_current_traceframe_cleanup (void *arg
)
3143 struct current_traceframe_cleanup
*old
= arg
;
3145 set_current_traceframe (old
->traceframe_number
);
3149 restore_current_traceframe_cleanup_dtor (void *arg
)
3151 struct current_traceframe_cleanup
*old
= arg
;
3157 make_cleanup_restore_current_traceframe (void)
3159 struct current_traceframe_cleanup
*old
;
3161 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
3162 old
->traceframe_number
= traceframe_number
;
3164 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
3165 restore_current_traceframe_cleanup_dtor
);
3169 make_cleanup_restore_traceframe_number (void)
3171 return make_cleanup_restore_integer (&traceframe_number
);
3174 /* Given a number and address, return an uploaded tracepoint with that
3175 number, creating if necessary. */
3177 struct uploaded_tp
*
3178 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
3180 struct uploaded_tp
*utp
;
3182 for (utp
= *utpp
; utp
; utp
= utp
->next
)
3183 if (utp
->number
== num
&& utp
->addr
== addr
)
3185 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
3186 memset (utp
, 0, sizeof (struct uploaded_tp
));
3189 utp
->actions
= NULL
;
3190 utp
->step_actions
= NULL
;
3191 utp
->cmd_strings
= NULL
;
3198 free_uploaded_tps (struct uploaded_tp
**utpp
)
3200 struct uploaded_tp
*next_one
;
3204 next_one
= (*utpp
)->next
;
3210 /* Given a number and address, return an uploaded tracepoint with that
3211 number, creating if necessary. */
3213 struct uploaded_tsv
*
3214 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
3216 struct uploaded_tsv
*utsv
;
3218 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
3219 if (utsv
->number
== num
)
3221 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
3222 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
3224 utsv
->next
= *utsvp
;
3230 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
3232 struct uploaded_tsv
*next_one
;
3236 next_one
= (*utsvp
)->next
;
3242 /* FIXME this function is heuristic and will miss the cases where the
3243 conditional is semantically identical but differs in whitespace,
3244 such as "x == 0" vs "x==0". */
3247 cond_string_is_same (char *str1
, char *str2
)
3249 if (str1
== NULL
|| str2
== NULL
)
3250 return (str1
== str2
);
3252 return (strcmp (str1
, str2
) == 0);
3255 /* Look for an existing tracepoint that seems similar enough to the
3256 uploaded one. Enablement isn't compared, because the user can
3257 toggle that freely, and may have done so in anticipation of the
3258 next trace run. Return the location of matched tracepoint. */
3260 struct bp_location
*
3261 find_matching_tracepoint_location (struct uploaded_tp
*utp
)
3263 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3265 struct breakpoint
*b
;
3266 struct bp_location
*loc
;
3268 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, b
); ix
++)
3270 struct tracepoint
*t
= (struct tracepoint
*) b
;
3272 if (b
->type
== utp
->type
3273 && t
->step_count
== utp
->step
3274 && t
->pass_count
== utp
->pass
3275 && cond_string_is_same (t
->base
.cond_string
, utp
->cond_string
)
3276 /* FIXME also test actions. */
3279 /* Scan the locations for an address match. */
3280 for (loc
= b
->loc
; loc
; loc
= loc
->next
)
3282 if (loc
->address
== utp
->addr
)
3290 /* Given a list of tracepoints uploaded from a target, attempt to
3291 match them up with existing tracepoints, and create new ones if not
3295 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3297 struct uploaded_tp
*utp
;
3299 /* Look for GDB tracepoints that match up with our uploaded versions. */
3300 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3302 struct bp_location
*loc
;
3303 struct tracepoint
*t
;
3305 loc
= find_matching_tracepoint_location (utp
);
3308 /* Mark this location as already inserted. */
3310 t
= (struct tracepoint
*) loc
->owner
;
3311 printf_filtered (_("Assuming tracepoint %d is same "
3312 "as target's tracepoint %d at %s.\n"),
3313 loc
->owner
->number
, utp
->number
,
3314 paddress (loc
->gdbarch
, utp
->addr
));
3318 t
= create_tracepoint_from_upload (utp
);
3320 printf_filtered (_("Created tracepoint %d for "
3321 "target's tracepoint %d at %s.\n"),
3322 t
->base
.number
, utp
->number
,
3323 paddress (get_current_arch (), utp
->addr
));
3325 printf_filtered (_("Failed to create tracepoint for target's "
3326 "tracepoint %d at %s, skipping it.\n"),
3328 paddress (get_current_arch (), utp
->addr
));
3330 /* Whether found or created, record the number used by the
3331 target, to help with mapping target tracepoints back to their
3332 counterparts here. */
3334 t
->number_on_target
= utp
->number
;
3337 free_uploaded_tps (uploaded_tps
);
3340 /* Trace state variables don't have much to identify them beyond their
3341 name, so just use that to detect matches. */
3343 struct trace_state_variable
*
3344 find_matching_tsv (struct uploaded_tsv
*utsv
)
3349 return find_trace_state_variable (utsv
->name
);
3352 struct trace_state_variable
*
3353 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3355 const char *namebase
;
3358 struct trace_state_variable
*tsv
;
3362 namebase
= utsv
->name
;
3363 sprintf (buf
, "%s", namebase
);
3368 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3371 /* Fish for a name that is not in use. */
3372 /* (should check against all internal vars?) */
3373 while (find_trace_state_variable (buf
))
3374 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3376 /* We have an available name, create the variable. */
3377 tsv
= create_trace_state_variable (buf
);
3378 tsv
->initial_value
= utsv
->initial_value
;
3379 tsv
->builtin
= utsv
->builtin
;
3384 /* Given a list of uploaded trace state variables, try to match them
3385 up with existing variables, or create additional ones. */
3388 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3391 struct uploaded_tsv
*utsv
;
3392 struct trace_state_variable
*tsv
;
3395 /* Most likely some numbers will have to be reassigned as part of
3396 the merge, so clear them all in anticipation. */
3397 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3400 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3402 tsv
= find_matching_tsv (utsv
);
3406 printf_filtered (_("Assuming trace state variable $%s "
3407 "is same as target's variable %d.\n"),
3408 tsv
->name
, utsv
->number
);
3412 tsv
= create_tsv_from_upload (utsv
);
3414 printf_filtered (_("Created trace state variable "
3415 "$%s for target's variable %d.\n"),
3416 tsv
->name
, utsv
->number
);
3418 /* Give precedence to numberings that come from the target. */
3420 tsv
->number
= utsv
->number
;
3423 /* Renumber everything that didn't get a target-assigned number. */
3425 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3426 if (tsv
->number
> highest
)
3427 highest
= tsv
->number
;
3430 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3431 if (tsv
->number
== 0)
3432 tsv
->number
= highest
++;
3434 free_uploaded_tsvs (uploaded_tsvs
);
3437 /* target tfile command */
3439 struct target_ops tfile_ops
;
3441 /* Fill in tfile_ops with its defined operations and properties. */
3443 #define TRACE_HEADER_SIZE 8
3445 char *trace_filename
;
3447 off_t trace_frames_offset
;
3449 int cur_traceframe_number
;
3451 int trace_regblock_size
;
3453 static void tfile_interp_line (char *line
,
3454 struct uploaded_tp
**utpp
,
3455 struct uploaded_tsv
**utsvp
);
3457 /* Read SIZE bytes into READBUF from the trace frame, starting at
3458 TRACE_FD's current position. Note that this call `read'
3459 underneath, hence it advances the file's seek position. Throws an
3460 error if the `read' syscall fails, or less than SIZE bytes are
3464 tfile_read (gdb_byte
*readbuf
, int size
)
3468 gotten
= read (trace_fd
, readbuf
, size
);
3470 perror_with_name (trace_filename
);
3471 else if (gotten
< size
)
3472 error (_("Premature end of file while reading trace file"));
3476 tfile_open (char *filename
, int from_tty
)
3478 volatile struct gdb_exception ex
;
3480 struct cleanup
*old_chain
;
3483 char header
[TRACE_HEADER_SIZE
];
3484 char linebuf
[1000]; /* Should be max remote packet size or so. */
3487 struct trace_status
*ts
;
3488 struct uploaded_tp
*uploaded_tps
= NULL
;
3489 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3491 target_preopen (from_tty
);
3493 error (_("No trace file specified."));
3495 filename
= tilde_expand (filename
);
3496 if (!IS_ABSOLUTE_PATH(filename
))
3498 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
3503 old_chain
= make_cleanup (xfree
, filename
);
3505 flags
= O_BINARY
| O_LARGEFILE
;
3507 scratch_chan
= open (filename
, flags
, 0);
3508 if (scratch_chan
< 0)
3509 perror_with_name (filename
);
3511 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3513 discard_cleanups (old_chain
); /* Don't free filename any more. */
3514 unpush_target (&tfile_ops
);
3516 trace_filename
= xstrdup (filename
);
3517 trace_fd
= scratch_chan
;
3520 /* Read the file header and test for validity. */
3521 tfile_read ((gdb_byte
*) &header
, TRACE_HEADER_SIZE
);
3523 bytes
+= TRACE_HEADER_SIZE
;
3524 if (!(header
[0] == 0x7f
3525 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3526 error (_("File is not a valid trace file."));
3528 push_target (&tfile_ops
);
3530 trace_regblock_size
= 0;
3531 ts
= current_trace_status ();
3532 /* We know we're working with a file. */
3534 /* Set defaults in case there is no status line. */
3535 ts
->running_known
= 0;
3536 ts
->stop_reason
= trace_stop_reason_unknown
;
3537 ts
->traceframe_count
= -1;
3538 ts
->buffer_free
= 0;
3539 ts
->disconnected_tracing
= 0;
3540 ts
->circular_buffer
= 0;
3542 cur_traceframe_number
= -1;
3544 TRY_CATCH (ex
, RETURN_MASK_ALL
)
3546 /* Read through a section of newline-terminated lines that
3547 define things like tracepoints. */
3551 tfile_read (&byte
, 1);
3556 /* Empty line marks end of the definition section. */
3561 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3564 linebuf
[i
++] = byte
;
3566 error (_("Excessively long lines in trace file"));
3569 /* Record the starting offset of the binary trace data. */
3570 trace_frames_offset
= bytes
;
3572 /* If we don't have a blocksize, we can't interpret the
3574 if (trace_regblock_size
== 0)
3575 error (_("No register block size recorded in trace file"));
3579 /* Pop the partially set up target. */
3581 throw_exception (ex
);
3584 inferior_appeared (current_inferior (), TFILE_PID
);
3585 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3586 add_thread_silent (inferior_ptid
);
3588 if (ts
->traceframe_count
<= 0)
3589 warning (_("No traceframes present in this file."));
3591 /* Add the file's tracepoints and variables into the current mix. */
3593 /* Get trace state variables first, they may be checked when parsing
3594 uploaded commands. */
3595 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3597 merge_uploaded_tracepoints (&uploaded_tps
);
3599 post_create_inferior (&tfile_ops
, from_tty
);
3602 /* Interpret the given line from the definitions part of the trace
3606 tfile_interp_line (char *line
,
3607 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3611 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3614 trace_regblock_size
= strtol (p
, &p
, 16);
3616 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3618 p
+= strlen ("status ");
3619 parse_trace_status (p
, current_trace_status ());
3621 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3623 p
+= strlen ("tp ");
3624 parse_tracepoint_definition (p
, utpp
);
3626 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3628 p
+= strlen ("tsv ");
3629 parse_tsv_definition (p
, utsvp
);
3632 warning (_("Ignoring trace file definition \"%s\""), line
);
3635 /* Parse the part of trace status syntax that is shared between
3636 the remote protocol and the trace file reader. */
3639 parse_trace_status (char *line
, struct trace_status
*ts
)
3641 char *p
= line
, *p1
, *p2
, *p_temp
;
3644 ts
->running_known
= 1;
3645 ts
->running
= (*p
++ == '1');
3646 ts
->stop_reason
= trace_stop_reason_unknown
;
3647 xfree (ts
->error_desc
);
3648 ts
->error_desc
= NULL
;
3649 ts
->traceframe_count
= -1;
3650 ts
->traceframes_created
= -1;
3651 ts
->buffer_free
= -1;
3652 ts
->buffer_size
= -1;
3653 ts
->disconnected_tracing
= 0;
3654 ts
->circular_buffer
= 0;
3658 p1
= strchr (p
, ':');
3660 error (_("Malformed trace status, at %s\n\
3661 Status line: '%s'\n"), p
, line
);
3662 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3664 p
= unpack_varlen_hex (++p1
, &val
);
3665 ts
->stop_reason
= trace_buffer_full
;
3667 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3669 p
= unpack_varlen_hex (++p1
, &val
);
3670 ts
->stop_reason
= trace_never_run
;
3672 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
],
3675 p
= unpack_varlen_hex (++p1
, &val
);
3676 ts
->stop_reason
= tracepoint_passcount
;
3677 ts
->stopping_tracepoint
= val
;
3679 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3681 p
= unpack_varlen_hex (++p1
, &val
);
3682 ts
->stop_reason
= tstop_command
;
3684 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3686 p
= unpack_varlen_hex (++p1
, &val
);
3687 ts
->stop_reason
= trace_disconnected
;
3689 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3691 p2
= strchr (++p1
, ':');
3696 ts
->error_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3697 end
= hex2bin (p1
, ts
->error_desc
, (p2
- p1
) / 2);
3698 ts
->error_desc
[end
] = '\0';
3701 ts
->error_desc
= xstrdup ("");
3703 p
= unpack_varlen_hex (++p2
, &val
);
3704 ts
->stopping_tracepoint
= val
;
3705 ts
->stop_reason
= tracepoint_error
;
3707 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3709 p
= unpack_varlen_hex (++p1
, &val
);
3710 ts
->traceframe_count
= val
;
3712 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3714 p
= unpack_varlen_hex (++p1
, &val
);
3715 ts
->traceframes_created
= val
;
3717 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3719 p
= unpack_varlen_hex (++p1
, &val
);
3720 ts
->buffer_free
= val
;
3722 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3724 p
= unpack_varlen_hex (++p1
, &val
);
3725 ts
->buffer_size
= val
;
3727 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3729 p
= unpack_varlen_hex (++p1
, &val
);
3730 ts
->disconnected_tracing
= val
;
3732 else if (strncmp (p
, "circular", p1
- p
) == 0)
3734 p
= unpack_varlen_hex (++p1
, &val
);
3735 ts
->circular_buffer
= val
;
3739 /* Silently skip unknown optional info. */
3740 p_temp
= strchr (p1
+ 1, ';');
3744 /* Must be at the end. */
3750 /* Given a line of text defining a part of a tracepoint, parse it into
3751 an "uploaded tracepoint". */
3754 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3758 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3761 char *cond
, *srctype
, *buf
;
3762 struct uploaded_tp
*utp
= NULL
;
3765 /* Both tracepoint and action definitions start with the same number
3766 and address sequence. */
3768 p
= unpack_varlen_hex (p
, &num
);
3769 p
++; /* skip a colon */
3770 p
= unpack_varlen_hex (p
, &addr
);
3771 p
++; /* skip a colon */
3774 enabled
= (*p
++ == 'E');
3775 p
++; /* skip a colon */
3776 p
= unpack_varlen_hex (p
, &step
);
3777 p
++; /* skip a colon */
3778 p
= unpack_varlen_hex (p
, &pass
);
3779 type
= bp_tracepoint
;
3781 /* Thumb through optional fields. */
3784 p
++; /* skip a colon */
3787 type
= bp_fast_tracepoint
;
3789 p
= unpack_varlen_hex (p
, &orig_size
);
3793 type
= bp_static_tracepoint
;
3799 p
= unpack_varlen_hex (p
, &xlen
);
3800 p
++; /* skip a comma */
3801 cond
= (char *) xmalloc (2 * xlen
+ 1);
3802 strncpy (cond
, p
, 2 * xlen
);
3803 cond
[2 * xlen
] = '\0';
3807 warning (_("Unrecognized char '%c' in tracepoint "
3808 "definition, skipping rest"), *p
);
3810 utp
= get_uploaded_tp (num
, addr
, utpp
);
3812 utp
->enabled
= enabled
;
3817 else if (piece
== 'A')
3819 utp
= get_uploaded_tp (num
, addr
, utpp
);
3820 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
3822 else if (piece
== 'S')
3824 utp
= get_uploaded_tp (num
, addr
, utpp
);
3825 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
3827 else if (piece
== 'Z')
3829 /* Parse a chunk of source form definition. */
3830 utp
= get_uploaded_tp (num
, addr
, utpp
);
3832 p
= strchr (p
, ':');
3833 p
++; /* skip a colon */
3834 p
= unpack_varlen_hex (p
, &start
);
3835 p
++; /* skip a colon */
3836 p
= unpack_varlen_hex (p
, &xlen
);
3837 p
++; /* skip a colon */
3839 buf
= alloca (strlen (line
));
3841 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3844 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
3845 utp
->at_string
= xstrdup (buf
);
3846 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
3847 utp
->cond_string
= xstrdup (buf
);
3848 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
3849 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
3853 /* Don't error out, the target might be sending us optional
3854 info that we don't care about. */
3855 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3859 /* Convert a textual description of a trace state variable into an
3863 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3866 ULONGEST num
, initval
, builtin
;
3868 struct uploaded_tsv
*utsv
= NULL
;
3870 buf
= alloca (strlen (line
));
3873 p
= unpack_varlen_hex (p
, &num
);
3874 p
++; /* skip a colon */
3875 p
= unpack_varlen_hex (p
, &initval
);
3876 p
++; /* skip a colon */
3877 p
= unpack_varlen_hex (p
, &builtin
);
3878 p
++; /* skip a colon */
3879 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3882 utsv
= get_uploaded_tsv (num
, utsvp
);
3883 utsv
->initial_value
= initval
;
3884 utsv
->builtin
= builtin
;
3885 utsv
->name
= xstrdup (buf
);
3888 /* Close the trace file and generally clean up. */
3891 tfile_close (int quitting
)
3898 pid
= ptid_get_pid (inferior_ptid
);
3899 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff. */
3900 exit_inferior_silent (pid
);
3904 xfree (trace_filename
);
3905 trace_filename
= NULL
;
3909 tfile_files_info (struct target_ops
*t
)
3911 /* (it would be useful to mention the name of the file). */
3912 printf_filtered ("Looking at a trace file.\n");
3915 /* The trace status for a file is that tracing can never be run. */
3918 tfile_get_trace_status (struct trace_status
*ts
)
3920 /* Other bits of trace status were collected as part of opening the
3921 trace files, so nothing to do here. */
3926 /* Given the position of a traceframe in the file, figure out what
3927 address the frame was collected at. This would normally be the
3928 value of a collected PC register, but if not available, we
3932 tfile_get_traceframe_address (off_t tframe_offset
)
3936 struct tracepoint
*tp
;
3937 off_t saved_offset
= cur_offset
;
3939 /* FIXME dig pc out of collected registers. */
3941 /* Fall back to using tracepoint address. */
3942 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
3943 tfile_read ((gdb_byte
*) &tpnum
, 2);
3944 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
3948 tp
= get_tracepoint_by_number_on_target (tpnum
);
3949 /* FIXME this is a poor heuristic if multiple locations. */
3950 if (tp
&& tp
->base
.loc
)
3951 addr
= tp
->base
.loc
->address
;
3953 /* Restore our seek position. */
3954 cur_offset
= saved_offset
;
3955 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3959 /* Make tfile's selected traceframe match GDB's selected
3963 set_tfile_traceframe (void)
3967 if (cur_traceframe_number
== get_traceframe_number ())
3970 /* Avoid recursion, tfile_trace_find calls us again. */
3971 cur_traceframe_number
= get_traceframe_number ();
3973 newnum
= target_trace_find (tfind_number
,
3974 get_traceframe_number (), 0, 0, NULL
);
3976 /* Should not happen. If it does, all bets are off. */
3977 if (newnum
!= get_traceframe_number ())
3978 warning (_("could not set tfile's traceframe"));
3981 /* Given a type of search and some parameters, scan the collection of
3982 traceframes in the file looking for a match. When found, return
3983 both the traceframe and tracepoint number, otherwise -1 for
3987 tfile_trace_find (enum trace_find_type type
, int num
,
3988 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
3991 int tfnum
= 0, found
= 0;
3992 unsigned int data_size
;
3993 struct tracepoint
*tp
;
3994 off_t offset
, tframe_offset
;
3997 /* Lookups other than by absolute frame number depend on the current
3998 trace selected, so make sure it is correct on the tfile end
4000 if (type
!= tfind_number
)
4001 set_tfile_traceframe ();
4009 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
4010 offset
= trace_frames_offset
;
4013 tframe_offset
= offset
;
4014 tfile_read ((gdb_byte
*) &tpnum
, 2);
4015 tpnum
= (short) extract_signed_integer ((gdb_byte
*) &tpnum
, 2,
4021 tfile_read ((gdb_byte
*) &data_size
, 4);
4022 data_size
= (unsigned int) extract_unsigned_integer
4023 ((gdb_byte
*) &data_size
, 4,
4024 gdbarch_byte_order (target_gdbarch
));
4033 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4034 if (tfaddr
== addr1
)
4038 tp
= get_tracepoint (num
);
4039 if (tp
&& tpnum
== tp
->number_on_target
)
4043 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4044 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
4048 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
4049 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
4053 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
4059 cur_offset
= offset
;
4060 cur_data_size
= data_size
;
4061 cur_traceframe_number
= tfnum
;
4064 /* Skip past the traceframe's data. */
4065 lseek (trace_fd
, data_size
, SEEK_CUR
);
4066 offset
+= data_size
;
4067 /* Update our own count of traceframes. */
4070 /* Did not find what we were looking for. */
4076 /* Prototype of the callback passed to tframe_walk_blocks. */
4077 typedef int (*walk_blocks_callback_func
) (char blocktype
, void *data
);
4079 /* Callback for traceframe_walk_blocks, used to find a given block
4080 type in a traceframe. */
4083 match_blocktype (char blocktype
, void *data
)
4085 char *wantedp
= data
;
4087 if (*wantedp
== blocktype
)
4093 /* Walk over all traceframe block starting at POS offset from
4094 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4095 unmodified. If CALLBACK returns true, this returns the position in
4096 the traceframe where the block is found, relative to the start of
4097 the traceframe (cur_offset). Returns -1 if no callback call
4098 returned true, indicating that all blocks have been walked. */
4101 traceframe_walk_blocks (walk_blocks_callback_func callback
,
4102 int pos
, void *data
)
4104 /* Iterate through a traceframe's blocks, looking for a block of the
4107 lseek (trace_fd
, cur_offset
+ pos
, SEEK_SET
);
4108 while (pos
< cur_data_size
)
4110 unsigned short mlen
;
4113 tfile_read (&block_type
, 1);
4117 if ((*callback
) (block_type
, data
))
4123 lseek (trace_fd
, cur_offset
+ pos
+ trace_regblock_size
, SEEK_SET
);
4124 pos
+= trace_regblock_size
;
4127 lseek (trace_fd
, cur_offset
+ pos
+ 8, SEEK_SET
);
4128 tfile_read ((gdb_byte
*) &mlen
, 2);
4129 mlen
= (unsigned short)
4130 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2,
4133 lseek (trace_fd
, mlen
, SEEK_CUR
);
4134 pos
+= (8 + 2 + mlen
);
4137 lseek (trace_fd
, cur_offset
+ pos
+ 4 + 8, SEEK_SET
);
4141 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4142 block_type
, block_type
);
4150 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4151 position offset of a block of type TYPE_WANTED in the current trace
4152 frame, starting at POS. Returns -1 if no such block was found. */
4155 traceframe_find_block_type (char type_wanted
, int pos
)
4157 return traceframe_walk_blocks (match_blocktype
, pos
, &type_wanted
);
4160 /* Look for a block of saved registers in the traceframe, and get the
4161 requested register from it. */
4164 tfile_fetch_registers (struct target_ops
*ops
,
4165 struct regcache
*regcache
, int regno
)
4167 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
4169 int pos
, offset
, regn
, regsize
, pc_regno
;
4170 unsigned short mlen
;
4173 /* An uninitialized reg size says we're not going to be
4174 successful at getting register blocks. */
4175 if (!trace_regblock_size
)
4178 set_tfile_traceframe ();
4180 regs
= alloca (trace_regblock_size
);
4182 if (traceframe_find_block_type ('R', 0) >= 0)
4184 tfile_read (regs
, trace_regblock_size
);
4186 /* Assume the block is laid out in GDB register number order,
4187 each register with the size that it has in GDB. */
4189 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4191 regsize
= register_size (gdbarch
, regn
);
4192 /* Make sure we stay within block bounds. */
4193 if (offset
+ regsize
>= trace_regblock_size
)
4195 if (regcache_register_status (regcache
, regn
) == REG_UNKNOWN
)
4199 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
4202 else if (regno
== -1)
4204 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
4212 /* We get here if no register data has been found. Mark registers
4214 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
4215 regcache_raw_supply (regcache
, regn
, NULL
);
4217 /* We can often usefully guess that the PC is going to be the same
4218 as the address of the tracepoint. */
4219 pc_regno
= gdbarch_pc_regnum (gdbarch
);
4220 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
4222 struct tracepoint
*tp
= get_tracepoint (tracepoint_number
);
4224 if (tp
&& tp
->base
.loc
)
4226 /* But don't try to guess if tracepoint is multi-location... */
4227 if (tp
->base
.loc
->next
)
4229 warning (_("Tracepoint %d has multiple "
4230 "locations, cannot infer $pc"),
4234 /* ... or does while-stepping. */
4235 if (tp
->step_count
> 0)
4237 warning (_("Tracepoint %d does while-stepping, "
4238 "cannot infer $pc"),
4243 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
4244 gdbarch_byte_order (gdbarch
),
4245 tp
->base
.loc
->address
);
4246 regcache_raw_supply (regcache
, pc_regno
, regs
);
4252 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
4253 const char *annex
, gdb_byte
*readbuf
,
4254 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
4256 /* We're only doing regular memory for now. */
4257 if (object
!= TARGET_OBJECT_MEMORY
)
4260 if (readbuf
== NULL
)
4261 error (_("tfile_xfer_partial: trace file is read-only"));
4263 set_tfile_traceframe ();
4265 if (traceframe_number
!= -1)
4269 /* Iterate through the traceframe's blocks, looking for
4271 while ((pos
= traceframe_find_block_type ('M', pos
)) >= 0)
4273 ULONGEST maddr
, amt
;
4274 unsigned short mlen
;
4275 enum bfd_endian byte_order
= gdbarch_byte_order (target_gdbarch
);
4277 tfile_read ((gdb_byte
*) &maddr
, 8);
4278 maddr
= extract_unsigned_integer ((gdb_byte
*) &maddr
, 8,
4280 tfile_read ((gdb_byte
*) &mlen
, 2);
4281 mlen
= (unsigned short)
4282 extract_unsigned_integer ((gdb_byte
*) &mlen
, 2, byte_order
);
4284 /* If the block includes the first part of the desired
4285 range, return as much it has; GDB will re-request the
4286 remainder, which might be in a different block of this
4288 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
4290 amt
= (maddr
+ mlen
) - offset
;
4294 tfile_read (readbuf
, amt
);
4298 /* Skip over this block. */
4299 pos
+= (8 + 2 + mlen
);
4303 /* It's unduly pedantic to refuse to look at the executable for
4304 read-only pieces; so do the equivalent of readonly regions aka
4306 /* FIXME account for relocation at some point. */
4313 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
4315 if ((s
->flags
& SEC_LOAD
) == 0
4316 || (s
->flags
& SEC_READONLY
) == 0)
4320 size
= bfd_get_section_size (s
);
4321 if (vma
<= offset
&& offset
< (vma
+ size
))
4325 amt
= (vma
+ size
) - offset
;
4329 amt
= bfd_get_section_contents (exec_bfd
, s
,
4330 readbuf
, offset
- vma
, amt
);
4336 /* Indicate failure to find the requested memory block. */
4340 /* Iterate through the blocks of a trace frame, looking for a 'V'
4341 block with a matching tsv number. */
4344 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
4348 set_tfile_traceframe ();
4351 while ((pos
= traceframe_find_block_type ('V', pos
)) >= 0)
4355 tfile_read ((gdb_byte
*) &vnum
, 4);
4356 vnum
= (int) extract_signed_integer ((gdb_byte
*) &vnum
, 4,
4361 tfile_read ((gdb_byte
*) val
, 8);
4362 *val
= extract_signed_integer ((gdb_byte
*) val
, 8,
4370 /* Didn't find anything. */
4375 tfile_has_all_memory (struct target_ops
*ops
)
4381 tfile_has_memory (struct target_ops
*ops
)
4387 tfile_has_stack (struct target_ops
*ops
)
4389 return traceframe_number
!= -1;
4393 tfile_has_registers (struct target_ops
*ops
)
4395 return traceframe_number
!= -1;
4399 tfile_thread_alive (struct target_ops
*ops
, ptid_t ptid
)
4404 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
4405 object for the tfile target's current traceframe. */
4408 build_traceframe_info (char blocktype
, void *data
)
4410 struct traceframe_info
*info
= data
;
4416 struct mem_range
*r
;
4418 unsigned short mlen
;
4420 tfile_read ((gdb_byte
*) &maddr
, 8);
4421 tfile_read ((gdb_byte
*) &mlen
, 2);
4423 r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4436 warning (_("Unhandled trace block type (%d) '%c ' "
4437 "while building trace frame info."),
4438 blocktype
, blocktype
);
4445 static struct traceframe_info
*
4446 tfile_traceframe_info (void)
4448 struct traceframe_info
*info
= XCNEW (struct traceframe_info
);
4450 traceframe_walk_blocks (build_traceframe_info
, 0, info
);
4455 init_tfile_ops (void)
4457 tfile_ops
.to_shortname
= "tfile";
4458 tfile_ops
.to_longname
= "Local trace dump file";
4460 = "Use a trace file as a target. Specify the filename of the trace file.";
4461 tfile_ops
.to_open
= tfile_open
;
4462 tfile_ops
.to_close
= tfile_close
;
4463 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
4464 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
4465 tfile_ops
.to_files_info
= tfile_files_info
;
4466 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
4467 tfile_ops
.to_trace_find
= tfile_trace_find
;
4468 tfile_ops
.to_get_trace_state_variable_value
4469 = tfile_get_trace_state_variable_value
;
4470 tfile_ops
.to_stratum
= process_stratum
;
4471 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
4472 tfile_ops
.to_has_memory
= tfile_has_memory
;
4473 tfile_ops
.to_has_stack
= tfile_has_stack
;
4474 tfile_ops
.to_has_registers
= tfile_has_registers
;
4475 tfile_ops
.to_traceframe_info
= tfile_traceframe_info
;
4476 tfile_ops
.to_thread_alive
= tfile_thread_alive
;
4477 tfile_ops
.to_magic
= OPS_MAGIC
;
4480 /* Given a line of text defining a static tracepoint marker, parse it
4481 into a "static tracepoint marker" object. Throws an error is
4482 parsing fails. If PP is non-null, it points to one past the end of
4483 the parsed marker definition. */
4486 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
4487 struct static_tracepoint_marker
*marker
)
4494 p
= unpack_varlen_hex (p
, &addr
);
4495 p
++; /* skip a colon */
4497 marker
->gdbarch
= target_gdbarch
;
4498 marker
->address
= (CORE_ADDR
) addr
;
4500 endp
= strchr (p
, ':');
4502 error (_("bad marker definition: %s"), line
);
4504 marker
->str_id
= xmalloc (endp
- p
+ 1);
4505 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
4506 marker
->str_id
[end
] = '\0';
4509 p
++; /* skip a colon */
4511 marker
->extra
= xmalloc (strlen (p
) + 1);
4512 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
4513 marker
->extra
[end
] = '\0';
4519 /* Release a static tracepoint marker's contents. Note that the
4520 object itself isn't released here. There objects are usually on
4524 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
4526 xfree (marker
->str_id
);
4527 marker
->str_id
= NULL
;
4530 /* Print MARKER to gdb_stdout. */
4533 print_one_static_tracepoint_marker (int count
,
4534 struct static_tracepoint_marker
*marker
)
4536 struct command_line
*l
;
4539 char wrap_indent
[80];
4540 char extra_field_indent
[80];
4541 struct ui_out
*uiout
= current_uiout
;
4542 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
4543 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4544 struct cleanup
*bkpt_chain
;
4545 VEC(breakpoint_p
) *tracepoints
;
4547 struct symtab_and_line sal
;
4551 sal
.pc
= marker
->address
;
4553 tracepoints
= static_tracepoints_here (marker
->address
);
4555 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
4557 /* A counter field to help readability. This is not a stable
4559 ui_out_field_int (uiout
, "count", count
);
4561 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
4563 ui_out_field_fmt (uiout
, "enabled", "%c",
4564 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
4565 ui_out_spaces (uiout
, 2);
4567 strcpy (wrap_indent
, " ");
4569 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
4570 strcat (wrap_indent
, " ");
4572 strcat (wrap_indent
, " ");
4574 strcpy (extra_field_indent
, " ");
4576 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
4578 sal
= find_pc_line (marker
->address
, 0);
4579 sym
= find_pc_sect_function (marker
->address
, NULL
);
4582 ui_out_text (uiout
, "in ");
4583 ui_out_field_string (uiout
, "func",
4584 SYMBOL_PRINT_NAME (sym
));
4585 ui_out_wrap_hint (uiout
, wrap_indent
);
4586 ui_out_text (uiout
, " at ");
4589 ui_out_field_skip (uiout
, "func");
4591 if (sal
.symtab
!= NULL
)
4593 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
4594 ui_out_text (uiout
, ":");
4596 if (ui_out_is_mi_like_p (uiout
))
4598 char *fullname
= symtab_to_fullname (sal
.symtab
);
4601 ui_out_field_string (uiout
, "fullname", fullname
);
4604 ui_out_field_skip (uiout
, "fullname");
4606 ui_out_field_int (uiout
, "line", sal
.line
);
4610 ui_out_field_skip (uiout
, "fullname");
4611 ui_out_field_skip (uiout
, "line");
4614 ui_out_text (uiout
, "\n");
4615 ui_out_text (uiout
, extra_field_indent
);
4616 ui_out_text (uiout
, _("Data: \""));
4617 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
4618 ui_out_text (uiout
, "\"\n");
4620 if (!VEC_empty (breakpoint_p
, tracepoints
))
4622 struct cleanup
*cleanup_chain
;
4624 struct breakpoint
*b
;
4626 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
4629 ui_out_text (uiout
, extra_field_indent
);
4630 ui_out_text (uiout
, _("Probed by static tracepoints: "));
4631 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
4634 ui_out_text (uiout
, ", ");
4635 ui_out_text (uiout
, "#");
4636 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
4639 do_cleanups (cleanup_chain
);
4641 if (ui_out_is_mi_like_p (uiout
))
4642 ui_out_field_int (uiout
, "number-of-tracepoints",
4643 VEC_length(breakpoint_p
, tracepoints
));
4645 ui_out_text (uiout
, "\n");
4647 VEC_free (breakpoint_p
, tracepoints
);
4649 do_cleanups (bkpt_chain
);
4650 do_cleanups (old_chain
);
4654 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
4656 VEC(static_tracepoint_marker_p
) *markers
;
4657 struct cleanup
*old_chain
;
4658 struct static_tracepoint_marker
*marker
;
4659 struct ui_out
*uiout
= current_uiout
;
4663 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
4664 "StaticTracepointMarkersTable");
4666 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
4668 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
4670 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
4671 if (gdbarch_addr_bit (target_gdbarch
) <= 32)
4672 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
4674 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
4675 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
4677 ui_out_table_body (uiout
);
4679 markers
= target_static_tracepoint_markers_by_strid (NULL
);
4680 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
4683 VEC_iterate (static_tracepoint_marker_p
,
4684 markers
, i
, marker
);
4687 print_one_static_tracepoint_marker (i
+ 1, marker
);
4688 release_static_tracepoint_marker (marker
);
4691 do_cleanups (old_chain
);
4694 /* The $_sdata convenience variable is a bit special. We don't know
4695 for sure type of the value until we actually have a chance to fetch
4696 the data --- the size of the object depends on what has been
4697 collected. We solve this by making $_sdata be an internalvar that
4698 creates a new value on access. */
4700 /* Return a new value with the correct type for the sdata object of
4701 the current trace frame. Return a void value if there's no object
4704 static struct value
*
4705 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
)
4710 /* We need to read the whole object before we know its size. */
4711 size
= target_read_alloc (¤t_target
,
4712 TARGET_OBJECT_STATIC_TRACE_DATA
,
4719 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
4721 v
= allocate_value (type
);
4722 memcpy (value_contents_raw (v
), buf
, size
);
4727 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
4730 #if !defined(HAVE_LIBEXPAT)
4732 struct traceframe_info
*
4733 parse_traceframe_info (const char *tframe_info
)
4735 static int have_warned
;
4740 warning (_("Can not parse XML trace frame info; XML support "
4741 "was disabled at compile time"));
4747 #else /* HAVE_LIBEXPAT */
4749 #include "xml-support.h"
4751 /* Handle the start of a <memory> element. */
4754 traceframe_info_start_memory (struct gdb_xml_parser
*parser
,
4755 const struct gdb_xml_element
*element
,
4756 void *user_data
, VEC(gdb_xml_value_s
) *attributes
)
4758 struct traceframe_info
*info
= user_data
;
4759 struct mem_range
*r
= VEC_safe_push (mem_range_s
, info
->memory
, NULL
);
4760 ULONGEST
*start_p
, *length_p
;
4762 start_p
= xml_find_attribute (attributes
, "start")->value
;
4763 length_p
= xml_find_attribute (attributes
, "length")->value
;
4765 r
->start
= *start_p
;
4766 r
->length
= *length_p
;
4769 /* Discard the constructed trace frame info (if an error occurs). */
4772 free_result (void *p
)
4774 struct traceframe_info
*result
= p
;
4776 free_traceframe_info (result
);
4779 /* The allowed elements and attributes for an XML memory map. */
4781 static const struct gdb_xml_attribute memory_attributes
[] = {
4782 { "start", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
4783 { "length", GDB_XML_AF_NONE
, gdb_xml_parse_attr_ulongest
, NULL
},
4784 { NULL
, GDB_XML_AF_NONE
, NULL
, NULL
}
4787 static const struct gdb_xml_element traceframe_info_children
[] = {
4788 { "memory", memory_attributes
, NULL
,
4789 GDB_XML_EF_REPEATABLE
| GDB_XML_EF_OPTIONAL
,
4790 traceframe_info_start_memory
, NULL
},
4791 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
4794 static const struct gdb_xml_element traceframe_info_elements
[] = {
4795 { "traceframe-info", NULL
, traceframe_info_children
, GDB_XML_EF_NONE
,
4797 { NULL
, NULL
, NULL
, GDB_XML_EF_NONE
, NULL
, NULL
}
4800 /* Parse a traceframe-info XML document. */
4802 struct traceframe_info
*
4803 parse_traceframe_info (const char *tframe_info
)
4805 struct traceframe_info
*result
;
4806 struct cleanup
*back_to
;
4808 result
= XCNEW (struct traceframe_info
);
4809 back_to
= make_cleanup (free_result
, result
);
4811 if (gdb_xml_parse_quick (_("trace frame info"),
4812 "traceframe-info.dtd", traceframe_info_elements
,
4813 tframe_info
, result
) == 0)
4815 /* Parsed successfully, keep the result. */
4816 discard_cleanups (back_to
);
4821 do_cleanups (back_to
);
4825 #endif /* HAVE_LIBEXPAT */
4827 /* Returns the traceframe_info object for the current traceframe.
4828 This is where we avoid re-fetching the object from the target if we
4829 already have it cached. */
4831 struct traceframe_info
*
4832 get_traceframe_info (void)
4834 if (traceframe_info
== NULL
)
4835 traceframe_info
= target_traceframe_info ();
4837 return traceframe_info
;
4840 /* If the target supports the query, return in RESULT the set of
4841 collected memory in the current traceframe, found within the LEN
4842 bytes range starting at MEMADDR. Returns true if the target
4843 supports the query, otherwise returns false, and RESULT is left
4847 traceframe_available_memory (VEC(mem_range_s
) **result
,
4848 CORE_ADDR memaddr
, ULONGEST len
)
4850 struct traceframe_info
*info
= get_traceframe_info ();
4854 struct mem_range
*r
;
4859 for (i
= 0; VEC_iterate (mem_range_s
, info
->memory
, i
, r
); i
++)
4860 if (mem_ranges_overlap (r
->start
, r
->length
, memaddr
, len
))
4862 ULONGEST lo1
, hi1
, lo2
, hi2
;
4863 struct mem_range
*nr
;
4866 hi1
= memaddr
+ len
;
4869 hi2
= r
->start
+ r
->length
;
4871 nr
= VEC_safe_push (mem_range_s
, *result
, NULL
);
4873 nr
->start
= max (lo1
, lo2
);
4874 nr
->length
= min (hi1
, hi2
) - nr
->start
;
4877 normalize_mem_ranges (*result
);
4884 /* module initialization */
4886 _initialize_tracepoint (void)
4888 struct cmd_list_element
*c
;
4890 /* Explicitly create without lookup, since that tries to create a
4891 value with a void typed value, and when we get here, gdbarch
4892 isn't initialized yet. At this point, we're quite sure there
4893 isn't another convenience variable of the same name. */
4894 create_internalvar_type_lazy ("_sdata", sdata_make_value
);
4896 traceframe_number
= -1;
4897 tracepoint_number
= -1;
4899 if (tracepoint_list
.list
== NULL
)
4901 tracepoint_list
.listsize
= 128;
4902 tracepoint_list
.list
= xmalloc
4903 (tracepoint_list
.listsize
* sizeof (struct memrange
));
4905 if (tracepoint_list
.aexpr_list
== NULL
)
4907 tracepoint_list
.aexpr_listsize
= 128;
4908 tracepoint_list
.aexpr_list
= xmalloc
4909 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
4912 if (stepping_list
.list
== NULL
)
4914 stepping_list
.listsize
= 128;
4915 stepping_list
.list
= xmalloc
4916 (stepping_list
.listsize
* sizeof (struct memrange
));
4919 if (stepping_list
.aexpr_list
== NULL
)
4921 stepping_list
.aexpr_listsize
= 128;
4922 stepping_list
.aexpr_list
= xmalloc
4923 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
4926 add_info ("scope", scope_info
,
4927 _("List the variables local to a scope"));
4929 add_cmd ("tracepoints", class_trace
, NULL
,
4930 _("Tracing of program execution without stopping the program."),
4933 add_com ("tdump", class_trace
, trace_dump_command
,
4934 _("Print everything collected at the current tracepoint."));
4936 add_com ("tsave", class_trace
, trace_save_command
, _("\
4937 Save the trace data to a file.\n\
4938 Use the '-r' option to direct the target to save directly to the file,\n\
4939 using its own filesystem."));
4941 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
4942 Define a trace state variable.\n\
4943 Argument is a $-prefixed name, optionally followed\n\
4944 by '=' and an expression that sets the initial value\n\
4945 at the start of tracing."));
4946 set_cmd_completer (c
, expression_completer
);
4948 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
4949 Delete one or more trace state variables.\n\
4950 Arguments are the names of the variables to delete.\n\
4951 If no arguments are supplied, delete all variables."), &deletelist
);
4952 /* FIXME add a trace variable completer. */
4954 add_info ("tvariables", tvariables_info
, _("\
4955 Status of trace state variables and their values.\n\
4958 add_info ("static-tracepoint-markers",
4959 info_static_tracepoint_markers_command
, _("\
4960 List target static tracepoints markers.\n\
4963 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
4964 Select a trace frame;\n\
4965 No argument means forward by one frame; '-' means backward by one frame."),
4966 &tfindlist
, "tfind ", 1, &cmdlist
);
4968 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
4969 Select a trace frame whose PC is outside the given range (exclusive).\n\
4970 Usage: tfind outside addr1, addr2"),
4973 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
4974 Select a trace frame whose PC is in the given range (inclusive).\n\
4975 Usage: tfind range addr1,addr2"),
4978 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
4979 Select a trace frame by source line.\n\
4980 Argument can be a line number (with optional source file),\n\
4981 a function name, or '*' followed by an address.\n\
4982 Default argument is 'the next source line that was traced'."),
4985 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
4986 Select a trace frame by tracepoint number.\n\
4987 Default is the tracepoint for the current trace frame."),
4990 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
4991 Select a trace frame by PC.\n\
4992 Default is the current PC, or the PC of the current trace frame."),
4995 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
4996 Synonym for 'none'.\n\
4997 De-select any trace frame and resume 'live' debugging."),
5000 add_cmd ("none", class_trace
, trace_find_none_command
,
5001 _("De-select any trace frame and resume 'live' debugging."),
5004 add_cmd ("start", class_trace
, trace_find_start_command
,
5005 _("Select the first trace frame in the trace buffer."),
5008 add_com ("tstatus", class_trace
, trace_status_command
,
5009 _("Display the status of the current trace data collection."));
5011 add_com ("tstop", class_trace
, trace_stop_command
,
5012 _("Stop trace data collection."));
5014 add_com ("tstart", class_trace
, trace_start_command
,
5015 _("Start trace data collection."));
5017 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
5018 Ends a list of commands or actions.\n\
5019 Several GDB commands allow you to enter a list of commands or actions.\n\
5020 Entering \"end\" on a line by itself is the normal way to terminate\n\
5022 Note: the \"end\" command cannot be used at the gdb prompt."));
5024 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
5025 Specify single-stepping behavior at a tracepoint.\n\
5026 Argument is number of instructions to trace in single-step mode\n\
5027 following the tracepoint. This command is normally followed by\n\
5028 one or more \"collect\" commands, to specify what to collect\n\
5029 while single-stepping.\n\n\
5030 Note: this command can only be used in a tracepoint \"actions\" list."));
5032 add_com_alias ("ws", "while-stepping", class_alias
, 0);
5033 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
5035 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
5036 Specify one or more data items to be collected at a tracepoint.\n\
5037 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5038 collect all data (variables, registers) referenced by that expression.\n\
5039 Also accepts the following special arguments:\n\
5040 $regs -- all registers.\n\
5041 $args -- all function arguments.\n\
5042 $locals -- all variables local to the block/function scope.\n\
5043 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5044 Note: this command can only be used in a tracepoint \"actions\" list."));
5046 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
5047 Specify one or more expressions to be evaluated at a tracepoint.\n\
5048 Accepts a comma-separated list of (one or more) expressions.\n\
5049 The result of each evaluation will be discarded.\n\
5050 Note: this command can only be used in a tracepoint \"actions\" list."));
5052 add_com ("actions", class_trace
, trace_actions_command
, _("\
5053 Specify the actions to be taken at a tracepoint.\n\
5054 Tracepoint actions may include collecting of specified data,\n\
5055 single-stepping, or enabling/disabling other tracepoints,\n\
5056 depending on target's capabilities."));
5058 default_collect
= xstrdup ("");
5059 add_setshow_string_cmd ("default-collect", class_trace
,
5060 &default_collect
, _("\
5061 Set the list of expressions to collect by default"), _("\
5062 Show the list of expressions to collect by default"), NULL
,
5064 &setlist
, &showlist
);
5066 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
5067 &disconnected_tracing
, _("\
5068 Set whether tracing continues after GDB disconnects."), _("\
5069 Show whether tracing continues after GDB disconnects."), _("\
5070 Use this to continue a tracing run even if GDB disconnects\n\
5071 or detaches from the target. You can reconnect later and look at\n\
5072 trace data collected in the meantime."),
5073 set_disconnected_tracing
,
5078 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
5079 &circular_trace_buffer
, _("\
5080 Set target's use of circular trace buffer."), _("\
5081 Show target's use of circular trace buffer."), _("\
5082 Use this to make the trace buffer into a circular buffer,\n\
5083 which will discard traceframes (oldest first) instead of filling\n\
5084 up and stopping the trace run."),
5085 set_circular_trace_buffer
,
5092 add_target (&tfile_ops
);