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"
51 /* readline include files */
52 #include "readline/readline.h"
53 #include "readline/history.h"
55 /* readline defines this. */
66 extern int hex2bin (const char *hex
, gdb_byte
*bin
, int count
);
67 extern int bin2hex (const gdb_byte
*bin
, char *hex
, int count
);
69 extern void stop_tracing ();
71 /* Maximum length of an agent aexpression.
72 This accounts for the fact that packets are limited to 400 bytes
73 (which includes everything -- including the checksum), and assumes
74 the worst case of maximum length for each of the pieces of a
77 NOTE: expressions get mem2hex'ed otherwise this would be twice as
78 large. (400 - 31)/2 == 184 */
79 #define MAX_AGENT_EXPR_LEN 184
81 /* A hook used to notify the UI of tracepoint operations. */
83 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
84 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
86 extern void (*deprecated_readline_begin_hook
) (char *, ...);
87 extern char *(*deprecated_readline_hook
) (char *);
88 extern void (*deprecated_readline_end_hook
) (void);
90 /* GDB commands implemented in other modules:
93 extern void output_command (char *, int);
98 This module defines the following debugger commands:
99 trace : set a tracepoint on a function, line, or address.
100 info trace : list all debugger-defined tracepoints.
101 delete trace : delete one or more tracepoints.
102 enable trace : enable one or more tracepoints.
103 disable trace : disable one or more tracepoints.
104 actions : specify actions to be taken at a tracepoint.
105 passcount : specify a pass count for a tracepoint.
106 tstart : start a trace experiment.
107 tstop : stop a trace experiment.
108 tstatus : query the status of a trace experiment.
109 tfind : find a trace frame in the trace buffer.
110 tdump : print everything collected at the current tracepoint.
111 save-tracepoints : write tracepoint setup into a file.
113 This module defines the following user-visible debugger variables:
114 $trace_frame : sequence number of trace frame currently being debugged.
115 $trace_line : source line of trace frame currently being debugged.
116 $trace_file : source file of trace frame currently being debugged.
117 $tracepoint : tracepoint number of trace frame currently being debugged.
121 /* ======= Important global variables: ======= */
123 /* The list of all trace state variables. We don't retain pointers to
124 any of these for any reason - API is by name or number only - so it
125 works to have a vector of objects. */
127 typedef struct trace_state_variable tsv_s
;
130 static VEC(tsv_s
) *tvariables
;
132 /* The next integer to assign to a variable. */
134 static int next_tsv_number
= 1;
136 /* Number of last traceframe collected. */
137 static int traceframe_number
;
139 /* Tracepoint for last traceframe collected. */
140 static int tracepoint_number
;
142 /* Symbol for function for last traceframe collected */
143 static struct symbol
*traceframe_fun
;
145 /* Symtab and line for last traceframe collected */
146 static struct symtab_and_line traceframe_sal
;
148 /* Tracing command lists */
149 static struct cmd_list_element
*tfindlist
;
151 /* List of expressions to collect by default at each tracepoint hit. */
152 char *default_collect
= "";
154 static int disconnected_tracing
;
156 /* This variable controls whether we ask the target for a linear or
157 circular trace buffer. */
159 static int circular_trace_buffer
;
161 /* ======= Important command functions: ======= */
162 static void trace_actions_command (char *, int);
163 static void trace_start_command (char *, int);
164 static void trace_stop_command (char *, int);
165 static void trace_status_command (char *, int);
166 static void trace_find_command (char *, int);
167 static void trace_find_pc_command (char *, int);
168 static void trace_find_tracepoint_command (char *, int);
169 static void trace_find_line_command (char *, int);
170 static void trace_find_range_command (char *, int);
171 static void trace_find_outside_command (char *, int);
172 static void trace_dump_command (char *, int);
174 /* support routines */
176 struct collection_list
;
177 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
178 static char *mem2hex (gdb_byte
*, char *, int);
179 static void add_register (struct collection_list
*collection
,
182 extern void send_disconnected_tracing_value (int value
);
184 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
185 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
188 extern void _initialize_tracepoint (void);
190 static struct trace_status trace_status
;
192 char *stop_reason_names
[] = {
202 struct trace_status
*
203 current_trace_status ()
205 return &trace_status
;
208 /* Set traceframe number to NUM. */
210 set_traceframe_num (int num
)
212 traceframe_number
= num
;
213 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
216 /* Set tracepoint number to NUM. */
218 set_tracepoint_num (int num
)
220 tracepoint_number
= num
;
221 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
224 /* Set externally visible debug variables for querying/printing
225 the traceframe context (line, function, file) */
228 set_traceframe_context (struct frame_info
*trace_frame
)
232 if (trace_frame
== NULL
) /* Cease debugging any trace buffers. */
235 traceframe_sal
.pc
= traceframe_sal
.line
= 0;
236 traceframe_sal
.symtab
= NULL
;
237 clear_internalvar (lookup_internalvar ("trace_func"));
238 clear_internalvar (lookup_internalvar ("trace_file"));
239 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
243 /* Save as globals for internal use. */
244 trace_pc
= get_frame_pc (trace_frame
);
245 traceframe_sal
= find_pc_line (trace_pc
, 0);
246 traceframe_fun
= find_pc_function (trace_pc
);
248 /* Save linenumber as "$trace_line", a debugger variable visible to
250 set_internalvar_integer (lookup_internalvar ("trace_line"),
251 traceframe_sal
.line
);
253 /* Save func name as "$trace_func", a debugger variable visible to
255 if (traceframe_fun
== NULL
256 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
257 clear_internalvar (lookup_internalvar ("trace_func"));
259 set_internalvar_string (lookup_internalvar ("trace_func"),
260 SYMBOL_LINKAGE_NAME (traceframe_fun
));
262 /* Save file name as "$trace_file", a debugger variable visible to
264 if (traceframe_sal
.symtab
== NULL
265 || traceframe_sal
.symtab
->filename
== NULL
)
266 clear_internalvar (lookup_internalvar ("trace_file"));
268 set_internalvar_string (lookup_internalvar ("trace_file"),
269 traceframe_sal
.symtab
->filename
);
272 /* Create a new trace state variable with the given name. */
274 struct trace_state_variable
*
275 create_trace_state_variable (const char *name
)
277 struct trace_state_variable tsv
;
279 memset (&tsv
, 0, sizeof (tsv
));
280 tsv
.name
= xstrdup (name
);
281 tsv
.number
= next_tsv_number
++;
282 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
285 /* Look for a trace state variable of the given name. */
287 struct trace_state_variable
*
288 find_trace_state_variable (const char *name
)
290 struct trace_state_variable
*tsv
;
293 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
294 if (strcmp (name
, tsv
->name
) == 0)
301 delete_trace_state_variable (const char *name
)
303 struct trace_state_variable
*tsv
;
306 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
307 if (strcmp (name
, tsv
->name
) == 0)
309 xfree ((void *)tsv
->name
);
310 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
314 warning (_("No trace variable named \"$%s\", not deleting"), name
);
317 /* The 'tvariable' command collects a name and optional expression to
318 evaluate into an initial value. */
321 trace_variable_command (char *args
, int from_tty
)
323 struct expression
*expr
;
324 struct cleanup
*old_chain
;
325 struct internalvar
*intvar
= NULL
;
327 struct trace_state_variable
*tsv
;
330 error_no_arg (_("trace state variable name"));
332 /* All the possible valid arguments are expressions. */
333 expr
= parse_expression (args
);
334 old_chain
= make_cleanup (free_current_contents
, &expr
);
336 if (expr
->nelts
== 0)
337 error (_("No expression?"));
339 /* Only allow two syntaxes; "$name" and "$name=value". */
340 if (expr
->elts
[0].opcode
== OP_INTERNALVAR
)
342 intvar
= expr
->elts
[1].internalvar
;
344 else if (expr
->elts
[0].opcode
== BINOP_ASSIGN
345 && expr
->elts
[1].opcode
== OP_INTERNALVAR
)
347 intvar
= expr
->elts
[2].internalvar
;
348 initval
= value_as_long (evaluate_subexpression_type (expr
, 4));
351 error (_("Syntax must be $NAME [ = EXPR ]"));
354 error (_("No name given"));
356 if (strlen (internalvar_name (intvar
)) <= 0)
357 error (_("Must supply a non-empty variable name"));
359 /* If the variable already exists, just change its initial value. */
360 tsv
= find_trace_state_variable (internalvar_name (intvar
));
363 tsv
->initial_value
= initval
;
364 printf_filtered (_("Trace state variable $%s now has initial value %s.\n"),
365 tsv
->name
, plongest (tsv
->initial_value
));
369 /* Create a new variable. */
370 tsv
= create_trace_state_variable (internalvar_name (intvar
));
371 tsv
->initial_value
= initval
;
373 printf_filtered (_("Trace state variable $%s created, with initial value %s.\n"),
374 tsv
->name
, plongest (tsv
->initial_value
));
376 do_cleanups (old_chain
);
380 delete_trace_variable_command (char *args
, int from_tty
)
384 struct cleanup
*back_to
;
385 struct trace_state_variable
*tsv
;
389 if (query (_("Delete all trace state variables? ")))
390 VEC_free (tsv_s
, tvariables
);
395 argv
= gdb_buildargv (args
);
396 back_to
= make_cleanup_freeargv (argv
);
398 for (i
= 0; argv
[i
] != NULL
; i
++)
401 delete_trace_state_variable (argv
[i
] + 1);
403 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[i
]);
406 do_cleanups (back_to
);
412 tvariables_info_1 (void)
414 struct trace_state_variable
*tsv
;
417 struct cleanup
*back_to
;
419 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
421 printf_filtered (_("No trace state variables.\n"));
425 /* Try to acquire values from the target. */
426 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
427 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
430 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
431 count
, "trace-variables");
432 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
433 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
434 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
436 ui_out_table_body (uiout
);
438 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
440 struct cleanup
*back_to2
;
444 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
446 name
= concat ("$", tsv
->name
, NULL
);
447 make_cleanup (xfree
, name
);
448 ui_out_field_string (uiout
, "name", name
);
449 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
451 if (tsv
->value_known
)
452 c
= plongest (tsv
->value
);
453 else if (ui_out_is_mi_like_p (uiout
))
454 /* For MI, we prefer not to use magic string constants, but rather
455 omit the field completely. The difference between unknown and
456 undefined does not seem important enough to represent. */
458 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
459 /* The value is/was defined, but we don't have it. */
462 /* It is not meaningful to ask about the value. */
465 ui_out_field_string (uiout
, "current", c
);
466 ui_out_text (uiout
, "\n");
468 do_cleanups (back_to2
);
471 do_cleanups (back_to
);
474 /* List all the trace state variables. */
477 tvariables_info (char *args
, int from_tty
)
479 tvariables_info_1 ();
482 /* Stash definitions of tsvs into the given file. */
485 save_trace_state_variables (struct ui_file
*fp
)
487 struct trace_state_variable
*tsv
;
490 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
492 fprintf_unfiltered (fp
, "tvariable $%s", tsv
->name
);
493 if (tsv
->initial_value
)
494 fprintf_unfiltered (fp
, " = %s", plongest (tsv
->initial_value
));
495 fprintf_unfiltered (fp
, "\n");
499 /* ACTIONS functions: */
501 /* The three functions:
502 collect_pseudocommand,
503 while_stepping_pseudocommand, and
504 end_actions_pseudocommand
505 are placeholders for "commands" that are actually ONLY to be used
506 within a tracepoint action list. If the actual function is ever called,
507 it means that somebody issued the "command" at the top level,
508 which is always an error. */
511 end_actions_pseudocommand (char *args
, int from_tty
)
513 error (_("This command cannot be used at the top level."));
517 while_stepping_pseudocommand (char *args
, int from_tty
)
519 error (_("This command can only be used in a tracepoint actions list."));
523 collect_pseudocommand (char *args
, int from_tty
)
525 error (_("This command can only be used in a tracepoint actions list."));
529 teval_pseudocommand (char *args
, int from_tty
)
531 error (_("This command can only be used in a tracepoint actions list."));
534 /* Enter a list of actions for a tracepoint. */
536 trace_actions_command (char *args
, int from_tty
)
538 struct breakpoint
*t
;
539 struct command_line
*l
;
541 t
= get_tracepoint_by_number (&args
, 0, 1);
545 xstrprintf ("Enter actions for tracepoint %d, one per line.",
547 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
549 l
= read_command_lines (tmpbuf
, from_tty
, 1, check_tracepoint_command
, t
);
550 do_cleanups (cleanups
);
551 breakpoint_set_commands (t
, l
);
553 /* else just return */
556 /* worker function */
558 validate_actionline (char **line
, struct breakpoint
*t
)
560 struct cmd_list_element
*c
;
561 struct expression
*exp
= NULL
;
562 struct cleanup
*old_chain
= NULL
;
564 struct bp_location
*loc
;
566 /* if EOF is typed, *line is NULL */
570 for (p
= *line
; isspace ((int) *p
);)
573 /* Symbol lookup etc. */
574 if (*p
== '\0') /* empty line: just prompt for another line. */
577 if (*p
== '#') /* comment line */
580 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
583 warning (_("'%s' is not an action that I know, or is ambiguous."),
588 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
590 struct agent_expr
*aexpr
;
591 struct agent_reqs areqs
;
594 { /* repeat over a comma-separated list */
595 QUIT
; /* allow user to bail out with ^C */
596 while (isspace ((int) *p
))
599 if (*p
== '$') /* look for special pseudo-symbols */
601 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
602 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
603 (0 == strncasecmp ("loc", p
+ 1, 3)))
608 /* else fall thru, treat p as an expression and parse it! */
611 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
614 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
615 old_chain
= make_cleanup (free_current_contents
, &exp
);
617 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
619 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
621 warning (_("constant %s (value %ld) will not be collected."),
622 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
623 SYMBOL_VALUE (exp
->elts
[2].symbol
));
626 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
628 warning (_("%s is optimized away and cannot be collected."),
629 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
634 /* We have something to collect, make sure that the expr to
635 bytecode translator can handle it and that it's not too
637 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
638 make_cleanup_free_agent_expr (aexpr
);
640 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
641 error (_("expression too complicated, try simplifying"));
643 ax_reqs (aexpr
, &areqs
);
644 (void) make_cleanup (xfree
, areqs
.reg_mask
);
646 if (areqs
.flaw
!= agent_flaw_none
)
647 error (_("malformed expression"));
649 if (areqs
.min_height
< 0)
650 error (_("gdb: Internal error: expression has min height < 0"));
652 if (areqs
.max_height
> 20)
653 error (_("expression too complicated, try simplifying"));
655 do_cleanups (old_chain
);
658 while (p
&& *p
++ == ',');
661 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
663 struct agent_expr
*aexpr
;
666 { /* repeat over a comma-separated list */
667 QUIT
; /* allow user to bail out with ^C */
668 while (isspace ((int) *p
))
672 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
675 /* Only expressions are allowed for this action. */
676 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
677 old_chain
= make_cleanup (free_current_contents
, &exp
);
679 /* We have something to evaluate, make sure that the expr to
680 bytecode translator can handle it and that it's not too
682 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
683 make_cleanup_free_agent_expr (aexpr
);
685 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
686 error (_("expression too complicated, try simplifying"));
688 do_cleanups (old_chain
);
691 while (p
&& *p
++ == ',');
694 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
696 char *steparg
; /* in case warning is necessary */
698 while (isspace ((int) *p
))
703 (t
->step_count
= strtol (p
, &p
, 0)) == 0)
705 error (_("'%s': bad step-count."), *line
);
709 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
713 error (_("'%s' is not a supported tracepoint action."), *line
);
718 memrange_absolute
= -1
723 int type
; /* memrange_absolute for absolute memory range,
724 else basereg number */
725 bfd_signed_vma start
;
729 struct collection_list
731 unsigned char regs_mask
[32]; /* room for up to 256 regs */
734 struct memrange
*list
;
735 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
737 struct agent_expr
**aexpr_list
;
740 tracepoint_list
, stepping_list
;
742 /* MEMRANGE functions: */
744 static int memrange_cmp (const void *, const void *);
746 /* compare memranges for qsort */
748 memrange_cmp (const void *va
, const void *vb
)
750 const struct memrange
*a
= va
, *b
= vb
;
752 if (a
->type
< b
->type
)
754 if (a
->type
> b
->type
)
756 if (a
->type
== memrange_absolute
)
758 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
760 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
765 if (a
->start
< b
->start
)
767 if (a
->start
> b
->start
)
773 /* Sort the memrange list using qsort, and merge adjacent memranges. */
775 memrange_sortmerge (struct collection_list
*memranges
)
779 qsort (memranges
->list
, memranges
->next_memrange
,
780 sizeof (struct memrange
), memrange_cmp
);
781 if (memranges
->next_memrange
> 0)
783 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
785 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
786 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
789 /* memrange b starts before memrange a ends; merge them. */
790 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
791 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
792 continue; /* next b, same a */
796 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
797 sizeof (struct memrange
));
799 memranges
->next_memrange
= a
+ 1;
803 /* Add a register to a collection list. */
805 add_register (struct collection_list
*collection
, unsigned int regno
)
808 printf_filtered ("collect register %d\n", regno
);
809 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
810 error (_("Internal: register number %d too large for tracepoint"),
812 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
815 /* Add a memrange to a collection list */
817 add_memrange (struct collection_list
*memranges
,
818 int type
, bfd_signed_vma base
,
823 printf_filtered ("(%d,", type
);
825 printf_filtered (",%ld)\n", len
);
828 /* type: memrange_absolute == memory, other n == basereg */
829 memranges
->list
[memranges
->next_memrange
].type
= type
;
830 /* base: addr if memory, offset if reg relative. */
831 memranges
->list
[memranges
->next_memrange
].start
= base
;
832 /* len: we actually save end (base + len) for convenience */
833 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
834 memranges
->next_memrange
++;
835 if (memranges
->next_memrange
>= memranges
->listsize
)
837 memranges
->listsize
*= 2;
838 memranges
->list
= xrealloc (memranges
->list
,
839 memranges
->listsize
);
842 if (type
!= memrange_absolute
) /* Better collect the base register! */
843 add_register (memranges
, type
);
846 /* Add a symbol to a collection list. */
848 collect_symbol (struct collection_list
*collect
,
850 struct gdbarch
*gdbarch
,
851 long frame_regno
, long frame_offset
,
856 bfd_signed_vma offset
;
857 int treat_as_expr
= 0;
859 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
860 switch (SYMBOL_CLASS (sym
))
863 printf_filtered ("%s: don't know symbol class %d\n",
864 SYMBOL_PRINT_NAME (sym
),
868 printf_filtered ("constant %s (value %ld) will not be collected.\n",
869 SYMBOL_PRINT_NAME (sym
), SYMBOL_VALUE (sym
));
872 offset
= SYMBOL_VALUE_ADDRESS (sym
);
877 sprintf_vma (tmp
, offset
);
878 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
879 SYMBOL_PRINT_NAME (sym
), len
,
882 /* A struct may be a C++ class with static fields, go to general
883 expression handling. */
884 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
887 add_memrange (collect
, memrange_absolute
, offset
, len
);
890 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
892 printf_filtered ("LOC_REG[parm] %s: ",
893 SYMBOL_PRINT_NAME (sym
));
894 add_register (collect
, reg
);
895 /* Check for doubles stored in two registers. */
896 /* FIXME: how about larger types stored in 3 or more regs? */
897 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
898 len
> register_size (gdbarch
, reg
))
899 add_register (collect
, reg
+ 1);
902 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
903 printf_filtered (" (will not collect %s)\n",
904 SYMBOL_PRINT_NAME (sym
));
908 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
911 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
912 SYMBOL_PRINT_NAME (sym
), len
);
914 printf_filtered (" from frame ptr reg %d\n", reg
);
916 add_memrange (collect
, reg
, offset
, len
);
918 case LOC_REGPARM_ADDR
:
919 reg
= SYMBOL_VALUE (sym
);
923 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
924 SYMBOL_PRINT_NAME (sym
), len
);
926 printf_filtered (" from reg %d\n", reg
);
928 add_memrange (collect
, reg
, offset
, len
);
932 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
935 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
936 SYMBOL_PRINT_NAME (sym
), len
);
938 printf_filtered (" from frame ptr reg %d\n", reg
);
940 add_memrange (collect
, reg
, offset
, len
);
947 case LOC_OPTIMIZED_OUT
:
948 printf_filtered ("%s has been optimized out of existence.\n",
949 SYMBOL_PRINT_NAME (sym
));
957 /* Expressions are the most general case. */
960 struct agent_expr
*aexpr
;
961 struct cleanup
*old_chain1
= NULL
;
962 struct agent_reqs areqs
;
964 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
966 /* It can happen that the symbol is recorded as a computed
967 location, but it's been optimized away and doesn't actually
968 have a location expression. */
971 printf_filtered ("%s has been optimized out of existence.\n",
972 SYMBOL_PRINT_NAME (sym
));
976 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
978 ax_reqs (aexpr
, &areqs
);
979 if (areqs
.flaw
!= agent_flaw_none
)
980 error (_("malformed expression"));
982 if (areqs
.min_height
< 0)
983 error (_("gdb: Internal error: expression has min height < 0"));
984 if (areqs
.max_height
> 20)
985 error (_("expression too complicated, try simplifying"));
987 discard_cleanups (old_chain1
);
988 add_aexpr (collect
, aexpr
);
990 /* take care of the registers */
991 if (areqs
.reg_mask_len
> 0)
995 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
997 QUIT
; /* allow user to bail out with ^C */
998 if (areqs
.reg_mask
[ndx1
] != 0)
1000 /* assume chars have 8 bits */
1001 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1002 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1003 /* it's used -- record it */
1004 add_register (collect
, ndx1
* 8 + ndx2
);
1011 /* Add all locals (or args) symbols to collection list */
1013 add_local_symbols (struct collection_list
*collect
,
1014 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1015 long frame_regno
, long frame_offset
, int type
)
1018 struct block
*block
;
1019 struct dict_iterator iter
;
1022 block
= block_for_pc (pc
);
1025 QUIT
; /* allow user to bail out with ^C */
1026 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
1028 if (SYMBOL_IS_ARGUMENT (sym
)
1029 ? type
== 'A' /* collecting Arguments */
1030 : type
== 'L') /* collecting Locals */
1033 collect_symbol (collect
, sym
, gdbarch
,
1034 frame_regno
, frame_offset
, pc
);
1037 if (BLOCK_FUNCTION (block
))
1040 block
= BLOCK_SUPERBLOCK (block
);
1043 warning (_("No %s found in scope."),
1044 type
== 'L' ? "locals" : "args");
1047 /* worker function */
1049 clear_collection_list (struct collection_list
*list
)
1053 list
->next_memrange
= 0;
1054 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1056 free_agent_expr (list
->aexpr_list
[ndx
]);
1057 list
->aexpr_list
[ndx
] = NULL
;
1059 list
->next_aexpr_elt
= 0;
1060 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1063 /* reduce a collection list to string form (for gdb protocol) */
1065 stringify_collection_list (struct collection_list
*list
, char *string
)
1067 char temp_buf
[2048];
1071 char *(*str_list
)[];
1075 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1076 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1078 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1079 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1081 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1084 printf_filtered ("\nCollecting registers (mask): 0x");
1089 QUIT
; /* allow user to bail out with ^C */
1091 printf_filtered ("%02X", list
->regs_mask
[i
]);
1092 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1095 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1099 printf_filtered ("\n");
1100 if (list
->next_memrange
> 0 && info_verbose
)
1101 printf_filtered ("Collecting memranges: \n");
1102 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1104 QUIT
; /* allow user to bail out with ^C */
1105 sprintf_vma (tmp2
, list
->list
[i
].start
);
1108 printf_filtered ("(%d, %s, %ld)\n",
1111 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1113 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1115 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1122 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1124 /* The "%X" conversion specifier expects an unsigned argument,
1125 so passing -1 (memrange_absolute) to it directly gives you
1126 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1128 if (list
->list
[i
].type
== memrange_absolute
)
1129 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1131 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1134 count
+= strlen (end
);
1135 end
= temp_buf
+ count
;
1138 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1140 QUIT
; /* allow user to bail out with ^C */
1141 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1143 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1148 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1149 end
+= 10; /* 'X' + 8 hex digits + ',' */
1152 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1153 end
, list
->aexpr_list
[i
]->len
);
1154 count
+= 2 * list
->aexpr_list
[i
]->len
;
1159 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1164 (*str_list
)[ndx
] = NULL
;
1177 encode_actions_1 (struct command_line
*action
,
1178 struct breakpoint
*t
,
1179 struct bp_location
*tloc
,
1181 LONGEST frame_offset
,
1182 struct collection_list
*collect
,
1183 struct collection_list
*stepping_list
)
1186 struct expression
*exp
= NULL
;
1187 struct command_line
*actions
;
1189 struct value
*tempval
;
1190 struct cmd_list_element
*cmd
;
1191 struct agent_expr
*aexpr
;
1193 for (; action
; action
= action
->next
)
1195 QUIT
; /* allow user to bail out with ^C */
1196 action_exp
= action
->line
;
1197 while (isspace ((int) *action_exp
))
1200 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1202 error (_("Bad action list item: %s"), action_exp
);
1204 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1207 { /* repeat over a comma-separated list */
1208 QUIT
; /* allow user to bail out with ^C */
1209 while (isspace ((int) *action_exp
))
1212 if (0 == strncasecmp ("$reg", action_exp
, 4))
1214 for (i
= 0; i
< gdbarch_num_regs (t
->gdbarch
); i
++)
1215 add_register (collect
, i
);
1216 action_exp
= strchr (action_exp
, ','); /* more? */
1218 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1220 add_local_symbols (collect
,
1226 action_exp
= strchr (action_exp
, ','); /* more? */
1228 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1230 add_local_symbols (collect
,
1236 action_exp
= strchr (action_exp
, ','); /* more? */
1240 unsigned long addr
, len
;
1241 struct cleanup
*old_chain
= NULL
;
1242 struct cleanup
*old_chain1
= NULL
;
1243 struct agent_reqs areqs
;
1245 exp
= parse_exp_1 (&action_exp
,
1246 block_for_pc (tloc
->address
), 1);
1247 old_chain
= make_cleanup (free_current_contents
, &exp
);
1249 switch (exp
->elts
[0].opcode
)
1253 const char *name
= &exp
->elts
[2].string
;
1255 i
= user_reg_map_name_to_regnum (t
->gdbarch
,
1256 name
, strlen (name
));
1258 internal_error (__FILE__
, __LINE__
,
1259 _("Register $%s not available"),
1262 printf_filtered ("OP_REGISTER: ");
1263 add_register (collect
, i
);
1268 /* safe because we know it's a simple expression */
1269 tempval
= evaluate_expression (exp
);
1270 addr
= value_address (tempval
);
1271 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1272 add_memrange (collect
, memrange_absolute
, addr
, len
);
1276 collect_symbol (collect
,
1277 exp
->elts
[2].symbol
,
1284 default: /* full-fledged expression */
1285 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1287 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1289 ax_reqs (aexpr
, &areqs
);
1290 if (areqs
.flaw
!= agent_flaw_none
)
1291 error (_("malformed expression"));
1293 if (areqs
.min_height
< 0)
1294 error (_("gdb: Internal error: expression has min height < 0"));
1295 if (areqs
.max_height
> 20)
1296 error (_("expression too complicated, try simplifying"));
1298 discard_cleanups (old_chain1
);
1299 add_aexpr (collect
, aexpr
);
1301 /* take care of the registers */
1302 if (areqs
.reg_mask_len
> 0)
1307 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1309 QUIT
; /* allow user to bail out with ^C */
1310 if (areqs
.reg_mask
[ndx1
] != 0)
1312 /* assume chars have 8 bits */
1313 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1314 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1315 /* it's used -- record it */
1316 add_register (collect
,
1323 do_cleanups (old_chain
);
1326 while (action_exp
&& *action_exp
++ == ',');
1328 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1331 { /* repeat over a comma-separated list */
1332 QUIT
; /* allow user to bail out with ^C */
1333 while (isspace ((int) *action_exp
))
1337 unsigned long addr
, len
;
1338 struct cleanup
*old_chain
= NULL
;
1339 struct cleanup
*old_chain1
= NULL
;
1340 struct agent_reqs areqs
;
1342 exp
= parse_exp_1 (&action_exp
,
1343 block_for_pc (tloc
->address
), 1);
1344 old_chain
= make_cleanup (free_current_contents
, &exp
);
1346 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1347 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1349 ax_reqs (aexpr
, &areqs
);
1350 if (areqs
.flaw
!= agent_flaw_none
)
1351 error (_("malformed expression"));
1353 if (areqs
.min_height
< 0)
1354 error (_("gdb: Internal error: expression has min height < 0"));
1355 if (areqs
.max_height
> 20)
1356 error (_("expression too complicated, try simplifying"));
1358 discard_cleanups (old_chain1
);
1359 /* Even though we're not officially collecting, add
1360 to the collect list anyway. */
1361 add_aexpr (collect
, aexpr
);
1363 do_cleanups (old_chain
);
1366 while (action_exp
&& *action_exp
++ == ',');
1368 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1370 /* We check against nested while-stepping when setting
1371 breakpoint action, so no way to run into nested
1373 gdb_assert (stepping_list
);
1375 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
, frame_offset
,
1376 stepping_list
, NULL
);
1379 error (_("Invalid tracepoint command '%s'"), action
->line
);
1383 /* Render all actions into gdb protocol. */
1385 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1386 char ***tdp_actions
, char ***stepping_actions
)
1388 static char tdp_buff
[2048], step_buff
[2048];
1389 char *default_collect_line
= NULL
;
1390 struct command_line
*actions
;
1391 struct command_line
*default_collect_action
= NULL
;
1393 LONGEST frame_offset
;
1394 struct cleanup
*back_to
;
1396 back_to
= make_cleanup (null_cleanup
, NULL
);
1398 clear_collection_list (&tracepoint_list
);
1399 clear_collection_list (&stepping_list
);
1401 *tdp_actions
= NULL
;
1402 *stepping_actions
= NULL
;
1404 gdbarch_virtual_frame_pointer (t
->gdbarch
,
1405 t
->loc
->address
, &frame_reg
, &frame_offset
);
1407 actions
= t
->commands
->commands
;
1409 /* If there are default expressions to collect, make up a collect
1410 action and prepend to the action list to encode. Note that since
1411 validation is per-tracepoint (local var "xyz" might be valid for
1412 one tracepoint and not another, etc), we make up the action on
1413 the fly, and don't cache it. */
1414 if (*default_collect
)
1417 enum actionline_type linetype
;
1419 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1420 make_cleanup (xfree
, default_collect_line
);
1422 line
= default_collect_line
;
1423 linetype
= validate_actionline (&line
, t
);
1424 if (linetype
!= BADLINE
)
1426 default_collect_action
= xmalloc (sizeof (struct command_line
));
1427 make_cleanup (xfree
, default_collect_action
);
1428 default_collect_action
->next
= t
->commands
->commands
;
1429 default_collect_action
->line
= line
;
1430 actions
= default_collect_action
;
1433 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1434 &tracepoint_list
, &stepping_list
);
1436 memrange_sortmerge (&tracepoint_list
);
1437 memrange_sortmerge (&stepping_list
);
1439 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1441 *stepping_actions
= stringify_collection_list (&stepping_list
,
1444 do_cleanups (back_to
);
1448 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1450 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1452 collect
->aexpr_list
=
1453 xrealloc (collect
->aexpr_list
,
1454 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1455 collect
->aexpr_listsize
*= 2;
1457 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1458 collect
->next_aexpr_elt
++;
1463 start_tracing (void)
1466 VEC(breakpoint_p
) *tp_vec
= NULL
;
1468 struct breakpoint
*t
;
1469 struct trace_state_variable
*tsv
;
1470 int any_enabled
= 0;
1472 tp_vec
= all_tracepoints ();
1474 /* No point in tracing without any tracepoints... */
1475 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1477 VEC_free (breakpoint_p
, tp_vec
);
1478 error (_("No tracepoints defined, not starting trace"));
1481 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1483 if (t
->enable_state
== bp_enabled
)
1490 /* No point in tracing with only disabled tracepoints. */
1493 VEC_free (breakpoint_p
, tp_vec
);
1494 error (_("No tracepoints enabled, not starting trace"));
1497 target_trace_init ();
1499 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1501 t
->number_on_target
= 0;
1502 target_download_tracepoint (t
);
1503 t
->number_on_target
= t
->number
;
1505 VEC_free (breakpoint_p
, tp_vec
);
1507 /* Send down all the trace state variables too. */
1508 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1510 target_download_trace_state_variable (tsv
);
1513 /* Tell target to treat text-like sections as transparent. */
1514 target_trace_set_readonly_regions ();
1515 /* Set some mode flags. */
1516 target_set_disconnected_tracing (disconnected_tracing
);
1517 target_set_circular_trace_buffer (circular_trace_buffer
);
1519 /* Now insert traps and begin collecting data. */
1520 target_trace_start ();
1522 /* Reset our local state. */
1523 set_traceframe_num (-1);
1524 set_tracepoint_num (-1);
1525 set_traceframe_context (NULL
);
1526 current_trace_status()->running
= 1;
1531 Tell target to clear any previous trace experiment.
1532 Walk the list of tracepoints, and send them (and their actions)
1533 to the target. If no errors,
1534 Tell target to start a new trace experiment. */
1537 trace_start_command (char *args
, int from_tty
)
1539 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1546 trace_stop_command (char *args
, int from_tty
)
1554 target_trace_stop ();
1555 /* should change in response to reply? */
1556 current_trace_status ()->running
= 0;
1559 /* tstatus command */
1561 trace_status_command (char *args
, int from_tty
)
1563 struct trace_status
*ts
= current_trace_status ();
1566 status
= target_get_trace_status (ts
);
1571 printf_filtered (_("Using a trace file.\n"));
1574 printf_filtered (_("Trace can not be run on this target.\n"));
1579 if (!ts
->running_known
)
1581 printf_filtered (_("Run/stop status is unknown.\n"));
1583 else if (ts
->running
)
1585 printf_filtered (_("Trace is running on the target.\n"));
1586 if (disconnected_tracing
)
1587 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1589 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1593 switch (ts
->stop_reason
)
1595 case trace_never_run
:
1596 printf_filtered (_("No trace has been run on the target.\n"));
1599 printf_filtered (_("Trace stopped by a tstop command.\n"));
1601 case trace_buffer_full
:
1602 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1604 case trace_disconnected
:
1605 printf_filtered (_("Trace stopped because of disconnection.\n"));
1607 case tracepoint_passcount
:
1608 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1609 ts
->stopping_tracepoint
);
1611 case tracepoint_error
:
1612 if (ts
->stopping_tracepoint
)
1613 printf_filtered (_("Trace stopped by an error (%s, tracepoint %d).\n"),
1614 ts
->error_desc
, ts
->stopping_tracepoint
);
1616 printf_filtered (_("Trace stopped by an error (%s).\n"),
1619 case trace_stop_reason_unknown
:
1620 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1623 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1629 if (ts
->traceframes_created
>= 0
1630 && ts
->traceframe_count
!= ts
->traceframes_created
)
1632 printf_filtered (_("Buffer contains %d trace frames (of %d created total).\n"),
1633 ts
->traceframe_count
, ts
->traceframes_created
);
1635 else if (ts
->traceframe_count
>= 0)
1637 printf_filtered (_("Collected %d trace frames.\n"),
1638 ts
->traceframe_count
);
1641 if (ts
->buffer_free
>= 0)
1643 if (ts
->buffer_size
>= 0)
1645 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1646 ts
->buffer_free
, ts
->buffer_size
);
1647 if (ts
->buffer_size
> 0)
1648 printf_filtered (_(" (%d%% full)"),
1649 ((int) ((((long long) (ts
->buffer_size
1650 - ts
->buffer_free
)) * 100)
1651 / ts
->buffer_size
)));
1652 printf_filtered (_(".\n"));
1655 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1659 /* Now report on what we're doing with tfind. */
1660 if (traceframe_number
>= 0)
1661 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1662 traceframe_number
, tracepoint_number
);
1664 printf_filtered (_("Not looking at any trace frame.\n"));
1667 /* Report the trace status to uiout, in a way suitable for MI, and not
1668 suitable for CLI. If ON_STOP is true, suppress a few fields that
1669 are not meaningful in the -trace-stop response.
1671 The implementation is essentially parallel to trace_status_command, but
1672 merging them will result in unreadable code. */
1674 trace_status_mi (int on_stop
)
1676 struct trace_status
*ts
= current_trace_status ();
1678 char *string_status
;
1680 status
= target_get_trace_status (ts
);
1682 if (status
== -1 && !ts
->from_file
)
1684 ui_out_field_string (uiout
, "supported", "0");
1689 ui_out_field_string (uiout
, "supported", "file");
1691 ui_out_field_string (uiout
, "supported", "1");
1693 gdb_assert (ts
->running_known
);
1697 ui_out_field_string (uiout
, "running", "1");
1699 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1700 Given that the frontend gets the status either on -trace-stop, or from
1701 -trace-status after re-connection, it does not seem like this
1702 information is necessary for anything. It is not necessary for either
1703 figuring the vital state of the target nor for navigation of trace
1704 frames. If the frontend wants to show the current state is some
1705 configure dialog, it can request the value when such dialog is
1706 invoked by the user. */
1710 char *stop_reason
= NULL
;
1711 int stopping_tracepoint
= -1;
1714 ui_out_field_string (uiout
, "running", "0");
1716 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
1718 switch (ts
->stop_reason
)
1721 stop_reason
= "request";
1723 case trace_buffer_full
:
1724 stop_reason
= "overflow";
1726 case trace_disconnected
:
1727 stop_reason
= "disconnection";
1729 case tracepoint_passcount
:
1730 stop_reason
= "passcount";
1731 stopping_tracepoint
= ts
->stopping_tracepoint
;
1733 case tracepoint_error
:
1734 stop_reason
= "error";
1735 stopping_tracepoint
= ts
->stopping_tracepoint
;
1741 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
1742 if (stopping_tracepoint
!= -1)
1743 ui_out_field_int (uiout
, "stopping-tracepoint",
1744 stopping_tracepoint
);
1745 if (ts
->stop_reason
== tracepoint_error
)
1746 ui_out_field_string (uiout
, "error-description",
1753 if ((int) ts
->traceframe_count
!= -1)
1754 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
1755 if ((int) ts
->buffer_size
!= -1)
1756 ui_out_field_int (uiout
, "buffer-size", (int) ts
->buffer_size
);
1757 if ((int) ts
->buffer_free
!= -1)
1758 ui_out_field_int (uiout
, "buffer-free", (int) ts
->buffer_free
);
1763 disconnect_or_stop_tracing (int from_tty
)
1765 /* It can happen that the target that was tracing went away on its
1766 own, and we didn't notice. Get a status update, and if the
1767 current target doesn't even do tracing, then assume it's not
1769 if (target_get_trace_status (current_trace_status ()) < 0)
1770 current_trace_status ()->running
= 0;
1772 if (current_trace_status ()->running
&& from_tty
)
1774 int cont
= query (_("Trace is running. Continue tracing after detach? "));
1775 /* Note that we send the query result without affecting the
1776 user's setting of disconnected_tracing, so that the answer is
1778 send_disconnected_tracing_value (cont
);
1780 /* Also ensure that we do the equivalent of a tstop command if
1781 tracing is not to continue after the detach. */
1786 /* Also we want to be out of tfind mode, otherwise things can get
1787 confusing upon reconnection. Just use these calls instead of
1788 full tfind_1 behavior because we're in the middle of detaching,
1789 and there's no point to updating current stack frame etc. */
1790 set_traceframe_number (-1);
1791 set_traceframe_context (NULL
);
1794 /* Worker function for the various flavors of the tfind command. */
1796 tfind_1 (enum trace_find_type type
, int num
,
1797 ULONGEST addr1
, ULONGEST addr2
,
1800 int target_frameno
= -1, target_tracept
= -1;
1801 struct frame_id old_frame_id
;
1803 struct breakpoint
*tp
;
1805 old_frame_id
= get_frame_id (get_current_frame ());
1807 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
1810 if (type
== tfind_number
1812 && target_frameno
== -1)
1814 /* We told the target to get out of tfind mode, and it did. */
1816 else if (target_frameno
== -1)
1818 /* A request for a non-existant trace frame has failed.
1819 Our response will be different, depending on FROM_TTY:
1821 If FROM_TTY is true, meaning that this command was
1822 typed interactively by the user, then give an error
1823 and DO NOT change the state of traceframe_number etc.
1825 However if FROM_TTY is false, meaning that we're either
1826 in a script, a loop, or a user-defined command, then
1827 DON'T give an error, but DO change the state of
1828 traceframe_number etc. to invalid.
1830 The rationalle is that if you typed the command, you
1831 might just have committed a typo or something, and you'd
1832 like to NOT lose your current debugging state. However
1833 if you're in a user-defined command or especially in a
1834 loop, then you need a way to detect that the command
1835 failed WITHOUT aborting. This allows you to write
1836 scripts that search thru the trace buffer until the end,
1837 and then continue on to do something else. */
1840 error (_("Target failed to find requested trace frame."));
1844 printf_filtered ("End of trace buffer.\n");
1845 #if 0 /* dubious now? */
1846 /* The following will not recurse, since it's
1848 trace_find_command ("-1", from_tty
);
1853 tp
= get_tracepoint_by_number_on_target (target_tracept
);
1855 reinit_frame_cache ();
1856 registers_changed ();
1857 target_dcache_invalidate ();
1858 set_traceframe_num (target_frameno
);
1859 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
1860 if (target_frameno
== -1)
1861 set_traceframe_context (NULL
);
1863 set_traceframe_context (get_current_frame ());
1865 if (traceframe_number
>= 0)
1867 /* Use different branches for MI and CLI to make CLI messages
1869 if (ui_out_is_mi_like_p (uiout
))
1871 ui_out_field_string (uiout
, "found", "1");
1872 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
1873 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
1877 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
1878 traceframe_number
, tracepoint_number
);
1883 if (ui_out_is_mi_like_p (uiout
))
1884 ui_out_field_string (uiout
, "found", "0");
1886 printf_unfiltered (_("No trace frame found"));
1889 /* If we're in nonstop mode and getting out of looking at trace
1890 frames, there won't be any current frame to go back to and
1893 && (has_stack_frames () || traceframe_number
>= 0))
1895 enum print_what print_what
;
1897 /* NOTE: in immitation of the step command, try to determine
1898 whether we have made a transition from one function to
1899 another. If so, we'll print the "stack frame" (ie. the new
1900 function and it's arguments) -- otherwise we'll just show the
1903 if (frame_id_eq (old_frame_id
,
1904 get_frame_id (get_current_frame ())))
1905 print_what
= SRC_LINE
;
1907 print_what
= SRC_AND_LOC
;
1909 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
1914 /* trace_find_command takes a trace frame number n,
1915 sends "QTFrame:<n>" to the target,
1916 and accepts a reply that may contain several optional pieces
1917 of information: a frame number, a tracepoint number, and an
1918 indication of whether this is a trap frame or a stepping frame.
1920 The minimal response is just "OK" (which indicates that the
1921 target does not give us a frame number or a tracepoint number).
1922 Instead of that, the target may send us a string containing
1924 F<hexnum> (gives the selected frame number)
1925 T<hexnum> (gives the selected tracepoint number)
1930 trace_find_command (char *args
, int from_tty
)
1931 { /* this should only be called with a numeric argument */
1934 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1935 error ("May not look at trace frames while trace is running.");
1937 if (args
== 0 || *args
== 0)
1938 { /* TFIND with no args means find NEXT trace frame. */
1939 if (traceframe_number
== -1)
1940 frameno
= 0; /* "next" is first one */
1942 frameno
= traceframe_number
+ 1;
1944 else if (0 == strcmp (args
, "-"))
1946 if (traceframe_number
== -1)
1947 error (_("not debugging trace buffer"));
1948 else if (from_tty
&& traceframe_number
== 0)
1949 error (_("already at start of trace buffer"));
1951 frameno
= traceframe_number
- 1;
1953 /* A hack to work around eval's need for fp to have been collected. */
1954 else if (0 == strcmp (args
, "-1"))
1957 frameno
= parse_and_eval_long (args
);
1960 error (_("invalid input (%d is less than zero)"), frameno
);
1962 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
1967 trace_find_end_command (char *args
, int from_tty
)
1969 trace_find_command ("-1", from_tty
);
1974 trace_find_none_command (char *args
, int from_tty
)
1976 trace_find_command ("-1", from_tty
);
1981 trace_find_start_command (char *args
, int from_tty
)
1983 trace_find_command ("0", from_tty
);
1986 /* tfind pc command */
1988 trace_find_pc_command (char *args
, int from_tty
)
1993 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1994 error ("May not look at trace frames while trace is running.");
1996 if (args
== 0 || *args
== 0)
1997 pc
= regcache_read_pc (get_current_regcache ());
1999 pc
= parse_and_eval_address (args
);
2001 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
2004 /* tfind tracepoint command */
2006 trace_find_tracepoint_command (char *args
, int from_tty
)
2009 struct breakpoint
*tp
;
2011 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2012 error ("May not look at trace frames while trace is running.");
2014 if (args
== 0 || *args
== 0)
2016 if (tracepoint_number
== -1)
2017 error (_("No current tracepoint -- please supply an argument."));
2019 tdp
= tracepoint_number
; /* default is current TDP */
2022 tdp
= parse_and_eval_long (args
);
2024 /* If we have the tracepoint on hand, use the number that the
2025 target knows about (which may be different if we disconnected
2026 and reconnected). */
2027 tp
= get_tracepoint (tdp
);
2029 tdp
= tp
->number_on_target
;
2031 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2034 /* TFIND LINE command:
2036 This command will take a sourceline for argument, just like BREAK
2037 or TRACE (ie. anything that "decode_line_1" can handle).
2039 With no argument, this command will find the next trace frame
2040 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2043 trace_find_line_command (char *args
, int from_tty
)
2045 static CORE_ADDR start_pc
, end_pc
;
2046 struct symtabs_and_lines sals
;
2047 struct symtab_and_line sal
;
2048 struct cleanup
*old_chain
;
2049 char startpc_str
[40], endpc_str
[40];
2051 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2052 error ("May not look at trace frames while trace is running.");
2054 if (args
== 0 || *args
== 0)
2056 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2058 sals
.sals
= (struct symtab_and_line
*)
2059 xmalloc (sizeof (struct symtab_and_line
));
2064 sals
= decode_line_spec (args
, 1);
2068 old_chain
= make_cleanup (xfree
, sals
.sals
);
2069 if (sal
.symtab
== 0)
2070 error (_("No line number information available."));
2072 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2074 if (start_pc
== end_pc
)
2076 printf_filtered ("Line %d of \"%s\"",
2077 sal
.line
, sal
.symtab
->filename
);
2079 printf_filtered (" is at address ");
2080 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2082 printf_filtered (" but contains no code.\n");
2083 sal
= find_pc_line (start_pc
, 0);
2085 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2086 && start_pc
!= end_pc
)
2087 printf_filtered ("Attempting to find line %d instead.\n",
2090 error (_("Cannot find a good line."));
2094 /* Is there any case in which we get here, and have an address
2095 which the user would want to see? If we have debugging
2096 symbols and no line numbers? */
2097 error (_("Line number %d is out of range for \"%s\"."),
2098 sal
.line
, sal
.symtab
->filename
);
2100 /* Find within range of stated line. */
2102 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2104 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2105 do_cleanups (old_chain
);
2108 /* tfind range command */
2110 trace_find_range_command (char *args
, int from_tty
)
2112 static CORE_ADDR start
, stop
;
2113 char start_str
[40], stop_str
[40];
2116 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2117 error ("May not look at trace frames while trace is running.");
2119 if (args
== 0 || *args
== 0)
2120 { /* XXX FIXME: what should default behavior be? */
2121 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2125 if (0 != (tmp
= strchr (args
, ',')))
2127 *tmp
++ = '\0'; /* terminate start address */
2128 while (isspace ((int) *tmp
))
2130 start
= parse_and_eval_address (args
);
2131 stop
= parse_and_eval_address (tmp
);
2134 { /* no explicit end address? */
2135 start
= parse_and_eval_address (args
);
2136 stop
= start
+ 1; /* ??? */
2139 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2142 /* tfind outside command */
2144 trace_find_outside_command (char *args
, int from_tty
)
2146 CORE_ADDR start
, stop
;
2147 char start_str
[40], stop_str
[40];
2150 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2151 error ("May not look at trace frames while trace is running.");
2153 if (args
== 0 || *args
== 0)
2154 { /* XXX FIXME: what should default behavior be? */
2155 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2159 if (0 != (tmp
= strchr (args
, ',')))
2161 *tmp
++ = '\0'; /* terminate start address */
2162 while (isspace ((int) *tmp
))
2164 start
= parse_and_eval_address (args
);
2165 stop
= parse_and_eval_address (tmp
);
2168 { /* no explicit end address? */
2169 start
= parse_and_eval_address (args
);
2170 stop
= start
+ 1; /* ??? */
2173 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2176 /* info scope command: list the locals for a scope. */
2178 scope_info (char *args
, int from_tty
)
2180 struct symtabs_and_lines sals
;
2182 struct minimal_symbol
*msym
;
2183 struct block
*block
;
2184 char **canonical
, *symname
, *save_args
= args
;
2185 struct dict_iterator iter
;
2187 struct gdbarch
*gdbarch
;
2190 if (args
== 0 || *args
== 0)
2191 error (_("requires an argument (function, line or *addr) to define a scope"));
2193 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2194 if (sals
.nelts
== 0)
2195 return; /* presumably decode_line_1 has already warned */
2197 /* Resolve line numbers to PC */
2198 resolve_sal_pc (&sals
.sals
[0]);
2199 block
= block_for_pc (sals
.sals
[0].pc
);
2203 QUIT
; /* allow user to bail out with ^C */
2204 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2206 QUIT
; /* allow user to bail out with ^C */
2208 printf_filtered ("Scope for %s:\n", save_args
);
2211 symname
= SYMBOL_PRINT_NAME (sym
);
2212 if (symname
== NULL
|| *symname
== '\0')
2213 continue; /* probably botched, certainly useless */
2215 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2217 printf_filtered ("Symbol %s is ", symname
);
2218 switch (SYMBOL_CLASS (sym
))
2221 case LOC_UNDEF
: /* messed up symbol? */
2222 printf_filtered ("a bogus symbol, class %d.\n",
2223 SYMBOL_CLASS (sym
));
2224 count
--; /* don't count this one */
2227 printf_filtered ("a constant with value %ld (0x%lx)",
2228 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2230 case LOC_CONST_BYTES
:
2231 printf_filtered ("constant bytes: ");
2232 if (SYMBOL_TYPE (sym
))
2233 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2234 fprintf_filtered (gdb_stdout
, " %02x",
2235 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2238 printf_filtered ("in static storage at address ");
2239 printf_filtered ("%s", paddress (gdbarch
,
2240 SYMBOL_VALUE_ADDRESS (sym
)));
2243 /* GDBARCH is the architecture associated with the objfile
2244 the symbol is defined in; the target architecture may be
2245 different, and may provide additional registers. However,
2246 we do not know the target architecture at this point.
2247 We assume the objfile architecture will contain all the
2248 standard registers that occur in debug info in that
2250 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2252 if (SYMBOL_IS_ARGUMENT (sym
))
2253 printf_filtered ("an argument in register $%s",
2254 gdbarch_register_name (gdbarch
, regno
));
2256 printf_filtered ("a local variable in register $%s",
2257 gdbarch_register_name (gdbarch
, regno
));
2260 printf_filtered ("an argument at stack/frame offset %ld",
2261 SYMBOL_VALUE (sym
));
2264 printf_filtered ("a local variable at frame offset %ld",
2265 SYMBOL_VALUE (sym
));
2268 printf_filtered ("a reference argument at offset %ld",
2269 SYMBOL_VALUE (sym
));
2271 case LOC_REGPARM_ADDR
:
2272 /* Note comment at LOC_REGISTER. */
2273 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2274 printf_filtered ("the address of an argument, in register $%s",
2275 gdbarch_register_name (gdbarch
, regno
));
2278 printf_filtered ("a typedef.\n");
2281 printf_filtered ("a label at address ");
2282 printf_filtered ("%s", paddress (gdbarch
,
2283 SYMBOL_VALUE_ADDRESS (sym
)));
2286 printf_filtered ("a function at address ");
2287 printf_filtered ("%s",
2288 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2290 case LOC_UNRESOLVED
:
2291 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2294 printf_filtered ("Unresolved Static");
2297 printf_filtered ("static storage at address ");
2298 printf_filtered ("%s",
2299 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2302 case LOC_OPTIMIZED_OUT
:
2303 printf_filtered ("optimized out.\n");
2306 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, gdb_stdout
);
2309 if (SYMBOL_TYPE (sym
))
2310 printf_filtered (", length %d.\n",
2311 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2313 if (BLOCK_FUNCTION (block
))
2316 block
= BLOCK_SUPERBLOCK (block
);
2319 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2323 /* worker function (cleanup) */
2325 replace_comma (void *data
)
2333 trace_dump_command (char *args
, int from_tty
)
2335 struct regcache
*regcache
;
2336 struct gdbarch
*gdbarch
;
2337 struct breakpoint
*t
;
2338 struct command_line
*action
;
2339 char *action_exp
, *next_comma
;
2340 struct cleanup
*old_cleanups
;
2341 int stepping_actions
= 0;
2342 int stepping_frame
= 0;
2343 struct bp_location
*loc
;
2345 if (tracepoint_number
== -1)
2347 warning (_("No current trace frame."));
2351 t
= get_tracepoint (tracepoint_number
);
2354 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2357 old_cleanups
= make_cleanup (null_cleanup
, NULL
);
2359 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2360 tracepoint_number
, traceframe_number
);
2362 /* The current frame is a trap frame if the frame PC is equal
2363 to the tracepoint PC. If not, then the current frame was
2364 collected during single-stepping. */
2366 regcache
= get_current_regcache ();
2367 gdbarch
= get_regcache_arch (regcache
);
2369 /* If the traceframe's address matches any of the tracepoint's
2370 locations, assume it is a direct hit rather than a while-stepping
2371 frame. (FIXME this is not reliable, should record each frame's
2374 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2375 if (loc
->address
== regcache_read_pc (regcache
))
2378 for (action
= t
->commands
->commands
; action
; action
= action
->next
)
2380 struct cmd_list_element
*cmd
;
2382 QUIT
; /* allow user to bail out with ^C */
2383 action_exp
= action
->line
;
2384 while (isspace ((int) *action_exp
))
2387 /* The collection actions to be done while stepping are
2388 bracketed by the commands "while-stepping" and "end". */
2390 if (*action_exp
== '#') /* comment line */
2393 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2395 error (_("Bad action list item: %s"), action_exp
);
2397 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2398 stepping_actions
= 1;
2399 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2400 stepping_actions
= 0;
2401 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2403 /* Display the collected data.
2404 For the trap frame, display only what was collected at
2405 the trap. Likewise for stepping frames, display only
2406 what was collected while stepping. This means that the
2407 two boolean variables, STEPPING_FRAME and
2408 STEPPING_ACTIONS should be equal. */
2409 if (stepping_frame
== stepping_actions
)
2412 { /* repeat over a comma-separated list */
2413 QUIT
; /* allow user to bail out with ^C */
2414 if (*action_exp
== ',')
2416 while (isspace ((int) *action_exp
))
2419 next_comma
= strchr (action_exp
, ',');
2421 if (0 == strncasecmp (action_exp
, "$reg", 4))
2422 registers_info (NULL
, from_tty
);
2423 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2424 locals_info (NULL
, from_tty
);
2425 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2426 args_info (NULL
, from_tty
);
2431 make_cleanup (replace_comma
, next_comma
);
2434 printf_filtered ("%s = ", action_exp
);
2435 output_command (action_exp
, from_tty
);
2436 printf_filtered ("\n");
2440 action_exp
= next_comma
;
2442 while (action_exp
&& *action_exp
== ',');
2446 discard_cleanups (old_cleanups
);
2449 /* Encode a piece of a tracepoint's source-level definition in a form
2450 that is suitable for both protocol and saving in files. */
2451 /* This version does not do multiple encodes for long strings; it should
2452 return an offset to the next piece to encode. FIXME */
2455 encode_source_string (int tpnum
, ULONGEST addr
,
2456 char *srctype
, char *src
, char *buf
, int buf_size
)
2458 if (80 + strlen (srctype
) > buf_size
)
2459 error (_("Buffer too small for source encoding"));
2460 sprintf (buf
, "%x:%s:%s:%x:%x:",
2461 tpnum
, phex_nz (addr
, sizeof (addr
)), srctype
, 0, (int) strlen (src
));
2462 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2463 error (_("Source string too long for buffer"));
2464 bin2hex (src
, buf
+ strlen (buf
), 0);
2468 extern int trace_regblock_size
;
2470 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2471 non-zero, the save is performed on the target, otherwise GDB obtains all
2472 trace data and saves it locally. */
2475 trace_save (const char *filename
, int target_does_save
)
2477 struct cleanup
*cleanup
;
2479 struct trace_status
*ts
= current_trace_status ();
2482 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2483 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2485 struct uploaded_string
*cmd
;
2487 ULONGEST offset
= 0;
2488 #define MAX_TRACE_UPLOAD 2000
2489 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2492 /* If the target is to save the data to a file on its own, then just
2493 send the command and be done with it. */
2494 if (target_does_save
)
2496 err
= target_save_trace_data (filename
);
2498 error (_("Target failed to save trace data to '%s'."),
2503 /* Get the trace status first before opening the file, so if the
2504 target is losing, we can get out without touching files. */
2505 status
= target_get_trace_status (ts
);
2507 pathname
= tilde_expand (filename
);
2508 cleanup
= make_cleanup (xfree
, pathname
);
2510 fp
= fopen (pathname
, "w");
2512 error (_("Unable to open file '%s' for saving trace data (%s)"),
2513 filename
, safe_strerror (errno
));
2514 make_cleanup_fclose (fp
);
2516 /* Write a file header, with a high-bit-set char to indicate a
2517 binary file, plus a hint as what this file is, and a version
2518 number in case of future needs. */
2519 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2521 perror_with_name (pathname
);
2523 /* Write descriptive info. */
2525 /* Write out the size of a register block. */
2526 fprintf (fp
, "R %x\n", trace_regblock_size
);
2528 /* Write out status of the tracing run (aka "tstatus" info). */
2529 fprintf (fp
, "status %c;%s",
2530 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
2531 if (ts
->stop_reason
== tracepoint_error
)
2533 char *buf
= (char *) alloca (strlen (ts
->error_desc
) * 2 + 1);
2534 bin2hex ((gdb_byte
*) ts
->error_desc
, buf
, 0);
2535 fprintf (fp
, ":%s", buf
);
2537 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
2538 if (ts
->traceframe_count
>= 0)
2539 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
2540 if (ts
->traceframes_created
>= 0)
2541 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
2542 if (ts
->buffer_free
>= 0)
2543 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
2544 if (ts
->buffer_size
>= 0)
2545 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
2548 /* Note that we want to upload tracepoints and save those, rather
2549 than simply writing out the local ones, because the user may have
2550 changed tracepoints in GDB in preparation for a future tracing
2551 run, or maybe just mass-deleted all types of breakpoints as part
2552 of cleaning up. So as not to contaminate the session, leave the
2553 data in its uploaded form, don't make into real tracepoints. */
2555 /* Get trace state variables first, they may be checked when parsing
2556 uploaded commands. */
2558 target_upload_trace_state_variables (&uploaded_tsvs
);
2560 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2566 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
2567 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
2570 fprintf (fp
, "tsv %x:%s:%x:%s\n",
2571 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
2572 utsv
->builtin
, buf
);
2578 free_uploaded_tsvs (&uploaded_tsvs
);
2580 target_upload_tracepoints (&uploaded_tps
);
2582 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
2584 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
2585 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2586 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
2587 if (utp
->type
== bp_fast_tracepoint
)
2588 fprintf (fp
, ":F%x", utp
->orig_size
);
2590 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
2593 for (a
= 0; a
< utp
->numactions
; ++a
)
2594 fprintf (fp
, "tp A%x:%s:%s\n",
2595 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2597 for (a
= 0; a
< utp
->num_step_actions
; ++a
)
2598 fprintf (fp
, "tp S%x:%s:%s\n",
2599 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2600 utp
->step_actions
[a
]);
2603 encode_source_string (utp
->number
, utp
->addr
,
2604 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
2605 fprintf (fp
, "tp Z%s\n", buf
);
2607 if (utp
->cond_string
)
2609 encode_source_string (utp
->number
, utp
->addr
,
2610 "cond", utp
->cond_string
, buf
, MAX_TRACE_UPLOAD
);
2611 fprintf (fp
, "tp Z%s\n", buf
);
2613 for (cmd
= utp
->cmd_strings
; cmd
; cmd
= cmd
->next
)
2615 encode_source_string (utp
->number
, utp
->addr
, "cmd", cmd
->str
,
2616 buf
, MAX_TRACE_UPLOAD
);
2617 fprintf (fp
, "tp Z%s\n", buf
);
2621 free_uploaded_tps (&uploaded_tps
);
2623 /* Mark the end of the definition section. */
2626 /* Get and write the trace data proper. We ask for big blocks, in
2627 the hopes of efficiency, but will take less if the target has
2628 packet size limitations or some such. */
2631 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
2633 error (_("Failure to get requested trace buffer data"));
2634 /* No more data is forthcoming, we're done. */
2637 written
= fwrite (buf
, gotten
, 1, fp
);
2639 perror_with_name (pathname
);
2643 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
2644 written
= fwrite (&gotten
, 4, 1, fp
);
2646 perror_with_name (pathname
);
2648 do_cleanups (cleanup
);
2652 trace_save_command (char *args
, int from_tty
)
2654 int target_does_save
= 0;
2656 char *filename
= NULL
;
2657 struct cleanup
*back_to
;
2660 error_no_arg (_("file in which to save trace data"));
2662 argv
= gdb_buildargv (args
);
2663 back_to
= make_cleanup_freeargv (argv
);
2665 for (; *argv
; ++argv
)
2667 if (strcmp (*argv
, "-r") == 0)
2668 target_does_save
= 1;
2669 else if (**argv
== '-')
2670 error (_("unknown option `%s'"), *argv
);
2676 error_no_arg (_("file in which to save trace data"));
2678 trace_save (filename
, target_does_save
);
2681 printf_filtered (_("Trace data saved to file '%s'.\n"), args
);
2683 do_cleanups (back_to
);
2686 /* Tell the target what to do with an ongoing tracing run if GDB
2687 disconnects for some reason. */
2690 send_disconnected_tracing_value (int value
)
2692 target_set_disconnected_tracing (value
);
2696 set_disconnected_tracing (char *args
, int from_tty
,
2697 struct cmd_list_element
*c
)
2699 send_disconnected_tracing_value (disconnected_tracing
);
2703 set_circular_trace_buffer (char *args
, int from_tty
,
2704 struct cmd_list_element
*c
)
2706 target_set_circular_trace_buffer (circular_trace_buffer
);
2709 /* Convert the memory pointed to by mem into hex, placing result in buf.
2710 * Return a pointer to the last char put in buf (null)
2711 * "stolen" from sparc-stub.c
2714 static const char hexchars
[] = "0123456789abcdef";
2717 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2725 *buf
++ = hexchars
[ch
>> 4];
2726 *buf
++ = hexchars
[ch
& 0xf];
2735 get_traceframe_number (void)
2737 return traceframe_number
;
2740 /* Make the traceframe NUM be the current trace frame. Does nothing
2741 if NUM is already current. */
2744 set_traceframe_number (int num
)
2748 if (traceframe_number
== num
)
2750 /* Nothing to do. */
2754 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
2757 warning (_("could not change traceframe"));
2759 traceframe_number
= newnum
;
2761 /* Changing the traceframe changes our view of registers and of the
2763 registers_changed ();
2766 /* A cleanup used when switching away and back from tfind mode. */
2768 struct current_traceframe_cleanup
2770 /* The traceframe we were inspecting. */
2771 int traceframe_number
;
2775 do_restore_current_traceframe_cleanup (void *arg
)
2777 struct current_traceframe_cleanup
*old
= arg
;
2779 set_traceframe_number (old
->traceframe_number
);
2783 restore_current_traceframe_cleanup_dtor (void *arg
)
2785 struct current_traceframe_cleanup
*old
= arg
;
2791 make_cleanup_restore_current_traceframe (void)
2793 struct current_traceframe_cleanup
*old
;
2795 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
2796 old
->traceframe_number
= traceframe_number
;
2798 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
2799 restore_current_traceframe_cleanup_dtor
);
2802 /* Given a number and address, return an uploaded tracepoint with that
2803 number, creating if necessary. */
2805 struct uploaded_tp
*
2806 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
2808 struct uploaded_tp
*utp
;
2810 for (utp
= *utpp
; utp
; utp
= utp
->next
)
2811 if (utp
->number
== num
&& utp
->addr
== addr
)
2813 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
2814 memset (utp
, 0, sizeof (struct uploaded_tp
));
2823 free_uploaded_tps (struct uploaded_tp
**utpp
)
2825 struct uploaded_tp
*next_one
;
2829 next_one
= (*utpp
)->next
;
2835 /* Given a number and address, return an uploaded tracepoint with that
2836 number, creating if necessary. */
2838 struct uploaded_tsv
*
2839 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
2841 struct uploaded_tsv
*utsv
;
2843 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
2844 if (utsv
->number
== num
)
2846 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
2847 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
2849 utsv
->next
= *utsvp
;
2855 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
2857 struct uploaded_tsv
*next_one
;
2861 next_one
= (*utsvp
)->next
;
2867 /* Look for an existing tracepoint that seems similar enough to the
2868 uploaded one. Enablement isn't compared, because the user can
2869 toggle that freely, and may have done so in anticipation of the
2873 find_matching_tracepoint (struct uploaded_tp
*utp
)
2875 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
2877 struct breakpoint
*t
;
2878 struct bp_location
*loc
;
2880 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2882 if (t
->type
== utp
->type
2883 && t
->step_count
== utp
->step
2884 && t
->pass_count
== utp
->pass
2885 /* FIXME also test conditionals and actions */
2888 /* Scan the locations for an address match. */
2889 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2891 if (loc
->address
== utp
->addr
)
2899 /* Given a list of tracepoints uploaded from a target, attempt to
2900 match them up with existing tracepoints, and create new ones if not
2904 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
2906 struct uploaded_tp
*utp
;
2907 struct breakpoint
*t
;
2909 /* Look for GDB tracepoints that match up with our uploaded versions. */
2910 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
2912 t
= find_matching_tracepoint (utp
);
2914 printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
2915 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2918 t
= create_tracepoint_from_upload (utp
);
2920 printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
2921 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2923 printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
2924 utp
->number
, paddress (get_current_arch (), utp
->addr
));
2926 /* Whether found or created, record the number used by the
2927 target, to help with mapping target tracepoints back to their
2928 counterparts here. */
2930 t
->number_on_target
= utp
->number
;
2933 free_uploaded_tps (uploaded_tps
);
2936 /* Trace state variables don't have much to identify them beyond their
2937 name, so just use that to detect matches. */
2939 struct trace_state_variable
*
2940 find_matching_tsv (struct uploaded_tsv
*utsv
)
2945 return find_trace_state_variable (utsv
->name
);
2948 struct trace_state_variable
*
2949 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
2951 const char *namebase
;
2954 struct trace_state_variable
*tsv
;
2958 namebase
= utsv
->name
;
2959 sprintf (buf
, "%s", namebase
);
2964 sprintf (buf
, "%s_%d", namebase
, try_num
++);
2967 /* Fish for a name that is not in use. */
2968 /* (should check against all internal vars?) */
2969 while (find_trace_state_variable (buf
))
2970 sprintf (buf
, "%s_%d", namebase
, try_num
++);
2972 /* We have an available name, create the variable. */
2973 tsv
= create_trace_state_variable (xstrdup (buf
));
2974 tsv
->initial_value
= utsv
->initial_value
;
2975 tsv
->builtin
= utsv
->builtin
;
2980 /* Given a list of uploaded trace state variables, try to match them
2981 up with existing variables, or create additional ones. */
2984 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
2987 struct uploaded_tsv
*utsv
;
2988 struct trace_state_variable
*tsv
;
2991 /* Most likely some numbers will have to be reassigned as part of
2992 the merge, so clear them all in anticipation. */
2993 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2996 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2998 tsv
= find_matching_tsv (utsv
);
3000 printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
3001 tsv
->name
, utsv
->number
);
3004 tsv
= create_tsv_from_upload (utsv
);
3005 printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
3006 tsv
->name
, utsv
->number
);
3008 /* Give precedence to numberings that come from the target. */
3010 tsv
->number
= utsv
->number
;
3013 /* Renumber everything that didn't get a target-assigned number. */
3015 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3016 if (tsv
->number
> highest
)
3017 highest
= tsv
->number
;
3020 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3021 if (tsv
->number
== 0)
3022 tsv
->number
= highest
++;
3024 free_uploaded_tsvs (uploaded_tsvs
);
3027 /* target tfile command */
3029 struct target_ops tfile_ops
;
3031 /* Fill in tfile_ops with its defined operations and properties. */
3033 #define TRACE_HEADER_SIZE 8
3035 char *trace_filename
;
3037 off_t trace_frames_offset
;
3040 int trace_regblock_size
;
3042 static void tfile_interp_line (char *line
,
3043 struct uploaded_tp
**utpp
,
3044 struct uploaded_tsv
**utsvp
);
3047 tfile_open (char *filename
, int from_tty
)
3050 struct cleanup
*old_chain
;
3053 char header
[TRACE_HEADER_SIZE
];
3054 char linebuf
[1000]; /* should be max remote packet size or so */
3056 int bytes
, i
, gotten
;
3057 struct trace_status
*ts
;
3058 struct uploaded_tp
*uploaded_tps
= NULL
;
3059 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3061 target_preopen (from_tty
);
3063 error (_("No trace file specified."));
3065 filename
= tilde_expand (filename
);
3066 if (!IS_ABSOLUTE_PATH(filename
))
3068 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
3073 old_chain
= make_cleanup (xfree
, filename
);
3075 flags
= O_BINARY
| O_LARGEFILE
;
3077 scratch_chan
= open (filename
, flags
, 0);
3078 if (scratch_chan
< 0)
3079 perror_with_name (filename
);
3081 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3083 discard_cleanups (old_chain
); /* Don't free filename any more */
3084 unpush_target (&tfile_ops
);
3086 push_target (&tfile_ops
);
3088 trace_filename
= xstrdup (filename
);
3089 trace_fd
= scratch_chan
;
3092 /* Read the file header and test for validity. */
3093 gotten
= read (trace_fd
, &header
, TRACE_HEADER_SIZE
);
3095 perror_with_name (trace_filename
);
3096 else if (gotten
< TRACE_HEADER_SIZE
)
3097 error (_("Premature end of file while reading trace file"));
3099 bytes
+= TRACE_HEADER_SIZE
;
3100 if (!(header
[0] == 0x7f
3101 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3102 error (_("File is not a valid trace file."));
3104 trace_regblock_size
= 0;
3105 ts
= current_trace_status ();
3106 /* We know we're working with a file. */
3108 /* Set defaults in case there is no status line. */
3109 ts
->running_known
= 0;
3110 ts
->stop_reason
= trace_stop_reason_unknown
;
3111 ts
->traceframe_count
= -1;
3112 ts
->buffer_free
= 0;
3114 /* Read through a section of newline-terminated lines that
3115 define things like tracepoints. */
3119 gotten
= read (trace_fd
, &byte
, 1);
3121 perror_with_name (trace_filename
);
3122 else if (gotten
< 1)
3123 error (_("Premature end of file while reading trace file"));
3128 /* Empty line marks end of the definition section. */
3133 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3136 linebuf
[i
++] = byte
;
3138 error (_("Excessively long lines in trace file"));
3141 /* Add the file's tracepoints and variables into the current mix. */
3143 /* Get trace state variables first, they may be checked when parsing
3144 uploaded commands. */
3145 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3147 merge_uploaded_tracepoints (&uploaded_tps
);
3149 /* Record the starting offset of the binary trace data. */
3150 trace_frames_offset
= bytes
;
3152 /* If we don't have a blocksize, we can't interpret the
3154 if (trace_regblock_size
== 0)
3155 error (_("No register block size recorded in trace file"));
3156 if (ts
->traceframe_count
<= 0)
3158 warning ("No traceframes present in this file.");
3162 #define TFILE_PID (1)
3163 inferior_appeared (current_inferior (), TFILE_PID
);
3164 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3165 add_thread_silent (inferior_ptid
);
3167 post_create_inferior (&tfile_ops
, from_tty
);
3170 /* FIXME this will get defined in MI patch submission */
3171 tfind_1 (tfind_number
, 0, 0, 0, 0);
3175 /* Interpret the given line from the definitions part of the trace
3179 tfile_interp_line (char *line
,
3180 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3184 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3187 trace_regblock_size
= strtol (p
, &p
, 16);
3189 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3191 p
+= strlen ("status ");
3192 parse_trace_status (p
, current_trace_status ());
3194 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3196 p
+= strlen ("tp ");
3197 parse_tracepoint_definition (p
, utpp
);
3199 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3201 p
+= strlen ("tsv ");
3202 parse_tsv_definition (p
, utsvp
);
3205 warning ("Ignoring trace file definition \"%s\"", line
);
3208 /* Parse the part of trace status syntax that is shared between
3209 the remote protocol and the trace file reader. */
3211 extern char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
3214 parse_trace_status (char *line
, struct trace_status
*ts
)
3216 char *p
= line
, *p1
, *p2
, *p_temp
;
3219 ts
->running_known
= 1;
3220 ts
->running
= (*p
++ == '1');
3221 ts
->stop_reason
= trace_stop_reason_unknown
;
3222 xfree (ts
->error_desc
);
3223 ts
->error_desc
= NULL
;
3224 ts
->traceframe_count
= -1;
3225 ts
->traceframes_created
= -1;
3226 ts
->buffer_free
= -1;
3227 ts
->buffer_size
= -1;
3231 p1
= strchr (p
, ':');
3233 error (_("Malformed trace status, at %s\n\
3234 Status line: '%s'\n"), p
, line
);
3235 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3237 p
= unpack_varlen_hex (++p1
, &val
);
3238 ts
->stop_reason
= trace_buffer_full
;
3240 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3242 p
= unpack_varlen_hex (++p1
, &val
);
3243 ts
->stop_reason
= trace_never_run
;
3245 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
], p1
- p
) == 0)
3247 p
= unpack_varlen_hex (++p1
, &val
);
3248 ts
->stop_reason
= tracepoint_passcount
;
3249 ts
->stopping_tracepoint
= val
;
3251 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3253 p
= unpack_varlen_hex (++p1
, &val
);
3254 ts
->stop_reason
= tstop_command
;
3256 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3258 p2
= strchr (++p1
, ':');
3263 ts
->error_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3264 end
= hex2bin (p1
, ts
->error_desc
, (p2
- p1
) / 2);
3265 ts
->error_desc
[end
] = '\0';
3268 ts
->error_desc
= xstrdup ("");
3270 p
= unpack_varlen_hex (++p2
, &val
);
3271 ts
->stopping_tracepoint
= val
;
3272 ts
->stop_reason
= tracepoint_error
;
3274 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3276 p
= unpack_varlen_hex (++p1
, &val
);
3277 ts
->traceframe_count
= val
;
3279 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3281 p
= unpack_varlen_hex (++p1
, &val
);
3282 ts
->traceframes_created
= val
;
3284 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3286 p
= unpack_varlen_hex (++p1
, &val
);
3287 ts
->buffer_free
= val
;
3289 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3291 p
= unpack_varlen_hex (++p1
, &val
);
3292 ts
->buffer_size
= val
;
3296 /* Silently skip unknown optional info. */
3297 p_temp
= strchr (p1
+ 1, ';');
3301 /* Must be at the end. */
3307 /* Given a line of text defining a part of a tracepoint, parse it into
3308 an "uploaded tracepoint". */
3311 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3315 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3316 int enabled
, i
, end
;
3318 char *cond
, *srctype
, *src
, *buf
;
3319 struct uploaded_tp
*utp
= NULL
;
3322 /* Both tracepoint and action definitions start with the same number
3323 and address sequence. */
3325 p
= unpack_varlen_hex (p
, &num
);
3326 p
++; /* skip a colon */
3327 p
= unpack_varlen_hex (p
, &addr
);
3328 p
++; /* skip a colon */
3331 enabled
= (*p
++ == 'E');
3332 p
++; /* skip a colon */
3333 p
= unpack_varlen_hex (p
, &step
);
3334 p
++; /* skip a colon */
3335 p
= unpack_varlen_hex (p
, &pass
);
3336 type
= bp_tracepoint
;
3338 /* Thumb through optional fields. */
3341 p
++; /* skip a colon */
3344 type
= bp_fast_tracepoint
;
3346 p
= unpack_varlen_hex (p
, &orig_size
);
3351 p
= unpack_varlen_hex (p
, &xlen
);
3352 p
++; /* skip a comma */
3353 cond
= (char *) xmalloc (2 * xlen
+ 1);
3354 strncpy (cond
, p
, 2 * xlen
);
3355 cond
[2 * xlen
] = '\0';
3359 warning (_("Unrecognized char '%c' in tracepoint definition, skipping rest"), *p
);
3361 utp
= get_uploaded_tp (num
, addr
, utpp
);
3363 utp
->enabled
= enabled
;
3368 else if (piece
== 'A')
3370 utp
= get_uploaded_tp (num
, addr
, utpp
);
3371 utp
->actions
[utp
->numactions
++] = xstrdup (p
);
3373 else if (piece
== 'S')
3375 utp
= get_uploaded_tp (num
, addr
, utpp
);
3376 utp
->step_actions
[utp
->num_step_actions
++] = xstrdup (p
);
3378 else if (piece
== 'Z')
3380 /* Parse a chunk of source form definition. */
3381 utp
= get_uploaded_tp (num
, addr
, utpp
);
3383 p
= strchr (p
, ':');
3384 p
++; /* skip a colon */
3385 p
= unpack_varlen_hex (p
, &start
);
3386 p
++; /* skip a colon */
3387 p
= unpack_varlen_hex (p
, &xlen
);
3388 p
++; /* skip a colon */
3390 buf
= alloca (strlen (line
));
3392 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3395 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
3396 utp
->at_string
= xstrdup (buf
);
3397 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
3398 utp
->cond_string
= xstrdup (buf
);
3399 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
3401 /* FIXME consider using a vector? */
3402 struct uploaded_string
*last
, *newlast
;
3403 newlast
= (struct uploaded_string
*) xmalloc (sizeof (struct uploaded_string
));
3404 newlast
->str
= xstrdup (buf
);
3405 newlast
->next
= NULL
;
3406 if (utp
->cmd_strings
)
3408 for (last
= utp
->cmd_strings
; last
->next
; last
= last
->next
)
3410 last
->next
= newlast
;
3413 utp
->cmd_strings
= newlast
;
3418 /* Don't error out, the target might be sending us optional
3419 info that we don't care about. */
3420 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3424 /* Convert a textual description of a trace state variable into an
3428 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3431 ULONGEST num
, initval
, builtin
;
3433 struct uploaded_tsv
*utsv
= NULL
;
3435 buf
= alloca (strlen (line
));
3438 p
= unpack_varlen_hex (p
, &num
);
3439 p
++; /* skip a colon */
3440 p
= unpack_varlen_hex (p
, &initval
);
3441 p
++; /* skip a colon */
3442 p
= unpack_varlen_hex (p
, &builtin
);
3443 p
++; /* skip a colon */
3444 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3447 utsv
= get_uploaded_tsv (num
, utsvp
);
3448 utsv
->initial_value
= initval
;
3449 utsv
->builtin
= builtin
;
3450 utsv
->name
= xstrdup (buf
);
3453 /* Close the trace file and generally clean up. */
3456 tfile_close (int quitting
)
3463 pid
= ptid_get_pid (inferior_ptid
);
3464 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
3465 exit_inferior_silent (pid
);
3470 xfree (trace_filename
);
3474 tfile_files_info (struct target_ops
*t
)
3476 /* (it would be useful to mention the name of the file) */
3477 printf_filtered ("Looking at a trace file.\n");
3480 /* The trace status for a file is that tracing can never be run. */
3483 tfile_get_trace_status (struct trace_status
*ts
)
3485 /* Other bits of trace status were collected as part of opening the
3486 trace files, so nothing to do here. */
3491 /* Given the position of a traceframe in the file, figure out what
3492 address the frame was collected at. This would normally be the
3493 value of a collected PC register, but if not available, we
3497 tfile_get_traceframe_address (off_t tframe_offset
)
3501 struct breakpoint
*tp
;
3502 off_t saved_offset
= cur_offset
;
3505 /* FIXME dig pc out of collected registers */
3507 /* Fall back to using tracepoint address. */
3508 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
3509 gotten
= read (trace_fd
, &tpnum
, 2);
3511 perror_with_name (trace_filename
);
3512 else if (gotten
< 2)
3513 error (_("Premature end of file while reading trace file"));
3515 tp
= get_tracepoint_by_number_on_target (tpnum
);
3516 /* FIXME this is a poor heuristic if multiple locations */
3518 addr
= tp
->loc
->address
;
3520 /* Restore our seek position. */
3521 cur_offset
= saved_offset
;
3522 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3526 /* Given a type of search and some parameters, scan the collection of
3527 traceframes in the file looking for a match. When found, return
3528 both the traceframe and tracepoint number, otherwise -1 for
3532 tfile_trace_find (enum trace_find_type type
, int num
,
3533 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
3536 int tfnum
= 0, found
= 0, gotten
;
3538 struct breakpoint
*tp
;
3539 off_t offset
, tframe_offset
;
3542 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
3543 offset
= trace_frames_offset
;
3546 tframe_offset
= offset
;
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"));
3555 gotten
= read (trace_fd
, &data_size
, 4);
3557 perror_with_name (trace_filename
);
3558 else if (gotten
< 4)
3559 error (_("Premature end of file while reading trace file"));
3568 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3569 if (tfaddr
== addr1
)
3573 tp
= get_tracepoint (num
);
3574 if (tp
&& tpnum
== tp
->number_on_target
)
3578 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3579 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
3583 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3584 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
3588 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
3594 cur_offset
= offset
;
3595 cur_data_size
= data_size
;
3598 /* Skip past the traceframe's data. */
3599 lseek (trace_fd
, data_size
, SEEK_CUR
);
3600 offset
+= data_size
;
3601 /* Update our own count of traceframes. */
3604 /* Did not find what we were looking for. */
3610 /* Look for a block of saved registers in the traceframe, and get the
3611 requested register from it. */
3614 tfile_fetch_registers (struct target_ops
*ops
,
3615 struct regcache
*regcache
, int regno
)
3617 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3619 int i
, pos
, offset
, regn
, regsize
, gotten
;
3620 unsigned short mlen
;
3623 /* An uninitialized reg size says we're not going to be
3624 successful at getting register blocks. */
3625 if (!trace_regblock_size
)
3628 regs
= alloca (trace_regblock_size
);
3630 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3632 while (pos
< cur_data_size
)
3634 gotten
= read (trace_fd
, &block_type
, 1);
3636 perror_with_name (trace_filename
);
3637 else if (gotten
< 1)
3638 error (_("Premature end of file while reading trace file"));
3644 gotten
= read (trace_fd
, regs
, trace_regblock_size
);
3646 perror_with_name (trace_filename
);
3647 else if (gotten
< trace_regblock_size
)
3648 error (_("Premature end of file while reading trace file"));
3650 /* Assume the block is laid out in GDB register number order,
3651 each register with the size that it has in GDB. */
3653 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3655 regsize
= register_size (gdbarch
, regn
);
3656 /* Make sure we stay within block bounds. */
3657 if (offset
+ regsize
>= trace_regblock_size
)
3659 if (!regcache_valid_p (regcache
, regn
))
3663 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
3666 else if (regno
== -1)
3668 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
3675 lseek (trace_fd
, 8, SEEK_CUR
);
3676 gotten
= read (trace_fd
, &mlen
, 2);
3678 perror_with_name (trace_filename
);
3679 else if (gotten
< 2)
3680 error (_("Premature end of file while reading trace file"));
3681 lseek (trace_fd
, mlen
, SEEK_CUR
);
3682 pos
+= (8 + 2 + mlen
);
3685 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3689 error ("Unknown block type '%c' (0x%x) in trace frame",
3690 block_type
, block_type
);
3697 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3698 const char *annex
, gdb_byte
*readbuf
,
3699 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3704 unsigned short mlen
;
3706 /* We're only doing regular memory for now. */
3707 if (object
!= TARGET_OBJECT_MEMORY
)
3710 if (readbuf
== NULL
)
3711 error ("tfile_xfer_partial: trace file is read-only");
3713 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3715 while (pos
< cur_data_size
)
3717 gotten
= read (trace_fd
, &block_type
, 1);
3719 perror_with_name (trace_filename
);
3720 else if (gotten
< 1)
3721 error (_("Premature end of file while reading trace file"));
3726 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3727 pos
+= trace_regblock_size
;
3730 gotten
= read (trace_fd
, &maddr
, 8);
3732 perror_with_name (trace_filename
);
3733 else if (gotten
< 8)
3734 error (_("Premature end of file while reading trace file"));
3736 gotten
= read (trace_fd
, &mlen
, 2);
3738 perror_with_name (trace_filename
);
3739 else if (gotten
< 2)
3740 error (_("Premature end of file while reading trace file"));
3741 if (maddr
<= offset
&& (offset
+ len
) <= (maddr
+ mlen
))
3743 gotten
= read (trace_fd
, readbuf
, mlen
);
3745 perror_with_name (trace_filename
);
3746 else if (gotten
< mlen
)
3747 error (_("Premature end of file qwhile reading trace file"));
3751 lseek (trace_fd
, mlen
, SEEK_CUR
);
3752 pos
+= (8 + 2 + mlen
);
3755 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3759 error ("Unknown block type '%c' (0x%x) in traceframe",
3760 block_type
, block_type
);
3764 /* Indicate failure to find the requested memory block. */
3768 /* Iterate through the blocks of a trace frame, looking for a 'V'
3769 block with a matching tsv number. */
3772 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
3775 int pos
, vnum
, gotten
;
3776 unsigned short mlen
;
3778 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3780 while (pos
< cur_data_size
)
3782 gotten
= read (trace_fd
, &block_type
, 1);
3784 perror_with_name (trace_filename
);
3785 else if (gotten
< 1)
3786 error (_("Premature end of file while reading trace file"));
3791 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3792 pos
+= trace_regblock_size
;
3795 lseek (trace_fd
, 8, SEEK_CUR
);
3796 gotten
= read (trace_fd
, &mlen
, 2);
3798 perror_with_name (trace_filename
);
3799 else if (gotten
< 2)
3800 error (_("Premature end of file while reading trace file"));
3801 lseek (trace_fd
, mlen
, SEEK_CUR
);
3802 pos
+= (8 + 2 + mlen
);
3805 gotten
= read (trace_fd
, &vnum
, 4);
3807 perror_with_name (trace_filename
);
3808 else if (gotten
< 4)
3809 error (_("Premature end of file while reading trace file"));
3812 gotten
= read (trace_fd
, val
, 8);
3814 perror_with_name (trace_filename
);
3815 else if (gotten
< 8)
3816 error (_("Premature end of file while reading trace file"));
3819 lseek (trace_fd
, 8, SEEK_CUR
);
3823 error ("Unknown block type '%c' (0x%x) in traceframe",
3824 block_type
, block_type
);
3828 /* Didn't find anything. */
3833 tfile_has_memory (struct target_ops
*ops
)
3839 tfile_has_stack (struct target_ops
*ops
)
3845 tfile_has_registers (struct target_ops
*ops
)
3851 init_tfile_ops (void)
3853 tfile_ops
.to_shortname
= "tfile";
3854 tfile_ops
.to_longname
= "Local trace dump file";
3856 "Use a trace file as a target. Specify the filename of the trace file.";
3857 tfile_ops
.to_open
= tfile_open
;
3858 tfile_ops
.to_close
= tfile_close
;
3859 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
3860 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
3861 tfile_ops
.to_files_info
= tfile_files_info
;
3862 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
3863 tfile_ops
.to_trace_find
= tfile_trace_find
;
3864 tfile_ops
.to_get_trace_state_variable_value
= tfile_get_trace_state_variable_value
;
3865 /* core_stratum might seem more logical, but GDB doesn't like having
3866 more than one core_stratum vector. */
3867 tfile_ops
.to_stratum
= process_stratum
;
3868 tfile_ops
.to_has_memory
= tfile_has_memory
;
3869 tfile_ops
.to_has_stack
= tfile_has_stack
;
3870 tfile_ops
.to_has_registers
= tfile_has_registers
;
3871 tfile_ops
.to_magic
= OPS_MAGIC
;
3874 /* module initialization */
3876 _initialize_tracepoint (void)
3878 struct cmd_list_element
*c
;
3880 traceframe_number
= -1;
3881 tracepoint_number
= -1;
3883 if (tracepoint_list
.list
== NULL
)
3885 tracepoint_list
.listsize
= 128;
3886 tracepoint_list
.list
= xmalloc
3887 (tracepoint_list
.listsize
* sizeof (struct memrange
));
3889 if (tracepoint_list
.aexpr_list
== NULL
)
3891 tracepoint_list
.aexpr_listsize
= 128;
3892 tracepoint_list
.aexpr_list
= xmalloc
3893 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3896 if (stepping_list
.list
== NULL
)
3898 stepping_list
.listsize
= 128;
3899 stepping_list
.list
= xmalloc
3900 (stepping_list
.listsize
* sizeof (struct memrange
));
3903 if (stepping_list
.aexpr_list
== NULL
)
3905 stepping_list
.aexpr_listsize
= 128;
3906 stepping_list
.aexpr_list
= xmalloc
3907 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3910 add_info ("scope", scope_info
,
3911 _("List the variables local to a scope"));
3913 add_cmd ("tracepoints", class_trace
, NULL
,
3914 _("Tracing of program execution without stopping the program."),
3917 add_com ("tdump", class_trace
, trace_dump_command
,
3918 _("Print everything collected at the current tracepoint."));
3920 add_com ("tsave", class_trace
, trace_save_command
, _("\
3921 Save the trace data to a file.\n\
3922 Use the '-r' option to direct the target to save directly to the file,\n\
3923 using its own filesystem."));
3925 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
3926 Define a trace state variable.\n\
3927 Argument is a $-prefixed name, optionally followed\n\
3928 by '=' and an expression that sets the initial value\n\
3929 at the start of tracing."));
3930 set_cmd_completer (c
, expression_completer
);
3932 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
3933 Delete one or more trace state variables.\n\
3934 Arguments are the names of the variables to delete.\n\
3935 If no arguments are supplied, delete all variables."), &deletelist
);
3936 /* FIXME add a trace variable completer */
3938 add_info ("tvariables", tvariables_info
, _("\
3939 Status of trace state variables and their values.\n\
3942 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
3943 Select a trace frame;\n\
3944 No argument means forward by one frame; '-' means backward by one frame."),
3945 &tfindlist
, "tfind ", 1, &cmdlist
);
3947 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
3948 Select a trace frame whose PC is outside the given range (exclusive).\n\
3949 Usage: tfind outside addr1, addr2"),
3952 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
3953 Select a trace frame whose PC is in the given range (inclusive).\n\
3954 Usage: tfind range addr1,addr2"),
3957 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
3958 Select a trace frame by source line.\n\
3959 Argument can be a line number (with optional source file), \n\
3960 a function name, or '*' followed by an address.\n\
3961 Default argument is 'the next source line that was traced'."),
3964 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
3965 Select a trace frame by tracepoint number.\n\
3966 Default is the tracepoint for the current trace frame."),
3969 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
3970 Select a trace frame by PC.\n\
3971 Default is the current PC, or the PC of the current trace frame."),
3974 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
3975 Synonym for 'none'.\n\
3976 De-select any trace frame and resume 'live' debugging."),
3979 add_cmd ("none", class_trace
, trace_find_none_command
,
3980 _("De-select any trace frame and resume 'live' debugging."),
3983 add_cmd ("start", class_trace
, trace_find_start_command
,
3984 _("Select the first trace frame in the trace buffer."),
3987 add_com ("tstatus", class_trace
, trace_status_command
,
3988 _("Display the status of the current trace data collection."));
3990 add_com ("tstop", class_trace
, trace_stop_command
,
3991 _("Stop trace data collection."));
3993 add_com ("tstart", class_trace
, trace_start_command
,
3994 _("Start trace data collection."));
3996 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
3997 Ends a list of commands or actions.\n\
3998 Several GDB commands allow you to enter a list of commands or actions.\n\
3999 Entering \"end\" on a line by itself is the normal way to terminate\n\
4001 Note: the \"end\" command cannot be used at the gdb prompt."));
4003 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
4004 Specify single-stepping behavior at a tracepoint.\n\
4005 Argument is number of instructions to trace in single-step mode\n\
4006 following the tracepoint. This command is normally followed by\n\
4007 one or more \"collect\" commands, to specify what to collect\n\
4008 while single-stepping.\n\n\
4009 Note: this command can only be used in a tracepoint \"actions\" list."));
4011 add_com_alias ("ws", "while-stepping", class_alias
, 0);
4012 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
4014 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
4015 Specify one or more data items to be collected at a tracepoint.\n\
4016 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4017 collect all data (variables, registers) referenced by that expression.\n\
4018 Also accepts the following special arguments:\n\
4019 $regs -- all registers.\n\
4020 $args -- all function arguments.\n\
4021 $locals -- all variables local to the block/function scope.\n\
4022 Note: this command can only be used in a tracepoint \"actions\" list."));
4024 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4025 Specify one or more expressions to be evaluated at a tracepoint.\n\
4026 Accepts a comma-separated list of (one or more) expressions.\n\
4027 The result of each evaluation will be discarded.\n\
4028 Note: this command can only be used in a tracepoint \"actions\" list."));
4030 add_com ("actions", class_trace
, trace_actions_command
, _("\
4031 Specify the actions to be taken at a tracepoint.\n\
4032 Tracepoint actions may include collecting of specified data, \n\
4033 single-stepping, or enabling/disabling other tracepoints, \n\
4034 depending on target's capabilities."));
4036 default_collect
= xstrdup ("");
4037 add_setshow_string_cmd ("default-collect", class_trace
,
4038 &default_collect
, _("\
4039 Set the list of expressions to collect by default"), _("\
4040 Show the list of expressions to collect by default"), NULL
,
4042 &setlist
, &showlist
);
4044 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4045 &disconnected_tracing
, _("\
4046 Set whether tracing continues after GDB disconnects."), _("\
4047 Show whether tracing continues after GDB disconnects."), _("\
4048 Use this to continue a tracing run even if GDB disconnects\n\
4049 or detaches from the target. You can reconnect later and look at\n\
4050 trace data collected in the meantime."),
4051 set_disconnected_tracing
,
4056 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4057 &circular_trace_buffer
, _("\
4058 Set target's use of circular trace buffer."), _("\
4059 Show target's use of circular trace buffer."), _("\
4060 Use this to make the trace buffer into a circular buffer,\n\
4061 which will discard traceframes (oldest first) instead of filling\n\
4062 up and stopping the trace run."),
4063 set_circular_trace_buffer
,
4070 add_target (&tfile_ops
);