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"
52 /* readline include files */
53 #include "readline/readline.h"
54 #include "readline/history.h"
56 /* readline defines this. */
67 extern int hex2bin (const char *hex
, gdb_byte
*bin
, int count
);
68 extern int bin2hex (const gdb_byte
*bin
, char *hex
, int count
);
70 extern void stop_tracing ();
72 /* Maximum length of an agent aexpression.
73 This accounts for the fact that packets are limited to 400 bytes
74 (which includes everything -- including the checksum), and assumes
75 the worst case of maximum length for each of the pieces of a
78 NOTE: expressions get mem2hex'ed otherwise this would be twice as
79 large. (400 - 31)/2 == 184 */
80 #define MAX_AGENT_EXPR_LEN 184
82 /* A hook used to notify the UI of tracepoint operations. */
84 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
85 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
87 extern void (*deprecated_readline_begin_hook
) (char *, ...);
88 extern char *(*deprecated_readline_hook
) (char *);
89 extern void (*deprecated_readline_end_hook
) (void);
91 /* GDB commands implemented in other modules:
94 extern void output_command (char *, int);
99 This module defines the following debugger commands:
100 trace : set a tracepoint on a function, line, or address.
101 info trace : list all debugger-defined tracepoints.
102 delete trace : delete one or more tracepoints.
103 enable trace : enable one or more tracepoints.
104 disable trace : disable one or more tracepoints.
105 actions : specify actions to be taken at a tracepoint.
106 passcount : specify a pass count for a tracepoint.
107 tstart : start a trace experiment.
108 tstop : stop a trace experiment.
109 tstatus : query the status of a trace experiment.
110 tfind : find a trace frame in the trace buffer.
111 tdump : print everything collected at the current tracepoint.
112 save-tracepoints : write tracepoint setup into a file.
114 This module defines the following user-visible debugger variables:
115 $trace_frame : sequence number of trace frame currently being debugged.
116 $trace_line : source line of trace frame currently being debugged.
117 $trace_file : source file of trace frame currently being debugged.
118 $tracepoint : tracepoint number of trace frame currently being debugged.
122 /* ======= Important global variables: ======= */
124 /* The list of all trace state variables. We don't retain pointers to
125 any of these for any reason - API is by name or number only - so it
126 works to have a vector of objects. */
128 typedef struct trace_state_variable tsv_s
;
131 static VEC(tsv_s
) *tvariables
;
133 /* The next integer to assign to a variable. */
135 static int next_tsv_number
= 1;
137 /* Number of last traceframe collected. */
138 static int traceframe_number
;
140 /* Tracepoint for last traceframe collected. */
141 static int tracepoint_number
;
143 /* Symbol for function for last traceframe collected */
144 static struct symbol
*traceframe_fun
;
146 /* Symtab and line for last traceframe collected */
147 static struct symtab_and_line traceframe_sal
;
149 /* Tracing command lists */
150 static struct cmd_list_element
*tfindlist
;
152 /* List of expressions to collect by default at each tracepoint hit. */
153 char *default_collect
= "";
155 static int disconnected_tracing
;
157 /* This variable controls whether we ask the target for a linear or
158 circular trace buffer. */
160 static int circular_trace_buffer
;
162 /* ======= Important command functions: ======= */
163 static void trace_actions_command (char *, int);
164 static void trace_start_command (char *, int);
165 static void trace_stop_command (char *, int);
166 static void trace_status_command (char *, int);
167 static void trace_find_command (char *, int);
168 static void trace_find_pc_command (char *, int);
169 static void trace_find_tracepoint_command (char *, int);
170 static void trace_find_line_command (char *, int);
171 static void trace_find_range_command (char *, int);
172 static void trace_find_outside_command (char *, int);
173 static void trace_dump_command (char *, int);
175 /* support routines */
177 struct collection_list
;
178 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
179 static char *mem2hex (gdb_byte
*, char *, int);
180 static void add_register (struct collection_list
*collection
,
183 extern void send_disconnected_tracing_value (int value
);
185 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
186 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
189 extern void _initialize_tracepoint (void);
191 static struct trace_status trace_status
;
193 char *stop_reason_names
[] = {
203 struct trace_status
*
204 current_trace_status ()
206 return &trace_status
;
209 /* Set traceframe number to NUM. */
211 set_traceframe_num (int num
)
213 traceframe_number
= num
;
214 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
217 /* Set tracepoint number to NUM. */
219 set_tracepoint_num (int num
)
221 tracepoint_number
= num
;
222 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
225 /* Set externally visible debug variables for querying/printing
226 the traceframe context (line, function, file) */
229 set_traceframe_context (struct frame_info
*trace_frame
)
233 if (trace_frame
== NULL
) /* Cease debugging any trace buffers. */
236 traceframe_sal
.pc
= traceframe_sal
.line
= 0;
237 traceframe_sal
.symtab
= NULL
;
238 clear_internalvar (lookup_internalvar ("trace_func"));
239 clear_internalvar (lookup_internalvar ("trace_file"));
240 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
244 /* Save as globals for internal use. */
245 trace_pc
= get_frame_pc (trace_frame
);
246 traceframe_sal
= find_pc_line (trace_pc
, 0);
247 traceframe_fun
= find_pc_function (trace_pc
);
249 /* Save linenumber as "$trace_line", a debugger variable visible to
251 set_internalvar_integer (lookup_internalvar ("trace_line"),
252 traceframe_sal
.line
);
254 /* Save func name as "$trace_func", a debugger variable visible to
256 if (traceframe_fun
== NULL
257 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
258 clear_internalvar (lookup_internalvar ("trace_func"));
260 set_internalvar_string (lookup_internalvar ("trace_func"),
261 SYMBOL_LINKAGE_NAME (traceframe_fun
));
263 /* Save file name as "$trace_file", a debugger variable visible to
265 if (traceframe_sal
.symtab
== NULL
266 || traceframe_sal
.symtab
->filename
== NULL
)
267 clear_internalvar (lookup_internalvar ("trace_file"));
269 set_internalvar_string (lookup_internalvar ("trace_file"),
270 traceframe_sal
.symtab
->filename
);
273 /* Create a new trace state variable with the given name. */
275 struct trace_state_variable
*
276 create_trace_state_variable (const char *name
)
278 struct trace_state_variable tsv
;
280 memset (&tsv
, 0, sizeof (tsv
));
281 tsv
.name
= xstrdup (name
);
282 tsv
.number
= next_tsv_number
++;
283 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
286 /* Look for a trace state variable of the given name. */
288 struct trace_state_variable
*
289 find_trace_state_variable (const char *name
)
291 struct trace_state_variable
*tsv
;
294 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
295 if (strcmp (name
, tsv
->name
) == 0)
302 delete_trace_state_variable (const char *name
)
304 struct trace_state_variable
*tsv
;
307 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
308 if (strcmp (name
, tsv
->name
) == 0)
310 xfree ((void *)tsv
->name
);
311 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
315 warning (_("No trace variable named \"$%s\", not deleting"), name
);
318 /* The 'tvariable' command collects a name and optional expression to
319 evaluate into an initial value. */
322 trace_variable_command (char *args
, int from_tty
)
324 struct expression
*expr
;
325 struct cleanup
*old_chain
;
326 struct internalvar
*intvar
= NULL
;
328 struct trace_state_variable
*tsv
;
331 error_no_arg (_("trace state variable name"));
333 /* All the possible valid arguments are expressions. */
334 expr
= parse_expression (args
);
335 old_chain
= make_cleanup (free_current_contents
, &expr
);
337 if (expr
->nelts
== 0)
338 error (_("No expression?"));
340 /* Only allow two syntaxes; "$name" and "$name=value". */
341 if (expr
->elts
[0].opcode
== OP_INTERNALVAR
)
343 intvar
= expr
->elts
[1].internalvar
;
345 else if (expr
->elts
[0].opcode
== BINOP_ASSIGN
346 && expr
->elts
[1].opcode
== OP_INTERNALVAR
)
348 intvar
= expr
->elts
[2].internalvar
;
349 initval
= value_as_long (evaluate_subexpression_type (expr
, 4));
352 error (_("Syntax must be $NAME [ = EXPR ]"));
355 error (_("No name given"));
357 if (strlen (internalvar_name (intvar
)) <= 0)
358 error (_("Must supply a non-empty variable name"));
360 /* If the variable already exists, just change its initial value. */
361 tsv
= find_trace_state_variable (internalvar_name (intvar
));
364 tsv
->initial_value
= initval
;
365 printf_filtered (_("Trace state variable $%s now has initial value %s.\n"),
366 tsv
->name
, plongest (tsv
->initial_value
));
370 /* Create a new variable. */
371 tsv
= create_trace_state_variable (internalvar_name (intvar
));
372 tsv
->initial_value
= initval
;
374 printf_filtered (_("Trace state variable $%s created, with initial value %s.\n"),
375 tsv
->name
, plongest (tsv
->initial_value
));
377 do_cleanups (old_chain
);
381 delete_trace_variable_command (char *args
, int from_tty
)
385 struct cleanup
*back_to
;
386 struct trace_state_variable
*tsv
;
390 if (query (_("Delete all trace state variables? ")))
391 VEC_free (tsv_s
, tvariables
);
396 argv
= gdb_buildargv (args
);
397 back_to
= make_cleanup_freeargv (argv
);
399 for (i
= 0; argv
[i
] != NULL
; i
++)
402 delete_trace_state_variable (argv
[i
] + 1);
404 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[i
]);
407 do_cleanups (back_to
);
413 tvariables_info_1 (void)
415 struct trace_state_variable
*tsv
;
418 struct cleanup
*back_to
;
420 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
422 printf_filtered (_("No trace state variables.\n"));
426 /* Try to acquire values from the target. */
427 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
428 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
431 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
432 count
, "trace-variables");
433 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
434 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
435 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
437 ui_out_table_body (uiout
);
439 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
441 struct cleanup
*back_to2
;
445 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
447 name
= concat ("$", tsv
->name
, NULL
);
448 make_cleanup (xfree
, name
);
449 ui_out_field_string (uiout
, "name", name
);
450 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
452 if (tsv
->value_known
)
453 c
= plongest (tsv
->value
);
454 else if (ui_out_is_mi_like_p (uiout
))
455 /* For MI, we prefer not to use magic string constants, but rather
456 omit the field completely. The difference between unknown and
457 undefined does not seem important enough to represent. */
459 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
460 /* The value is/was defined, but we don't have it. */
463 /* It is not meaningful to ask about the value. */
466 ui_out_field_string (uiout
, "current", c
);
467 ui_out_text (uiout
, "\n");
469 do_cleanups (back_to2
);
472 do_cleanups (back_to
);
475 /* List all the trace state variables. */
478 tvariables_info (char *args
, int from_tty
)
480 tvariables_info_1 ();
483 /* Stash definitions of tsvs into the given file. */
486 save_trace_state_variables (struct ui_file
*fp
)
488 struct trace_state_variable
*tsv
;
491 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
493 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
494 if (tsv
->initial_value
)
495 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
496 fprintf_unfiltered (fp
, "\n");
500 /* ACTIONS functions: */
502 /* The three functions:
503 collect_pseudocommand,
504 while_stepping_pseudocommand, and
505 end_actions_pseudocommand
506 are placeholders for "commands" that are actually ONLY to be used
507 within a tracepoint action list. If the actual function is ever called,
508 it means that somebody issued the "command" at the top level,
509 which is always an error. */
512 end_actions_pseudocommand (char *args
, int from_tty
)
514 error (_("This command cannot be used at the top level."));
518 while_stepping_pseudocommand (char *args
, int from_tty
)
520 error (_("This command can only be used in a tracepoint actions list."));
524 collect_pseudocommand (char *args
, int from_tty
)
526 error (_("This command can only be used in a tracepoint actions list."));
530 teval_pseudocommand (char *args
, int from_tty
)
532 error (_("This command can only be used in a tracepoint actions list."));
535 /* Enter a list of actions for a tracepoint. */
537 trace_actions_command (char *args
, int from_tty
)
539 struct breakpoint
*t
;
540 struct command_line
*l
;
542 t
= get_tracepoint_by_number (&args
, 0, 1);
546 xstrprintf ("Enter actions for tracepoint %d, one per line.",
548 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
550 l
= read_command_lines (tmpbuf
, from_tty
, 1, check_tracepoint_command
, t
);
551 do_cleanups (cleanups
);
552 breakpoint_set_commands (t
, l
);
554 /* else just return */
557 /* worker function */
559 validate_actionline (char **line
, struct breakpoint
*t
)
561 struct cmd_list_element
*c
;
562 struct expression
*exp
= NULL
;
563 struct cleanup
*old_chain
= NULL
;
565 struct bp_location
*loc
;
567 /* if EOF is typed, *line is NULL */
571 for (p
= *line
; isspace ((int) *p
);)
574 /* Symbol lookup etc. */
575 if (*p
== '\0') /* empty line: just prompt for another line. */
578 if (*p
== '#') /* comment line */
581 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
584 warning (_("'%s' is not an action that I know, or is ambiguous."),
589 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
591 struct agent_expr
*aexpr
;
592 struct agent_reqs areqs
;
595 { /* repeat over a comma-separated list */
596 QUIT
; /* allow user to bail out with ^C */
597 while (isspace ((int) *p
))
600 if (*p
== '$') /* look for special pseudo-symbols */
602 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
603 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
604 (0 == strncasecmp ("loc", p
+ 1, 3)))
609 /* else fall thru, treat p as an expression and parse it! */
612 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
615 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
616 old_chain
= make_cleanup (free_current_contents
, &exp
);
618 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
620 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
622 warning (_("constant %s (value %ld) will not be collected."),
623 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
624 SYMBOL_VALUE (exp
->elts
[2].symbol
));
627 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
629 warning (_("%s is optimized away and cannot be collected."),
630 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
635 /* We have something to collect, make sure that the expr to
636 bytecode translator can handle it and that it's not too
638 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
639 make_cleanup_free_agent_expr (aexpr
);
641 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
642 error (_("expression too complicated, try simplifying"));
644 ax_reqs (aexpr
, &areqs
);
645 (void) make_cleanup (xfree
, areqs
.reg_mask
);
647 if (areqs
.flaw
!= agent_flaw_none
)
648 error (_("malformed expression"));
650 if (areqs
.min_height
< 0)
651 error (_("gdb: Internal error: expression has min height < 0"));
653 if (areqs
.max_height
> 20)
654 error (_("expression too complicated, try simplifying"));
656 do_cleanups (old_chain
);
659 while (p
&& *p
++ == ',');
662 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
664 struct agent_expr
*aexpr
;
667 { /* repeat over a comma-separated list */
668 QUIT
; /* allow user to bail out with ^C */
669 while (isspace ((int) *p
))
673 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
676 /* Only expressions are allowed for this action. */
677 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
678 old_chain
= make_cleanup (free_current_contents
, &exp
);
680 /* We have something to evaluate, make sure that the expr to
681 bytecode translator can handle it and that it's not too
683 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
684 make_cleanup_free_agent_expr (aexpr
);
686 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
687 error (_("expression too complicated, try simplifying"));
689 do_cleanups (old_chain
);
692 while (p
&& *p
++ == ',');
695 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
697 char *steparg
; /* in case warning is necessary */
699 while (isspace ((int) *p
))
704 (t
->step_count
= strtol (p
, &p
, 0)) == 0)
706 error (_("'%s': bad step-count."), *line
);
710 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
714 error (_("'%s' is not a supported tracepoint action."), *line
);
719 memrange_absolute
= -1
724 int type
; /* memrange_absolute for absolute memory range,
725 else basereg number */
726 bfd_signed_vma start
;
730 struct collection_list
732 unsigned char regs_mask
[32]; /* room for up to 256 regs */
735 struct memrange
*list
;
736 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
738 struct agent_expr
**aexpr_list
;
741 tracepoint_list
, stepping_list
;
743 /* MEMRANGE functions: */
745 static int memrange_cmp (const void *, const void *);
747 /* compare memranges for qsort */
749 memrange_cmp (const void *va
, const void *vb
)
751 const struct memrange
*a
= va
, *b
= vb
;
753 if (a
->type
< b
->type
)
755 if (a
->type
> b
->type
)
757 if (a
->type
== memrange_absolute
)
759 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
761 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
766 if (a
->start
< b
->start
)
768 if (a
->start
> b
->start
)
774 /* Sort the memrange list using qsort, and merge adjacent memranges. */
776 memrange_sortmerge (struct collection_list
*memranges
)
780 qsort (memranges
->list
, memranges
->next_memrange
,
781 sizeof (struct memrange
), memrange_cmp
);
782 if (memranges
->next_memrange
> 0)
784 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
786 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
787 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
790 /* memrange b starts before memrange a ends; merge them. */
791 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
792 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
793 continue; /* next b, same a */
797 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
798 sizeof (struct memrange
));
800 memranges
->next_memrange
= a
+ 1;
804 /* Add a register to a collection list. */
806 add_register (struct collection_list
*collection
, unsigned int regno
)
809 printf_filtered ("collect register %d\n", regno
);
810 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
811 error (_("Internal: register number %d too large for tracepoint"),
813 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
816 /* Add a memrange to a collection list */
818 add_memrange (struct collection_list
*memranges
,
819 int type
, bfd_signed_vma base
,
824 printf_filtered ("(%d,", type
);
826 printf_filtered (",%ld)\n", len
);
829 /* type: memrange_absolute == memory, other n == basereg */
830 memranges
->list
[memranges
->next_memrange
].type
= type
;
831 /* base: addr if memory, offset if reg relative. */
832 memranges
->list
[memranges
->next_memrange
].start
= base
;
833 /* len: we actually save end (base + len) for convenience */
834 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
835 memranges
->next_memrange
++;
836 if (memranges
->next_memrange
>= memranges
->listsize
)
838 memranges
->listsize
*= 2;
839 memranges
->list
= xrealloc (memranges
->list
,
840 memranges
->listsize
);
843 if (type
!= memrange_absolute
) /* Better collect the base register! */
844 add_register (memranges
, type
);
847 /* Add a symbol to a collection list. */
849 collect_symbol (struct collection_list
*collect
,
851 struct gdbarch
*gdbarch
,
852 long frame_regno
, long frame_offset
,
857 bfd_signed_vma offset
;
858 int treat_as_expr
= 0;
860 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
861 switch (SYMBOL_CLASS (sym
))
864 printf_filtered ("%s: don't know symbol class %d\n",
865 SYMBOL_PRINT_NAME (sym
),
869 printf_filtered ("constant %s (value %ld) will not be collected.\n",
870 SYMBOL_PRINT_NAME (sym
), SYMBOL_VALUE (sym
));
873 offset
= SYMBOL_VALUE_ADDRESS (sym
);
878 sprintf_vma (tmp
, offset
);
879 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
880 SYMBOL_PRINT_NAME (sym
), len
,
883 /* A struct may be a C++ class with static fields, go to general
884 expression handling. */
885 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
888 add_memrange (collect
, memrange_absolute
, offset
, len
);
891 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
893 printf_filtered ("LOC_REG[parm] %s: ",
894 SYMBOL_PRINT_NAME (sym
));
895 add_register (collect
, reg
);
896 /* Check for doubles stored in two registers. */
897 /* FIXME: how about larger types stored in 3 or more regs? */
898 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
899 len
> register_size (gdbarch
, reg
))
900 add_register (collect
, reg
+ 1);
903 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
904 printf_filtered (" (will not collect %s)\n",
905 SYMBOL_PRINT_NAME (sym
));
909 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
912 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
913 SYMBOL_PRINT_NAME (sym
), len
);
915 printf_filtered (" from frame ptr reg %d\n", reg
);
917 add_memrange (collect
, reg
, offset
, len
);
919 case LOC_REGPARM_ADDR
:
920 reg
= SYMBOL_VALUE (sym
);
924 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
925 SYMBOL_PRINT_NAME (sym
), len
);
927 printf_filtered (" from reg %d\n", reg
);
929 add_memrange (collect
, reg
, offset
, len
);
933 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
936 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
937 SYMBOL_PRINT_NAME (sym
), len
);
939 printf_filtered (" from frame ptr reg %d\n", reg
);
941 add_memrange (collect
, reg
, offset
, len
);
948 case LOC_OPTIMIZED_OUT
:
949 printf_filtered ("%s has been optimized out of existence.\n",
950 SYMBOL_PRINT_NAME (sym
));
958 /* Expressions are the most general case. */
961 struct agent_expr
*aexpr
;
962 struct cleanup
*old_chain1
= NULL
;
963 struct agent_reqs areqs
;
965 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
967 /* It can happen that the symbol is recorded as a computed
968 location, but it's been optimized away and doesn't actually
969 have a location expression. */
972 printf_filtered ("%s has been optimized out of existence.\n",
973 SYMBOL_PRINT_NAME (sym
));
977 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
979 ax_reqs (aexpr
, &areqs
);
980 if (areqs
.flaw
!= agent_flaw_none
)
981 error (_("malformed expression"));
983 if (areqs
.min_height
< 0)
984 error (_("gdb: Internal error: expression has min height < 0"));
985 if (areqs
.max_height
> 20)
986 error (_("expression too complicated, try simplifying"));
988 discard_cleanups (old_chain1
);
989 add_aexpr (collect
, aexpr
);
991 /* take care of the registers */
992 if (areqs
.reg_mask_len
> 0)
996 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
998 QUIT
; /* allow user to bail out with ^C */
999 if (areqs
.reg_mask
[ndx1
] != 0)
1001 /* assume chars have 8 bits */
1002 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1003 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1004 /* it's used -- record it */
1005 add_register (collect
, ndx1
* 8 + ndx2
);
1012 /* Data to be passed around in the calls to the locals and args
1015 struct add_local_symbols_data
1017 struct collection_list
*collect
;
1018 struct gdbarch
*gdbarch
;
1025 /* The callback for the locals and args iterators */
1028 do_collect_symbol (const char *print_name
,
1032 struct add_local_symbols_data
*p
= cb_data
;
1034 collect_symbol (p
->collect
, sym
, p
->gdbarch
, p
->frame_regno
,
1035 p
->frame_offset
, p
->pc
);
1039 /* Add all locals (or args) symbols to collection list */
1041 add_local_symbols (struct collection_list
*collect
,
1042 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1043 long frame_regno
, long frame_offset
, int type
)
1045 struct block
*block
;
1046 struct add_local_symbols_data cb_data
;
1048 cb_data
.collect
= collect
;
1049 cb_data
.gdbarch
= gdbarch
;
1051 cb_data
.frame_regno
= frame_regno
;
1052 cb_data
.frame_offset
= frame_offset
;
1057 block
= block_for_pc (pc
);
1060 warning (_("Can't collect locals; "
1061 "no symbol table info available.\n"));
1065 iterate_over_block_local_vars (block
, do_collect_symbol
, &cb_data
);
1066 if (cb_data
.count
== 0)
1067 warning (_("No locals found in scope."));
1071 pc
= get_pc_function_start (pc
);
1072 block
= block_for_pc (pc
);
1075 warning (_("Can't collect args; no symbol table info available.\n"));
1079 iterate_over_block_arg_vars (block
, do_collect_symbol
, &cb_data
);
1080 if (cb_data
.count
== 0)
1081 warning (_("No args found in scope."));
1085 /* worker function */
1087 clear_collection_list (struct collection_list
*list
)
1091 list
->next_memrange
= 0;
1092 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1094 free_agent_expr (list
->aexpr_list
[ndx
]);
1095 list
->aexpr_list
[ndx
] = NULL
;
1097 list
->next_aexpr_elt
= 0;
1098 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1101 /* reduce a collection list to string form (for gdb protocol) */
1103 stringify_collection_list (struct collection_list
*list
, char *string
)
1105 char temp_buf
[2048];
1109 char *(*str_list
)[];
1113 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1114 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1116 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1117 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1119 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1122 printf_filtered ("\nCollecting registers (mask): 0x");
1127 QUIT
; /* allow user to bail out with ^C */
1129 printf_filtered ("%02X", list
->regs_mask
[i
]);
1130 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1133 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1137 printf_filtered ("\n");
1138 if (list
->next_memrange
> 0 && info_verbose
)
1139 printf_filtered ("Collecting memranges: \n");
1140 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1142 QUIT
; /* allow user to bail out with ^C */
1143 sprintf_vma (tmp2
, list
->list
[i
].start
);
1146 printf_filtered ("(%d, %s, %ld)\n",
1149 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1151 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1153 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1160 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1162 /* The "%X" conversion specifier expects an unsigned argument,
1163 so passing -1 (memrange_absolute) to it directly gives you
1164 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1166 if (list
->list
[i
].type
== memrange_absolute
)
1167 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1169 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1172 count
+= strlen (end
);
1173 end
= temp_buf
+ count
;
1176 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1178 QUIT
; /* allow user to bail out with ^C */
1179 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1181 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1186 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1187 end
+= 10; /* 'X' + 8 hex digits + ',' */
1190 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1191 end
, list
->aexpr_list
[i
]->len
);
1192 count
+= 2 * list
->aexpr_list
[i
]->len
;
1197 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1202 (*str_list
)[ndx
] = NULL
;
1215 encode_actions_1 (struct command_line
*action
,
1216 struct breakpoint
*t
,
1217 struct bp_location
*tloc
,
1219 LONGEST frame_offset
,
1220 struct collection_list
*collect
,
1221 struct collection_list
*stepping_list
)
1224 struct expression
*exp
= NULL
;
1225 struct command_line
*actions
;
1227 struct value
*tempval
;
1228 struct cmd_list_element
*cmd
;
1229 struct agent_expr
*aexpr
;
1231 for (; action
; action
= action
->next
)
1233 QUIT
; /* allow user to bail out with ^C */
1234 action_exp
= action
->line
;
1235 while (isspace ((int) *action_exp
))
1238 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1240 error (_("Bad action list item: %s"), action_exp
);
1242 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1245 { /* repeat over a comma-separated list */
1246 QUIT
; /* allow user to bail out with ^C */
1247 while (isspace ((int) *action_exp
))
1250 if (0 == strncasecmp ("$reg", action_exp
, 4))
1252 for (i
= 0; i
< gdbarch_num_regs (t
->gdbarch
); i
++)
1253 add_register (collect
, i
);
1254 action_exp
= strchr (action_exp
, ','); /* more? */
1256 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1258 add_local_symbols (collect
,
1264 action_exp
= strchr (action_exp
, ','); /* more? */
1266 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1268 add_local_symbols (collect
,
1274 action_exp
= strchr (action_exp
, ','); /* more? */
1278 unsigned long addr
, len
;
1279 struct cleanup
*old_chain
= NULL
;
1280 struct cleanup
*old_chain1
= NULL
;
1281 struct agent_reqs areqs
;
1283 exp
= parse_exp_1 (&action_exp
,
1284 block_for_pc (tloc
->address
), 1);
1285 old_chain
= make_cleanup (free_current_contents
, &exp
);
1287 switch (exp
->elts
[0].opcode
)
1291 const char *name
= &exp
->elts
[2].string
;
1293 i
= user_reg_map_name_to_regnum (t
->gdbarch
,
1294 name
, strlen (name
));
1296 internal_error (__FILE__
, __LINE__
,
1297 _("Register $%s not available"),
1300 printf_filtered ("OP_REGISTER: ");
1301 add_register (collect
, i
);
1306 /* safe because we know it's a simple expression */
1307 tempval
= evaluate_expression (exp
);
1308 addr
= value_address (tempval
);
1309 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1310 add_memrange (collect
, memrange_absolute
, addr
, len
);
1314 collect_symbol (collect
,
1315 exp
->elts
[2].symbol
,
1322 default: /* full-fledged expression */
1323 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1325 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1327 ax_reqs (aexpr
, &areqs
);
1328 if (areqs
.flaw
!= agent_flaw_none
)
1329 error (_("malformed expression"));
1331 if (areqs
.min_height
< 0)
1332 error (_("gdb: Internal error: expression has min height < 0"));
1333 if (areqs
.max_height
> 20)
1334 error (_("expression too complicated, try simplifying"));
1336 discard_cleanups (old_chain1
);
1337 add_aexpr (collect
, aexpr
);
1339 /* take care of the registers */
1340 if (areqs
.reg_mask_len
> 0)
1345 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1347 QUIT
; /* allow user to bail out with ^C */
1348 if (areqs
.reg_mask
[ndx1
] != 0)
1350 /* assume chars have 8 bits */
1351 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1352 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1353 /* it's used -- record it */
1354 add_register (collect
,
1361 do_cleanups (old_chain
);
1364 while (action_exp
&& *action_exp
++ == ',');
1366 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1369 { /* repeat over a comma-separated list */
1370 QUIT
; /* allow user to bail out with ^C */
1371 while (isspace ((int) *action_exp
))
1375 unsigned long addr
, len
;
1376 struct cleanup
*old_chain
= NULL
;
1377 struct cleanup
*old_chain1
= NULL
;
1378 struct agent_reqs areqs
;
1380 exp
= parse_exp_1 (&action_exp
,
1381 block_for_pc (tloc
->address
), 1);
1382 old_chain
= make_cleanup (free_current_contents
, &exp
);
1384 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1385 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1387 ax_reqs (aexpr
, &areqs
);
1388 if (areqs
.flaw
!= agent_flaw_none
)
1389 error (_("malformed expression"));
1391 if (areqs
.min_height
< 0)
1392 error (_("gdb: Internal error: expression has min height < 0"));
1393 if (areqs
.max_height
> 20)
1394 error (_("expression too complicated, try simplifying"));
1396 discard_cleanups (old_chain1
);
1397 /* Even though we're not officially collecting, add
1398 to the collect list anyway. */
1399 add_aexpr (collect
, aexpr
);
1401 do_cleanups (old_chain
);
1404 while (action_exp
&& *action_exp
++ == ',');
1406 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1408 /* We check against nested while-stepping when setting
1409 breakpoint action, so no way to run into nested
1411 gdb_assert (stepping_list
);
1413 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
, frame_offset
,
1414 stepping_list
, NULL
);
1417 error (_("Invalid tracepoint command '%s'"), action
->line
);
1421 /* Render all actions into gdb protocol. */
1423 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1424 char ***tdp_actions
, char ***stepping_actions
)
1426 static char tdp_buff
[2048], step_buff
[2048];
1427 char *default_collect_line
= NULL
;
1428 struct command_line
*actions
;
1429 struct command_line
*default_collect_action
= NULL
;
1431 LONGEST frame_offset
;
1432 struct cleanup
*back_to
;
1434 back_to
= make_cleanup (null_cleanup
, NULL
);
1436 clear_collection_list (&tracepoint_list
);
1437 clear_collection_list (&stepping_list
);
1439 *tdp_actions
= NULL
;
1440 *stepping_actions
= NULL
;
1442 gdbarch_virtual_frame_pointer (t
->gdbarch
,
1443 t
->loc
->address
, &frame_reg
, &frame_offset
);
1445 actions
= t
->commands
->commands
;
1447 /* If there are default expressions to collect, make up a collect
1448 action and prepend to the action list to encode. Note that since
1449 validation is per-tracepoint (local var "xyz" might be valid for
1450 one tracepoint and not another, etc), we make up the action on
1451 the fly, and don't cache it. */
1452 if (*default_collect
)
1455 enum actionline_type linetype
;
1457 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1458 make_cleanup (xfree
, default_collect_line
);
1460 line
= default_collect_line
;
1461 linetype
= validate_actionline (&line
, t
);
1462 if (linetype
!= BADLINE
)
1464 default_collect_action
= xmalloc (sizeof (struct command_line
));
1465 make_cleanup (xfree
, default_collect_action
);
1466 default_collect_action
->next
= t
->commands
->commands
;
1467 default_collect_action
->line
= line
;
1468 actions
= default_collect_action
;
1471 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1472 &tracepoint_list
, &stepping_list
);
1474 memrange_sortmerge (&tracepoint_list
);
1475 memrange_sortmerge (&stepping_list
);
1477 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1479 *stepping_actions
= stringify_collection_list (&stepping_list
,
1482 do_cleanups (back_to
);
1486 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1488 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1490 collect
->aexpr_list
=
1491 xrealloc (collect
->aexpr_list
,
1492 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1493 collect
->aexpr_listsize
*= 2;
1495 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1496 collect
->next_aexpr_elt
++;
1501 start_tracing (void)
1504 VEC(breakpoint_p
) *tp_vec
= NULL
;
1506 struct breakpoint
*t
;
1507 struct trace_state_variable
*tsv
;
1508 int any_enabled
= 0;
1510 tp_vec
= all_tracepoints ();
1512 /* No point in tracing without any tracepoints... */
1513 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1515 VEC_free (breakpoint_p
, tp_vec
);
1516 error (_("No tracepoints defined, not starting trace"));
1519 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1521 if (t
->enable_state
== bp_enabled
)
1528 /* No point in tracing with only disabled tracepoints. */
1531 VEC_free (breakpoint_p
, tp_vec
);
1532 error (_("No tracepoints enabled, not starting trace"));
1535 target_trace_init ();
1537 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1539 t
->number_on_target
= 0;
1540 target_download_tracepoint (t
);
1541 t
->number_on_target
= t
->number
;
1543 VEC_free (breakpoint_p
, tp_vec
);
1545 /* Send down all the trace state variables too. */
1546 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1548 target_download_trace_state_variable (tsv
);
1551 /* Tell target to treat text-like sections as transparent. */
1552 target_trace_set_readonly_regions ();
1553 /* Set some mode flags. */
1554 target_set_disconnected_tracing (disconnected_tracing
);
1555 target_set_circular_trace_buffer (circular_trace_buffer
);
1557 /* Now insert traps and begin collecting data. */
1558 target_trace_start ();
1560 /* Reset our local state. */
1561 set_traceframe_num (-1);
1562 set_tracepoint_num (-1);
1563 set_traceframe_context (NULL
);
1564 current_trace_status()->running
= 1;
1569 Tell target to clear any previous trace experiment.
1570 Walk the list of tracepoints, and send them (and their actions)
1571 to the target. If no errors,
1572 Tell target to start a new trace experiment. */
1575 trace_start_command (char *args
, int from_tty
)
1577 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1584 trace_stop_command (char *args
, int from_tty
)
1592 target_trace_stop ();
1593 /* should change in response to reply? */
1594 current_trace_status ()->running
= 0;
1597 /* tstatus command */
1599 trace_status_command (char *args
, int from_tty
)
1601 struct trace_status
*ts
= current_trace_status ();
1604 status
= target_get_trace_status (ts
);
1609 printf_filtered (_("Using a trace file.\n"));
1612 printf_filtered (_("Trace can not be run on this target.\n"));
1617 if (!ts
->running_known
)
1619 printf_filtered (_("Run/stop status is unknown.\n"));
1621 else if (ts
->running
)
1623 printf_filtered (_("Trace is running on the target.\n"));
1624 if (disconnected_tracing
)
1625 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1627 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1631 switch (ts
->stop_reason
)
1633 case trace_never_run
:
1634 printf_filtered (_("No trace has been run on the target.\n"));
1637 printf_filtered (_("Trace stopped by a tstop command.\n"));
1639 case trace_buffer_full
:
1640 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1642 case trace_disconnected
:
1643 printf_filtered (_("Trace stopped because of disconnection.\n"));
1645 case tracepoint_passcount
:
1646 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1647 ts
->stopping_tracepoint
);
1649 case tracepoint_error
:
1650 if (ts
->stopping_tracepoint
)
1651 printf_filtered (_("Trace stopped by an error (%s, tracepoint %d).\n"),
1652 ts
->error_desc
, ts
->stopping_tracepoint
);
1654 printf_filtered (_("Trace stopped by an error (%s).\n"),
1657 case trace_stop_reason_unknown
:
1658 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1661 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1667 if (ts
->traceframes_created
>= 0
1668 && ts
->traceframe_count
!= ts
->traceframes_created
)
1670 printf_filtered (_("Buffer contains %d trace frames (of %d created total).\n"),
1671 ts
->traceframe_count
, ts
->traceframes_created
);
1673 else if (ts
->traceframe_count
>= 0)
1675 printf_filtered (_("Collected %d trace frames.\n"),
1676 ts
->traceframe_count
);
1679 if (ts
->buffer_free
>= 0)
1681 if (ts
->buffer_size
>= 0)
1683 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1684 ts
->buffer_free
, ts
->buffer_size
);
1685 if (ts
->buffer_size
> 0)
1686 printf_filtered (_(" (%d%% full)"),
1687 ((int) ((((long long) (ts
->buffer_size
1688 - ts
->buffer_free
)) * 100)
1689 / ts
->buffer_size
)));
1690 printf_filtered (_(".\n"));
1693 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1697 /* Now report on what we're doing with tfind. */
1698 if (traceframe_number
>= 0)
1699 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1700 traceframe_number
, tracepoint_number
);
1702 printf_filtered (_("Not looking at any trace frame.\n"));
1705 /* Report the trace status to uiout, in a way suitable for MI, and not
1706 suitable for CLI. If ON_STOP is true, suppress a few fields that
1707 are not meaningful in the -trace-stop response.
1709 The implementation is essentially parallel to trace_status_command, but
1710 merging them will result in unreadable code. */
1712 trace_status_mi (int on_stop
)
1714 struct trace_status
*ts
= current_trace_status ();
1716 char *string_status
;
1718 status
= target_get_trace_status (ts
);
1720 if (status
== -1 && !ts
->from_file
)
1722 ui_out_field_string (uiout
, "supported", "0");
1727 ui_out_field_string (uiout
, "supported", "file");
1729 ui_out_field_string (uiout
, "supported", "1");
1731 gdb_assert (ts
->running_known
);
1735 ui_out_field_string (uiout
, "running", "1");
1737 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1738 Given that the frontend gets the status either on -trace-stop, or from
1739 -trace-status after re-connection, it does not seem like this
1740 information is necessary for anything. It is not necessary for either
1741 figuring the vital state of the target nor for navigation of trace
1742 frames. If the frontend wants to show the current state is some
1743 configure dialog, it can request the value when such dialog is
1744 invoked by the user. */
1748 char *stop_reason
= NULL
;
1749 int stopping_tracepoint
= -1;
1752 ui_out_field_string (uiout
, "running", "0");
1754 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
1756 switch (ts
->stop_reason
)
1759 stop_reason
= "request";
1761 case trace_buffer_full
:
1762 stop_reason
= "overflow";
1764 case trace_disconnected
:
1765 stop_reason
= "disconnection";
1767 case tracepoint_passcount
:
1768 stop_reason
= "passcount";
1769 stopping_tracepoint
= ts
->stopping_tracepoint
;
1771 case tracepoint_error
:
1772 stop_reason
= "error";
1773 stopping_tracepoint
= ts
->stopping_tracepoint
;
1779 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
1780 if (stopping_tracepoint
!= -1)
1781 ui_out_field_int (uiout
, "stopping-tracepoint",
1782 stopping_tracepoint
);
1783 if (ts
->stop_reason
== tracepoint_error
)
1784 ui_out_field_string (uiout
, "error-description",
1791 if ((int) ts
->traceframe_count
!= -1)
1792 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
1793 if ((int) ts
->buffer_size
!= -1)
1794 ui_out_field_int (uiout
, "buffer-size", (int) ts
->buffer_size
);
1795 if ((int) ts
->buffer_free
!= -1)
1796 ui_out_field_int (uiout
, "buffer-free", (int) ts
->buffer_free
);
1801 disconnect_or_stop_tracing (int from_tty
)
1803 /* It can happen that the target that was tracing went away on its
1804 own, and we didn't notice. Get a status update, and if the
1805 current target doesn't even do tracing, then assume it's not
1807 if (target_get_trace_status (current_trace_status ()) < 0)
1808 current_trace_status ()->running
= 0;
1810 if (current_trace_status ()->running
&& from_tty
)
1812 int cont
= query (_("Trace is running. Continue tracing after detach? "));
1813 /* Note that we send the query result without affecting the
1814 user's setting of disconnected_tracing, so that the answer is
1816 send_disconnected_tracing_value (cont
);
1818 /* Also ensure that we do the equivalent of a tstop command if
1819 tracing is not to continue after the detach. */
1824 /* Also we want to be out of tfind mode, otherwise things can get
1825 confusing upon reconnection. Just use these calls instead of
1826 full tfind_1 behavior because we're in the middle of detaching,
1827 and there's no point to updating current stack frame etc. */
1828 set_traceframe_number (-1);
1829 set_traceframe_context (NULL
);
1832 /* Worker function for the various flavors of the tfind command. */
1834 tfind_1 (enum trace_find_type type
, int num
,
1835 ULONGEST addr1
, ULONGEST addr2
,
1838 int target_frameno
= -1, target_tracept
= -1;
1839 struct frame_id old_frame_id
;
1841 struct breakpoint
*tp
;
1843 old_frame_id
= get_frame_id (get_current_frame ());
1845 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
1848 if (type
== tfind_number
1850 && target_frameno
== -1)
1852 /* We told the target to get out of tfind mode, and it did. */
1854 else if (target_frameno
== -1)
1856 /* A request for a non-existant trace frame has failed.
1857 Our response will be different, depending on FROM_TTY:
1859 If FROM_TTY is true, meaning that this command was
1860 typed interactively by the user, then give an error
1861 and DO NOT change the state of traceframe_number etc.
1863 However if FROM_TTY is false, meaning that we're either
1864 in a script, a loop, or a user-defined command, then
1865 DON'T give an error, but DO change the state of
1866 traceframe_number etc. to invalid.
1868 The rationalle is that if you typed the command, you
1869 might just have committed a typo or something, and you'd
1870 like to NOT lose your current debugging state. However
1871 if you're in a user-defined command or especially in a
1872 loop, then you need a way to detect that the command
1873 failed WITHOUT aborting. This allows you to write
1874 scripts that search thru the trace buffer until the end,
1875 and then continue on to do something else. */
1878 error (_("Target failed to find requested trace frame."));
1882 printf_filtered ("End of trace buffer.\n");
1883 #if 0 /* dubious now? */
1884 /* The following will not recurse, since it's
1886 trace_find_command ("-1", from_tty
);
1891 tp
= get_tracepoint_by_number_on_target (target_tracept
);
1893 reinit_frame_cache ();
1894 registers_changed ();
1895 target_dcache_invalidate ();
1896 set_traceframe_num (target_frameno
);
1897 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
1898 if (target_frameno
== -1)
1899 set_traceframe_context (NULL
);
1901 set_traceframe_context (get_current_frame ());
1903 if (traceframe_number
>= 0)
1905 /* Use different branches for MI and CLI to make CLI messages
1907 if (ui_out_is_mi_like_p (uiout
))
1909 ui_out_field_string (uiout
, "found", "1");
1910 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
1911 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
1915 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
1916 traceframe_number
, tracepoint_number
);
1921 if (ui_out_is_mi_like_p (uiout
))
1922 ui_out_field_string (uiout
, "found", "0");
1924 printf_unfiltered (_("No trace frame found"));
1927 /* If we're in nonstop mode and getting out of looking at trace
1928 frames, there won't be any current frame to go back to and
1931 && (has_stack_frames () || traceframe_number
>= 0))
1933 enum print_what print_what
;
1935 /* NOTE: in immitation of the step command, try to determine
1936 whether we have made a transition from one function to
1937 another. If so, we'll print the "stack frame" (ie. the new
1938 function and it's arguments) -- otherwise we'll just show the
1941 if (frame_id_eq (old_frame_id
,
1942 get_frame_id (get_current_frame ())))
1943 print_what
= SRC_LINE
;
1945 print_what
= SRC_AND_LOC
;
1947 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
1952 /* trace_find_command takes a trace frame number n,
1953 sends "QTFrame:<n>" to the target,
1954 and accepts a reply that may contain several optional pieces
1955 of information: a frame number, a tracepoint number, and an
1956 indication of whether this is a trap frame or a stepping frame.
1958 The minimal response is just "OK" (which indicates that the
1959 target does not give us a frame number or a tracepoint number).
1960 Instead of that, the target may send us a string containing
1962 F<hexnum> (gives the selected frame number)
1963 T<hexnum> (gives the selected tracepoint number)
1968 trace_find_command (char *args
, int from_tty
)
1969 { /* this should only be called with a numeric argument */
1972 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1973 error ("May not look at trace frames while trace is running.");
1975 if (args
== 0 || *args
== 0)
1976 { /* TFIND with no args means find NEXT trace frame. */
1977 if (traceframe_number
== -1)
1978 frameno
= 0; /* "next" is first one */
1980 frameno
= traceframe_number
+ 1;
1982 else if (0 == strcmp (args
, "-"))
1984 if (traceframe_number
== -1)
1985 error (_("not debugging trace buffer"));
1986 else if (from_tty
&& traceframe_number
== 0)
1987 error (_("already at start of trace buffer"));
1989 frameno
= traceframe_number
- 1;
1991 /* A hack to work around eval's need for fp to have been collected. */
1992 else if (0 == strcmp (args
, "-1"))
1995 frameno
= parse_and_eval_long (args
);
1998 error (_("invalid input (%d is less than zero)"), frameno
);
2000 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
2005 trace_find_end_command (char *args
, int from_tty
)
2007 trace_find_command ("-1", from_tty
);
2012 trace_find_none_command (char *args
, int from_tty
)
2014 trace_find_command ("-1", from_tty
);
2019 trace_find_start_command (char *args
, int from_tty
)
2021 trace_find_command ("0", from_tty
);
2024 /* tfind pc command */
2026 trace_find_pc_command (char *args
, int from_tty
)
2031 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2032 error ("May not look at trace frames while trace is running.");
2034 if (args
== 0 || *args
== 0)
2035 pc
= regcache_read_pc (get_current_regcache ());
2037 pc
= parse_and_eval_address (args
);
2039 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2042 /* tfind tracepoint command */
2044 trace_find_tracepoint_command (char *args
, int from_tty
)
2047 struct breakpoint
*tp
;
2049 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2050 error ("May not look at trace frames while trace is running.");
2052 if (args
== 0 || *args
== 0)
2054 if (tracepoint_number
== -1)
2055 error (_("No current tracepoint -- please supply an argument."));
2057 tdp
= tracepoint_number
; /* default is current TDP */
2060 tdp
= parse_and_eval_long (args
);
2062 /* If we have the tracepoint on hand, use the number that the
2063 target knows about (which may be different if we disconnected
2064 and reconnected). */
2065 tp
= get_tracepoint (tdp
);
2067 tdp
= tp
->number_on_target
;
2069 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2072 /* TFIND LINE command:
2074 This command will take a sourceline for argument, just like BREAK
2075 or TRACE (ie. anything that "decode_line_1" can handle).
2077 With no argument, this command will find the next trace frame
2078 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2081 trace_find_line_command (char *args
, int from_tty
)
2083 static CORE_ADDR start_pc
, end_pc
;
2084 struct symtabs_and_lines sals
;
2085 struct symtab_and_line sal
;
2086 struct cleanup
*old_chain
;
2087 char startpc_str
[40], endpc_str
[40];
2089 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2090 error ("May not look at trace frames while trace is running.");
2092 if (args
== 0 || *args
== 0)
2094 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2096 sals
.sals
= (struct symtab_and_line
*)
2097 xmalloc (sizeof (struct symtab_and_line
));
2102 sals
= decode_line_spec (args
, 1);
2106 old_chain
= make_cleanup (xfree
, sals
.sals
);
2107 if (sal
.symtab
== 0)
2108 error (_("No line number information available."));
2110 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2112 if (start_pc
== end_pc
)
2114 printf_filtered ("Line %d of \"%s\"",
2115 sal
.line
, sal
.symtab
->filename
);
2117 printf_filtered (" is at address ");
2118 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2120 printf_filtered (" but contains no code.\n");
2121 sal
= find_pc_line (start_pc
, 0);
2123 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2124 && start_pc
!= end_pc
)
2125 printf_filtered ("Attempting to find line %d instead.\n",
2128 error (_("Cannot find a good line."));
2132 /* Is there any case in which we get here, and have an address
2133 which the user would want to see? If we have debugging
2134 symbols and no line numbers? */
2135 error (_("Line number %d is out of range for \"%s\"."),
2136 sal
.line
, sal
.symtab
->filename
);
2138 /* Find within range of stated line. */
2140 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2142 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2143 do_cleanups (old_chain
);
2146 /* tfind range command */
2148 trace_find_range_command (char *args
, int from_tty
)
2150 static CORE_ADDR start
, stop
;
2151 char start_str
[40], stop_str
[40];
2154 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2155 error ("May not look at trace frames while trace is running.");
2157 if (args
== 0 || *args
== 0)
2158 { /* XXX FIXME: what should default behavior be? */
2159 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2163 if (0 != (tmp
= strchr (args
, ',')))
2165 *tmp
++ = '\0'; /* terminate start address */
2166 while (isspace ((int) *tmp
))
2168 start
= parse_and_eval_address (args
);
2169 stop
= parse_and_eval_address (tmp
);
2172 { /* no explicit end address? */
2173 start
= parse_and_eval_address (args
);
2174 stop
= start
+ 1; /* ??? */
2177 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2180 /* tfind outside command */
2182 trace_find_outside_command (char *args
, int from_tty
)
2184 CORE_ADDR start
, stop
;
2185 char start_str
[40], stop_str
[40];
2188 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2189 error ("May not look at trace frames while trace is running.");
2191 if (args
== 0 || *args
== 0)
2192 { /* XXX FIXME: what should default behavior be? */
2193 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2197 if (0 != (tmp
= strchr (args
, ',')))
2199 *tmp
++ = '\0'; /* terminate start address */
2200 while (isspace ((int) *tmp
))
2202 start
= parse_and_eval_address (args
);
2203 stop
= parse_and_eval_address (tmp
);
2206 { /* no explicit end address? */
2207 start
= parse_and_eval_address (args
);
2208 stop
= start
+ 1; /* ??? */
2211 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2214 /* info scope command: list the locals for a scope. */
2216 scope_info (char *args
, int from_tty
)
2218 struct symtabs_and_lines sals
;
2220 struct minimal_symbol
*msym
;
2221 struct block
*block
;
2222 char **canonical
, *symname
, *save_args
= args
;
2223 struct dict_iterator iter
;
2225 struct gdbarch
*gdbarch
;
2228 if (args
== 0 || *args
== 0)
2229 error (_("requires an argument (function, line or *addr) to define a scope"));
2231 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2232 if (sals
.nelts
== 0)
2233 return; /* presumably decode_line_1 has already warned */
2235 /* Resolve line numbers to PC */
2236 resolve_sal_pc (&sals
.sals
[0]);
2237 block
= block_for_pc (sals
.sals
[0].pc
);
2241 QUIT
; /* allow user to bail out with ^C */
2242 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2244 QUIT
; /* allow user to bail out with ^C */
2246 printf_filtered ("Scope for %s:\n", save_args
);
2249 symname
= SYMBOL_PRINT_NAME (sym
);
2250 if (symname
== NULL
|| *symname
== '\0')
2251 continue; /* probably botched, certainly useless */
2253 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2255 printf_filtered ("Symbol %s is ", symname
);
2256 switch (SYMBOL_CLASS (sym
))
2259 case LOC_UNDEF
: /* messed up symbol? */
2260 printf_filtered ("a bogus symbol, class %d.\n",
2261 SYMBOL_CLASS (sym
));
2262 count
--; /* don't count this one */
2265 printf_filtered ("a constant with value %ld (0x%lx)",
2266 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2268 case LOC_CONST_BYTES
:
2269 printf_filtered ("constant bytes: ");
2270 if (SYMBOL_TYPE (sym
))
2271 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2272 fprintf_filtered (gdb_stdout
, " %02x",
2273 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2276 printf_filtered ("in static storage at address ");
2277 printf_filtered ("%s", paddress (gdbarch
,
2278 SYMBOL_VALUE_ADDRESS (sym
)));
2281 /* GDBARCH is the architecture associated with the objfile
2282 the symbol is defined in; the target architecture may be
2283 different, and may provide additional registers. However,
2284 we do not know the target architecture at this point.
2285 We assume the objfile architecture will contain all the
2286 standard registers that occur in debug info in that
2288 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2290 if (SYMBOL_IS_ARGUMENT (sym
))
2291 printf_filtered ("an argument in register $%s",
2292 gdbarch_register_name (gdbarch
, regno
));
2294 printf_filtered ("a local variable in register $%s",
2295 gdbarch_register_name (gdbarch
, regno
));
2298 printf_filtered ("an argument at stack/frame offset %ld",
2299 SYMBOL_VALUE (sym
));
2302 printf_filtered ("a local variable at frame offset %ld",
2303 SYMBOL_VALUE (sym
));
2306 printf_filtered ("a reference argument at offset %ld",
2307 SYMBOL_VALUE (sym
));
2309 case LOC_REGPARM_ADDR
:
2310 /* Note comment at LOC_REGISTER. */
2311 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2312 printf_filtered ("the address of an argument, in register $%s",
2313 gdbarch_register_name (gdbarch
, regno
));
2316 printf_filtered ("a typedef.\n");
2319 printf_filtered ("a label at address ");
2320 printf_filtered ("%s", paddress (gdbarch
,
2321 SYMBOL_VALUE_ADDRESS (sym
)));
2324 printf_filtered ("a function at address ");
2325 printf_filtered ("%s",
2326 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2328 case LOC_UNRESOLVED
:
2329 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2332 printf_filtered ("Unresolved Static");
2335 printf_filtered ("static storage at address ");
2336 printf_filtered ("%s",
2337 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2340 case LOC_OPTIMIZED_OUT
:
2341 printf_filtered ("optimized out.\n");
2344 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, gdb_stdout
);
2347 if (SYMBOL_TYPE (sym
))
2348 printf_filtered (", length %d.\n",
2349 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2351 if (BLOCK_FUNCTION (block
))
2354 block
= BLOCK_SUPERBLOCK (block
);
2357 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2361 /* worker function (cleanup) */
2363 replace_comma (void *data
)
2371 trace_dump_command (char *args
, int from_tty
)
2373 struct regcache
*regcache
;
2374 struct gdbarch
*gdbarch
;
2375 struct breakpoint
*t
;
2376 struct command_line
*action
;
2377 char *action_exp
, *next_comma
;
2378 struct cleanup
*old_cleanups
;
2379 int stepping_actions
= 0;
2380 int stepping_frame
= 0;
2381 struct bp_location
*loc
;
2383 if (tracepoint_number
== -1)
2385 warning (_("No current trace frame."));
2389 t
= get_tracepoint (tracepoint_number
);
2392 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2395 old_cleanups
= make_cleanup (null_cleanup
, NULL
);
2397 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2398 tracepoint_number
, traceframe_number
);
2400 /* The current frame is a trap frame if the frame PC is equal
2401 to the tracepoint PC. If not, then the current frame was
2402 collected during single-stepping. */
2404 regcache
= get_current_regcache ();
2405 gdbarch
= get_regcache_arch (regcache
);
2407 /* If the traceframe's address matches any of the tracepoint's
2408 locations, assume it is a direct hit rather than a while-stepping
2409 frame. (FIXME this is not reliable, should record each frame's
2412 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2413 if (loc
->address
== regcache_read_pc (regcache
))
2416 for (action
= t
->commands
->commands
; action
; action
= action
->next
)
2418 struct cmd_list_element
*cmd
;
2420 QUIT
; /* allow user to bail out with ^C */
2421 action_exp
= action
->line
;
2422 while (isspace ((int) *action_exp
))
2425 /* The collection actions to be done while stepping are
2426 bracketed by the commands "while-stepping" and "end". */
2428 if (*action_exp
== '#') /* comment line */
2431 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2433 error (_("Bad action list item: %s"), action_exp
);
2435 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2436 stepping_actions
= 1;
2437 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2438 stepping_actions
= 0;
2439 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2441 /* Display the collected data.
2442 For the trap frame, display only what was collected at
2443 the trap. Likewise for stepping frames, display only
2444 what was collected while stepping. This means that the
2445 two boolean variables, STEPPING_FRAME and
2446 STEPPING_ACTIONS should be equal. */
2447 if (stepping_frame
== stepping_actions
)
2450 { /* repeat over a comma-separated list */
2451 QUIT
; /* allow user to bail out with ^C */
2452 if (*action_exp
== ',')
2454 while (isspace ((int) *action_exp
))
2457 next_comma
= strchr (action_exp
, ',');
2459 if (0 == strncasecmp (action_exp
, "$reg", 4))
2460 registers_info (NULL
, from_tty
);
2461 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2462 locals_info (NULL
, from_tty
);
2463 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2464 args_info (NULL
, from_tty
);
2469 make_cleanup (replace_comma
, next_comma
);
2472 printf_filtered ("%s = ", action_exp
);
2473 output_command (action_exp
, from_tty
);
2474 printf_filtered ("\n");
2478 action_exp
= next_comma
;
2480 while (action_exp
&& *action_exp
== ',');
2484 discard_cleanups (old_cleanups
);
2487 /* Encode a piece of a tracepoint's source-level definition in a form
2488 that is suitable for both protocol and saving in files. */
2489 /* This version does not do multiple encodes for long strings; it should
2490 return an offset to the next piece to encode. FIXME */
2493 encode_source_string (int tpnum
, ULONGEST addr
,
2494 char *srctype
, char *src
, char *buf
, int buf_size
)
2496 if (80 + strlen (srctype
) > buf_size
)
2497 error (_("Buffer too small for source encoding"));
2498 sprintf (buf
, "%x:%s:%s:%x:%x:",
2499 tpnum
, phex_nz (addr
, sizeof (addr
)), srctype
, 0, (int) strlen (src
));
2500 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2501 error (_("Source string too long for buffer"));
2502 bin2hex (src
, buf
+ strlen (buf
), 0);
2506 extern int trace_regblock_size
;
2508 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2509 non-zero, the save is performed on the target, otherwise GDB obtains all
2510 trace data and saves it locally. */
2513 trace_save (const char *filename
, int target_does_save
)
2515 struct cleanup
*cleanup
;
2517 struct trace_status
*ts
= current_trace_status ();
2520 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2521 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2523 struct uploaded_string
*cmd
;
2525 ULONGEST offset
= 0;
2526 #define MAX_TRACE_UPLOAD 2000
2527 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2530 /* If the target is to save the data to a file on its own, then just
2531 send the command and be done with it. */
2532 if (target_does_save
)
2534 err
= target_save_trace_data (filename
);
2536 error (_("Target failed to save trace data to '%s'."),
2541 /* Get the trace status first before opening the file, so if the
2542 target is losing, we can get out without touching files. */
2543 status
= target_get_trace_status (ts
);
2545 pathname
= tilde_expand (filename
);
2546 cleanup
= make_cleanup (xfree
, pathname
);
2548 fp
= fopen (pathname
, "w");
2550 error (_("Unable to open file '%s' for saving trace data (%s)"),
2551 filename
, safe_strerror (errno
));
2552 make_cleanup_fclose (fp
);
2554 /* Write a file header, with a high-bit-set char to indicate a
2555 binary file, plus a hint as what this file is, and a version
2556 number in case of future needs. */
2557 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2559 perror_with_name (pathname
);
2561 /* Write descriptive info. */
2563 /* Write out the size of a register block. */
2564 fprintf (fp
, "R %x\n", trace_regblock_size
);
2566 /* Write out status of the tracing run (aka "tstatus" info). */
2567 fprintf (fp
, "status %c;%s",
2568 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
2569 if (ts
->stop_reason
== tracepoint_error
)
2571 char *buf
= (char *) alloca (strlen (ts
->error_desc
) * 2 + 1);
2572 bin2hex ((gdb_byte
*) ts
->error_desc
, buf
, 0);
2573 fprintf (fp
, ":%s", buf
);
2575 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
2576 if (ts
->traceframe_count
>= 0)
2577 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
2578 if (ts
->traceframes_created
>= 0)
2579 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
2580 if (ts
->buffer_free
>= 0)
2581 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
2582 if (ts
->buffer_size
>= 0)
2583 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
2586 /* Note that we want to upload tracepoints and save those, rather
2587 than simply writing out the local ones, because the user may have
2588 changed tracepoints in GDB in preparation for a future tracing
2589 run, or maybe just mass-deleted all types of breakpoints as part
2590 of cleaning up. So as not to contaminate the session, leave the
2591 data in its uploaded form, don't make into real tracepoints. */
2593 /* Get trace state variables first, they may be checked when parsing
2594 uploaded commands. */
2596 target_upload_trace_state_variables (&uploaded_tsvs
);
2598 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2604 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
2605 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
2608 fprintf (fp
, "tsv %x:%s:%x:%s\n",
2609 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
2610 utsv
->builtin
, buf
);
2616 free_uploaded_tsvs (&uploaded_tsvs
);
2618 target_upload_tracepoints (&uploaded_tps
);
2620 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
2622 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
2623 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2624 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
2625 if (utp
->type
== bp_fast_tracepoint
)
2626 fprintf (fp
, ":F%x", utp
->orig_size
);
2628 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
2631 for (a
= 0; a
< utp
->numactions
; ++a
)
2632 fprintf (fp
, "tp A%x:%s:%s\n",
2633 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2635 for (a
= 0; a
< utp
->num_step_actions
; ++a
)
2636 fprintf (fp
, "tp S%x:%s:%s\n",
2637 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2638 utp
->step_actions
[a
]);
2641 encode_source_string (utp
->number
, utp
->addr
,
2642 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
2643 fprintf (fp
, "tp Z%s\n", buf
);
2645 if (utp
->cond_string
)
2647 encode_source_string (utp
->number
, utp
->addr
,
2648 "cond", utp
->cond_string
, buf
, MAX_TRACE_UPLOAD
);
2649 fprintf (fp
, "tp Z%s\n", buf
);
2651 for (cmd
= utp
->cmd_strings
; cmd
; cmd
= cmd
->next
)
2653 encode_source_string (utp
->number
, utp
->addr
, "cmd", cmd
->str
,
2654 buf
, MAX_TRACE_UPLOAD
);
2655 fprintf (fp
, "tp Z%s\n", buf
);
2659 free_uploaded_tps (&uploaded_tps
);
2661 /* Mark the end of the definition section. */
2664 /* Get and write the trace data proper. We ask for big blocks, in
2665 the hopes of efficiency, but will take less if the target has
2666 packet size limitations or some such. */
2669 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
2671 error (_("Failure to get requested trace buffer data"));
2672 /* No more data is forthcoming, we're done. */
2675 written
= fwrite (buf
, gotten
, 1, fp
);
2677 perror_with_name (pathname
);
2681 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
2682 written
= fwrite (&gotten
, 4, 1, fp
);
2684 perror_with_name (pathname
);
2686 do_cleanups (cleanup
);
2690 trace_save_command (char *args
, int from_tty
)
2692 int target_does_save
= 0;
2694 char *filename
= NULL
;
2695 struct cleanup
*back_to
;
2698 error_no_arg (_("file in which to save trace data"));
2700 argv
= gdb_buildargv (args
);
2701 back_to
= make_cleanup_freeargv (argv
);
2703 for (; *argv
; ++argv
)
2705 if (strcmp (*argv
, "-r") == 0)
2706 target_does_save
= 1;
2707 else if (**argv
== '-')
2708 error (_("unknown option `%s'"), *argv
);
2714 error_no_arg (_("file in which to save trace data"));
2716 trace_save (filename
, target_does_save
);
2719 printf_filtered (_("Trace data saved to file '%s'.\n"), args
);
2721 do_cleanups (back_to
);
2724 /* Tell the target what to do with an ongoing tracing run if GDB
2725 disconnects for some reason. */
2728 send_disconnected_tracing_value (int value
)
2730 target_set_disconnected_tracing (value
);
2734 set_disconnected_tracing (char *args
, int from_tty
,
2735 struct cmd_list_element
*c
)
2737 send_disconnected_tracing_value (disconnected_tracing
);
2741 set_circular_trace_buffer (char *args
, int from_tty
,
2742 struct cmd_list_element
*c
)
2744 target_set_circular_trace_buffer (circular_trace_buffer
);
2747 /* Convert the memory pointed to by mem into hex, placing result in buf.
2748 * Return a pointer to the last char put in buf (null)
2749 * "stolen" from sparc-stub.c
2752 static const char hexchars
[] = "0123456789abcdef";
2755 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2763 *buf
++ = hexchars
[ch
>> 4];
2764 *buf
++ = hexchars
[ch
& 0xf];
2773 get_traceframe_number (void)
2775 return traceframe_number
;
2778 /* Make the traceframe NUM be the current trace frame. Does nothing
2779 if NUM is already current. */
2782 set_traceframe_number (int num
)
2786 if (traceframe_number
== num
)
2788 /* Nothing to do. */
2792 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
2795 warning (_("could not change traceframe"));
2797 traceframe_number
= newnum
;
2799 /* Changing the traceframe changes our view of registers and of the
2801 registers_changed ();
2804 /* A cleanup used when switching away and back from tfind mode. */
2806 struct current_traceframe_cleanup
2808 /* The traceframe we were inspecting. */
2809 int traceframe_number
;
2813 do_restore_current_traceframe_cleanup (void *arg
)
2815 struct current_traceframe_cleanup
*old
= arg
;
2817 set_traceframe_number (old
->traceframe_number
);
2821 restore_current_traceframe_cleanup_dtor (void *arg
)
2823 struct current_traceframe_cleanup
*old
= arg
;
2829 make_cleanup_restore_current_traceframe (void)
2831 struct current_traceframe_cleanup
*old
;
2833 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
2834 old
->traceframe_number
= traceframe_number
;
2836 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
2837 restore_current_traceframe_cleanup_dtor
);
2840 /* Given a number and address, return an uploaded tracepoint with that
2841 number, creating if necessary. */
2843 struct uploaded_tp
*
2844 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
2846 struct uploaded_tp
*utp
;
2848 for (utp
= *utpp
; utp
; utp
= utp
->next
)
2849 if (utp
->number
== num
&& utp
->addr
== addr
)
2851 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
2852 memset (utp
, 0, sizeof (struct uploaded_tp
));
2861 free_uploaded_tps (struct uploaded_tp
**utpp
)
2863 struct uploaded_tp
*next_one
;
2867 next_one
= (*utpp
)->next
;
2873 /* Given a number and address, return an uploaded tracepoint with that
2874 number, creating if necessary. */
2876 struct uploaded_tsv
*
2877 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
2879 struct uploaded_tsv
*utsv
;
2881 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
2882 if (utsv
->number
== num
)
2884 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
2885 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
2887 utsv
->next
= *utsvp
;
2893 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
2895 struct uploaded_tsv
*next_one
;
2899 next_one
= (*utsvp
)->next
;
2905 /* Look for an existing tracepoint that seems similar enough to the
2906 uploaded one. Enablement isn't compared, because the user can
2907 toggle that freely, and may have done so in anticipation of the
2911 find_matching_tracepoint (struct uploaded_tp
*utp
)
2913 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
2915 struct breakpoint
*t
;
2916 struct bp_location
*loc
;
2918 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2920 if (t
->type
== utp
->type
2921 && t
->step_count
== utp
->step
2922 && t
->pass_count
== utp
->pass
2923 /* FIXME also test conditionals and actions */
2926 /* Scan the locations for an address match. */
2927 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2929 if (loc
->address
== utp
->addr
)
2937 /* Given a list of tracepoints uploaded from a target, attempt to
2938 match them up with existing tracepoints, and create new ones if not
2942 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
2944 struct uploaded_tp
*utp
;
2945 struct breakpoint
*t
;
2947 /* Look for GDB tracepoints that match up with our uploaded versions. */
2948 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
2950 t
= find_matching_tracepoint (utp
);
2952 printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
2953 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2956 t
= create_tracepoint_from_upload (utp
);
2958 printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
2959 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2961 printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
2962 utp
->number
, paddress (get_current_arch (), utp
->addr
));
2964 /* Whether found or created, record the number used by the
2965 target, to help with mapping target tracepoints back to their
2966 counterparts here. */
2968 t
->number_on_target
= utp
->number
;
2971 free_uploaded_tps (uploaded_tps
);
2974 /* Trace state variables don't have much to identify them beyond their
2975 name, so just use that to detect matches. */
2977 struct trace_state_variable
*
2978 find_matching_tsv (struct uploaded_tsv
*utsv
)
2983 return find_trace_state_variable (utsv
->name
);
2986 struct trace_state_variable
*
2987 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
2989 const char *namebase
;
2992 struct trace_state_variable
*tsv
;
2996 namebase
= utsv
->name
;
2997 sprintf (buf
, "%s", namebase
);
3002 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3005 /* Fish for a name that is not in use. */
3006 /* (should check against all internal vars?) */
3007 while (find_trace_state_variable (buf
))
3008 sprintf (buf
, "%s_%d", namebase
, try_num
++);
3010 /* We have an available name, create the variable. */
3011 tsv
= create_trace_state_variable (xstrdup (buf
));
3012 tsv
->initial_value
= utsv
->initial_value
;
3013 tsv
->builtin
= utsv
->builtin
;
3018 /* Given a list of uploaded trace state variables, try to match them
3019 up with existing variables, or create additional ones. */
3022 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
3025 struct uploaded_tsv
*utsv
;
3026 struct trace_state_variable
*tsv
;
3029 /* Most likely some numbers will have to be reassigned as part of
3030 the merge, so clear them all in anticipation. */
3031 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3034 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
3036 tsv
= find_matching_tsv (utsv
);
3038 printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
3039 tsv
->name
, utsv
->number
);
3042 tsv
= create_tsv_from_upload (utsv
);
3043 printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
3044 tsv
->name
, utsv
->number
);
3046 /* Give precedence to numberings that come from the target. */
3048 tsv
->number
= utsv
->number
;
3051 /* Renumber everything that didn't get a target-assigned number. */
3053 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3054 if (tsv
->number
> highest
)
3055 highest
= tsv
->number
;
3058 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3059 if (tsv
->number
== 0)
3060 tsv
->number
= highest
++;
3062 free_uploaded_tsvs (uploaded_tsvs
);
3065 /* target tfile command */
3067 struct target_ops tfile_ops
;
3069 /* Fill in tfile_ops with its defined operations and properties. */
3071 #define TRACE_HEADER_SIZE 8
3073 char *trace_filename
;
3075 off_t trace_frames_offset
;
3078 int trace_regblock_size
;
3080 static void tfile_interp_line (char *line
,
3081 struct uploaded_tp
**utpp
,
3082 struct uploaded_tsv
**utsvp
);
3085 tfile_open (char *filename
, int from_tty
)
3088 struct cleanup
*old_chain
;
3091 char header
[TRACE_HEADER_SIZE
];
3092 char linebuf
[1000]; /* should be max remote packet size or so */
3094 int bytes
, i
, gotten
;
3095 struct trace_status
*ts
;
3096 struct uploaded_tp
*uploaded_tps
= NULL
;
3097 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3099 target_preopen (from_tty
);
3101 error (_("No trace file specified."));
3103 filename
= tilde_expand (filename
);
3104 if (!IS_ABSOLUTE_PATH(filename
))
3106 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
3111 old_chain
= make_cleanup (xfree
, filename
);
3113 flags
= O_BINARY
| O_LARGEFILE
;
3115 scratch_chan
= open (filename
, flags
, 0);
3116 if (scratch_chan
< 0)
3117 perror_with_name (filename
);
3119 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3121 discard_cleanups (old_chain
); /* Don't free filename any more */
3122 unpush_target (&tfile_ops
);
3124 push_target (&tfile_ops
);
3126 trace_filename
= xstrdup (filename
);
3127 trace_fd
= scratch_chan
;
3130 /* Read the file header and test for validity. */
3131 gotten
= read (trace_fd
, &header
, TRACE_HEADER_SIZE
);
3133 perror_with_name (trace_filename
);
3134 else if (gotten
< TRACE_HEADER_SIZE
)
3135 error (_("Premature end of file while reading trace file"));
3137 bytes
+= TRACE_HEADER_SIZE
;
3138 if (!(header
[0] == 0x7f
3139 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3140 error (_("File is not a valid trace file."));
3142 trace_regblock_size
= 0;
3143 ts
= current_trace_status ();
3144 /* We know we're working with a file. */
3146 /* Set defaults in case there is no status line. */
3147 ts
->running_known
= 0;
3148 ts
->stop_reason
= trace_stop_reason_unknown
;
3149 ts
->traceframe_count
= -1;
3150 ts
->buffer_free
= 0;
3152 /* Read through a section of newline-terminated lines that
3153 define things like tracepoints. */
3157 gotten
= read (trace_fd
, &byte
, 1);
3159 perror_with_name (trace_filename
);
3160 else if (gotten
< 1)
3161 error (_("Premature end of file while reading trace file"));
3166 /* Empty line marks end of the definition section. */
3171 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3174 linebuf
[i
++] = byte
;
3176 error (_("Excessively long lines in trace file"));
3179 /* Add the file's tracepoints and variables into the current mix. */
3181 /* Get trace state variables first, they may be checked when parsing
3182 uploaded commands. */
3183 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3185 merge_uploaded_tracepoints (&uploaded_tps
);
3187 /* Record the starting offset of the binary trace data. */
3188 trace_frames_offset
= bytes
;
3190 /* If we don't have a blocksize, we can't interpret the
3192 if (trace_regblock_size
== 0)
3193 error (_("No register block size recorded in trace file"));
3194 if (ts
->traceframe_count
<= 0)
3196 warning ("No traceframes present in this file.");
3200 #define TFILE_PID (1)
3201 inferior_appeared (current_inferior (), TFILE_PID
);
3202 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3203 add_thread_silent (inferior_ptid
);
3205 post_create_inferior (&tfile_ops
, from_tty
);
3208 /* FIXME this will get defined in MI patch submission */
3209 tfind_1 (tfind_number
, 0, 0, 0, 0);
3213 /* Interpret the given line from the definitions part of the trace
3217 tfile_interp_line (char *line
,
3218 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3222 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3225 trace_regblock_size
= strtol (p
, &p
, 16);
3227 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3229 p
+= strlen ("status ");
3230 parse_trace_status (p
, current_trace_status ());
3232 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3234 p
+= strlen ("tp ");
3235 parse_tracepoint_definition (p
, utpp
);
3237 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3239 p
+= strlen ("tsv ");
3240 parse_tsv_definition (p
, utsvp
);
3243 warning ("Ignoring trace file definition \"%s\"", line
);
3246 /* Parse the part of trace status syntax that is shared between
3247 the remote protocol and the trace file reader. */
3249 extern char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
3252 parse_trace_status (char *line
, struct trace_status
*ts
)
3254 char *p
= line
, *p1
, *p2
, *p_temp
;
3257 ts
->running_known
= 1;
3258 ts
->running
= (*p
++ == '1');
3259 ts
->stop_reason
= trace_stop_reason_unknown
;
3260 xfree (ts
->error_desc
);
3261 ts
->error_desc
= NULL
;
3262 ts
->traceframe_count
= -1;
3263 ts
->traceframes_created
= -1;
3264 ts
->buffer_free
= -1;
3265 ts
->buffer_size
= -1;
3269 p1
= strchr (p
, ':');
3271 error (_("Malformed trace status, at %s\n\
3272 Status line: '%s'\n"), p
, line
);
3273 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3275 p
= unpack_varlen_hex (++p1
, &val
);
3276 ts
->stop_reason
= trace_buffer_full
;
3278 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3280 p
= unpack_varlen_hex (++p1
, &val
);
3281 ts
->stop_reason
= trace_never_run
;
3283 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
], p1
- p
) == 0)
3285 p
= unpack_varlen_hex (++p1
, &val
);
3286 ts
->stop_reason
= tracepoint_passcount
;
3287 ts
->stopping_tracepoint
= val
;
3289 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3291 p
= unpack_varlen_hex (++p1
, &val
);
3292 ts
->stop_reason
= tstop_command
;
3294 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3296 p2
= strchr (++p1
, ':');
3301 ts
->error_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3302 end
= hex2bin (p1
, ts
->error_desc
, (p2
- p1
) / 2);
3303 ts
->error_desc
[end
] = '\0';
3306 ts
->error_desc
= xstrdup ("");
3308 p
= unpack_varlen_hex (++p2
, &val
);
3309 ts
->stopping_tracepoint
= val
;
3310 ts
->stop_reason
= tracepoint_error
;
3312 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3314 p
= unpack_varlen_hex (++p1
, &val
);
3315 ts
->traceframe_count
= val
;
3317 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3319 p
= unpack_varlen_hex (++p1
, &val
);
3320 ts
->traceframes_created
= val
;
3322 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3324 p
= unpack_varlen_hex (++p1
, &val
);
3325 ts
->buffer_free
= val
;
3327 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3329 p
= unpack_varlen_hex (++p1
, &val
);
3330 ts
->buffer_size
= val
;
3334 /* Silently skip unknown optional info. */
3335 p_temp
= strchr (p1
+ 1, ';');
3339 /* Must be at the end. */
3345 /* Given a line of text defining a part of a tracepoint, parse it into
3346 an "uploaded tracepoint". */
3349 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3353 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3354 int enabled
, i
, end
;
3356 char *cond
, *srctype
, *src
, *buf
;
3357 struct uploaded_tp
*utp
= NULL
;
3360 /* Both tracepoint and action definitions start with the same number
3361 and address sequence. */
3363 p
= unpack_varlen_hex (p
, &num
);
3364 p
++; /* skip a colon */
3365 p
= unpack_varlen_hex (p
, &addr
);
3366 p
++; /* skip a colon */
3369 enabled
= (*p
++ == 'E');
3370 p
++; /* skip a colon */
3371 p
= unpack_varlen_hex (p
, &step
);
3372 p
++; /* skip a colon */
3373 p
= unpack_varlen_hex (p
, &pass
);
3374 type
= bp_tracepoint
;
3376 /* Thumb through optional fields. */
3379 p
++; /* skip a colon */
3382 type
= bp_fast_tracepoint
;
3384 p
= unpack_varlen_hex (p
, &orig_size
);
3389 p
= unpack_varlen_hex (p
, &xlen
);
3390 p
++; /* skip a comma */
3391 cond
= (char *) xmalloc (2 * xlen
+ 1);
3392 strncpy (cond
, p
, 2 * xlen
);
3393 cond
[2 * xlen
] = '\0';
3397 warning (_("Unrecognized char '%c' in tracepoint definition, skipping rest"), *p
);
3399 utp
= get_uploaded_tp (num
, addr
, utpp
);
3401 utp
->enabled
= enabled
;
3406 else if (piece
== 'A')
3408 utp
= get_uploaded_tp (num
, addr
, utpp
);
3409 utp
->actions
[utp
->numactions
++] = xstrdup (p
);
3411 else if (piece
== 'S')
3413 utp
= get_uploaded_tp (num
, addr
, utpp
);
3414 utp
->step_actions
[utp
->num_step_actions
++] = xstrdup (p
);
3416 else if (piece
== 'Z')
3418 /* Parse a chunk of source form definition. */
3419 utp
= get_uploaded_tp (num
, addr
, utpp
);
3421 p
= strchr (p
, ':');
3422 p
++; /* skip a colon */
3423 p
= unpack_varlen_hex (p
, &start
);
3424 p
++; /* skip a colon */
3425 p
= unpack_varlen_hex (p
, &xlen
);
3426 p
++; /* skip a colon */
3428 buf
= alloca (strlen (line
));
3430 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3433 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
3434 utp
->at_string
= xstrdup (buf
);
3435 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
3436 utp
->cond_string
= xstrdup (buf
);
3437 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
3439 /* FIXME consider using a vector? */
3440 struct uploaded_string
*last
, *newlast
;
3441 newlast
= (struct uploaded_string
*) xmalloc (sizeof (struct uploaded_string
));
3442 newlast
->str
= xstrdup (buf
);
3443 newlast
->next
= NULL
;
3444 if (utp
->cmd_strings
)
3446 for (last
= utp
->cmd_strings
; last
->next
; last
= last
->next
)
3448 last
->next
= newlast
;
3451 utp
->cmd_strings
= newlast
;
3456 /* Don't error out, the target might be sending us optional
3457 info that we don't care about. */
3458 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3462 /* Convert a textual description of a trace state variable into an
3466 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3469 ULONGEST num
, initval
, builtin
;
3471 struct uploaded_tsv
*utsv
= NULL
;
3473 buf
= alloca (strlen (line
));
3476 p
= unpack_varlen_hex (p
, &num
);
3477 p
++; /* skip a colon */
3478 p
= unpack_varlen_hex (p
, &initval
);
3479 p
++; /* skip a colon */
3480 p
= unpack_varlen_hex (p
, &builtin
);
3481 p
++; /* skip a colon */
3482 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3485 utsv
= get_uploaded_tsv (num
, utsvp
);
3486 utsv
->initial_value
= initval
;
3487 utsv
->builtin
= builtin
;
3488 utsv
->name
= xstrdup (buf
);
3491 /* Close the trace file and generally clean up. */
3494 tfile_close (int quitting
)
3501 pid
= ptid_get_pid (inferior_ptid
);
3502 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
3503 exit_inferior_silent (pid
);
3508 xfree (trace_filename
);
3512 tfile_files_info (struct target_ops
*t
)
3514 /* (it would be useful to mention the name of the file) */
3515 printf_filtered ("Looking at a trace file.\n");
3518 /* The trace status for a file is that tracing can never be run. */
3521 tfile_get_trace_status (struct trace_status
*ts
)
3523 /* Other bits of trace status were collected as part of opening the
3524 trace files, so nothing to do here. */
3529 /* Given the position of a traceframe in the file, figure out what
3530 address the frame was collected at. This would normally be the
3531 value of a collected PC register, but if not available, we
3535 tfile_get_traceframe_address (off_t tframe_offset
)
3539 struct breakpoint
*tp
;
3540 off_t saved_offset
= cur_offset
;
3543 /* FIXME dig pc out of collected registers */
3545 /* Fall back to using tracepoint address. */
3546 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
3547 gotten
= read (trace_fd
, &tpnum
, 2);
3549 perror_with_name (trace_filename
);
3550 else if (gotten
< 2)
3551 error (_("Premature end of file while reading trace file"));
3553 tp
= get_tracepoint_by_number_on_target (tpnum
);
3554 /* FIXME this is a poor heuristic if multiple locations */
3556 addr
= tp
->loc
->address
;
3558 /* Restore our seek position. */
3559 cur_offset
= saved_offset
;
3560 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3564 /* Given a type of search and some parameters, scan the collection of
3565 traceframes in the file looking for a match. When found, return
3566 both the traceframe and tracepoint number, otherwise -1 for
3570 tfile_trace_find (enum trace_find_type type
, int num
,
3571 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
3574 int tfnum
= 0, found
= 0, gotten
;
3576 struct breakpoint
*tp
;
3577 off_t offset
, tframe_offset
;
3580 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
3581 offset
= trace_frames_offset
;
3584 tframe_offset
= offset
;
3585 gotten
= read (trace_fd
, &tpnum
, 2);
3587 perror_with_name (trace_filename
);
3588 else if (gotten
< 2)
3589 error (_("Premature end of file while reading trace file"));
3593 gotten
= read (trace_fd
, &data_size
, 4);
3595 perror_with_name (trace_filename
);
3596 else if (gotten
< 4)
3597 error (_("Premature end of file while reading trace file"));
3606 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3607 if (tfaddr
== addr1
)
3611 tp
= get_tracepoint (num
);
3612 if (tp
&& tpnum
== tp
->number_on_target
)
3616 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3617 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
3621 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3622 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
3626 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
3632 cur_offset
= offset
;
3633 cur_data_size
= data_size
;
3636 /* Skip past the traceframe's data. */
3637 lseek (trace_fd
, data_size
, SEEK_CUR
);
3638 offset
+= data_size
;
3639 /* Update our own count of traceframes. */
3642 /* Did not find what we were looking for. */
3648 /* Look for a block of saved registers in the traceframe, and get the
3649 requested register from it. */
3652 tfile_fetch_registers (struct target_ops
*ops
,
3653 struct regcache
*regcache
, int regno
)
3655 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3657 int i
, pos
, offset
, regn
, regsize
, gotten
;
3658 unsigned short mlen
;
3661 /* An uninitialized reg size says we're not going to be
3662 successful at getting register blocks. */
3663 if (!trace_regblock_size
)
3666 regs
= alloca (trace_regblock_size
);
3668 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3670 while (pos
< cur_data_size
)
3672 gotten
= read (trace_fd
, &block_type
, 1);
3674 perror_with_name (trace_filename
);
3675 else if (gotten
< 1)
3676 error (_("Premature end of file while reading trace file"));
3682 gotten
= read (trace_fd
, regs
, trace_regblock_size
);
3684 perror_with_name (trace_filename
);
3685 else if (gotten
< trace_regblock_size
)
3686 error (_("Premature end of file while reading trace file"));
3688 /* Assume the block is laid out in GDB register number order,
3689 each register with the size that it has in GDB. */
3691 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3693 regsize
= register_size (gdbarch
, regn
);
3694 /* Make sure we stay within block bounds. */
3695 if (offset
+ regsize
>= trace_regblock_size
)
3697 if (!regcache_valid_p (regcache
, regn
))
3701 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
3704 else if (regno
== -1)
3706 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
3713 lseek (trace_fd
, 8, SEEK_CUR
);
3714 gotten
= read (trace_fd
, &mlen
, 2);
3716 perror_with_name (trace_filename
);
3717 else if (gotten
< 2)
3718 error (_("Premature end of file while reading trace file"));
3719 lseek (trace_fd
, mlen
, SEEK_CUR
);
3720 pos
+= (8 + 2 + mlen
);
3723 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3727 error ("Unknown block type '%c' (0x%x) in trace frame",
3728 block_type
, block_type
);
3735 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3736 const char *annex
, gdb_byte
*readbuf
,
3737 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3742 unsigned short mlen
;
3744 /* We're only doing regular memory for now. */
3745 if (object
!= TARGET_OBJECT_MEMORY
)
3748 if (readbuf
== NULL
)
3749 error ("tfile_xfer_partial: trace file is read-only");
3751 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3753 while (pos
< cur_data_size
)
3755 gotten
= read (trace_fd
, &block_type
, 1);
3757 perror_with_name (trace_filename
);
3758 else if (gotten
< 1)
3759 error (_("Premature end of file while reading trace file"));
3764 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3765 pos
+= trace_regblock_size
;
3768 gotten
= read (trace_fd
, &maddr
, 8);
3770 perror_with_name (trace_filename
);
3771 else if (gotten
< 8)
3772 error (_("Premature end of file while reading trace file"));
3774 gotten
= read (trace_fd
, &mlen
, 2);
3776 perror_with_name (trace_filename
);
3777 else if (gotten
< 2)
3778 error (_("Premature end of file while reading trace file"));
3779 if (maddr
<= offset
&& (offset
+ len
) <= (maddr
+ mlen
))
3781 gotten
= read (trace_fd
, readbuf
, mlen
);
3783 perror_with_name (trace_filename
);
3784 else if (gotten
< mlen
)
3785 error (_("Premature end of file qwhile reading trace file"));
3789 lseek (trace_fd
, mlen
, SEEK_CUR
);
3790 pos
+= (8 + 2 + mlen
);
3793 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3797 error ("Unknown block type '%c' (0x%x) in traceframe",
3798 block_type
, block_type
);
3802 /* Indicate failure to find the requested memory block. */
3806 /* Iterate through the blocks of a trace frame, looking for a 'V'
3807 block with a matching tsv number. */
3810 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
3813 int pos
, vnum
, gotten
;
3814 unsigned short mlen
;
3816 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3818 while (pos
< cur_data_size
)
3820 gotten
= read (trace_fd
, &block_type
, 1);
3822 perror_with_name (trace_filename
);
3823 else if (gotten
< 1)
3824 error (_("Premature end of file while reading trace file"));
3829 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3830 pos
+= trace_regblock_size
;
3833 lseek (trace_fd
, 8, SEEK_CUR
);
3834 gotten
= read (trace_fd
, &mlen
, 2);
3836 perror_with_name (trace_filename
);
3837 else if (gotten
< 2)
3838 error (_("Premature end of file while reading trace file"));
3839 lseek (trace_fd
, mlen
, SEEK_CUR
);
3840 pos
+= (8 + 2 + mlen
);
3843 gotten
= read (trace_fd
, &vnum
, 4);
3845 perror_with_name (trace_filename
);
3846 else if (gotten
< 4)
3847 error (_("Premature end of file while reading trace file"));
3850 gotten
= read (trace_fd
, val
, 8);
3852 perror_with_name (trace_filename
);
3853 else if (gotten
< 8)
3854 error (_("Premature end of file while reading trace file"));
3857 lseek (trace_fd
, 8, SEEK_CUR
);
3861 error ("Unknown block type '%c' (0x%x) in traceframe",
3862 block_type
, block_type
);
3866 /* Didn't find anything. */
3871 tfile_has_memory (struct target_ops
*ops
)
3877 tfile_has_stack (struct target_ops
*ops
)
3883 tfile_has_registers (struct target_ops
*ops
)
3889 init_tfile_ops (void)
3891 tfile_ops
.to_shortname
= "tfile";
3892 tfile_ops
.to_longname
= "Local trace dump file";
3894 "Use a trace file as a target. Specify the filename of the trace file.";
3895 tfile_ops
.to_open
= tfile_open
;
3896 tfile_ops
.to_close
= tfile_close
;
3897 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
3898 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
3899 tfile_ops
.to_files_info
= tfile_files_info
;
3900 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
3901 tfile_ops
.to_trace_find
= tfile_trace_find
;
3902 tfile_ops
.to_get_trace_state_variable_value
= tfile_get_trace_state_variable_value
;
3903 /* core_stratum might seem more logical, but GDB doesn't like having
3904 more than one core_stratum vector. */
3905 tfile_ops
.to_stratum
= process_stratum
;
3906 tfile_ops
.to_has_memory
= tfile_has_memory
;
3907 tfile_ops
.to_has_stack
= tfile_has_stack
;
3908 tfile_ops
.to_has_registers
= tfile_has_registers
;
3909 tfile_ops
.to_magic
= OPS_MAGIC
;
3912 /* module initialization */
3914 _initialize_tracepoint (void)
3916 struct cmd_list_element
*c
;
3918 traceframe_number
= -1;
3919 tracepoint_number
= -1;
3921 if (tracepoint_list
.list
== NULL
)
3923 tracepoint_list
.listsize
= 128;
3924 tracepoint_list
.list
= xmalloc
3925 (tracepoint_list
.listsize
* sizeof (struct memrange
));
3927 if (tracepoint_list
.aexpr_list
== NULL
)
3929 tracepoint_list
.aexpr_listsize
= 128;
3930 tracepoint_list
.aexpr_list
= xmalloc
3931 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3934 if (stepping_list
.list
== NULL
)
3936 stepping_list
.listsize
= 128;
3937 stepping_list
.list
= xmalloc
3938 (stepping_list
.listsize
* sizeof (struct memrange
));
3941 if (stepping_list
.aexpr_list
== NULL
)
3943 stepping_list
.aexpr_listsize
= 128;
3944 stepping_list
.aexpr_list
= xmalloc
3945 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3948 add_info ("scope", scope_info
,
3949 _("List the variables local to a scope"));
3951 add_cmd ("tracepoints", class_trace
, NULL
,
3952 _("Tracing of program execution without stopping the program."),
3955 add_com ("tdump", class_trace
, trace_dump_command
,
3956 _("Print everything collected at the current tracepoint."));
3958 add_com ("tsave", class_trace
, trace_save_command
, _("\
3959 Save the trace data to a file.\n\
3960 Use the '-r' option to direct the target to save directly to the file,\n\
3961 using its own filesystem."));
3963 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
3964 Define a trace state variable.\n\
3965 Argument is a $-prefixed name, optionally followed\n\
3966 by '=' and an expression that sets the initial value\n\
3967 at the start of tracing."));
3968 set_cmd_completer (c
, expression_completer
);
3970 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
3971 Delete one or more trace state variables.\n\
3972 Arguments are the names of the variables to delete.\n\
3973 If no arguments are supplied, delete all variables."), &deletelist
);
3974 /* FIXME add a trace variable completer */
3976 add_info ("tvariables", tvariables_info
, _("\
3977 Status of trace state variables and their values.\n\
3980 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
3981 Select a trace frame;\n\
3982 No argument means forward by one frame; '-' means backward by one frame."),
3983 &tfindlist
, "tfind ", 1, &cmdlist
);
3985 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
3986 Select a trace frame whose PC is outside the given range (exclusive).\n\
3987 Usage: tfind outside addr1, addr2"),
3990 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
3991 Select a trace frame whose PC is in the given range (inclusive).\n\
3992 Usage: tfind range addr1,addr2"),
3995 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
3996 Select a trace frame by source line.\n\
3997 Argument can be a line number (with optional source file), \n\
3998 a function name, or '*' followed by an address.\n\
3999 Default argument is 'the next source line that was traced'."),
4002 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
4003 Select a trace frame by tracepoint number.\n\
4004 Default is the tracepoint for the current trace frame."),
4007 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
4008 Select a trace frame by PC.\n\
4009 Default is the current PC, or the PC of the current trace frame."),
4012 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
4013 Synonym for 'none'.\n\
4014 De-select any trace frame and resume 'live' debugging."),
4017 add_cmd ("none", class_trace
, trace_find_none_command
,
4018 _("De-select any trace frame and resume 'live' debugging."),
4021 add_cmd ("start", class_trace
, trace_find_start_command
,
4022 _("Select the first trace frame in the trace buffer."),
4025 add_com ("tstatus", class_trace
, trace_status_command
,
4026 _("Display the status of the current trace data collection."));
4028 add_com ("tstop", class_trace
, trace_stop_command
,
4029 _("Stop trace data collection."));
4031 add_com ("tstart", class_trace
, trace_start_command
,
4032 _("Start trace data collection."));
4034 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
4035 Ends a list of commands or actions.\n\
4036 Several GDB commands allow you to enter a list of commands or actions.\n\
4037 Entering \"end\" on a line by itself is the normal way to terminate\n\
4039 Note: the \"end\" command cannot be used at the gdb prompt."));
4041 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
4042 Specify single-stepping behavior at a tracepoint.\n\
4043 Argument is number of instructions to trace in single-step mode\n\
4044 following the tracepoint. This command is normally followed by\n\
4045 one or more \"collect\" commands, to specify what to collect\n\
4046 while single-stepping.\n\n\
4047 Note: this command can only be used in a tracepoint \"actions\" list."));
4049 add_com_alias ("ws", "while-stepping", class_alias
, 0);
4050 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
4052 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
4053 Specify one or more data items to be collected at a tracepoint.\n\
4054 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4055 collect all data (variables, registers) referenced by that expression.\n\
4056 Also accepts the following special arguments:\n\
4057 $regs -- all registers.\n\
4058 $args -- all function arguments.\n\
4059 $locals -- all variables local to the block/function scope.\n\
4060 Note: this command can only be used in a tracepoint \"actions\" list."));
4062 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4063 Specify one or more expressions to be evaluated at a tracepoint.\n\
4064 Accepts a comma-separated list of (one or more) expressions.\n\
4065 The result of each evaluation will be discarded.\n\
4066 Note: this command can only be used in a tracepoint \"actions\" list."));
4068 add_com ("actions", class_trace
, trace_actions_command
, _("\
4069 Specify the actions to be taken at a tracepoint.\n\
4070 Tracepoint actions may include collecting of specified data, \n\
4071 single-stepping, or enabling/disabling other tracepoints, \n\
4072 depending on target's capabilities."));
4074 default_collect
= xstrdup ("");
4075 add_setshow_string_cmd ("default-collect", class_trace
,
4076 &default_collect
, _("\
4077 Set the list of expressions to collect by default"), _("\
4078 Show the list of expressions to collect by default"), NULL
,
4080 &setlist
, &showlist
);
4082 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4083 &disconnected_tracing
, _("\
4084 Set whether tracing continues after GDB disconnects."), _("\
4085 Show whether tracing continues after GDB disconnects."), _("\
4086 Use this to continue a tracing run even if GDB disconnects\n\
4087 or detaches from the target. You can reconnect later and look at\n\
4088 trace data collected in the meantime."),
4089 set_disconnected_tracing
,
4094 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4095 &circular_trace_buffer
, _("\
4096 Set target's use of circular trace buffer."), _("\
4097 Show target's use of circular trace buffer."), _("\
4098 Use this to make the trace buffer into a circular buffer,\n\
4099 which will discard traceframes (oldest first) instead of filling\n\
4100 up and stopping the trace run."),
4101 set_circular_trace_buffer
,
4108 add_target (&tfile_ops
);