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 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 /* readline include files */
55 #include "readline/readline.h"
56 #include "readline/history.h"
58 /* readline defines this. */
69 extern int hex2bin (const char *hex
, gdb_byte
*bin
, int count
);
70 extern int bin2hex (const gdb_byte
*bin
, char *hex
, int count
);
72 extern void stop_tracing ();
74 /* Maximum length of an agent aexpression.
75 This accounts for the fact that packets are limited to 400 bytes
76 (which includes everything -- including the checksum), and assumes
77 the worst case of maximum length for each of the pieces of a
80 NOTE: expressions get mem2hex'ed otherwise this would be twice as
81 large. (400 - 31)/2 == 184 */
82 #define MAX_AGENT_EXPR_LEN 184
84 /* A hook used to notify the UI of tracepoint operations. */
86 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
87 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
89 extern void (*deprecated_readline_begin_hook
) (char *, ...);
90 extern char *(*deprecated_readline_hook
) (char *);
91 extern void (*deprecated_readline_end_hook
) (void);
93 /* GDB commands implemented in other modules:
96 extern void output_command (char *, int);
101 This module defines the following debugger commands:
102 trace : set a tracepoint on a function, line, or address.
103 info trace : list all debugger-defined tracepoints.
104 delete trace : delete one or more tracepoints.
105 enable trace : enable one or more tracepoints.
106 disable trace : disable one or more tracepoints.
107 actions : specify actions to be taken at a tracepoint.
108 passcount : specify a pass count for a tracepoint.
109 tstart : start a trace experiment.
110 tstop : stop a trace experiment.
111 tstatus : query the status of a trace experiment.
112 tfind : find a trace frame in the trace buffer.
113 tdump : print everything collected at the current tracepoint.
114 save-tracepoints : write tracepoint setup into a file.
116 This module defines the following user-visible debugger variables:
117 $trace_frame : sequence number of trace frame currently being debugged.
118 $trace_line : source line of trace frame currently being debugged.
119 $trace_file : source file of trace frame currently being debugged.
120 $tracepoint : tracepoint number of trace frame currently being debugged.
124 /* ======= Important global variables: ======= */
126 /* The list of all trace state variables. We don't retain pointers to
127 any of these for any reason - API is by name or number only - so it
128 works to have a vector of objects. */
130 typedef struct trace_state_variable tsv_s
;
133 static VEC(tsv_s
) *tvariables
;
135 /* The next integer to assign to a variable. */
137 static int next_tsv_number
= 1;
139 /* Number of last traceframe collected. */
140 static int traceframe_number
;
142 /* Tracepoint for last traceframe collected. */
143 static int tracepoint_number
;
145 /* Symbol for function for last traceframe collected */
146 static struct symbol
*traceframe_fun
;
148 /* Symtab and line for last traceframe collected */
149 static struct symtab_and_line traceframe_sal
;
151 /* Tracing command lists */
152 static struct cmd_list_element
*tfindlist
;
154 /* List of expressions to collect by default at each tracepoint hit. */
155 char *default_collect
= "";
157 static int disconnected_tracing
;
159 /* This variable controls whether we ask the target for a linear or
160 circular trace buffer. */
162 static int circular_trace_buffer
;
164 /* ======= Important command functions: ======= */
165 static void trace_actions_command (char *, int);
166 static void trace_start_command (char *, int);
167 static void trace_stop_command (char *, int);
168 static void trace_status_command (char *, int);
169 static void trace_find_command (char *, int);
170 static void trace_find_pc_command (char *, int);
171 static void trace_find_tracepoint_command (char *, int);
172 static void trace_find_line_command (char *, int);
173 static void trace_find_range_command (char *, int);
174 static void trace_find_outside_command (char *, int);
175 static void trace_dump_command (char *, int);
177 /* support routines */
179 struct collection_list
;
180 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
181 static char *mem2hex (gdb_byte
*, char *, int);
182 static void add_register (struct collection_list
*collection
,
185 extern void send_disconnected_tracing_value (int value
);
187 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
188 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
191 extern void _initialize_tracepoint (void);
193 static struct trace_status trace_status
;
195 char *stop_reason_names
[] = {
205 struct trace_status
*
206 current_trace_status ()
208 return &trace_status
;
211 /* Set traceframe number to NUM. */
213 set_traceframe_num (int num
)
215 traceframe_number
= num
;
216 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
219 /* Set tracepoint number to NUM. */
221 set_tracepoint_num (int num
)
223 tracepoint_number
= num
;
224 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
227 /* Set externally visible debug variables for querying/printing
228 the traceframe context (line, function, file) */
231 set_traceframe_context (struct frame_info
*trace_frame
)
235 if (trace_frame
== NULL
) /* Cease debugging any trace buffers. */
238 traceframe_sal
.pc
= traceframe_sal
.line
= 0;
239 traceframe_sal
.symtab
= NULL
;
240 clear_internalvar (lookup_internalvar ("trace_func"));
241 clear_internalvar (lookup_internalvar ("trace_file"));
242 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
246 /* Save as globals for internal use. */
247 trace_pc
= get_frame_pc (trace_frame
);
248 traceframe_sal
= find_pc_line (trace_pc
, 0);
249 traceframe_fun
= find_pc_function (trace_pc
);
251 /* Save linenumber as "$trace_line", a debugger variable visible to
253 set_internalvar_integer (lookup_internalvar ("trace_line"),
254 traceframe_sal
.line
);
256 /* Save func name as "$trace_func", a debugger variable visible to
258 if (traceframe_fun
== NULL
259 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
260 clear_internalvar (lookup_internalvar ("trace_func"));
262 set_internalvar_string (lookup_internalvar ("trace_func"),
263 SYMBOL_LINKAGE_NAME (traceframe_fun
));
265 /* Save file name as "$trace_file", a debugger variable visible to
267 if (traceframe_sal
.symtab
== NULL
268 || traceframe_sal
.symtab
->filename
== NULL
)
269 clear_internalvar (lookup_internalvar ("trace_file"));
271 set_internalvar_string (lookup_internalvar ("trace_file"),
272 traceframe_sal
.symtab
->filename
);
275 /* Create a new trace state variable with the given name. */
277 struct trace_state_variable
*
278 create_trace_state_variable (const char *name
)
280 struct trace_state_variable tsv
;
282 memset (&tsv
, 0, sizeof (tsv
));
283 tsv
.name
= xstrdup (name
);
284 tsv
.number
= next_tsv_number
++;
285 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
288 /* Look for a trace state variable of the given name. */
290 struct trace_state_variable
*
291 find_trace_state_variable (const char *name
)
293 struct trace_state_variable
*tsv
;
296 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
297 if (strcmp (name
, tsv
->name
) == 0)
304 delete_trace_state_variable (const char *name
)
306 struct trace_state_variable
*tsv
;
309 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
310 if (strcmp (name
, tsv
->name
) == 0)
312 xfree ((void *)tsv
->name
);
313 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
317 warning (_("No trace variable named \"$%s\", not deleting"), name
);
320 /* The 'tvariable' command collects a name and optional expression to
321 evaluate into an initial value. */
324 trace_variable_command (char *args
, int from_tty
)
326 struct expression
*expr
;
327 struct cleanup
*old_chain
;
328 struct internalvar
*intvar
= NULL
;
330 struct trace_state_variable
*tsv
;
333 error_no_arg (_("trace state variable name"));
335 /* All the possible valid arguments are expressions. */
336 expr
= parse_expression (args
);
337 old_chain
= make_cleanup (free_current_contents
, &expr
);
339 if (expr
->nelts
== 0)
340 error (_("No expression?"));
342 /* Only allow two syntaxes; "$name" and "$name=value". */
343 if (expr
->elts
[0].opcode
== OP_INTERNALVAR
)
345 intvar
= expr
->elts
[1].internalvar
;
347 else if (expr
->elts
[0].opcode
== BINOP_ASSIGN
348 && expr
->elts
[1].opcode
== OP_INTERNALVAR
)
350 intvar
= expr
->elts
[2].internalvar
;
351 initval
= value_as_long (evaluate_subexpression_type (expr
, 4));
354 error (_("Syntax must be $NAME [ = EXPR ]"));
357 error (_("No name given"));
359 if (strlen (internalvar_name (intvar
)) <= 0)
360 error (_("Must supply a non-empty variable name"));
362 /* If the variable already exists, just change its initial value. */
363 tsv
= find_trace_state_variable (internalvar_name (intvar
));
366 tsv
->initial_value
= initval
;
367 printf_filtered (_("Trace state variable $%s now has initial value %s.\n"),
368 tsv
->name
, plongest (tsv
->initial_value
));
369 do_cleanups (old_chain
);
373 /* Create a new variable. */
374 tsv
= create_trace_state_variable (internalvar_name (intvar
));
375 tsv
->initial_value
= initval
;
377 printf_filtered (_("Trace state variable $%s created, with initial value %s.\n"),
378 tsv
->name
, plongest (tsv
->initial_value
));
380 do_cleanups (old_chain
);
384 delete_trace_variable_command (char *args
, int from_tty
)
388 struct cleanup
*back_to
;
392 if (query (_("Delete all trace state variables? ")))
393 VEC_free (tsv_s
, tvariables
);
398 argv
= gdb_buildargv (args
);
399 back_to
= make_cleanup_freeargv (argv
);
401 for (ix
= 0; argv
[ix
] != NULL
; ix
++)
403 if (*argv
[ix
] == '$')
404 delete_trace_state_variable (argv
[ix
] + 1);
406 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[ix
]);
409 do_cleanups (back_to
);
415 tvariables_info_1 (void)
417 struct trace_state_variable
*tsv
;
420 struct cleanup
*back_to
;
422 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
424 printf_filtered (_("No trace state variables.\n"));
428 /* Try to acquire values from the target. */
429 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
430 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
433 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
434 count
, "trace-variables");
435 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
436 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
437 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
439 ui_out_table_body (uiout
);
441 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
443 struct cleanup
*back_to2
;
447 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
449 name
= concat ("$", tsv
->name
, (char *) NULL
);
450 make_cleanup (xfree
, name
);
451 ui_out_field_string (uiout
, "name", name
);
452 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
454 if (tsv
->value_known
)
455 c
= plongest (tsv
->value
);
456 else if (ui_out_is_mi_like_p (uiout
))
457 /* For MI, we prefer not to use magic string constants, but rather
458 omit the field completely. The difference between unknown and
459 undefined does not seem important enough to represent. */
461 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
462 /* The value is/was defined, but we don't have it. */
465 /* It is not meaningful to ask about the value. */
468 ui_out_field_string (uiout
, "current", c
);
469 ui_out_text (uiout
, "\n");
471 do_cleanups (back_to2
);
474 do_cleanups (back_to
);
477 /* List all the trace state variables. */
480 tvariables_info (char *args
, int from_tty
)
482 tvariables_info_1 ();
485 /* Stash definitions of tsvs into the given file. */
488 save_trace_state_variables (struct ui_file
*fp
)
490 struct trace_state_variable
*tsv
;
493 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
495 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
496 if (tsv
->initial_value
)
497 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
498 fprintf_unfiltered (fp
, "\n");
502 /* ACTIONS functions: */
504 /* The three functions:
505 collect_pseudocommand,
506 while_stepping_pseudocommand, and
507 end_actions_pseudocommand
508 are placeholders for "commands" that are actually ONLY to be used
509 within a tracepoint action list. If the actual function is ever called,
510 it means that somebody issued the "command" at the top level,
511 which is always an error. */
514 end_actions_pseudocommand (char *args
, int from_tty
)
516 error (_("This command cannot be used at the top level."));
520 while_stepping_pseudocommand (char *args
, int from_tty
)
522 error (_("This command can only be used in a tracepoint actions list."));
526 collect_pseudocommand (char *args
, int from_tty
)
528 error (_("This command can only be used in a tracepoint actions list."));
532 teval_pseudocommand (char *args
, int from_tty
)
534 error (_("This command can only be used in a tracepoint actions list."));
537 /* Enter a list of actions for a tracepoint. */
539 trace_actions_command (char *args
, int from_tty
)
541 struct breakpoint
*t
;
542 struct command_line
*l
;
544 t
= get_tracepoint_by_number (&args
, 0, 1);
548 xstrprintf ("Enter actions for tracepoint %d, one per line.",
550 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
552 l
= read_command_lines (tmpbuf
, from_tty
, 1, check_tracepoint_command
, t
);
553 do_cleanups (cleanups
);
554 breakpoint_set_commands (t
, l
);
556 /* else just return */
559 /* Report the results of checking the agent expression, as errors or
563 report_agent_reqs_errors (struct agent_expr
*aexpr
)
565 /* All of the "flaws" are serious bytecode generation issues that
566 should never occur. */
567 if (aexpr
->flaw
!= agent_flaw_none
)
568 internal_error (__FILE__
, __LINE__
, _("expression is malformed"));
570 /* If analysis shows a stack underflow, GDB must have done something
571 badly wrong in its bytecode generation. */
572 if (aexpr
->min_height
< 0)
573 internal_error (__FILE__
, __LINE__
,
574 _("expression has min height < 0"));
576 /* Issue this error if the stack is predicted to get too deep. The
577 limit is rather arbitrary; a better scheme might be for the
578 target to report how much stack it will have available. The
579 depth roughly corresponds to parenthesization, so a limit of 20
580 amounts to 20 levels of expression nesting, which is actually
581 a pretty big hairy expression. */
582 if (aexpr
->max_height
> 20)
583 error (_("Expression is too complicated."));
586 /* worker function */
588 validate_actionline (char **line
, struct breakpoint
*t
)
590 struct cmd_list_element
*c
;
591 struct expression
*exp
= NULL
;
592 struct cleanup
*old_chain
= NULL
;
594 struct bp_location
*loc
;
595 struct agent_expr
*aexpr
;
597 /* if EOF is typed, *line is NULL */
601 for (p
= *line
; isspace ((int) *p
);)
604 /* Symbol lookup etc. */
605 if (*p
== '\0') /* empty line: just prompt for another line. */
608 if (*p
== '#') /* comment line */
611 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
613 error (_("`%s' is not a tracepoint action, or is ambiguous."), p
);
615 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
618 { /* repeat over a comma-separated list */
619 QUIT
; /* allow user to bail out with ^C */
620 while (isspace ((int) *p
))
623 if (*p
== '$') /* look for special pseudo-symbols */
625 if (0 == strncasecmp ("reg", p
+ 1, 3)
626 || 0 == strncasecmp ("arg", p
+ 1, 3)
627 || 0 == strncasecmp ("loc", p
+ 1, 3)
628 || 0 == strncasecmp ("_sdata", p
+ 1, 6))
633 /* else fall thru, treat p as an expression and parse it! */
636 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
639 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
640 old_chain
= make_cleanup (free_current_contents
, &exp
);
642 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
644 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
646 error (_("constant `%s' (value %ld) will not be collected."),
647 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
648 SYMBOL_VALUE (exp
->elts
[2].symbol
));
650 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
652 error (_("`%s' is optimized away and cannot be collected."),
653 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
657 /* We have something to collect, make sure that the expr to
658 bytecode translator can handle it and that it's not too
660 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
661 make_cleanup_free_agent_expr (aexpr
);
663 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
664 error (_("Expression is too complicated."));
668 report_agent_reqs_errors (aexpr
);
670 do_cleanups (old_chain
);
673 while (p
&& *p
++ == ',');
676 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
679 { /* repeat over a comma-separated list */
680 QUIT
; /* allow user to bail out with ^C */
681 while (isspace ((int) *p
))
685 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
688 /* Only expressions are allowed for this action. */
689 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
690 old_chain
= make_cleanup (free_current_contents
, &exp
);
692 /* We have something to evaluate, make sure that the expr to
693 bytecode translator can handle it and that it's not too
695 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
696 make_cleanup_free_agent_expr (aexpr
);
698 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
699 error (_("Expression is too complicated."));
702 report_agent_reqs_errors (aexpr
);
704 do_cleanups (old_chain
);
707 while (p
&& *p
++ == ',');
710 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
712 char *steparg
; /* in case warning is necessary */
714 while (isspace ((int) *p
))
718 if (*p
== '\0' || (t
->step_count
= strtol (p
, &p
, 0)) == 0)
719 error (_("while-stepping step count `%s' is malformed."), *line
);
722 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
726 error (_("`%s' is not a supported tracepoint action."), *line
);
730 memrange_absolute
= -1
735 int type
; /* memrange_absolute for absolute memory range,
736 else basereg number */
737 bfd_signed_vma start
;
741 struct collection_list
743 unsigned char regs_mask
[32]; /* room for up to 256 regs */
746 struct memrange
*list
;
747 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
749 struct agent_expr
**aexpr_list
;
751 /* True is the user requested a collection of "$_sdata", "static
755 tracepoint_list
, stepping_list
;
757 /* MEMRANGE functions: */
759 static int memrange_cmp (const void *, const void *);
761 /* compare memranges for qsort */
763 memrange_cmp (const void *va
, const void *vb
)
765 const struct memrange
*a
= va
, *b
= vb
;
767 if (a
->type
< b
->type
)
769 if (a
->type
> b
->type
)
771 if (a
->type
== memrange_absolute
)
773 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
775 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
780 if (a
->start
< b
->start
)
782 if (a
->start
> b
->start
)
788 /* Sort the memrange list using qsort, and merge adjacent memranges. */
790 memrange_sortmerge (struct collection_list
*memranges
)
794 qsort (memranges
->list
, memranges
->next_memrange
,
795 sizeof (struct memrange
), memrange_cmp
);
796 if (memranges
->next_memrange
> 0)
798 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
800 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
801 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
804 /* memrange b starts before memrange a ends; merge them. */
805 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
806 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
807 continue; /* next b, same a */
811 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
812 sizeof (struct memrange
));
814 memranges
->next_memrange
= a
+ 1;
818 /* Add a register to a collection list. */
820 add_register (struct collection_list
*collection
, unsigned int regno
)
823 printf_filtered ("collect register %d\n", regno
);
824 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
825 error (_("Internal: register number %d too large for tracepoint"),
827 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
830 /* Add a memrange to a collection list */
832 add_memrange (struct collection_list
*memranges
,
833 int type
, bfd_signed_vma base
,
838 printf_filtered ("(%d,", type
);
840 printf_filtered (",%ld)\n", len
);
843 /* type: memrange_absolute == memory, other n == basereg */
844 memranges
->list
[memranges
->next_memrange
].type
= type
;
845 /* base: addr if memory, offset if reg relative. */
846 memranges
->list
[memranges
->next_memrange
].start
= base
;
847 /* len: we actually save end (base + len) for convenience */
848 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
849 memranges
->next_memrange
++;
850 if (memranges
->next_memrange
>= memranges
->listsize
)
852 memranges
->listsize
*= 2;
853 memranges
->list
= xrealloc (memranges
->list
,
854 memranges
->listsize
);
857 if (type
!= memrange_absolute
) /* Better collect the base register! */
858 add_register (memranges
, type
);
861 /* Add a symbol to a collection list. */
863 collect_symbol (struct collection_list
*collect
,
865 struct gdbarch
*gdbarch
,
866 long frame_regno
, long frame_offset
,
871 bfd_signed_vma offset
;
872 int treat_as_expr
= 0;
874 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
875 switch (SYMBOL_CLASS (sym
))
878 printf_filtered ("%s: don't know symbol class %d\n",
879 SYMBOL_PRINT_NAME (sym
),
883 printf_filtered ("constant %s (value %ld) will not be collected.\n",
884 SYMBOL_PRINT_NAME (sym
), SYMBOL_VALUE (sym
));
887 offset
= SYMBOL_VALUE_ADDRESS (sym
);
892 sprintf_vma (tmp
, offset
);
893 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
894 SYMBOL_PRINT_NAME (sym
), len
,
897 /* A struct may be a C++ class with static fields, go to general
898 expression handling. */
899 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
902 add_memrange (collect
, memrange_absolute
, offset
, len
);
905 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
907 printf_filtered ("LOC_REG[parm] %s: ",
908 SYMBOL_PRINT_NAME (sym
));
909 add_register (collect
, reg
);
910 /* Check for doubles stored in two registers. */
911 /* FIXME: how about larger types stored in 3 or more regs? */
912 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
913 len
> register_size (gdbarch
, reg
))
914 add_register (collect
, reg
+ 1);
917 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
918 printf_filtered (" (will not collect %s)\n",
919 SYMBOL_PRINT_NAME (sym
));
923 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
926 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
927 SYMBOL_PRINT_NAME (sym
), len
);
929 printf_filtered (" from frame ptr reg %d\n", reg
);
931 add_memrange (collect
, reg
, offset
, len
);
933 case LOC_REGPARM_ADDR
:
934 reg
= SYMBOL_VALUE (sym
);
938 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
939 SYMBOL_PRINT_NAME (sym
), len
);
941 printf_filtered (" from reg %d\n", reg
);
943 add_memrange (collect
, reg
, offset
, len
);
947 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
950 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
951 SYMBOL_PRINT_NAME (sym
), len
);
953 printf_filtered (" from frame ptr reg %d\n", reg
);
955 add_memrange (collect
, reg
, offset
, len
);
962 case LOC_OPTIMIZED_OUT
:
963 printf_filtered ("%s has been optimized out of existence.\n",
964 SYMBOL_PRINT_NAME (sym
));
972 /* Expressions are the most general case. */
975 struct agent_expr
*aexpr
;
976 struct cleanup
*old_chain1
= NULL
;
978 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
980 /* It can happen that the symbol is recorded as a computed
981 location, but it's been optimized away and doesn't actually
982 have a location expression. */
985 printf_filtered ("%s has been optimized out of existence.\n",
986 SYMBOL_PRINT_NAME (sym
));
990 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
994 report_agent_reqs_errors (aexpr
);
996 discard_cleanups (old_chain1
);
997 add_aexpr (collect
, aexpr
);
999 /* take care of the registers */
1000 if (aexpr
->reg_mask_len
> 0)
1004 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1006 QUIT
; /* allow user to bail out with ^C */
1007 if (aexpr
->reg_mask
[ndx1
] != 0)
1009 /* assume chars have 8 bits */
1010 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1011 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1012 /* it's used -- record it */
1013 add_register (collect
, ndx1
* 8 + ndx2
);
1020 /* Data to be passed around in the calls to the locals and args
1023 struct add_local_symbols_data
1025 struct collection_list
*collect
;
1026 struct gdbarch
*gdbarch
;
1033 /* The callback for the locals and args iterators */
1036 do_collect_symbol (const char *print_name
,
1040 struct add_local_symbols_data
*p
= cb_data
;
1042 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1043 p
->frame_offset
, p
->pc
);
1047 /* Add all locals (or args) symbols to collection list */
1049 add_local_symbols (struct collection_list
*collect
,
1050 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1051 long frame_regno
, long frame_offset
, int type
)
1053 struct block
*block
;
1054 struct add_local_symbols_data cb_data
;
1056 cb_data
.collect
= collect
;
1057 cb_data
.gdbarch
= gdbarch
;
1059 cb_data
.frame_regno
= frame_regno
;
1060 cb_data
.frame_offset
= frame_offset
;
1065 block
= block_for_pc (pc
);
1068 warning (_("Can't collect locals; "
1069 "no symbol table info available.\n"));
1073 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1074 if (cb_data
.count
== 0)
1075 warning (_("No locals found in scope."));
1079 pc
= get_pc_function_start (pc
);
1080 block
= block_for_pc (pc
);
1083 warning (_("Can't collect args; no symbol table info available.\n"));
1087 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1088 if (cb_data
.count
== 0)
1089 warning (_("No args found in scope."));
1094 add_static_trace_data (struct collection_list
*collection
)
1097 printf_filtered ("collect static trace data\n");
1098 collection
->strace_data
= 1;
1101 /* worker function */
1103 clear_collection_list (struct collection_list
*list
)
1107 list
->next_memrange
= 0;
1108 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1110 free_agent_expr (list
->aexpr_list
[ndx
]);
1111 list
->aexpr_list
[ndx
] = NULL
;
1113 list
->next_aexpr_elt
= 0;
1114 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1115 list
->strace_data
= 0;
1118 /* reduce a collection list to string form (for gdb protocol) */
1120 stringify_collection_list (struct collection_list
*list
, char *string
)
1122 char temp_buf
[2048];
1126 char *(*str_list
)[];
1130 count
= 1 + 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1131 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1133 if (list
->strace_data
)
1136 printf_filtered ("\nCollecting static trace data\n");
1139 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1143 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1144 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1146 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1149 printf_filtered ("\nCollecting registers (mask): 0x");
1154 QUIT
; /* allow user to bail out with ^C */
1156 printf_filtered ("%02X", list
->regs_mask
[i
]);
1157 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1160 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1164 printf_filtered ("\n");
1165 if (list
->next_memrange
> 0 && info_verbose
)
1166 printf_filtered ("Collecting memranges: \n");
1167 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1169 QUIT
; /* allow user to bail out with ^C */
1170 sprintf_vma (tmp2
, list
->list
[i
].start
);
1173 printf_filtered ("(%d, %s, %ld)\n",
1176 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1178 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1180 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1187 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1189 /* The "%X" conversion specifier expects an unsigned argument,
1190 so passing -1 (memrange_absolute) to it directly gives you
1191 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1193 if (list
->list
[i
].type
== memrange_absolute
)
1194 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1196 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1199 count
+= strlen (end
);
1200 end
= temp_buf
+ count
;
1203 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1205 QUIT
; /* allow user to bail out with ^C */
1206 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1208 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1213 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1214 end
+= 10; /* 'X' + 8 hex digits + ',' */
1217 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1218 end
, list
->aexpr_list
[i
]->len
);
1219 count
+= 2 * list
->aexpr_list
[i
]->len
;
1224 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1229 (*str_list
)[ndx
] = NULL
;
1242 encode_actions_1 (struct command_line
*action
,
1243 struct breakpoint
*t
,
1244 struct bp_location
*tloc
,
1246 LONGEST frame_offset
,
1247 struct collection_list
*collect
,
1248 struct collection_list
*stepping_list
)
1251 struct expression
*exp
= NULL
;
1253 struct value
*tempval
;
1254 struct cmd_list_element
*cmd
;
1255 struct agent_expr
*aexpr
;
1257 for (; action
; action
= action
->next
)
1259 QUIT
; /* allow user to bail out with ^C */
1260 action_exp
= action
->line
;
1261 while (isspace ((int) *action_exp
))
1264 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1266 error (_("Bad action list item: %s"), action_exp
);
1268 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1271 { /* repeat over a comma-separated list */
1272 QUIT
; /* allow user to bail out with ^C */
1273 while (isspace ((int) *action_exp
))
1276 if (0 == strncasecmp ("$reg", action_exp
, 4))
1278 for (i
= 0; i
< gdbarch_num_regs (t
->gdbarch
); i
++)
1279 add_register (collect
, i
);
1280 action_exp
= strchr (action_exp
, ','); /* more? */
1282 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1284 add_local_symbols (collect
,
1290 action_exp
= strchr (action_exp
, ','); /* more? */
1292 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1294 add_local_symbols (collect
,
1300 action_exp
= strchr (action_exp
, ','); /* more? */
1302 else if (0 == strncasecmp ("$_sdata", action_exp
, 7))
1304 add_static_trace_data (collect
);
1305 action_exp
= strchr (action_exp
, ','); /* more? */
1309 unsigned long addr
, len
;
1310 struct cleanup
*old_chain
= NULL
;
1311 struct cleanup
*old_chain1
= NULL
;
1313 exp
= parse_exp_1 (&action_exp
,
1314 block_for_pc (tloc
->address
), 1);
1315 old_chain
= make_cleanup (free_current_contents
, &exp
);
1317 switch (exp
->elts
[0].opcode
)
1321 const char *name
= &exp
->elts
[2].string
;
1323 i
= user_reg_map_name_to_regnum (t
->gdbarch
,
1324 name
, strlen (name
));
1326 internal_error (__FILE__
, __LINE__
,
1327 _("Register $%s not available"),
1330 printf_filtered ("OP_REGISTER: ");
1331 add_register (collect
, i
);
1336 /* safe because we know it's a simple expression */
1337 tempval
= evaluate_expression (exp
);
1338 addr
= value_address (tempval
);
1339 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1340 add_memrange (collect
, memrange_absolute
, addr
, len
);
1344 collect_symbol (collect
,
1345 exp
->elts
[2].symbol
,
1352 default: /* full-fledged expression */
1353 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1355 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1359 report_agent_reqs_errors (aexpr
);
1361 discard_cleanups (old_chain1
);
1362 add_aexpr (collect
, aexpr
);
1364 /* take care of the registers */
1365 if (aexpr
->reg_mask_len
> 0)
1370 for (ndx1
= 0; ndx1
< aexpr
->reg_mask_len
; ndx1
++)
1372 QUIT
; /* allow user to bail out with ^C */
1373 if (aexpr
->reg_mask
[ndx1
] != 0)
1375 /* assume chars have 8 bits */
1376 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1377 if (aexpr
->reg_mask
[ndx1
] & (1 << ndx2
))
1378 /* it's used -- record it */
1379 add_register (collect
,
1386 do_cleanups (old_chain
);
1389 while (action_exp
&& *action_exp
++ == ',');
1391 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1394 { /* repeat over a comma-separated list */
1395 QUIT
; /* allow user to bail out with ^C */
1396 while (isspace ((int) *action_exp
))
1400 struct cleanup
*old_chain
= NULL
;
1401 struct cleanup
*old_chain1
= NULL
;
1403 exp
= parse_exp_1 (&action_exp
,
1404 block_for_pc (tloc
->address
), 1);
1405 old_chain
= make_cleanup (free_current_contents
, &exp
);
1407 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1408 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1411 report_agent_reqs_errors (aexpr
);
1413 discard_cleanups (old_chain1
);
1414 /* Even though we're not officially collecting, add
1415 to the collect list anyway. */
1416 add_aexpr (collect
, aexpr
);
1418 do_cleanups (old_chain
);
1421 while (action_exp
&& *action_exp
++ == ',');
1423 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1425 /* We check against nested while-stepping when setting
1426 breakpoint action, so no way to run into nested
1428 gdb_assert (stepping_list
);
1430 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
,
1431 frame_offset
, stepping_list
, NULL
);
1434 error (_("Invalid tracepoint command '%s'"), action
->line
);
1438 /* Render all actions into gdb protocol. */
1440 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1441 char ***tdp_actions
, char ***stepping_actions
)
1443 static char tdp_buff
[2048], step_buff
[2048];
1444 char *default_collect_line
= NULL
;
1445 struct command_line
*actions
;
1446 struct command_line
*default_collect_action
= NULL
;
1448 LONGEST frame_offset
;
1449 struct cleanup
*back_to
;
1451 back_to
= make_cleanup (null_cleanup
, NULL
);
1453 clear_collection_list (&tracepoint_list
);
1454 clear_collection_list (&stepping_list
);
1456 *tdp_actions
= NULL
;
1457 *stepping_actions
= NULL
;
1459 gdbarch_virtual_frame_pointer (t
->gdbarch
,
1460 t
->loc
->address
, &frame_reg
, &frame_offset
);
1462 actions
= breakpoint_commands (t
);
1464 /* If there are default expressions to collect, make up a collect
1465 action and prepend to the action list to encode. Note that since
1466 validation is per-tracepoint (local var "xyz" might be valid for
1467 one tracepoint and not another, etc), we make up the action on
1468 the fly, and don't cache it. */
1469 if (*default_collect
)
1473 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1474 make_cleanup (xfree
, default_collect_line
);
1476 line
= default_collect_line
;
1477 validate_actionline (&line
, t
);
1479 default_collect_action
= xmalloc (sizeof (struct command_line
));
1480 make_cleanup (xfree
, default_collect_action
);
1481 default_collect_action
->next
= actions
;
1482 default_collect_action
->line
= line
;
1483 actions
= default_collect_action
;
1485 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1486 &tracepoint_list
, &stepping_list
);
1488 memrange_sortmerge (&tracepoint_list
);
1489 memrange_sortmerge (&stepping_list
);
1491 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1493 *stepping_actions
= stringify_collection_list (&stepping_list
,
1496 do_cleanups (back_to
);
1500 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1502 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1504 collect
->aexpr_list
=
1505 xrealloc (collect
->aexpr_list
,
1506 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1507 collect
->aexpr_listsize
*= 2;
1509 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1510 collect
->next_aexpr_elt
++;
1515 start_tracing (void)
1517 VEC(breakpoint_p
) *tp_vec
= NULL
;
1519 struct breakpoint
*t
;
1520 struct trace_state_variable
*tsv
;
1521 int any_enabled
= 0, num_to_download
= 0;
1523 tp_vec
= all_tracepoints ();
1525 /* No point in tracing without any tracepoints... */
1526 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1528 VEC_free (breakpoint_p
, tp_vec
);
1529 error (_("No tracepoints defined, not starting trace"));
1532 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1534 if (t
->enable_state
== bp_enabled
)
1537 if ((t
->type
== bp_fast_tracepoint
1538 ? may_insert_fast_tracepoints
1539 : may_insert_tracepoints
))
1542 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1543 (t
->type
== bp_fast_tracepoint
? "fast " : ""), t
->number
);
1546 /* No point in tracing with only disabled tracepoints. */
1549 VEC_free (breakpoint_p
, tp_vec
);
1550 error (_("No tracepoints enabled, not starting trace"));
1553 if (num_to_download
<= 0)
1555 VEC_free (breakpoint_p
, tp_vec
);
1556 error (_("No tracepoints that may be downloaded, not starting trace"));
1559 target_trace_init ();
1561 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1563 if ((t
->type
== bp_fast_tracepoint
1564 ? !may_insert_fast_tracepoints
1565 : !may_insert_tracepoints
))
1568 t
->number_on_target
= 0;
1569 target_download_tracepoint (t
);
1570 t
->number_on_target
= t
->number
;
1572 VEC_free (breakpoint_p
, tp_vec
);
1574 /* Send down all the trace state variables too. */
1575 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1577 target_download_trace_state_variable (tsv
);
1580 /* Tell target to treat text-like sections as transparent. */
1581 target_trace_set_readonly_regions ();
1582 /* Set some mode flags. */
1583 target_set_disconnected_tracing (disconnected_tracing
);
1584 target_set_circular_trace_buffer (circular_trace_buffer
);
1586 /* Now insert traps and begin collecting data. */
1587 target_trace_start ();
1589 /* Reset our local state. */
1590 set_traceframe_num (-1);
1591 set_tracepoint_num (-1);
1592 set_traceframe_context (NULL
);
1593 current_trace_status()->running
= 1;
1598 Tell target to clear any previous trace experiment.
1599 Walk the list of tracepoints, and send them (and their actions)
1600 to the target. If no errors,
1601 Tell target to start a new trace experiment. */
1604 trace_start_command (char *args
, int from_tty
)
1606 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1608 if (current_trace_status ()->running
)
1611 && !query (_("A trace is running already. Start a new run? ")))
1612 error (_("New trace run not started."));
1620 trace_stop_command (char *args
, int from_tty
)
1622 if (!current_trace_status ()->running
)
1623 error (_("Trace is not running."));
1631 target_trace_stop ();
1632 /* should change in response to reply? */
1633 current_trace_status ()->running
= 0;
1636 /* tstatus command */
1638 trace_status_command (char *args
, int from_tty
)
1640 struct trace_status
*ts
= current_trace_status ();
1643 status
= target_get_trace_status (ts
);
1648 printf_filtered (_("Using a trace file.\n"));
1651 printf_filtered (_("Trace can not be run on this target.\n"));
1656 if (!ts
->running_known
)
1658 printf_filtered (_("Run/stop status is unknown.\n"));
1660 else if (ts
->running
)
1662 printf_filtered (_("Trace is running on the target.\n"));
1666 switch (ts
->stop_reason
)
1668 case trace_never_run
:
1669 printf_filtered (_("No trace has been run on the target.\n"));
1672 printf_filtered (_("Trace stopped by a tstop command.\n"));
1674 case trace_buffer_full
:
1675 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1677 case trace_disconnected
:
1678 printf_filtered (_("Trace stopped because of disconnection.\n"));
1680 case tracepoint_passcount
:
1681 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1682 ts
->stopping_tracepoint
);
1684 case tracepoint_error
:
1685 if (ts
->stopping_tracepoint
)
1686 printf_filtered (_("Trace stopped by an error (%s, tracepoint %d).\n"),
1687 ts
->error_desc
, ts
->stopping_tracepoint
);
1689 printf_filtered (_("Trace stopped by an error (%s).\n"),
1692 case trace_stop_reason_unknown
:
1693 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1696 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1702 if (ts
->traceframes_created
>= 0
1703 && ts
->traceframe_count
!= ts
->traceframes_created
)
1705 printf_filtered (_("Buffer contains %d trace frames (of %d created total).\n"),
1706 ts
->traceframe_count
, ts
->traceframes_created
);
1708 else if (ts
->traceframe_count
>= 0)
1710 printf_filtered (_("Collected %d trace frames.\n"),
1711 ts
->traceframe_count
);
1714 if (ts
->buffer_free
>= 0)
1716 if (ts
->buffer_size
>= 0)
1718 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1719 ts
->buffer_free
, ts
->buffer_size
);
1720 if (ts
->buffer_size
> 0)
1721 printf_filtered (_(" (%d%% full)"),
1722 ((int) ((((long long) (ts
->buffer_size
1723 - ts
->buffer_free
)) * 100)
1724 / ts
->buffer_size
)));
1725 printf_filtered (_(".\n"));
1728 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1732 if (ts
->disconnected_tracing
)
1733 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1735 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1737 if (ts
->circular_buffer
)
1738 printf_filtered (_("Trace buffer is circular.\n"));
1740 /* Now report on what we're doing with tfind. */
1741 if (traceframe_number
>= 0)
1742 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1743 traceframe_number
, tracepoint_number
);
1745 printf_filtered (_("Not looking at any trace frame.\n"));
1748 /* Report the trace status to uiout, in a way suitable for MI, and not
1749 suitable for CLI. If ON_STOP is true, suppress a few fields that
1750 are not meaningful in the -trace-stop response.
1752 The implementation is essentially parallel to trace_status_command, but
1753 merging them will result in unreadable code. */
1755 trace_status_mi (int on_stop
)
1757 struct trace_status
*ts
= current_trace_status ();
1760 status
= target_get_trace_status (ts
);
1762 if (status
== -1 && !ts
->from_file
)
1764 ui_out_field_string (uiout
, "supported", "0");
1769 ui_out_field_string (uiout
, "supported", "file");
1771 ui_out_field_string (uiout
, "supported", "1");
1773 gdb_assert (ts
->running_known
);
1777 ui_out_field_string (uiout
, "running", "1");
1779 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1780 Given that the frontend gets the status either on -trace-stop, or from
1781 -trace-status after re-connection, it does not seem like this
1782 information is necessary for anything. It is not necessary for either
1783 figuring the vital state of the target nor for navigation of trace
1784 frames. If the frontend wants to show the current state is some
1785 configure dialog, it can request the value when such dialog is
1786 invoked by the user. */
1790 char *stop_reason
= NULL
;
1791 int stopping_tracepoint
= -1;
1794 ui_out_field_string (uiout
, "running", "0");
1796 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
1798 switch (ts
->stop_reason
)
1801 stop_reason
= "request";
1803 case trace_buffer_full
:
1804 stop_reason
= "overflow";
1806 case trace_disconnected
:
1807 stop_reason
= "disconnection";
1809 case tracepoint_passcount
:
1810 stop_reason
= "passcount";
1811 stopping_tracepoint
= ts
->stopping_tracepoint
;
1813 case tracepoint_error
:
1814 stop_reason
= "error";
1815 stopping_tracepoint
= ts
->stopping_tracepoint
;
1821 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
1822 if (stopping_tracepoint
!= -1)
1823 ui_out_field_int (uiout
, "stopping-tracepoint",
1824 stopping_tracepoint
);
1825 if (ts
->stop_reason
== tracepoint_error
)
1826 ui_out_field_string (uiout
, "error-description",
1832 if (ts
->traceframe_count
!= -1)
1833 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
1834 if (ts
->traceframes_created
!= -1)
1835 ui_out_field_int (uiout
, "frames-created", ts
->traceframes_created
);
1836 if (ts
->buffer_size
!= -1)
1837 ui_out_field_int (uiout
, "buffer-size", ts
->buffer_size
);
1838 if (ts
->buffer_free
!= -1)
1839 ui_out_field_int (uiout
, "buffer-free", ts
->buffer_free
);
1841 ui_out_field_int (uiout
, "disconnected", ts
->disconnected_tracing
);
1842 ui_out_field_int (uiout
, "circular", ts
->circular_buffer
);
1845 /* This function handles the details of what to do about an ongoing
1846 tracing run if the user has asked to detach or otherwise disconnect
1849 disconnect_tracing (int from_tty
)
1851 /* It can happen that the target that was tracing went away on its
1852 own, and we didn't notice. Get a status update, and if the
1853 current target doesn't even do tracing, then assume it's not
1855 if (target_get_trace_status (current_trace_status ()) < 0)
1856 current_trace_status ()->running
= 0;
1858 /* If running interactively, give the user the option to cancel and
1859 then decide what to do differently with the run. Scripts are
1860 just going to disconnect and let the target deal with it,
1861 according to how it's been instructed previously via
1862 disconnected-tracing. */
1863 if (current_trace_status ()->running
&& from_tty
)
1865 if (current_trace_status ()->disconnected_tracing
)
1867 if (!query (_("Trace is running and will continue after detach; detach anyway? ")))
1868 error (_("Not confirmed."));
1872 if (!query (_("Trace is running but will stop on detach; detach anyway? ")))
1873 error (_("Not confirmed."));
1877 /* Also we want to be out of tfind mode, otherwise things can get
1878 confusing upon reconnection. Just use these calls instead of
1879 full tfind_1 behavior because we're in the middle of detaching,
1880 and there's no point to updating current stack frame etc. */
1881 set_traceframe_number (-1);
1882 set_traceframe_context (NULL
);
1885 /* Worker function for the various flavors of the tfind command. */
1887 tfind_1 (enum trace_find_type type
, int num
,
1888 ULONGEST addr1
, ULONGEST addr2
,
1891 int target_frameno
= -1, target_tracept
= -1;
1892 struct frame_id old_frame_id
= null_frame_id
;
1893 struct breakpoint
*tp
;
1895 /* Only try to get the current stack frame if we have a chance of
1896 succeeding. In particular, if we're trying to get a first trace
1897 frame while all threads are running, it's not going to succeed,
1898 so leave it with a default value and let the frame comparison
1899 below (correctly) decide to print out the source location of the
1901 if (!(type
== tfind_number
&& num
== -1)
1902 && (has_stack_frames () || traceframe_number
>= 0))
1903 old_frame_id
= get_frame_id (get_current_frame ());
1905 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
1908 if (type
== tfind_number
1910 && target_frameno
== -1)
1912 /* We told the target to get out of tfind mode, and it did. */
1914 else if (target_frameno
== -1)
1916 /* A request for a non-existent trace frame has failed.
1917 Our response will be different, depending on FROM_TTY:
1919 If FROM_TTY is true, meaning that this command was
1920 typed interactively by the user, then give an error
1921 and DO NOT change the state of traceframe_number etc.
1923 However if FROM_TTY is false, meaning that we're either
1924 in a script, a loop, or a user-defined command, then
1925 DON'T give an error, but DO change the state of
1926 traceframe_number etc. to invalid.
1928 The rationalle is that if you typed the command, you
1929 might just have committed a typo or something, and you'd
1930 like to NOT lose your current debugging state. However
1931 if you're in a user-defined command or especially in a
1932 loop, then you need a way to detect that the command
1933 failed WITHOUT aborting. This allows you to write
1934 scripts that search thru the trace buffer until the end,
1935 and then continue on to do something else. */
1938 error (_("Target failed to find requested trace frame."));
1942 printf_filtered ("End of trace buffer.\n");
1943 #if 0 /* dubious now? */
1944 /* The following will not recurse, since it's
1946 trace_find_command ("-1", from_tty
);
1951 tp
= get_tracepoint_by_number_on_target (target_tracept
);
1953 reinit_frame_cache ();
1954 registers_changed ();
1955 target_dcache_invalidate ();
1956 set_traceframe_num (target_frameno
);
1957 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
1958 if (target_frameno
== -1)
1959 set_traceframe_context (NULL
);
1961 set_traceframe_context (get_current_frame ());
1963 if (traceframe_number
>= 0)
1965 /* Use different branches for MI and CLI to make CLI messages
1967 if (ui_out_is_mi_like_p (uiout
))
1969 ui_out_field_string (uiout
, "found", "1");
1970 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
1971 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
1975 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
1976 traceframe_number
, tracepoint_number
);
1981 if (ui_out_is_mi_like_p (uiout
))
1982 ui_out_field_string (uiout
, "found", "0");
1983 else if (type
== tfind_number
&& num
== -1)
1984 printf_unfiltered (_("No longer looking at any trace frame\n"));
1985 else /* this case may never occur, check */
1986 printf_unfiltered (_("No trace frame found\n"));
1989 /* If we're in nonstop mode and getting out of looking at trace
1990 frames, there won't be any current frame to go back to and
1993 && (has_stack_frames () || traceframe_number
>= 0))
1995 enum print_what print_what
;
1997 /* NOTE: in imitation of the step command, try to determine
1998 whether we have made a transition from one function to
1999 another. If so, we'll print the "stack frame" (ie. the new
2000 function and it's arguments) -- otherwise we'll just show the
2003 if (frame_id_eq (old_frame_id
,
2004 get_frame_id (get_current_frame ())))
2005 print_what
= SRC_LINE
;
2007 print_what
= SRC_AND_LOC
;
2009 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2014 /* trace_find_command takes a trace frame number n,
2015 sends "QTFrame:<n>" to the target,
2016 and accepts a reply that may contain several optional pieces
2017 of information: a frame number, a tracepoint number, and an
2018 indication of whether this is a trap frame or a stepping frame.
2020 The minimal response is just "OK" (which indicates that the
2021 target does not give us a frame number or a tracepoint number).
2022 Instead of that, the target may send us a string containing
2024 F<hexnum> (gives the selected frame number)
2025 T<hexnum> (gives the selected tracepoint number)
2030 trace_find_command (char *args
, int from_tty
)
2031 { /* this should only be called with a numeric argument */
2034 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2035 error ("May not look at trace frames while trace is running.");
2037 if (args
== 0 || *args
== 0)
2038 { /* TFIND with no args means find NEXT trace frame. */
2039 if (traceframe_number
== -1)
2040 frameno
= 0; /* "next" is first one */
2042 frameno
= traceframe_number
+ 1;
2044 else if (0 == strcmp (args
, "-"))
2046 if (traceframe_number
== -1)
2047 error (_("not debugging trace buffer"));
2048 else if (from_tty
&& traceframe_number
== 0)
2049 error (_("already at start of trace buffer"));
2051 frameno
= traceframe_number
- 1;
2053 /* A hack to work around eval's need for fp to have been collected. */
2054 else if (0 == strcmp (args
, "-1"))
2057 frameno
= parse_and_eval_long (args
);
2060 error (_("invalid input (%d is less than zero)"), frameno
);
2062 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2067 trace_find_end_command (char *args
, int from_tty
)
2069 trace_find_command ("-1", from_tty
);
2074 trace_find_none_command (char *args
, int from_tty
)
2076 trace_find_command ("-1", from_tty
);
2081 trace_find_start_command (char *args
, int from_tty
)
2083 trace_find_command ("0", from_tty
);
2086 /* tfind pc command */
2088 trace_find_pc_command (char *args
, int from_tty
)
2092 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2093 error ("May not look at trace frames while trace is running.");
2095 if (args
== 0 || *args
== 0)
2096 pc
= regcache_read_pc (get_current_regcache ());
2098 pc
= parse_and_eval_address (args
);
2100 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2103 /* tfind tracepoint command */
2105 trace_find_tracepoint_command (char *args
, int from_tty
)
2108 struct breakpoint
*tp
;
2110 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2111 error ("May not look at trace frames while trace is running.");
2113 if (args
== 0 || *args
== 0)
2115 if (tracepoint_number
== -1)
2116 error (_("No current tracepoint -- please supply an argument."));
2118 tdp
= tracepoint_number
; /* default is current TDP */
2121 tdp
= parse_and_eval_long (args
);
2123 /* If we have the tracepoint on hand, use the number that the
2124 target knows about (which may be different if we disconnected
2125 and reconnected). */
2126 tp
= get_tracepoint (tdp
);
2128 tdp
= tp
->number_on_target
;
2130 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2133 /* TFIND LINE command:
2135 This command will take a sourceline for argument, just like BREAK
2136 or TRACE (ie. anything that "decode_line_1" can handle).
2138 With no argument, this command will find the next trace frame
2139 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2142 trace_find_line_command (char *args
, int from_tty
)
2144 static CORE_ADDR start_pc
, end_pc
;
2145 struct symtabs_and_lines sals
;
2146 struct symtab_and_line sal
;
2147 struct cleanup
*old_chain
;
2149 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2150 error ("May not look at trace frames while trace is running.");
2152 if (args
== 0 || *args
== 0)
2154 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2156 sals
.sals
= (struct symtab_and_line
*)
2157 xmalloc (sizeof (struct symtab_and_line
));
2162 sals
= decode_line_spec (args
, 1);
2166 old_chain
= make_cleanup (xfree
, sals
.sals
);
2167 if (sal
.symtab
== 0)
2168 error (_("No line number information available."));
2170 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2172 if (start_pc
== end_pc
)
2174 printf_filtered ("Line %d of \"%s\"",
2175 sal
.line
, sal
.symtab
->filename
);
2177 printf_filtered (" is at address ");
2178 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2180 printf_filtered (" but contains no code.\n");
2181 sal
= find_pc_line (start_pc
, 0);
2183 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2184 && start_pc
!= end_pc
)
2185 printf_filtered ("Attempting to find line %d instead.\n",
2188 error (_("Cannot find a good line."));
2192 /* Is there any case in which we get here, and have an address
2193 which the user would want to see? If we have debugging
2194 symbols and no line numbers? */
2195 error (_("Line number %d is out of range for \"%s\"."),
2196 sal
.line
, sal
.symtab
->filename
);
2198 /* Find within range of stated line. */
2200 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2202 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2203 do_cleanups (old_chain
);
2206 /* tfind range command */
2208 trace_find_range_command (char *args
, int from_tty
)
2210 static CORE_ADDR start
, stop
;
2213 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2214 error ("May not look at trace frames while trace is running.");
2216 if (args
== 0 || *args
== 0)
2217 { /* XXX FIXME: what should default behavior be? */
2218 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2222 if (0 != (tmp
= strchr (args
, ',')))
2224 *tmp
++ = '\0'; /* terminate start address */
2225 while (isspace ((int) *tmp
))
2227 start
= parse_and_eval_address (args
);
2228 stop
= parse_and_eval_address (tmp
);
2231 { /* no explicit end address? */
2232 start
= parse_and_eval_address (args
);
2233 stop
= start
+ 1; /* ??? */
2236 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2239 /* tfind outside command */
2241 trace_find_outside_command (char *args
, int from_tty
)
2243 CORE_ADDR start
, stop
;
2246 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2247 error ("May not look at trace frames while trace is running.");
2249 if (args
== 0 || *args
== 0)
2250 { /* XXX FIXME: what should default behavior be? */
2251 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2255 if (0 != (tmp
= strchr (args
, ',')))
2257 *tmp
++ = '\0'; /* terminate start address */
2258 while (isspace ((int) *tmp
))
2260 start
= parse_and_eval_address (args
);
2261 stop
= parse_and_eval_address (tmp
);
2264 { /* no explicit end address? */
2265 start
= parse_and_eval_address (args
);
2266 stop
= start
+ 1; /* ??? */
2269 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2272 /* info scope command: list the locals for a scope. */
2274 scope_info (char *args
, int from_tty
)
2276 struct symtabs_and_lines sals
;
2278 struct minimal_symbol
*msym
;
2279 struct block
*block
;
2280 char **canonical
, *symname
, *save_args
= args
;
2281 struct dict_iterator iter
;
2283 struct gdbarch
*gdbarch
;
2286 if (args
== 0 || *args
== 0)
2287 error (_("requires an argument (function, line or *addr) to define a scope"));
2289 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2290 if (sals
.nelts
== 0)
2291 return; /* presumably decode_line_1 has already warned */
2293 /* Resolve line numbers to PC */
2294 resolve_sal_pc (&sals
.sals
[0]);
2295 block
= block_for_pc (sals
.sals
[0].pc
);
2299 QUIT
; /* allow user to bail out with ^C */
2300 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2302 QUIT
; /* allow user to bail out with ^C */
2304 printf_filtered ("Scope for %s:\n", save_args
);
2307 symname
= SYMBOL_PRINT_NAME (sym
);
2308 if (symname
== NULL
|| *symname
== '\0')
2309 continue; /* probably botched, certainly useless */
2311 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2313 printf_filtered ("Symbol %s is ", symname
);
2314 switch (SYMBOL_CLASS (sym
))
2317 case LOC_UNDEF
: /* messed up symbol? */
2318 printf_filtered ("a bogus symbol, class %d.\n",
2319 SYMBOL_CLASS (sym
));
2320 count
--; /* don't count this one */
2323 printf_filtered ("a constant with value %ld (0x%lx)",
2324 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2326 case LOC_CONST_BYTES
:
2327 printf_filtered ("constant bytes: ");
2328 if (SYMBOL_TYPE (sym
))
2329 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2330 fprintf_filtered (gdb_stdout
, " %02x",
2331 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2334 printf_filtered ("in static storage at address ");
2335 printf_filtered ("%s", paddress (gdbarch
,
2336 SYMBOL_VALUE_ADDRESS (sym
)));
2339 /* GDBARCH is the architecture associated with the objfile
2340 the symbol is defined in; the target architecture may be
2341 different, and may provide additional registers. However,
2342 we do not know the target architecture at this point.
2343 We assume the objfile architecture will contain all the
2344 standard registers that occur in debug info in that
2346 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2348 if (SYMBOL_IS_ARGUMENT (sym
))
2349 printf_filtered ("an argument in register $%s",
2350 gdbarch_register_name (gdbarch
, regno
));
2352 printf_filtered ("a local variable in register $%s",
2353 gdbarch_register_name (gdbarch
, regno
));
2356 printf_filtered ("an argument at stack/frame offset %ld",
2357 SYMBOL_VALUE (sym
));
2360 printf_filtered ("a local variable at frame offset %ld",
2361 SYMBOL_VALUE (sym
));
2364 printf_filtered ("a reference argument at offset %ld",
2365 SYMBOL_VALUE (sym
));
2367 case LOC_REGPARM_ADDR
:
2368 /* Note comment at LOC_REGISTER. */
2369 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2370 printf_filtered ("the address of an argument, in register $%s",
2371 gdbarch_register_name (gdbarch
, regno
));
2374 printf_filtered ("a typedef.\n");
2377 printf_filtered ("a label at address ");
2378 printf_filtered ("%s", paddress (gdbarch
,
2379 SYMBOL_VALUE_ADDRESS (sym
)));
2382 printf_filtered ("a function at address ");
2383 printf_filtered ("%s",
2384 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2386 case LOC_UNRESOLVED
:
2387 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2390 printf_filtered ("Unresolved Static");
2393 printf_filtered ("static storage at address ");
2394 printf_filtered ("%s",
2395 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2398 case LOC_OPTIMIZED_OUT
:
2399 printf_filtered ("optimized out.\n");
2402 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
,
2403 BLOCK_START (block
),
2407 if (SYMBOL_TYPE (sym
))
2408 printf_filtered (", length %d.\n",
2409 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2411 if (BLOCK_FUNCTION (block
))
2414 block
= BLOCK_SUPERBLOCK (block
);
2417 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2421 /* worker function (cleanup) */
2423 replace_comma (void *data
)
2430 /* Helper for trace_dump_command. Dump the action list starting at
2431 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2432 actions of the body of a while-stepping action. STEPPING_FRAME is
2433 set if the current traceframe was determined to be a while-stepping
2437 trace_dump_actions (struct command_line
*action
,
2438 int stepping_actions
, int stepping_frame
,
2441 char *action_exp
, *next_comma
;
2443 for (; action
!= NULL
; action
= action
->next
)
2445 struct cmd_list_element
*cmd
;
2447 QUIT
; /* allow user to bail out with ^C */
2448 action_exp
= action
->line
;
2449 while (isspace ((int) *action_exp
))
2452 /* The collection actions to be done while stepping are
2453 bracketed by the commands "while-stepping" and "end". */
2455 if (*action_exp
== '#') /* comment line */
2458 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2460 error (_("Bad action list item: %s"), action_exp
);
2462 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2466 for (i
= 0; i
< action
->body_count
; ++i
)
2467 trace_dump_actions (action
->body_list
[i
],
2468 1, stepping_frame
, from_tty
);
2470 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2472 /* Display the collected data.
2473 For the trap frame, display only what was collected at
2474 the trap. Likewise for stepping frames, display only
2475 what was collected while stepping. This means that the
2476 two boolean variables, STEPPING_FRAME and
2477 STEPPING_ACTIONS should be equal. */
2478 if (stepping_frame
== stepping_actions
)
2481 { /* repeat over a comma-separated list */
2482 QUIT
; /* allow user to bail out with ^C */
2483 if (*action_exp
== ',')
2485 while (isspace ((int) *action_exp
))
2488 next_comma
= strchr (action_exp
, ',');
2490 if (0 == strncasecmp (action_exp
, "$reg", 4))
2491 registers_info (NULL
, from_tty
);
2492 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2493 locals_info (NULL
, from_tty
);
2494 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2495 args_info (NULL
, from_tty
);
2500 make_cleanup (replace_comma
, next_comma
);
2503 printf_filtered ("%s = ", action_exp
);
2504 output_command (action_exp
, from_tty
);
2505 printf_filtered ("\n");
2509 action_exp
= next_comma
;
2511 while (action_exp
&& *action_exp
== ',');
2517 /* The tdump command. */
2520 trace_dump_command (char *args
, int from_tty
)
2522 struct regcache
*regcache
;
2523 struct breakpoint
*t
;
2524 int stepping_frame
= 0;
2525 struct bp_location
*loc
;
2526 char *line
, *default_collect_line
= NULL
;
2527 struct command_line
*actions
, *default_collect_action
= NULL
;
2528 struct cleanup
*old_chain
= NULL
;
2530 if (tracepoint_number
== -1)
2532 warning (_("No current trace frame."));
2536 t
= get_tracepoint (tracepoint_number
);
2539 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2542 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2543 tracepoint_number
, traceframe_number
);
2545 /* The current frame is a trap frame if the frame PC is equal
2546 to the tracepoint PC. If not, then the current frame was
2547 collected during single-stepping. */
2549 regcache
= get_current_regcache ();
2551 /* If the traceframe's address matches any of the tracepoint's
2552 locations, assume it is a direct hit rather than a while-stepping
2553 frame. (FIXME this is not reliable, should record each frame's
2556 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2557 if (loc
->address
== regcache_read_pc (regcache
))
2560 actions
= breakpoint_commands (t
);
2562 /* If there is a default-collect list, make up a collect command,
2563 prepend to the tracepoint's commands, and pass the whole mess to
2564 the trace dump scanner. We need to validate because
2565 default-collect might have been junked since the trace run. */
2566 if (*default_collect
)
2568 default_collect_line
= xstrprintf ("collect %s", default_collect
);
2569 old_chain
= make_cleanup (xfree
, default_collect_line
);
2570 line
= default_collect_line
;
2571 validate_actionline (&line
, t
);
2572 default_collect_action
= xmalloc (sizeof (struct command_line
));
2573 make_cleanup (xfree
, default_collect_action
);
2574 default_collect_action
->next
= actions
;
2575 default_collect_action
->line
= line
;
2576 actions
= default_collect_action
;
2579 trace_dump_actions (actions
, 0, stepping_frame
, from_tty
);
2581 if (*default_collect
)
2582 do_cleanups (old_chain
);
2585 /* Encode a piece of a tracepoint's source-level definition in a form
2586 that is suitable for both protocol and saving in files. */
2587 /* This version does not do multiple encodes for long strings; it should
2588 return an offset to the next piece to encode. FIXME */
2591 encode_source_string (int tpnum
, ULONGEST addr
,
2592 char *srctype
, char *src
, char *buf
, int buf_size
)
2594 if (80 + strlen (srctype
) > buf_size
)
2595 error (_("Buffer too small for source encoding"));
2596 sprintf (buf
, "%x:%s:%s:%x:%x:",
2597 tpnum
, phex_nz (addr
, sizeof (addr
)), srctype
, 0, (int) strlen (src
));
2598 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2599 error (_("Source string too long for buffer"));
2600 bin2hex (src
, buf
+ strlen (buf
), 0);
2604 extern int trace_regblock_size
;
2606 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2607 non-zero, the save is performed on the target, otherwise GDB obtains all
2608 trace data and saves it locally. */
2611 trace_save (const char *filename
, int target_does_save
)
2613 struct cleanup
*cleanup
;
2615 struct trace_status
*ts
= current_trace_status ();
2618 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2619 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2623 ULONGEST offset
= 0;
2624 #define MAX_TRACE_UPLOAD 2000
2625 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2628 /* If the target is to save the data to a file on its own, then just
2629 send the command and be done with it. */
2630 if (target_does_save
)
2632 err
= target_save_trace_data (filename
);
2634 error (_("Target failed to save trace data to '%s'."),
2639 /* Get the trace status first before opening the file, so if the
2640 target is losing, we can get out without touching files. */
2641 status
= target_get_trace_status (ts
);
2643 pathname
= tilde_expand (filename
);
2644 cleanup
= make_cleanup (xfree
, pathname
);
2646 fp
= fopen (pathname
, "wb");
2648 error (_("Unable to open file '%s' for saving trace data (%s)"),
2649 filename
, safe_strerror (errno
));
2650 make_cleanup_fclose (fp
);
2652 /* Write a file header, with a high-bit-set char to indicate a
2653 binary file, plus a hint as what this file is, and a version
2654 number in case of future needs. */
2655 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2657 perror_with_name (pathname
);
2659 /* Write descriptive info. */
2661 /* Write out the size of a register block. */
2662 fprintf (fp
, "R %x\n", trace_regblock_size
);
2664 /* Write out status of the tracing run (aka "tstatus" info). */
2665 fprintf (fp
, "status %c;%s",
2666 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
2667 if (ts
->stop_reason
== tracepoint_error
)
2669 char *buf
= (char *) alloca (strlen (ts
->error_desc
) * 2 + 1);
2671 bin2hex ((gdb_byte
*) ts
->error_desc
, buf
, 0);
2672 fprintf (fp
, ":%s", buf
);
2674 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
2675 if (ts
->traceframe_count
>= 0)
2676 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
2677 if (ts
->traceframes_created
>= 0)
2678 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
2679 if (ts
->buffer_free
>= 0)
2680 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
2681 if (ts
->buffer_size
>= 0)
2682 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
2683 if (ts
->disconnected_tracing
)
2684 fprintf (fp
, ";disconn:%x", ts
->disconnected_tracing
);
2685 if (ts
->circular_buffer
)
2686 fprintf (fp
, ";circular:%x", ts
->circular_buffer
);
2689 /* Note that we want to upload tracepoints and save those, rather
2690 than simply writing out the local ones, because the user may have
2691 changed tracepoints in GDB in preparation for a future tracing
2692 run, or maybe just mass-deleted all types of breakpoints as part
2693 of cleaning up. So as not to contaminate the session, leave the
2694 data in its uploaded form, don't make into real tracepoints. */
2696 /* Get trace state variables first, they may be checked when parsing
2697 uploaded commands. */
2699 target_upload_trace_state_variables (&uploaded_tsvs
);
2701 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2707 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
2708 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
2711 fprintf (fp
, "tsv %x:%s:%x:%s\n",
2712 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
2713 utsv
->builtin
, buf
);
2719 free_uploaded_tsvs (&uploaded_tsvs
);
2721 target_upload_tracepoints (&uploaded_tps
);
2723 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
2725 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
2726 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2727 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
2728 if (utp
->type
== bp_fast_tracepoint
)
2729 fprintf (fp
, ":F%x", utp
->orig_size
);
2731 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
2734 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
2735 fprintf (fp
, "tp A%x:%s:%s\n",
2736 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
2737 for (a
= 0; VEC_iterate (char_ptr
, utp
->actions
, a
, act
); ++a
)
2738 fprintf (fp
, "tp S%x:%s:%s\n",
2739 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)), act
);
2742 encode_source_string (utp
->number
, utp
->addr
,
2743 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
2744 fprintf (fp
, "tp Z%s\n", buf
);
2746 if (utp
->cond_string
)
2748 encode_source_string (utp
->number
, utp
->addr
,
2749 "cond", utp
->cond_string
, buf
, MAX_TRACE_UPLOAD
);
2750 fprintf (fp
, "tp Z%s\n", buf
);
2752 for (a
= 0; VEC_iterate (char_ptr
, utp
->cmd_strings
, a
, act
); ++a
)
2754 encode_source_string (utp
->number
, utp
->addr
, "cmd", act
,
2755 buf
, MAX_TRACE_UPLOAD
);
2756 fprintf (fp
, "tp Z%s\n", buf
);
2760 free_uploaded_tps (&uploaded_tps
);
2762 /* Mark the end of the definition section. */
2765 /* Get and write the trace data proper. We ask for big blocks, in
2766 the hopes of efficiency, but will take less if the target has
2767 packet size limitations or some such. */
2770 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
2772 error (_("Failure to get requested trace buffer data"));
2773 /* No more data is forthcoming, we're done. */
2776 written
= fwrite (buf
, gotten
, 1, fp
);
2778 perror_with_name (pathname
);
2782 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
2783 written
= fwrite (&gotten
, 4, 1, fp
);
2785 perror_with_name (pathname
);
2787 do_cleanups (cleanup
);
2791 trace_save_command (char *args
, int from_tty
)
2793 int target_does_save
= 0;
2795 char *filename
= NULL
;
2796 struct cleanup
*back_to
;
2799 error_no_arg (_("file in which to save trace data"));
2801 argv
= gdb_buildargv (args
);
2802 back_to
= make_cleanup_freeargv (argv
);
2804 for (; *argv
; ++argv
)
2806 if (strcmp (*argv
, "-r") == 0)
2807 target_does_save
= 1;
2808 else if (**argv
== '-')
2809 error (_("unknown option `%s'"), *argv
);
2815 error_no_arg (_("file in which to save trace data"));
2817 trace_save (filename
, target_does_save
);
2820 printf_filtered (_("Trace data saved to file '%s'.\n"), args
);
2822 do_cleanups (back_to
);
2825 /* Tell the target what to do with an ongoing tracing run if GDB
2826 disconnects for some reason. */
2829 send_disconnected_tracing_value (int value
)
2831 target_set_disconnected_tracing (value
);
2835 set_disconnected_tracing (char *args
, int from_tty
,
2836 struct cmd_list_element
*c
)
2838 send_disconnected_tracing_value (disconnected_tracing
);
2842 set_circular_trace_buffer (char *args
, int from_tty
,
2843 struct cmd_list_element
*c
)
2845 target_set_circular_trace_buffer (circular_trace_buffer
);
2848 /* Convert the memory pointed to by mem into hex, placing result in buf.
2849 * Return a pointer to the last char put in buf (null)
2850 * "stolen" from sparc-stub.c
2853 static const char hexchars
[] = "0123456789abcdef";
2856 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2864 *buf
++ = hexchars
[ch
>> 4];
2865 *buf
++ = hexchars
[ch
& 0xf];
2874 get_traceframe_number (void)
2876 return traceframe_number
;
2879 /* Make the traceframe NUM be the current trace frame. Does nothing
2880 if NUM is already current. */
2883 set_traceframe_number (int num
)
2887 if (traceframe_number
== num
)
2889 /* Nothing to do. */
2893 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
2896 warning (_("could not change traceframe"));
2898 traceframe_number
= newnum
;
2900 /* Changing the traceframe changes our view of registers and of the
2902 registers_changed ();
2905 /* A cleanup used when switching away and back from tfind mode. */
2907 struct current_traceframe_cleanup
2909 /* The traceframe we were inspecting. */
2910 int traceframe_number
;
2914 do_restore_current_traceframe_cleanup (void *arg
)
2916 struct current_traceframe_cleanup
*old
= arg
;
2918 set_traceframe_number (old
->traceframe_number
);
2922 restore_current_traceframe_cleanup_dtor (void *arg
)
2924 struct current_traceframe_cleanup
*old
= arg
;
2930 make_cleanup_restore_current_traceframe (void)
2932 struct current_traceframe_cleanup
*old
;
2934 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
2935 old
->traceframe_number
= traceframe_number
;
2937 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
2938 restore_current_traceframe_cleanup_dtor
);
2941 /* Given a number and address, return an uploaded tracepoint with that
2942 number, creating if necessary. */
2944 struct uploaded_tp
*
2945 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
2947 struct uploaded_tp
*utp
;
2949 for (utp
= *utpp
; utp
; utp
= utp
->next
)
2950 if (utp
->number
== num
&& utp
->addr
== addr
)
2952 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
2953 memset (utp
, 0, sizeof (struct uploaded_tp
));
2956 utp
->actions
= NULL
;
2957 utp
->step_actions
= NULL
;
2958 utp
->cmd_strings
= NULL
;
2965 free_uploaded_tps (struct uploaded_tp
**utpp
)
2967 struct uploaded_tp
*next_one
;
2971 next_one
= (*utpp
)->next
;
2977 /* Given a number and address, return an uploaded tracepoint with that
2978 number, creating if necessary. */
2980 struct uploaded_tsv
*
2981 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
2983 struct uploaded_tsv
*utsv
;
2985 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
2986 if (utsv
->number
== num
)
2988 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
2989 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
2991 utsv
->next
= *utsvp
;
2997 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
2999 struct uploaded_tsv
*next_one
;
3003 next_one
= (*utsvp
)->next
;
3009 /* Look for an existing tracepoint that seems similar enough to the
3010 uploaded one. Enablement isn't compared, because the user can
3011 toggle that freely, and may have done so in anticipation of the
3015 find_matching_tracepoint (struct uploaded_tp
*utp
)
3017 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
3019 struct breakpoint
*t
;
3020 struct bp_location
*loc
;
3022 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
3024 if (t
->type
== utp
->type
3025 && t
->step_count
== utp
->step
3026 && t
->pass_count
== utp
->pass
3027 /* FIXME also test conditionals and actions */
3030 /* Scan the locations for an address match. */
3031 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
3033 if (loc
->address
== utp
->addr
)
3041 /* Given a list of tracepoints uploaded from a target, attempt to
3042 match them up with existing tracepoints, and create new ones if not
3046 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
3048 struct uploaded_tp
*utp
;
3049 struct breakpoint
*t
;
3051 /* Look for GDB tracepoints that match up with our uploaded versions. */
3052 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
3054 t
= find_matching_tracepoint (utp
);
3056 printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
3057 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
3060 t
= create_tracepoint_from_upload (utp
);
3062 printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
3063 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
3065 printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
3066 utp
->number
, paddress (get_current_arch (), utp
->addr
));
3068 /* Whether found or created, record the number used by the
3069 target, to help with mapping target tracepoints back to their
3070 counterparts here. */
3072 t
->number_on_target
= utp
->number
;
3075 free_uploaded_tps (uploaded_tps
);
3078 /* Trace state variables don't have much to identify them beyond their
3079 name, so just use that to detect matches. */
3081 struct trace_state_variable
*
3082 find_matching_tsv (struct uploaded_tsv
*utsv
)
3087 return find_trace_state_variable (utsv
->name
);
3090 struct trace_state_variable
*
3091 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
3093 const char *namebase
;
3096 struct trace_state_variable
*tsv
;
3100 namebase
= utsv
->name
;
3101 sprintf (buf
, "%s", namebase
);
3106 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3109 /* Fish for a name that is not in use. */
3110 /* (should check against all internal vars?) */
3111 while (find_trace_state_variable (buf
))
3112 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3114 /* We have an available name, create the variable. */
3115 tsv
= create_trace_state_variable (xstrdup (buf
));
3116 tsv
->initial_value
= utsv
->initial_value
;
3117 tsv
->builtin
= utsv
->builtin
;
3122 /* Given a list of uploaded trace state variables, try to match them
3123 up with existing variables, or create additional ones. */
3126 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3129 struct uploaded_tsv
*utsv
;
3130 struct trace_state_variable
*tsv
;
3133 /* Most likely some numbers will have to be reassigned as part of
3134 the merge, so clear them all in anticipation. */
3135 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3138 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3140 tsv
= find_matching_tsv (utsv
);
3142 printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
3143 tsv
->name
, utsv
->number
);
3146 tsv
= create_tsv_from_upload (utsv
);
3147 printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
3148 tsv
->name
, utsv
->number
);
3150 /* Give precedence to numberings that come from the target. */
3152 tsv
->number
= utsv
->number
;
3155 /* Renumber everything that didn't get a target-assigned number. */
3157 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3158 if (tsv
->number
> highest
)
3159 highest
= tsv
->number
;
3162 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3163 if (tsv
->number
== 0)
3164 tsv
->number
= highest
++;
3166 free_uploaded_tsvs (uploaded_tsvs
);
3169 /* target tfile command */
3171 struct target_ops tfile_ops
;
3173 /* Fill in tfile_ops with its defined operations and properties. */
3175 #define TRACE_HEADER_SIZE 8
3177 char *trace_filename
;
3179 off_t trace_frames_offset
;
3182 int trace_regblock_size
;
3184 static void tfile_interp_line (char *line
,
3185 struct uploaded_tp
**utpp
,
3186 struct uploaded_tsv
**utsvp
);
3189 tfile_open (char *filename
, int from_tty
)
3192 struct cleanup
*old_chain
;
3195 char header
[TRACE_HEADER_SIZE
];
3196 char linebuf
[1000]; /* should be max remote packet size or so */
3198 int bytes
, i
, gotten
;
3199 struct trace_status
*ts
;
3200 struct uploaded_tp
*uploaded_tps
= NULL
;
3201 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3203 target_preopen (from_tty
);
3205 error (_("No trace file specified."));
3207 filename
= tilde_expand (filename
);
3208 if (!IS_ABSOLUTE_PATH(filename
))
3210 temp
= concat (current_directory
, "/", filename
, (char *) NULL
);
3215 old_chain
= make_cleanup (xfree
, filename
);
3217 flags
= O_BINARY
| O_LARGEFILE
;
3219 scratch_chan
= open (filename
, flags
, 0);
3220 if (scratch_chan
< 0)
3221 perror_with_name (filename
);
3223 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3225 discard_cleanups (old_chain
); /* Don't free filename any more */
3226 unpush_target (&tfile_ops
);
3228 push_target (&tfile_ops
);
3230 trace_filename
= xstrdup (filename
);
3231 trace_fd
= scratch_chan
;
3234 /* Read the file header and test for validity. */
3235 gotten
= read (trace_fd
, &header
, TRACE_HEADER_SIZE
);
3237 perror_with_name (trace_filename
);
3238 else if (gotten
< TRACE_HEADER_SIZE
)
3239 error (_("Premature end of file while reading trace file"));
3241 bytes
+= TRACE_HEADER_SIZE
;
3242 if (!(header
[0] == 0x7f
3243 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3244 error (_("File is not a valid trace file."));
3246 trace_regblock_size
= 0;
3247 ts
= current_trace_status ();
3248 /* We know we're working with a file. */
3250 /* Set defaults in case there is no status line. */
3251 ts
->running_known
= 0;
3252 ts
->stop_reason
= trace_stop_reason_unknown
;
3253 ts
->traceframe_count
= -1;
3254 ts
->buffer_free
= 0;
3255 ts
->disconnected_tracing
= 0;
3256 ts
->circular_buffer
= 0;
3258 /* Read through a section of newline-terminated lines that
3259 define things like tracepoints. */
3263 gotten
= read (trace_fd
, &byte
, 1);
3265 perror_with_name (trace_filename
);
3266 else if (gotten
< 1)
3267 error (_("Premature end of file while reading trace file"));
3272 /* Empty line marks end of the definition section. */
3277 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3280 linebuf
[i
++] = byte
;
3282 error (_("Excessively long lines in trace file"));
3285 /* Add the file's tracepoints and variables into the current mix. */
3287 /* Get trace state variables first, they may be checked when parsing
3288 uploaded commands. */
3289 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3291 merge_uploaded_tracepoints (&uploaded_tps
);
3293 /* Record the starting offset of the binary trace data. */
3294 trace_frames_offset
= bytes
;
3296 /* If we don't have a blocksize, we can't interpret the
3298 if (trace_regblock_size
== 0)
3299 error (_("No register block size recorded in trace file"));
3300 if (ts
->traceframe_count
<= 0)
3302 warning ("No traceframes present in this file.");
3306 #define TFILE_PID (1)
3307 inferior_appeared (current_inferior (), TFILE_PID
);
3308 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3309 add_thread_silent (inferior_ptid
);
3311 post_create_inferior (&tfile_ops
, from_tty
);
3314 /* FIXME this will get defined in MI patch submission */
3315 tfind_1 (tfind_number
, 0, 0, 0, 0);
3319 /* Interpret the given line from the definitions part of the trace
3323 tfile_interp_line (char *line
,
3324 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3328 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3331 trace_regblock_size
= strtol (p
, &p
, 16);
3333 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3335 p
+= strlen ("status ");
3336 parse_trace_status (p
, current_trace_status ());
3338 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3340 p
+= strlen ("tp ");
3341 parse_tracepoint_definition (p
, utpp
);
3343 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3345 p
+= strlen ("tsv ");
3346 parse_tsv_definition (p
, utsvp
);
3349 warning ("Ignoring trace file definition \"%s\"", line
);
3352 /* Parse the part of trace status syntax that is shared between
3353 the remote protocol and the trace file reader. */
3356 parse_trace_status (char *line
, struct trace_status
*ts
)
3358 char *p
= line
, *p1
, *p2
, *p_temp
;
3361 ts
->running_known
= 1;
3362 ts
->running
= (*p
++ == '1');
3363 ts
->stop_reason
= trace_stop_reason_unknown
;
3364 xfree (ts
->error_desc
);
3365 ts
->error_desc
= NULL
;
3366 ts
->traceframe_count
= -1;
3367 ts
->traceframes_created
= -1;
3368 ts
->buffer_free
= -1;
3369 ts
->buffer_size
= -1;
3370 ts
->disconnected_tracing
= 0;
3371 ts
->circular_buffer
= 0;
3375 p1
= strchr (p
, ':');
3377 error (_("Malformed trace status, at %s\n\
3378 Status line: '%s'\n"), p
, line
);
3379 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3381 p
= unpack_varlen_hex (++p1
, &val
);
3382 ts
->stop_reason
= trace_buffer_full
;
3384 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3386 p
= unpack_varlen_hex (++p1
, &val
);
3387 ts
->stop_reason
= trace_never_run
;
3389 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
], p1
- p
) == 0)
3391 p
= unpack_varlen_hex (++p1
, &val
);
3392 ts
->stop_reason
= tracepoint_passcount
;
3393 ts
->stopping_tracepoint
= val
;
3395 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3397 p
= unpack_varlen_hex (++p1
, &val
);
3398 ts
->stop_reason
= tstop_command
;
3400 else if (strncmp (p
, stop_reason_names
[trace_disconnected
], p1
- p
) == 0)
3402 p
= unpack_varlen_hex (++p1
, &val
);
3403 ts
->stop_reason
= trace_disconnected
;
3405 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3407 p2
= strchr (++p1
, ':');
3412 ts
->error_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3413 end
= hex2bin (p1
, ts
->error_desc
, (p2
- p1
) / 2);
3414 ts
->error_desc
[end
] = '\0';
3417 ts
->error_desc
= xstrdup ("");
3419 p
= unpack_varlen_hex (++p2
, &val
);
3420 ts
->stopping_tracepoint
= val
;
3421 ts
->stop_reason
= tracepoint_error
;
3423 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3425 p
= unpack_varlen_hex (++p1
, &val
);
3426 ts
->traceframe_count
= val
;
3428 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3430 p
= unpack_varlen_hex (++p1
, &val
);
3431 ts
->traceframes_created
= val
;
3433 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3435 p
= unpack_varlen_hex (++p1
, &val
);
3436 ts
->buffer_free
= val
;
3438 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3440 p
= unpack_varlen_hex (++p1
, &val
);
3441 ts
->buffer_size
= val
;
3443 else if (strncmp (p
, "disconn", p1
- p
) == 0)
3445 p
= unpack_varlen_hex (++p1
, &val
);
3446 ts
->disconnected_tracing
= val
;
3448 else if (strncmp (p
, "circular", p1
- p
) == 0)
3450 p
= unpack_varlen_hex (++p1
, &val
);
3451 ts
->circular_buffer
= val
;
3455 /* Silently skip unknown optional info. */
3456 p_temp
= strchr (p1
+ 1, ';');
3460 /* Must be at the end. */
3466 /* Given a line of text defining a part of a tracepoint, parse it into
3467 an "uploaded tracepoint". */
3470 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3474 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3477 char *cond
, *srctype
, *buf
;
3478 struct uploaded_tp
*utp
= NULL
;
3481 /* Both tracepoint and action definitions start with the same number
3482 and address sequence. */
3484 p
= unpack_varlen_hex (p
, &num
);
3485 p
++; /* skip a colon */
3486 p
= unpack_varlen_hex (p
, &addr
);
3487 p
++; /* skip a colon */
3490 enabled
= (*p
++ == 'E');
3491 p
++; /* skip a colon */
3492 p
= unpack_varlen_hex (p
, &step
);
3493 p
++; /* skip a colon */
3494 p
= unpack_varlen_hex (p
, &pass
);
3495 type
= bp_tracepoint
;
3497 /* Thumb through optional fields. */
3500 p
++; /* skip a colon */
3503 type
= bp_fast_tracepoint
;
3505 p
= unpack_varlen_hex (p
, &orig_size
);
3509 type
= bp_static_tracepoint
;
3515 p
= unpack_varlen_hex (p
, &xlen
);
3516 p
++; /* skip a comma */
3517 cond
= (char *) xmalloc (2 * xlen
+ 1);
3518 strncpy (cond
, p
, 2 * xlen
);
3519 cond
[2 * xlen
] = '\0';
3523 warning (_("Unrecognized char '%c' in tracepoint definition, skipping rest"), *p
);
3525 utp
= get_uploaded_tp (num
, addr
, utpp
);
3527 utp
->enabled
= enabled
;
3532 else if (piece
== 'A')
3534 utp
= get_uploaded_tp (num
, addr
, utpp
);
3535 VEC_safe_push (char_ptr
, utp
->actions
, xstrdup (p
));
3537 else if (piece
== 'S')
3539 utp
= get_uploaded_tp (num
, addr
, utpp
);
3540 VEC_safe_push (char_ptr
, utp
->step_actions
, xstrdup (p
));
3542 else if (piece
== 'Z')
3544 /* Parse a chunk of source form definition. */
3545 utp
= get_uploaded_tp (num
, addr
, utpp
);
3547 p
= strchr (p
, ':');
3548 p
++; /* skip a colon */
3549 p
= unpack_varlen_hex (p
, &start
);
3550 p
++; /* skip a colon */
3551 p
= unpack_varlen_hex (p
, &xlen
);
3552 p
++; /* skip a colon */
3554 buf
= alloca (strlen (line
));
3556 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3559 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
3560 utp
->at_string
= xstrdup (buf
);
3561 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
3562 utp
->cond_string
= xstrdup (buf
);
3563 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
3564 VEC_safe_push (char_ptr
, utp
->cmd_strings
, xstrdup (buf
));
3568 /* Don't error out, the target might be sending us optional
3569 info that we don't care about. */
3570 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3574 /* Convert a textual description of a trace state variable into an
3578 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3581 ULONGEST num
, initval
, builtin
;
3583 struct uploaded_tsv
*utsv
= NULL
;
3585 buf
= alloca (strlen (line
));
3588 p
= unpack_varlen_hex (p
, &num
);
3589 p
++; /* skip a colon */
3590 p
= unpack_varlen_hex (p
, &initval
);
3591 p
++; /* skip a colon */
3592 p
= unpack_varlen_hex (p
, &builtin
);
3593 p
++; /* skip a colon */
3594 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3597 utsv
= get_uploaded_tsv (num
, utsvp
);
3598 utsv
->initial_value
= initval
;
3599 utsv
->builtin
= builtin
;
3600 utsv
->name
= xstrdup (buf
);
3603 /* Close the trace file and generally clean up. */
3606 tfile_close (int quitting
)
3613 pid
= ptid_get_pid (inferior_ptid
);
3614 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
3615 exit_inferior_silent (pid
);
3620 xfree (trace_filename
);
3624 tfile_files_info (struct target_ops
*t
)
3626 /* (it would be useful to mention the name of the file) */
3627 printf_filtered ("Looking at a trace file.\n");
3630 /* The trace status for a file is that tracing can never be run. */
3633 tfile_get_trace_status (struct trace_status
*ts
)
3635 /* Other bits of trace status were collected as part of opening the
3636 trace files, so nothing to do here. */
3641 /* Given the position of a traceframe in the file, figure out what
3642 address the frame was collected at. This would normally be the
3643 value of a collected PC register, but if not available, we
3647 tfile_get_traceframe_address (off_t tframe_offset
)
3651 struct breakpoint
*tp
;
3652 off_t saved_offset
= cur_offset
;
3655 /* FIXME dig pc out of collected registers */
3657 /* Fall back to using tracepoint address. */
3658 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
3659 gotten
= read (trace_fd
, &tpnum
, 2);
3661 perror_with_name (trace_filename
);
3662 else if (gotten
< 2)
3663 error (_("Premature end of file while reading trace file"));
3665 tp
= get_tracepoint_by_number_on_target (tpnum
);
3666 /* FIXME this is a poor heuristic if multiple locations */
3668 addr
= tp
->loc
->address
;
3670 /* Restore our seek position. */
3671 cur_offset
= saved_offset
;
3672 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3676 /* Given a type of search and some parameters, scan the collection of
3677 traceframes in the file looking for a match. When found, return
3678 both the traceframe and tracepoint number, otherwise -1 for
3682 tfile_trace_find (enum trace_find_type type
, int num
,
3683 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
3686 int tfnum
= 0, found
= 0, gotten
;
3688 struct breakpoint
*tp
;
3689 off_t offset
, tframe_offset
;
3692 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
3693 offset
= trace_frames_offset
;
3696 tframe_offset
= offset
;
3697 gotten
= read (trace_fd
, &tpnum
, 2);
3699 perror_with_name (trace_filename
);
3700 else if (gotten
< 2)
3701 error (_("Premature end of file while reading trace file"));
3705 gotten
= read (trace_fd
, &data_size
, 4);
3707 perror_with_name (trace_filename
);
3708 else if (gotten
< 4)
3709 error (_("Premature end of file while reading trace file"));
3718 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3719 if (tfaddr
== addr1
)
3723 tp
= get_tracepoint (num
);
3724 if (tp
&& tpnum
== tp
->number_on_target
)
3728 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3729 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
3733 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3734 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
3738 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
3744 cur_offset
= offset
;
3745 cur_data_size
= data_size
;
3748 /* Skip past the traceframe's data. */
3749 lseek (trace_fd
, data_size
, SEEK_CUR
);
3750 offset
+= data_size
;
3751 /* Update our own count of traceframes. */
3754 /* Did not find what we were looking for. */
3760 /* Look for a block of saved registers in the traceframe, and get the
3761 requested register from it. */
3764 tfile_fetch_registers (struct target_ops
*ops
,
3765 struct regcache
*regcache
, int regno
)
3767 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3769 int pos
, offset
, regn
, regsize
, gotten
, pc_regno
;
3770 unsigned short mlen
;
3773 /* An uninitialized reg size says we're not going to be
3774 successful at getting register blocks. */
3775 if (!trace_regblock_size
)
3778 regs
= alloca (trace_regblock_size
);
3780 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3782 while (pos
< cur_data_size
)
3784 gotten
= read (trace_fd
, &block_type
, 1);
3786 perror_with_name (trace_filename
);
3787 else if (gotten
< 1)
3788 error (_("Premature end of file while reading trace file"));
3794 gotten
= read (trace_fd
, regs
, trace_regblock_size
);
3796 perror_with_name (trace_filename
);
3797 else if (gotten
< trace_regblock_size
)
3798 error (_("Premature end of file while reading trace file"));
3800 /* Assume the block is laid out in GDB register number order,
3801 each register with the size that it has in GDB. */
3803 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3805 regsize
= register_size (gdbarch
, regn
);
3806 /* Make sure we stay within block bounds. */
3807 if (offset
+ regsize
>= trace_regblock_size
)
3809 if (!regcache_valid_p (regcache
, regn
))
3813 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
3816 else if (regno
== -1)
3818 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
3825 lseek (trace_fd
, 8, SEEK_CUR
);
3826 gotten
= read (trace_fd
, &mlen
, 2);
3828 perror_with_name (trace_filename
);
3829 else if (gotten
< 2)
3830 error (_("Premature end of file while reading trace file"));
3831 lseek (trace_fd
, mlen
, SEEK_CUR
);
3832 pos
+= (8 + 2 + mlen
);
3835 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3839 error ("Unknown block type '%c' (0x%x) in trace frame",
3840 block_type
, block_type
);
3845 /* We get here if no register data has been found. Although we
3846 don't like making up numbers, GDB has all manner of troubles when
3847 the target says some register is not available. Filling in with
3848 zeroes is a reasonable fallback. */
3849 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3850 regcache_raw_supply (regcache
, regn
, NULL
);
3852 /* We can often usefully guess that the PC is going to be the same
3853 as the address of the tracepoint. */
3854 pc_regno
= gdbarch_pc_regnum (gdbarch
);
3855 if (pc_regno
>= 0 && (regno
== -1 || regno
== pc_regno
))
3857 struct breakpoint
*tp
= get_tracepoint (tracepoint_number
);
3861 /* But don't try to guess if tracepoint is multi-location... */
3864 warning ("Tracepoint %d has multiple locations, cannot infer $pc",
3868 /* ... or does while-stepping. */
3869 if (tp
->step_count
> 0)
3871 warning ("Tracepoint %d does while-stepping, cannot infer $pc",
3876 store_unsigned_integer (regs
, register_size (gdbarch
, pc_regno
),
3877 gdbarch_byte_order (gdbarch
),
3879 regcache_raw_supply (regcache
, pc_regno
, regs
);
3885 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3886 const char *annex
, gdb_byte
*readbuf
,
3887 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3891 ULONGEST maddr
, amt
;
3892 unsigned short mlen
;
3894 /* We're only doing regular memory for now. */
3895 if (object
!= TARGET_OBJECT_MEMORY
)
3898 if (readbuf
== NULL
)
3899 error ("tfile_xfer_partial: trace file is read-only");
3901 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3903 while (pos
< cur_data_size
)
3905 gotten
= read (trace_fd
, &block_type
, 1);
3907 perror_with_name (trace_filename
);
3908 else if (gotten
< 1)
3909 error (_("Premature end of file while reading trace file"));
3914 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3915 pos
+= trace_regblock_size
;
3918 gotten
= read (trace_fd
, &maddr
, 8);
3920 perror_with_name (trace_filename
);
3921 else if (gotten
< 8)
3922 error (_("Premature end of file while reading trace file"));
3924 gotten
= read (trace_fd
, &mlen
, 2);
3926 perror_with_name (trace_filename
);
3927 else if (gotten
< 2)
3928 error (_("Premature end of file while reading trace file"));
3929 /* If the block includes the first part of the desired
3930 range, return as much it has; GDB will re-request the
3931 remainder, which might be in a different block of this
3933 if (maddr
<= offset
&& offset
< (maddr
+ mlen
))
3935 amt
= (maddr
+ mlen
) - offset
;
3939 gotten
= read (trace_fd
, readbuf
, amt
);
3941 perror_with_name (trace_filename
);
3942 /* While it's acceptable to return less than was
3943 originally asked for, it's not acceptable to return
3944 less than what this block claims to contain. */
3945 else if (gotten
< amt
)
3946 error (_("Premature end of file while reading trace file"));
3949 lseek (trace_fd
, mlen
, SEEK_CUR
);
3950 pos
+= (8 + 2 + mlen
);
3953 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3957 error ("Unknown block type '%c' (0x%x) in traceframe",
3958 block_type
, block_type
);
3963 /* It's unduly pedantic to refuse to look at the executable for
3964 read-only pieces; so do the equivalent of readonly regions aka
3966 /* FIXME account for relocation at some point */
3973 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
3975 if ((s
->flags
& SEC_LOAD
) == 0 ||
3976 (s
->flags
& SEC_READONLY
) == 0)
3980 size
= bfd_get_section_size (s
);
3981 if (lma
<= offset
&& offset
< (lma
+ size
))
3983 amt
= (lma
+ size
) - offset
;
3987 amt
= bfd_get_section_contents (exec_bfd
, s
,
3988 readbuf
, offset
- lma
, amt
);
3994 /* Indicate failure to find the requested memory block. */
3998 /* Iterate through the blocks of a trace frame, looking for a 'V'
3999 block with a matching tsv number. */
4002 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
4005 int pos
, vnum
, gotten
;
4006 unsigned short mlen
;
4008 lseek (trace_fd
, cur_offset
, SEEK_SET
);
4010 while (pos
< cur_data_size
)
4012 gotten
= read (trace_fd
, &block_type
, 1);
4014 perror_with_name (trace_filename
);
4015 else if (gotten
< 1)
4016 error (_("Premature end of file while reading trace file"));
4021 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
4022 pos
+= trace_regblock_size
;
4025 lseek (trace_fd
, 8, SEEK_CUR
);
4026 gotten
= read (trace_fd
, &mlen
, 2);
4028 perror_with_name (trace_filename
);
4029 else if (gotten
< 2)
4030 error (_("Premature end of file while reading trace file"));
4031 lseek (trace_fd
, mlen
, SEEK_CUR
);
4032 pos
+= (8 + 2 + mlen
);
4035 gotten
= read (trace_fd
, &vnum
, 4);
4037 perror_with_name (trace_filename
);
4038 else if (gotten
< 4)
4039 error (_("Premature end of file while reading trace file"));
4042 gotten
= read (trace_fd
, val
, 8);
4044 perror_with_name (trace_filename
);
4045 else if (gotten
< 8)
4046 error (_("Premature end of file while reading trace file"));
4049 lseek (trace_fd
, 8, SEEK_CUR
);
4053 error ("Unknown block type '%c' (0x%x) in traceframe",
4054 block_type
, block_type
);
4058 /* Didn't find anything. */
4063 tfile_has_all_memory (struct target_ops
*ops
)
4069 tfile_has_memory (struct target_ops
*ops
)
4075 tfile_has_stack (struct target_ops
*ops
)
4081 tfile_has_registers (struct target_ops
*ops
)
4087 init_tfile_ops (void)
4089 tfile_ops
.to_shortname
= "tfile";
4090 tfile_ops
.to_longname
= "Local trace dump file";
4092 "Use a trace file as a target. Specify the filename of the trace file.";
4093 tfile_ops
.to_open
= tfile_open
;
4094 tfile_ops
.to_close
= tfile_close
;
4095 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
4096 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
4097 tfile_ops
.to_files_info
= tfile_files_info
;
4098 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
4099 tfile_ops
.to_trace_find
= tfile_trace_find
;
4100 tfile_ops
.to_get_trace_state_variable_value
= tfile_get_trace_state_variable_value
;
4101 tfile_ops
.to_stratum
= process_stratum
;
4102 tfile_ops
.to_has_all_memory
= tfile_has_all_memory
;
4103 tfile_ops
.to_has_memory
= tfile_has_memory
;
4104 tfile_ops
.to_has_stack
= tfile_has_stack
;
4105 tfile_ops
.to_has_registers
= tfile_has_registers
;
4106 tfile_ops
.to_magic
= OPS_MAGIC
;
4109 /* Given a line of text defining a static tracepoint marker, parse it
4110 into a "static tracepoint marker" object. Throws an error is
4111 parsing fails. If PP is non-null, it points to one past the end of
4112 the parsed marker definition. */
4115 parse_static_tracepoint_marker_definition (char *line
, char **pp
,
4116 struct static_tracepoint_marker
*marker
)
4123 p
= unpack_varlen_hex (p
, &addr
);
4124 p
++; /* skip a colon */
4126 marker
->gdbarch
= target_gdbarch
;
4127 marker
->address
= (CORE_ADDR
) addr
;
4129 endp
= strchr (p
, ':');
4131 error ("bad marker definition: %s", line
);
4133 marker
->str_id
= xmalloc (endp
- p
+ 1);
4134 end
= hex2bin (p
, (gdb_byte
*) marker
->str_id
, (endp
- p
+ 1) / 2);
4135 marker
->str_id
[end
] = '\0';
4138 p
++; /* skip a colon */
4140 marker
->extra
= xmalloc (strlen (p
) + 1);
4141 end
= hex2bin (p
, (gdb_byte
*) marker
->extra
, strlen (p
) / 2);
4142 marker
->extra
[end
] = '\0';
4148 /* Release a static tracepoint marker's contents. Note that the
4149 object itself isn't released here. There objects are usually on
4153 release_static_tracepoint_marker (struct static_tracepoint_marker
*marker
)
4155 xfree (marker
->str_id
);
4156 marker
->str_id
= NULL
;
4159 /* Print MARKER to gdb_stdout. */
4162 print_one_static_tracepoint_marker (int count
,
4163 struct static_tracepoint_marker
*marker
)
4165 struct command_line
*l
;
4168 char wrap_indent
[80];
4169 char extra_field_indent
[80];
4170 struct ui_stream
*stb
= ui_out_stream_new (uiout
);
4171 struct cleanup
*old_chain
= make_cleanup_ui_out_stream_delete (stb
);
4172 struct cleanup
*bkpt_chain
;
4173 VEC(breakpoint_p
) *tracepoints
;
4175 struct symtab_and_line sal
;
4179 sal
.pc
= marker
->address
;
4181 tracepoints
= static_tracepoints_here (marker
->address
);
4183 bkpt_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, "marker");
4185 /* A counter field to help readability. This is not a stable
4187 ui_out_field_int (uiout
, "count", count
);
4189 ui_out_field_string (uiout
, "marker-id", marker
->str_id
);
4191 ui_out_field_fmt (uiout
, "enabled", "%c",
4192 !VEC_empty (breakpoint_p
, tracepoints
) ? 'y' : 'n');
4193 ui_out_spaces (uiout
, 2);
4195 strcpy (wrap_indent
, " ");
4197 if (gdbarch_addr_bit (marker
->gdbarch
) <= 32)
4198 strcat (wrap_indent
, " ");
4200 strcat (wrap_indent
, " ");
4202 strcpy (extra_field_indent
, " ");
4204 ui_out_field_core_addr (uiout
, "addr", marker
->gdbarch
, marker
->address
);
4206 sal
= find_pc_line (marker
->address
, 0);
4207 sym
= find_pc_sect_function (marker
->address
, NULL
);
4210 ui_out_text (uiout
, "in ");
4211 ui_out_field_string (uiout
, "func",
4212 SYMBOL_PRINT_NAME (sym
));
4213 ui_out_wrap_hint (uiout
, wrap_indent
);
4214 ui_out_text (uiout
, " at ");
4217 ui_out_field_skip (uiout
, "func");
4219 if (sal
.symtab
!= NULL
)
4221 ui_out_field_string (uiout
, "file", sal
.symtab
->filename
);
4222 ui_out_text (uiout
, ":");
4224 if (ui_out_is_mi_like_p (uiout
))
4226 char *fullname
= symtab_to_fullname (sal
.symtab
);
4229 ui_out_field_string (uiout
, "fullname", fullname
);
4232 ui_out_field_skip (uiout
, "fullname");
4234 ui_out_field_int (uiout
, "line", sal
.line
);
4238 ui_out_field_skip (uiout
, "fullname");
4239 ui_out_field_skip (uiout
, "line");
4242 ui_out_text (uiout
, "\n");
4243 ui_out_text (uiout
, extra_field_indent
);
4244 ui_out_text (uiout
, _("Data: \""));
4245 ui_out_field_string (uiout
, "extra-data", marker
->extra
);
4246 ui_out_text (uiout
, "\"\n");
4248 if (!VEC_empty (breakpoint_p
, tracepoints
))
4250 struct cleanup
*cleanup_chain
;
4252 struct breakpoint
*b
;
4254 cleanup_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
,
4257 ui_out_text (uiout
, extra_field_indent
);
4258 ui_out_text (uiout
, _("Probed by static tracepoints: "));
4259 for (ix
= 0; VEC_iterate(breakpoint_p
, tracepoints
, ix
, b
); ix
++)
4262 ui_out_text (uiout
, ", ");
4263 ui_out_text (uiout
, "#");
4264 ui_out_field_int (uiout
, "tracepoint-id", b
->number
);
4267 do_cleanups (cleanup_chain
);
4269 if (ui_out_is_mi_like_p (uiout
))
4270 ui_out_field_int (uiout
, "number-of-tracepoints",
4271 VEC_length(breakpoint_p
, tracepoints
));
4273 ui_out_text (uiout
, "\n");
4275 VEC_free (breakpoint_p
, tracepoints
);
4277 do_cleanups (bkpt_chain
);
4278 do_cleanups (old_chain
);
4282 info_static_tracepoint_markers_command (char *arg
, int from_tty
)
4284 VEC(static_tracepoint_marker_p
) *markers
;
4285 struct cleanup
*old_chain
;
4286 struct static_tracepoint_marker
*marker
;
4290 = make_cleanup_ui_out_table_begin_end (uiout
, 5, -1,
4291 "StaticTracepointMarkersTable");
4293 ui_out_table_header (uiout
, 7, ui_left
, "counter", "Cnt");
4295 ui_out_table_header (uiout
, 40, ui_left
, "marker-id", "ID");
4297 ui_out_table_header (uiout
, 3, ui_left
, "enabled", "Enb");
4298 if (gdbarch_addr_bit (target_gdbarch
) <= 32)
4299 ui_out_table_header (uiout
, 10, ui_left
, "addr", "Address");
4301 ui_out_table_header (uiout
, 18, ui_left
, "addr", "Address");
4302 ui_out_table_header (uiout
, 40, ui_noalign
, "what", "What");
4304 ui_out_table_body (uiout
);
4306 markers
= target_static_tracepoint_markers_by_strid (NULL
);
4307 make_cleanup (VEC_cleanup (static_tracepoint_marker_p
), &markers
);
4310 VEC_iterate (static_tracepoint_marker_p
,
4311 markers
, i
, marker
);
4314 print_one_static_tracepoint_marker (i
+ 1, marker
);
4315 release_static_tracepoint_marker (marker
);
4318 do_cleanups (old_chain
);
4321 /* The $_sdata convenience variable is a bit special. We don't know
4322 for sure type of the value until we actually have a chance to fetch
4323 the data --- the size of the object depends on what has been
4324 collected. We solve this by making $_sdata be an internalvar that
4325 creates a new value on access. */
4327 /* Return a new value with the correct type for the sdata object of
4328 the current trace frame. Return a void value if there's no object
4331 static struct value
*
4332 sdata_make_value (struct gdbarch
*gdbarch
, struct internalvar
*var
)
4337 /* We need to read the whole object before we know its size. */
4338 size
= target_read_alloc (¤t_target
,
4339 TARGET_OBJECT_STATIC_TRACE_DATA
,
4346 type
= init_vector_type (builtin_type (gdbarch
)->builtin_true_char
,
4348 v
= allocate_value (type
);
4349 memcpy (value_contents_raw (v
), buf
, size
);
4354 return allocate_value (builtin_type (gdbarch
)->builtin_void
);
4357 /* module initialization */
4359 _initialize_tracepoint (void)
4361 struct cmd_list_element
*c
;
4363 /* Explicitly create without lookup, since that tries to create a
4364 value with a void typed value, and when we get here, gdbarch
4365 isn't initialized yet. At this point, we're quite sure there
4366 isn't another convenience variable of the same name. */
4367 create_internalvar_type_lazy ("_sdata", sdata_make_value
);
4369 traceframe_number
= -1;
4370 tracepoint_number
= -1;
4372 if (tracepoint_list
.list
== NULL
)
4374 tracepoint_list
.listsize
= 128;
4375 tracepoint_list
.list
= xmalloc
4376 (tracepoint_list
.listsize
* sizeof (struct memrange
));
4378 if (tracepoint_list
.aexpr_list
== NULL
)
4380 tracepoint_list
.aexpr_listsize
= 128;
4381 tracepoint_list
.aexpr_list
= xmalloc
4382 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
4385 if (stepping_list
.list
== NULL
)
4387 stepping_list
.listsize
= 128;
4388 stepping_list
.list
= xmalloc
4389 (stepping_list
.listsize
* sizeof (struct memrange
));
4392 if (stepping_list
.aexpr_list
== NULL
)
4394 stepping_list
.aexpr_listsize
= 128;
4395 stepping_list
.aexpr_list
= xmalloc
4396 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
4399 add_info ("scope", scope_info
,
4400 _("List the variables local to a scope"));
4402 add_cmd ("tracepoints", class_trace
, NULL
,
4403 _("Tracing of program execution without stopping the program."),
4406 add_com ("tdump", class_trace
, trace_dump_command
,
4407 _("Print everything collected at the current tracepoint."));
4409 add_com ("tsave", class_trace
, trace_save_command
, _("\
4410 Save the trace data to a file.\n\
4411 Use the '-r' option to direct the target to save directly to the file,\n\
4412 using its own filesystem."));
4414 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
4415 Define a trace state variable.\n\
4416 Argument is a $-prefixed name, optionally followed\n\
4417 by '=' and an expression that sets the initial value\n\
4418 at the start of tracing."));
4419 set_cmd_completer (c
, expression_completer
);
4421 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
4422 Delete one or more trace state variables.\n\
4423 Arguments are the names of the variables to delete.\n\
4424 If no arguments are supplied, delete all variables."), &deletelist
);
4425 /* FIXME add a trace variable completer */
4427 add_info ("tvariables", tvariables_info
, _("\
4428 Status of trace state variables and their values.\n\
4431 add_info ("static-tracepoint-markers",
4432 info_static_tracepoint_markers_command
, _("\
4433 List target static tracepoints markers.\n\
4436 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
4437 Select a trace frame;\n\
4438 No argument means forward by one frame; '-' means backward by one frame."),
4439 &tfindlist
, "tfind ", 1, &cmdlist
);
4441 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
4442 Select a trace frame whose PC is outside the given range (exclusive).\n\
4443 Usage: tfind outside addr1, addr2"),
4446 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
4447 Select a trace frame whose PC is in the given range (inclusive).\n\
4448 Usage: tfind range addr1,addr2"),
4451 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
4452 Select a trace frame by source line.\n\
4453 Argument can be a line number (with optional source file),\n\
4454 a function name, or '*' followed by an address.\n\
4455 Default argument is 'the next source line that was traced'."),
4458 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
4459 Select a trace frame by tracepoint number.\n\
4460 Default is the tracepoint for the current trace frame."),
4463 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
4464 Select a trace frame by PC.\n\
4465 Default is the current PC, or the PC of the current trace frame."),
4468 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
4469 Synonym for 'none'.\n\
4470 De-select any trace frame and resume 'live' debugging."),
4473 add_cmd ("none", class_trace
, trace_find_none_command
,
4474 _("De-select any trace frame and resume 'live' debugging."),
4477 add_cmd ("start", class_trace
, trace_find_start_command
,
4478 _("Select the first trace frame in the trace buffer."),
4481 add_com ("tstatus", class_trace
, trace_status_command
,
4482 _("Display the status of the current trace data collection."));
4484 add_com ("tstop", class_trace
, trace_stop_command
,
4485 _("Stop trace data collection."));
4487 add_com ("tstart", class_trace
, trace_start_command
,
4488 _("Start trace data collection."));
4490 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
4491 Ends a list of commands or actions.\n\
4492 Several GDB commands allow you to enter a list of commands or actions.\n\
4493 Entering \"end\" on a line by itself is the normal way to terminate\n\
4495 Note: the \"end\" command cannot be used at the gdb prompt."));
4497 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
4498 Specify single-stepping behavior at a tracepoint.\n\
4499 Argument is number of instructions to trace in single-step mode\n\
4500 following the tracepoint. This command is normally followed by\n\
4501 one or more \"collect\" commands, to specify what to collect\n\
4502 while single-stepping.\n\n\
4503 Note: this command can only be used in a tracepoint \"actions\" list."));
4505 add_com_alias ("ws", "while-stepping", class_alias
, 0);
4506 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
4508 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
4509 Specify one or more data items to be collected at a tracepoint.\n\
4510 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4511 collect all data (variables, registers) referenced by that expression.\n\
4512 Also accepts the following special arguments:\n\
4513 $regs -- all registers.\n\
4514 $args -- all function arguments.\n\
4515 $locals -- all variables local to the block/function scope.\n\
4516 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4517 Note: this command can only be used in a tracepoint \"actions\" list."));
4519 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4520 Specify one or more expressions to be evaluated at a tracepoint.\n\
4521 Accepts a comma-separated list of (one or more) expressions.\n\
4522 The result of each evaluation will be discarded.\n\
4523 Note: this command can only be used in a tracepoint \"actions\" list."));
4525 add_com ("actions", class_trace
, trace_actions_command
, _("\
4526 Specify the actions to be taken at a tracepoint.\n\
4527 Tracepoint actions may include collecting of specified data,\n\
4528 single-stepping, or enabling/disabling other tracepoints,\n\
4529 depending on target's capabilities."));
4531 default_collect
= xstrdup ("");
4532 add_setshow_string_cmd ("default-collect", class_trace
,
4533 &default_collect
, _("\
4534 Set the list of expressions to collect by default"), _("\
4535 Show the list of expressions to collect by default"), NULL
,
4537 &setlist
, &showlist
);
4539 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4540 &disconnected_tracing
, _("\
4541 Set whether tracing continues after GDB disconnects."), _("\
4542 Show whether tracing continues after GDB disconnects."), _("\
4543 Use this to continue a tracing run even if GDB disconnects\n\
4544 or detaches from the target. You can reconnect later and look at\n\
4545 trace data collected in the meantime."),
4546 set_disconnected_tracing
,
4551 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4552 &circular_trace_buffer
, _("\
4553 Set target's use of circular trace buffer."), _("\
4554 Show target's use of circular trace buffer."), _("\
4555 Use this to make the trace buffer into a circular buffer,\n\
4556 which will discard traceframes (oldest first) instead of filling\n\
4557 up and stopping the trace run."),
4558 set_circular_trace_buffer
,
4565 add_target (&tfile_ops
);