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 /* ACTIONS functions: */
484 /* The three functions:
485 collect_pseudocommand,
486 while_stepping_pseudocommand, and
487 end_actions_pseudocommand
488 are placeholders for "commands" that are actually ONLY to be used
489 within a tracepoint action list. If the actual function is ever called,
490 it means that somebody issued the "command" at the top level,
491 which is always an error. */
494 end_actions_pseudocommand (char *args
, int from_tty
)
496 error (_("This command cannot be used at the top level."));
500 while_stepping_pseudocommand (char *args
, int from_tty
)
502 error (_("This command can only be used in a tracepoint actions list."));
506 collect_pseudocommand (char *args
, int from_tty
)
508 error (_("This command can only be used in a tracepoint actions list."));
512 teval_pseudocommand (char *args
, int from_tty
)
514 error (_("This command can only be used in a tracepoint actions list."));
517 /* Enter a list of actions for a tracepoint. */
519 trace_actions_command (char *args
, int from_tty
)
521 struct breakpoint
*t
;
522 struct command_line
*l
;
524 t
= get_tracepoint_by_number (&args
, 0, 1);
528 xstrprintf ("Enter actions for tracepoint %d, one per line.",
530 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
532 l
= read_command_lines (tmpbuf
, from_tty
, 1, check_tracepoint_command
, t
);
533 do_cleanups (cleanups
);
534 breakpoint_set_commands (t
, l
);
536 /* else just return */
539 /* worker function */
541 validate_actionline (char **line
, struct breakpoint
*t
)
543 struct cmd_list_element
*c
;
544 struct expression
*exp
= NULL
;
545 struct cleanup
*old_chain
= NULL
;
547 struct bp_location
*loc
;
549 /* if EOF is typed, *line is NULL */
553 for (p
= *line
; isspace ((int) *p
);)
556 /* Symbol lookup etc. */
557 if (*p
== '\0') /* empty line: just prompt for another line. */
560 if (*p
== '#') /* comment line */
563 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
566 warning (_("'%s' is not an action that I know, or is ambiguous."),
571 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
573 struct agent_expr
*aexpr
;
574 struct agent_reqs areqs
;
577 { /* repeat over a comma-separated list */
578 QUIT
; /* allow user to bail out with ^C */
579 while (isspace ((int) *p
))
582 if (*p
== '$') /* look for special pseudo-symbols */
584 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
585 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
586 (0 == strncasecmp ("loc", p
+ 1, 3)))
591 /* else fall thru, treat p as an expression and parse it! */
594 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
597 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
598 old_chain
= make_cleanup (free_current_contents
, &exp
);
600 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
602 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
604 warning (_("constant %s (value %ld) will not be collected."),
605 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
606 SYMBOL_VALUE (exp
->elts
[2].symbol
));
609 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
611 warning (_("%s is optimized away and cannot be collected."),
612 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
617 /* We have something to collect, make sure that the expr to
618 bytecode translator can handle it and that it's not too
620 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
621 make_cleanup_free_agent_expr (aexpr
);
623 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
624 error (_("expression too complicated, try simplifying"));
626 ax_reqs (aexpr
, &areqs
);
627 (void) make_cleanup (xfree
, areqs
.reg_mask
);
629 if (areqs
.flaw
!= agent_flaw_none
)
630 error (_("malformed expression"));
632 if (areqs
.min_height
< 0)
633 error (_("gdb: Internal error: expression has min height < 0"));
635 if (areqs
.max_height
> 20)
636 error (_("expression too complicated, try simplifying"));
638 do_cleanups (old_chain
);
641 while (p
&& *p
++ == ',');
644 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
646 struct agent_expr
*aexpr
;
649 { /* repeat over a comma-separated list */
650 QUIT
; /* allow user to bail out with ^C */
651 while (isspace ((int) *p
))
655 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
658 /* Only expressions are allowed for this action. */
659 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
660 old_chain
= make_cleanup (free_current_contents
, &exp
);
662 /* We have something to evaluate, make sure that the expr to
663 bytecode translator can handle it and that it's not too
665 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
666 make_cleanup_free_agent_expr (aexpr
);
668 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
669 error (_("expression too complicated, try simplifying"));
671 do_cleanups (old_chain
);
674 while (p
&& *p
++ == ',');
677 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
679 char *steparg
; /* in case warning is necessary */
681 while (isspace ((int) *p
))
686 (t
->step_count
= strtol (p
, &p
, 0)) == 0)
688 error (_("'%s': bad step-count."), *line
);
692 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
696 error (_("'%s' is not a supported tracepoint action."), *line
);
701 memrange_absolute
= -1
706 int type
; /* memrange_absolute for absolute memory range,
707 else basereg number */
708 bfd_signed_vma start
;
712 struct collection_list
714 unsigned char regs_mask
[32]; /* room for up to 256 regs */
717 struct memrange
*list
;
718 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
720 struct agent_expr
**aexpr_list
;
723 tracepoint_list
, stepping_list
;
725 /* MEMRANGE functions: */
727 static int memrange_cmp (const void *, const void *);
729 /* compare memranges for qsort */
731 memrange_cmp (const void *va
, const void *vb
)
733 const struct memrange
*a
= va
, *b
= vb
;
735 if (a
->type
< b
->type
)
737 if (a
->type
> b
->type
)
739 if (a
->type
== memrange_absolute
)
741 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
743 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
748 if (a
->start
< b
->start
)
750 if (a
->start
> b
->start
)
756 /* Sort the memrange list using qsort, and merge adjacent memranges. */
758 memrange_sortmerge (struct collection_list
*memranges
)
762 qsort (memranges
->list
, memranges
->next_memrange
,
763 sizeof (struct memrange
), memrange_cmp
);
764 if (memranges
->next_memrange
> 0)
766 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
768 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
769 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
772 /* memrange b starts before memrange a ends; merge them. */
773 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
774 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
775 continue; /* next b, same a */
779 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
780 sizeof (struct memrange
));
782 memranges
->next_memrange
= a
+ 1;
786 /* Add a register to a collection list. */
788 add_register (struct collection_list
*collection
, unsigned int regno
)
791 printf_filtered ("collect register %d\n", regno
);
792 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
793 error (_("Internal: register number %d too large for tracepoint"),
795 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
798 /* Add a memrange to a collection list */
800 add_memrange (struct collection_list
*memranges
,
801 int type
, bfd_signed_vma base
,
806 printf_filtered ("(%d,", type
);
808 printf_filtered (",%ld)\n", len
);
811 /* type: memrange_absolute == memory, other n == basereg */
812 memranges
->list
[memranges
->next_memrange
].type
= type
;
813 /* base: addr if memory, offset if reg relative. */
814 memranges
->list
[memranges
->next_memrange
].start
= base
;
815 /* len: we actually save end (base + len) for convenience */
816 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
817 memranges
->next_memrange
++;
818 if (memranges
->next_memrange
>= memranges
->listsize
)
820 memranges
->listsize
*= 2;
821 memranges
->list
= xrealloc (memranges
->list
,
822 memranges
->listsize
);
825 if (type
!= memrange_absolute
) /* Better collect the base register! */
826 add_register (memranges
, type
);
829 /* Add a symbol to a collection list. */
831 collect_symbol (struct collection_list
*collect
,
833 struct gdbarch
*gdbarch
,
834 long frame_regno
, long frame_offset
,
839 bfd_signed_vma offset
;
840 int treat_as_expr
= 0;
842 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
843 switch (SYMBOL_CLASS (sym
))
846 printf_filtered ("%s: don't know symbol class %d\n",
847 SYMBOL_PRINT_NAME (sym
),
851 printf_filtered ("constant %s (value %ld) will not be collected.\n",
852 SYMBOL_PRINT_NAME (sym
), SYMBOL_VALUE (sym
));
855 offset
= SYMBOL_VALUE_ADDRESS (sym
);
860 sprintf_vma (tmp
, offset
);
861 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
862 SYMBOL_PRINT_NAME (sym
), len
,
865 /* A struct may be a C++ class with static fields, go to general
866 expression handling. */
867 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
870 add_memrange (collect
, memrange_absolute
, offset
, len
);
873 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
875 printf_filtered ("LOC_REG[parm] %s: ",
876 SYMBOL_PRINT_NAME (sym
));
877 add_register (collect
, reg
);
878 /* Check for doubles stored in two registers. */
879 /* FIXME: how about larger types stored in 3 or more regs? */
880 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
881 len
> register_size (gdbarch
, reg
))
882 add_register (collect
, reg
+ 1);
885 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
886 printf_filtered (" (will not collect %s)\n",
887 SYMBOL_PRINT_NAME (sym
));
891 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
894 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
895 SYMBOL_PRINT_NAME (sym
), len
);
897 printf_filtered (" from frame ptr reg %d\n", reg
);
899 add_memrange (collect
, reg
, offset
, len
);
901 case LOC_REGPARM_ADDR
:
902 reg
= SYMBOL_VALUE (sym
);
906 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
907 SYMBOL_PRINT_NAME (sym
), len
);
909 printf_filtered (" from reg %d\n", reg
);
911 add_memrange (collect
, reg
, offset
, len
);
915 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
918 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
919 SYMBOL_PRINT_NAME (sym
), len
);
921 printf_filtered (" from frame ptr reg %d\n", reg
);
923 add_memrange (collect
, reg
, offset
, len
);
930 case LOC_OPTIMIZED_OUT
:
931 printf_filtered ("%s has been optimized out of existence.\n",
932 SYMBOL_PRINT_NAME (sym
));
940 /* Expressions are the most general case. */
943 struct agent_expr
*aexpr
;
944 struct cleanup
*old_chain1
= NULL
;
945 struct agent_reqs areqs
;
947 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
949 /* It can happen that the symbol is recorded as a computed
950 location, but it's been optimized away and doesn't actually
951 have a location expression. */
954 printf_filtered ("%s has been optimized out of existence.\n",
955 SYMBOL_PRINT_NAME (sym
));
959 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
961 ax_reqs (aexpr
, &areqs
);
962 if (areqs
.flaw
!= agent_flaw_none
)
963 error (_("malformed expression"));
965 if (areqs
.min_height
< 0)
966 error (_("gdb: Internal error: expression has min height < 0"));
967 if (areqs
.max_height
> 20)
968 error (_("expression too complicated, try simplifying"));
970 discard_cleanups (old_chain1
);
971 add_aexpr (collect
, aexpr
);
973 /* take care of the registers */
974 if (areqs
.reg_mask_len
> 0)
978 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
980 QUIT
; /* allow user to bail out with ^C */
981 if (areqs
.reg_mask
[ndx1
] != 0)
983 /* assume chars have 8 bits */
984 for (ndx2
= 0; ndx2
< 8; ndx2
++)
985 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
986 /* it's used -- record it */
987 add_register (collect
, ndx1
* 8 + ndx2
);
994 /* Add all locals (or args) symbols to collection list */
996 add_local_symbols (struct collection_list
*collect
,
997 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
998 long frame_regno
, long frame_offset
, int type
)
1001 struct block
*block
;
1002 struct dict_iterator iter
;
1005 block
= block_for_pc (pc
);
1008 QUIT
; /* allow user to bail out with ^C */
1009 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
1011 if (SYMBOL_IS_ARGUMENT (sym
)
1012 ? type
== 'A' /* collecting Arguments */
1013 : type
== 'L') /* collecting Locals */
1016 collect_symbol (collect
, sym
, gdbarch
,
1017 frame_regno
, frame_offset
, pc
);
1020 if (BLOCK_FUNCTION (block
))
1023 block
= BLOCK_SUPERBLOCK (block
);
1026 warning (_("No %s found in scope."),
1027 type
== 'L' ? "locals" : "args");
1030 /* worker function */
1032 clear_collection_list (struct collection_list
*list
)
1036 list
->next_memrange
= 0;
1037 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1039 free_agent_expr (list
->aexpr_list
[ndx
]);
1040 list
->aexpr_list
[ndx
] = NULL
;
1042 list
->next_aexpr_elt
= 0;
1043 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1046 /* reduce a collection list to string form (for gdb protocol) */
1048 stringify_collection_list (struct collection_list
*list
, char *string
)
1050 char temp_buf
[2048];
1054 char *(*str_list
)[];
1058 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1059 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1061 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1062 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1064 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1067 printf_filtered ("\nCollecting registers (mask): 0x");
1072 QUIT
; /* allow user to bail out with ^C */
1074 printf_filtered ("%02X", list
->regs_mask
[i
]);
1075 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1078 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1082 printf_filtered ("\n");
1083 if (list
->next_memrange
> 0 && info_verbose
)
1084 printf_filtered ("Collecting memranges: \n");
1085 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1087 QUIT
; /* allow user to bail out with ^C */
1088 sprintf_vma (tmp2
, list
->list
[i
].start
);
1091 printf_filtered ("(%d, %s, %ld)\n",
1094 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1096 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1098 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1105 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1107 /* The "%X" conversion specifier expects an unsigned argument,
1108 so passing -1 (memrange_absolute) to it directly gives you
1109 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1111 if (list
->list
[i
].type
== memrange_absolute
)
1112 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1114 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1117 count
+= strlen (end
);
1118 end
= temp_buf
+ count
;
1121 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1123 QUIT
; /* allow user to bail out with ^C */
1124 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1126 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1131 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1132 end
+= 10; /* 'X' + 8 hex digits + ',' */
1135 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1136 end
, list
->aexpr_list
[i
]->len
);
1137 count
+= 2 * list
->aexpr_list
[i
]->len
;
1142 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1147 (*str_list
)[ndx
] = NULL
;
1160 encode_actions_1 (struct command_line
*action
,
1161 struct breakpoint
*t
,
1162 struct bp_location
*tloc
,
1164 LONGEST frame_offset
,
1165 struct collection_list
*collect
,
1166 struct collection_list
*stepping_list
)
1169 struct expression
*exp
= NULL
;
1170 struct command_line
*actions
;
1172 struct value
*tempval
;
1173 struct cmd_list_element
*cmd
;
1174 struct agent_expr
*aexpr
;
1176 for (; action
; action
= action
->next
)
1178 QUIT
; /* allow user to bail out with ^C */
1179 action_exp
= action
->line
;
1180 while (isspace ((int) *action_exp
))
1183 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1185 error (_("Bad action list item: %s"), action_exp
);
1187 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1190 { /* repeat over a comma-separated list */
1191 QUIT
; /* allow user to bail out with ^C */
1192 while (isspace ((int) *action_exp
))
1195 if (0 == strncasecmp ("$reg", action_exp
, 4))
1197 for (i
= 0; i
< gdbarch_num_regs (t
->gdbarch
); i
++)
1198 add_register (collect
, i
);
1199 action_exp
= strchr (action_exp
, ','); /* more? */
1201 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1203 add_local_symbols (collect
,
1209 action_exp
= strchr (action_exp
, ','); /* more? */
1211 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1213 add_local_symbols (collect
,
1219 action_exp
= strchr (action_exp
, ','); /* more? */
1223 unsigned long addr
, len
;
1224 struct cleanup
*old_chain
= NULL
;
1225 struct cleanup
*old_chain1
= NULL
;
1226 struct agent_reqs areqs
;
1228 exp
= parse_exp_1 (&action_exp
,
1229 block_for_pc (tloc
->address
), 1);
1230 old_chain
= make_cleanup (free_current_contents
, &exp
);
1232 switch (exp
->elts
[0].opcode
)
1236 const char *name
= &exp
->elts
[2].string
;
1238 i
= user_reg_map_name_to_regnum (t
->gdbarch
,
1239 name
, strlen (name
));
1241 internal_error (__FILE__
, __LINE__
,
1242 _("Register $%s not available"),
1245 printf_filtered ("OP_REGISTER: ");
1246 add_register (collect
, i
);
1251 /* safe because we know it's a simple expression */
1252 tempval
= evaluate_expression (exp
);
1253 addr
= value_address (tempval
);
1254 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1255 add_memrange (collect
, memrange_absolute
, addr
, len
);
1259 collect_symbol (collect
,
1260 exp
->elts
[2].symbol
,
1267 default: /* full-fledged expression */
1268 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1270 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1272 ax_reqs (aexpr
, &areqs
);
1273 if (areqs
.flaw
!= agent_flaw_none
)
1274 error (_("malformed expression"));
1276 if (areqs
.min_height
< 0)
1277 error (_("gdb: Internal error: expression has min height < 0"));
1278 if (areqs
.max_height
> 20)
1279 error (_("expression too complicated, try simplifying"));
1281 discard_cleanups (old_chain1
);
1282 add_aexpr (collect
, aexpr
);
1284 /* take care of the registers */
1285 if (areqs
.reg_mask_len
> 0)
1290 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1292 QUIT
; /* allow user to bail out with ^C */
1293 if (areqs
.reg_mask
[ndx1
] != 0)
1295 /* assume chars have 8 bits */
1296 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1297 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1298 /* it's used -- record it */
1299 add_register (collect
,
1306 do_cleanups (old_chain
);
1309 while (action_exp
&& *action_exp
++ == ',');
1311 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1314 { /* repeat over a comma-separated list */
1315 QUIT
; /* allow user to bail out with ^C */
1316 while (isspace ((int) *action_exp
))
1320 unsigned long addr
, len
;
1321 struct cleanup
*old_chain
= NULL
;
1322 struct cleanup
*old_chain1
= NULL
;
1323 struct agent_reqs areqs
;
1325 exp
= parse_exp_1 (&action_exp
,
1326 block_for_pc (tloc
->address
), 1);
1327 old_chain
= make_cleanup (free_current_contents
, &exp
);
1329 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1330 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1332 ax_reqs (aexpr
, &areqs
);
1333 if (areqs
.flaw
!= agent_flaw_none
)
1334 error (_("malformed expression"));
1336 if (areqs
.min_height
< 0)
1337 error (_("gdb: Internal error: expression has min height < 0"));
1338 if (areqs
.max_height
> 20)
1339 error (_("expression too complicated, try simplifying"));
1341 discard_cleanups (old_chain1
);
1342 /* Even though we're not officially collecting, add
1343 to the collect list anyway. */
1344 add_aexpr (collect
, aexpr
);
1346 do_cleanups (old_chain
);
1349 while (action_exp
&& *action_exp
++ == ',');
1351 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1353 /* We check against nested while-stepping when setting
1354 breakpoint action, so no way to run into nested
1356 gdb_assert (stepping_list
);
1358 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
, frame_offset
,
1359 stepping_list
, NULL
);
1362 error (_("Invalid tracepoint command '%s'"), action
->line
);
1366 /* Render all actions into gdb protocol. */
1368 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1369 char ***tdp_actions
, char ***stepping_actions
)
1371 static char tdp_buff
[2048], step_buff
[2048];
1372 char *default_collect_line
= NULL
;
1373 struct command_line
*actions
;
1374 struct command_line
*default_collect_action
= NULL
;
1376 LONGEST frame_offset
;
1377 struct cleanup
*back_to
;
1379 back_to
= make_cleanup (null_cleanup
, NULL
);
1381 clear_collection_list (&tracepoint_list
);
1382 clear_collection_list (&stepping_list
);
1384 *tdp_actions
= NULL
;
1385 *stepping_actions
= NULL
;
1387 gdbarch_virtual_frame_pointer (t
->gdbarch
,
1388 t
->loc
->address
, &frame_reg
, &frame_offset
);
1390 actions
= t
->commands
->commands
;
1392 /* If there are default expressions to collect, make up a collect
1393 action and prepend to the action list to encode. Note that since
1394 validation is per-tracepoint (local var "xyz" might be valid for
1395 one tracepoint and not another, etc), we make up the action on
1396 the fly, and don't cache it. */
1397 if (*default_collect
)
1400 enum actionline_type linetype
;
1402 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1403 make_cleanup (xfree
, default_collect_line
);
1405 line
= default_collect_line
;
1406 linetype
= validate_actionline (&line
, t
);
1407 if (linetype
!= BADLINE
)
1409 default_collect_action
= xmalloc (sizeof (struct command_line
));
1410 make_cleanup (xfree
, default_collect_action
);
1411 default_collect_action
->next
= t
->commands
->commands
;
1412 default_collect_action
->line
= line
;
1413 actions
= default_collect_action
;
1416 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1417 &tracepoint_list
, &stepping_list
);
1419 memrange_sortmerge (&tracepoint_list
);
1420 memrange_sortmerge (&stepping_list
);
1422 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1424 *stepping_actions
= stringify_collection_list (&stepping_list
,
1427 do_cleanups (back_to
);
1431 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1433 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1435 collect
->aexpr_list
=
1436 xrealloc (collect
->aexpr_list
,
1437 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1438 collect
->aexpr_listsize
*= 2;
1440 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1441 collect
->next_aexpr_elt
++;
1446 start_tracing (void)
1449 VEC(breakpoint_p
) *tp_vec
= NULL
;
1451 struct breakpoint
*t
;
1452 struct trace_state_variable
*tsv
;
1453 int any_enabled
= 0;
1455 tp_vec
= all_tracepoints ();
1457 /* No point in tracing without any tracepoints... */
1458 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1460 VEC_free (breakpoint_p
, tp_vec
);
1461 error (_("No tracepoints defined, not starting trace"));
1464 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1466 if (t
->enable_state
== bp_enabled
)
1473 /* No point in tracing with only disabled tracepoints. */
1476 VEC_free (breakpoint_p
, tp_vec
);
1477 error (_("No tracepoints enabled, not starting trace"));
1480 target_trace_init ();
1482 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1484 t
->number_on_target
= 0;
1485 target_download_tracepoint (t
);
1486 t
->number_on_target
= t
->number
;
1488 VEC_free (breakpoint_p
, tp_vec
);
1490 /* Send down all the trace state variables too. */
1491 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1493 target_download_trace_state_variable (tsv
);
1496 /* Tell target to treat text-like sections as transparent. */
1497 target_trace_set_readonly_regions ();
1498 /* Set some mode flags. */
1499 target_set_disconnected_tracing (disconnected_tracing
);
1500 target_set_circular_trace_buffer (circular_trace_buffer
);
1502 /* Now insert traps and begin collecting data. */
1503 target_trace_start ();
1505 /* Reset our local state. */
1506 set_traceframe_num (-1);
1507 set_tracepoint_num (-1);
1508 set_traceframe_context (NULL
);
1509 current_trace_status()->running
= 1;
1514 Tell target to clear any previous trace experiment.
1515 Walk the list of tracepoints, and send them (and their actions)
1516 to the target. If no errors,
1517 Tell target to start a new trace experiment. */
1520 trace_start_command (char *args
, int from_tty
)
1522 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1529 trace_stop_command (char *args
, int from_tty
)
1537 target_trace_stop ();
1538 /* should change in response to reply? */
1539 current_trace_status ()->running
= 0;
1542 /* tstatus command */
1544 trace_status_command (char *args
, int from_tty
)
1546 struct trace_status
*ts
= current_trace_status ();
1549 status
= target_get_trace_status (ts
);
1554 printf_filtered (_("Using a trace file.\n"));
1557 printf_filtered (_("Trace can not be run on this target.\n"));
1562 if (!ts
->running_known
)
1564 printf_filtered (_("Run/stop status is unknown.\n"));
1566 else if (ts
->running
)
1568 printf_filtered (_("Trace is running on the target.\n"));
1569 if (disconnected_tracing
)
1570 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1572 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1576 switch (ts
->stop_reason
)
1578 case trace_never_run
:
1579 printf_filtered (_("No trace has been run on the target.\n"));
1582 printf_filtered (_("Trace stopped by a tstop command.\n"));
1584 case trace_buffer_full
:
1585 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1587 case trace_disconnected
:
1588 printf_filtered (_("Trace stopped because of disconnection.\n"));
1590 case tracepoint_passcount
:
1591 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1592 ts
->stopping_tracepoint
);
1594 case tracepoint_error
:
1595 if (ts
->stopping_tracepoint
)
1596 printf_filtered (_("Trace stopped by an error (%s, tracepoint %d).\n"),
1597 ts
->error_desc
, ts
->stopping_tracepoint
);
1599 printf_filtered (_("Trace stopped by an error (%s).\n"),
1602 case trace_stop_reason_unknown
:
1603 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1606 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1612 if (ts
->traceframes_created
>= 0
1613 && ts
->traceframe_count
!= ts
->traceframes_created
)
1615 printf_filtered (_("Buffer contains %d trace frames (of %d created total).\n"),
1616 ts
->traceframe_count
, ts
->traceframes_created
);
1618 else if (ts
->traceframe_count
>= 0)
1620 printf_filtered (_("Collected %d trace frames.\n"),
1621 ts
->traceframe_count
);
1624 if (ts
->buffer_free
>= 0)
1626 if (ts
->buffer_size
>= 0)
1628 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1629 ts
->buffer_free
, ts
->buffer_size
);
1630 if (ts
->buffer_size
> 0)
1631 printf_filtered (_(" (%d%% full)"),
1632 ((int) ((((long long) (ts
->buffer_size
1633 - ts
->buffer_free
)) * 100)
1634 / ts
->buffer_size
)));
1635 printf_filtered (_(".\n"));
1638 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1642 /* Now report on what we're doing with tfind. */
1643 if (traceframe_number
>= 0)
1644 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1645 traceframe_number
, tracepoint_number
);
1647 printf_filtered (_("Not looking at any trace frame.\n"));
1650 /* Report the trace status to uiout, in a way suitable for MI, and not
1651 suitable for CLI. If ON_STOP is true, suppress a few fields that
1652 are not meaningful in the -trace-stop response.
1654 The implementation is essentially parallel to trace_status_command, but
1655 merging them will result in unreadable code. */
1657 trace_status_mi (int on_stop
)
1659 struct trace_status
*ts
= current_trace_status ();
1661 char *string_status
;
1663 status
= target_get_trace_status (ts
);
1665 if (status
== -1 && !ts
->from_file
)
1667 ui_out_field_string (uiout
, "supported", "0");
1672 ui_out_field_string (uiout
, "supported", "file");
1674 ui_out_field_string (uiout
, "supported", "1");
1676 gdb_assert (ts
->running_known
);
1680 ui_out_field_string (uiout
, "running", "1");
1682 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1683 Given that the frontend gets the status either on -trace-stop, or from
1684 -trace-status after re-connection, it does not seem like this
1685 information is necessary for anything. It is not necessary for either
1686 figuring the vital state of the target nor for navigation of trace
1687 frames. If the frontend wants to show the current state is some
1688 configure dialog, it can request the value when such dialog is
1689 invoked by the user. */
1693 char *stop_reason
= NULL
;
1694 int stopping_tracepoint
= -1;
1697 ui_out_field_string (uiout
, "running", "0");
1699 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
1701 switch (ts
->stop_reason
)
1704 stop_reason
= "request";
1706 case trace_buffer_full
:
1707 stop_reason
= "overflow";
1709 case trace_disconnected
:
1710 stop_reason
= "disconnection";
1712 case tracepoint_passcount
:
1713 stop_reason
= "passcount";
1714 stopping_tracepoint
= ts
->stopping_tracepoint
;
1716 case tracepoint_error
:
1717 stop_reason
= "error";
1718 stopping_tracepoint
= ts
->stopping_tracepoint
;
1724 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
1725 if (stopping_tracepoint
!= -1)
1726 ui_out_field_int (uiout
, "stopping-tracepoint",
1727 stopping_tracepoint
);
1728 if (ts
->stop_reason
== tracepoint_error
)
1729 ui_out_field_string (uiout
, "error-description",
1736 if ((int) ts
->traceframe_count
!= -1)
1737 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
1738 if ((int) ts
->buffer_size
!= -1)
1739 ui_out_field_int (uiout
, "buffer-size", (int) ts
->buffer_size
);
1740 if ((int) ts
->buffer_free
!= -1)
1741 ui_out_field_int (uiout
, "buffer-free", (int) ts
->buffer_free
);
1746 disconnect_or_stop_tracing (int from_tty
)
1748 /* It can happen that the target that was tracing went away on its
1749 own, and we didn't notice. Get a status update, and if the
1750 current target doesn't even do tracing, then assume it's not
1752 if (target_get_trace_status (current_trace_status ()) < 0)
1753 current_trace_status ()->running
= 0;
1755 if (current_trace_status ()->running
&& from_tty
)
1757 int cont
= query (_("Trace is running. Continue tracing after detach? "));
1758 /* Note that we send the query result without affecting the
1759 user's setting of disconnected_tracing, so that the answer is
1761 send_disconnected_tracing_value (cont
);
1763 /* Also ensure that we do the equivalent of a tstop command if
1764 tracing is not to continue after the detach. */
1769 /* Also we want to be out of tfind mode, otherwise things can get
1770 confusing upon reconnection. Just use these calls instead of
1771 full tfind_1 behavior because we're in the middle of detaching,
1772 and there's no point to updating current stack frame etc. */
1773 set_traceframe_number (-1);
1774 set_traceframe_context (NULL
);
1777 /* Worker function for the various flavors of the tfind command. */
1779 tfind_1 (enum trace_find_type type
, int num
,
1780 ULONGEST addr1
, ULONGEST addr2
,
1783 int target_frameno
= -1, target_tracept
= -1;
1784 struct frame_id old_frame_id
;
1786 struct breakpoint
*tp
;
1788 old_frame_id
= get_frame_id (get_current_frame ());
1790 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
1793 if (type
== tfind_number
1795 && target_frameno
== -1)
1797 /* We told the target to get out of tfind mode, and it did. */
1799 else if (target_frameno
== -1)
1801 /* A request for a non-existant trace frame has failed.
1802 Our response will be different, depending on FROM_TTY:
1804 If FROM_TTY is true, meaning that this command was
1805 typed interactively by the user, then give an error
1806 and DO NOT change the state of traceframe_number etc.
1808 However if FROM_TTY is false, meaning that we're either
1809 in a script, a loop, or a user-defined command, then
1810 DON'T give an error, but DO change the state of
1811 traceframe_number etc. to invalid.
1813 The rationalle is that if you typed the command, you
1814 might just have committed a typo or something, and you'd
1815 like to NOT lose your current debugging state. However
1816 if you're in a user-defined command or especially in a
1817 loop, then you need a way to detect that the command
1818 failed WITHOUT aborting. This allows you to write
1819 scripts that search thru the trace buffer until the end,
1820 and then continue on to do something else. */
1823 error (_("Target failed to find requested trace frame."));
1827 printf_filtered ("End of trace buffer.\n");
1828 #if 0 /* dubious now? */
1829 /* The following will not recurse, since it's
1831 trace_find_command ("-1", from_tty
);
1836 tp
= get_tracepoint_by_number_on_target (target_tracept
);
1838 reinit_frame_cache ();
1839 registers_changed ();
1840 target_dcache_invalidate ();
1841 set_traceframe_num (target_frameno
);
1842 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
1843 if (target_frameno
== -1)
1844 set_traceframe_context (NULL
);
1846 set_traceframe_context (get_current_frame ());
1848 if (traceframe_number
>= 0)
1850 /* Use different branches for MI and CLI to make CLI messages
1852 if (ui_out_is_mi_like_p (uiout
))
1854 ui_out_field_string (uiout
, "found", "1");
1855 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
1856 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
1860 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
1861 traceframe_number
, tracepoint_number
);
1866 if (ui_out_is_mi_like_p (uiout
))
1867 ui_out_field_string (uiout
, "found", "0");
1869 printf_unfiltered (_("No trace frame found"));
1872 /* If we're in nonstop mode and getting out of looking at trace
1873 frames, there won't be any current frame to go back to and
1876 && (has_stack_frames () || traceframe_number
>= 0))
1878 enum print_what print_what
;
1880 /* NOTE: in immitation of the step command, try to determine
1881 whether we have made a transition from one function to
1882 another. If so, we'll print the "stack frame" (ie. the new
1883 function and it's arguments) -- otherwise we'll just show the
1886 if (frame_id_eq (old_frame_id
,
1887 get_frame_id (get_current_frame ())))
1888 print_what
= SRC_LINE
;
1890 print_what
= SRC_AND_LOC
;
1892 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
1897 /* trace_find_command takes a trace frame number n,
1898 sends "QTFrame:<n>" to the target,
1899 and accepts a reply that may contain several optional pieces
1900 of information: a frame number, a tracepoint number, and an
1901 indication of whether this is a trap frame or a stepping frame.
1903 The minimal response is just "OK" (which indicates that the
1904 target does not give us a frame number or a tracepoint number).
1905 Instead of that, the target may send us a string containing
1907 F<hexnum> (gives the selected frame number)
1908 T<hexnum> (gives the selected tracepoint number)
1913 trace_find_command (char *args
, int from_tty
)
1914 { /* this should only be called with a numeric argument */
1917 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1918 error ("May not look at trace frames while trace is running.");
1920 if (args
== 0 || *args
== 0)
1921 { /* TFIND with no args means find NEXT trace frame. */
1922 if (traceframe_number
== -1)
1923 frameno
= 0; /* "next" is first one */
1925 frameno
= traceframe_number
+ 1;
1927 else if (0 == strcmp (args
, "-"))
1929 if (traceframe_number
== -1)
1930 error (_("not debugging trace buffer"));
1931 else if (from_tty
&& traceframe_number
== 0)
1932 error (_("already at start of trace buffer"));
1934 frameno
= traceframe_number
- 1;
1936 /* A hack to work around eval's need for fp to have been collected. */
1937 else if (0 == strcmp (args
, "-1"))
1940 frameno
= parse_and_eval_long (args
);
1943 error (_("invalid input (%d is less than zero)"), frameno
);
1945 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
1950 trace_find_end_command (char *args
, int from_tty
)
1952 trace_find_command ("-1", from_tty
);
1957 trace_find_none_command (char *args
, int from_tty
)
1959 trace_find_command ("-1", from_tty
);
1964 trace_find_start_command (char *args
, int from_tty
)
1966 trace_find_command ("0", from_tty
);
1969 /* tfind pc command */
1971 trace_find_pc_command (char *args
, int from_tty
)
1976 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1977 error ("May not look at trace frames while trace is running.");
1979 if (args
== 0 || *args
== 0)
1980 pc
= regcache_read_pc (get_current_regcache ());
1982 pc
= parse_and_eval_address (args
);
1984 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
1987 /* tfind tracepoint command */
1989 trace_find_tracepoint_command (char *args
, int from_tty
)
1992 struct breakpoint
*tp
;
1994 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1995 error ("May not look at trace frames while trace is running.");
1997 if (args
== 0 || *args
== 0)
1999 if (tracepoint_number
== -1)
2000 error (_("No current tracepoint -- please supply an argument."));
2002 tdp
= tracepoint_number
; /* default is current TDP */
2005 tdp
= parse_and_eval_long (args
);
2007 /* If we have the tracepoint on hand, use the number that the
2008 target knows about (which may be different if we disconnected
2009 and reconnected). */
2010 tp
= get_tracepoint (tdp
);
2012 tdp
= tp
->number_on_target
;
2014 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2017 /* TFIND LINE command:
2019 This command will take a sourceline for argument, just like BREAK
2020 or TRACE (ie. anything that "decode_line_1" can handle).
2022 With no argument, this command will find the next trace frame
2023 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2026 trace_find_line_command (char *args
, int from_tty
)
2028 static CORE_ADDR start_pc
, end_pc
;
2029 struct symtabs_and_lines sals
;
2030 struct symtab_and_line sal
;
2031 struct cleanup
*old_chain
;
2032 char startpc_str
[40], endpc_str
[40];
2034 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2035 error ("May not look at trace frames while trace is running.");
2037 if (args
== 0 || *args
== 0)
2039 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2041 sals
.sals
= (struct symtab_and_line
*)
2042 xmalloc (sizeof (struct symtab_and_line
));
2047 sals
= decode_line_spec (args
, 1);
2051 old_chain
= make_cleanup (xfree
, sals
.sals
);
2052 if (sal
.symtab
== 0)
2053 error (_("No line number information available."));
2055 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2057 if (start_pc
== end_pc
)
2059 printf_filtered ("Line %d of \"%s\"",
2060 sal
.line
, sal
.symtab
->filename
);
2062 printf_filtered (" is at address ");
2063 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2065 printf_filtered (" but contains no code.\n");
2066 sal
= find_pc_line (start_pc
, 0);
2068 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2069 && start_pc
!= end_pc
)
2070 printf_filtered ("Attempting to find line %d instead.\n",
2073 error (_("Cannot find a good line."));
2077 /* Is there any case in which we get here, and have an address
2078 which the user would want to see? If we have debugging
2079 symbols and no line numbers? */
2080 error (_("Line number %d is out of range for \"%s\"."),
2081 sal
.line
, sal
.symtab
->filename
);
2083 /* Find within range of stated line. */
2085 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2087 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2088 do_cleanups (old_chain
);
2091 /* tfind range command */
2093 trace_find_range_command (char *args
, int from_tty
)
2095 static CORE_ADDR start
, stop
;
2096 char start_str
[40], stop_str
[40];
2099 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2100 error ("May not look at trace frames while trace is running.");
2102 if (args
== 0 || *args
== 0)
2103 { /* XXX FIXME: what should default behavior be? */
2104 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2108 if (0 != (tmp
= strchr (args
, ',')))
2110 *tmp
++ = '\0'; /* terminate start address */
2111 while (isspace ((int) *tmp
))
2113 start
= parse_and_eval_address (args
);
2114 stop
= parse_and_eval_address (tmp
);
2117 { /* no explicit end address? */
2118 start
= parse_and_eval_address (args
);
2119 stop
= start
+ 1; /* ??? */
2122 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2125 /* tfind outside command */
2127 trace_find_outside_command (char *args
, int from_tty
)
2129 CORE_ADDR start
, stop
;
2130 char start_str
[40], stop_str
[40];
2133 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2134 error ("May not look at trace frames while trace is running.");
2136 if (args
== 0 || *args
== 0)
2137 { /* XXX FIXME: what should default behavior be? */
2138 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2142 if (0 != (tmp
= strchr (args
, ',')))
2144 *tmp
++ = '\0'; /* terminate start address */
2145 while (isspace ((int) *tmp
))
2147 start
= parse_and_eval_address (args
);
2148 stop
= parse_and_eval_address (tmp
);
2151 { /* no explicit end address? */
2152 start
= parse_and_eval_address (args
);
2153 stop
= start
+ 1; /* ??? */
2156 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2159 /* info scope command: list the locals for a scope. */
2161 scope_info (char *args
, int from_tty
)
2163 struct symtabs_and_lines sals
;
2165 struct minimal_symbol
*msym
;
2166 struct block
*block
;
2167 char **canonical
, *symname
, *save_args
= args
;
2168 struct dict_iterator iter
;
2170 struct gdbarch
*gdbarch
;
2173 if (args
== 0 || *args
== 0)
2174 error (_("requires an argument (function, line or *addr) to define a scope"));
2176 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2177 if (sals
.nelts
== 0)
2178 return; /* presumably decode_line_1 has already warned */
2180 /* Resolve line numbers to PC */
2181 resolve_sal_pc (&sals
.sals
[0]);
2182 block
= block_for_pc (sals
.sals
[0].pc
);
2186 QUIT
; /* allow user to bail out with ^C */
2187 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2189 QUIT
; /* allow user to bail out with ^C */
2191 printf_filtered ("Scope for %s:\n", save_args
);
2194 symname
= SYMBOL_PRINT_NAME (sym
);
2195 if (symname
== NULL
|| *symname
== '\0')
2196 continue; /* probably botched, certainly useless */
2198 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2200 printf_filtered ("Symbol %s is ", symname
);
2201 switch (SYMBOL_CLASS (sym
))
2204 case LOC_UNDEF
: /* messed up symbol? */
2205 printf_filtered ("a bogus symbol, class %d.\n",
2206 SYMBOL_CLASS (sym
));
2207 count
--; /* don't count this one */
2210 printf_filtered ("a constant with value %ld (0x%lx)",
2211 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2213 case LOC_CONST_BYTES
:
2214 printf_filtered ("constant bytes: ");
2215 if (SYMBOL_TYPE (sym
))
2216 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2217 fprintf_filtered (gdb_stdout
, " %02x",
2218 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2221 printf_filtered ("in static storage at address ");
2222 printf_filtered ("%s", paddress (gdbarch
,
2223 SYMBOL_VALUE_ADDRESS (sym
)));
2226 /* GDBARCH is the architecture associated with the objfile
2227 the symbol is defined in; the target architecture may be
2228 different, and may provide additional registers. However,
2229 we do not know the target architecture at this point.
2230 We assume the objfile architecture will contain all the
2231 standard registers that occur in debug info in that
2233 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2235 if (SYMBOL_IS_ARGUMENT (sym
))
2236 printf_filtered ("an argument in register $%s",
2237 gdbarch_register_name (gdbarch
, regno
));
2239 printf_filtered ("a local variable in register $%s",
2240 gdbarch_register_name (gdbarch
, regno
));
2243 printf_filtered ("an argument at stack/frame offset %ld",
2244 SYMBOL_VALUE (sym
));
2247 printf_filtered ("a local variable at frame offset %ld",
2248 SYMBOL_VALUE (sym
));
2251 printf_filtered ("a reference argument at offset %ld",
2252 SYMBOL_VALUE (sym
));
2254 case LOC_REGPARM_ADDR
:
2255 /* Note comment at LOC_REGISTER. */
2256 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2257 printf_filtered ("the address of an argument, in register $%s",
2258 gdbarch_register_name (gdbarch
, regno
));
2261 printf_filtered ("a typedef.\n");
2264 printf_filtered ("a label at address ");
2265 printf_filtered ("%s", paddress (gdbarch
,
2266 SYMBOL_VALUE_ADDRESS (sym
)));
2269 printf_filtered ("a function at address ");
2270 printf_filtered ("%s",
2271 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2273 case LOC_UNRESOLVED
:
2274 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2277 printf_filtered ("Unresolved Static");
2280 printf_filtered ("static storage at address ");
2281 printf_filtered ("%s",
2282 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2285 case LOC_OPTIMIZED_OUT
:
2286 printf_filtered ("optimized out.\n");
2289 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, gdb_stdout
);
2292 if (SYMBOL_TYPE (sym
))
2293 printf_filtered (", length %d.\n",
2294 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2296 if (BLOCK_FUNCTION (block
))
2299 block
= BLOCK_SUPERBLOCK (block
);
2302 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2306 /* worker function (cleanup) */
2308 replace_comma (void *data
)
2316 trace_dump_command (char *args
, int from_tty
)
2318 struct regcache
*regcache
;
2319 struct gdbarch
*gdbarch
;
2320 struct breakpoint
*t
;
2321 struct command_line
*action
;
2322 char *action_exp
, *next_comma
;
2323 struct cleanup
*old_cleanups
;
2324 int stepping_actions
= 0;
2325 int stepping_frame
= 0;
2326 struct bp_location
*loc
;
2328 if (tracepoint_number
== -1)
2330 warning (_("No current trace frame."));
2334 t
= get_tracepoint (tracepoint_number
);
2337 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2340 old_cleanups
= make_cleanup (null_cleanup
, NULL
);
2342 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2343 tracepoint_number
, traceframe_number
);
2345 /* The current frame is a trap frame if the frame PC is equal
2346 to the tracepoint PC. If not, then the current frame was
2347 collected during single-stepping. */
2349 regcache
= get_current_regcache ();
2350 gdbarch
= get_regcache_arch (regcache
);
2352 /* If the traceframe's address matches any of the tracepoint's
2353 locations, assume it is a direct hit rather than a while-stepping
2354 frame. (FIXME this is not reliable, should record each frame's
2357 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2358 if (loc
->address
== regcache_read_pc (regcache
))
2361 for (action
= t
->commands
->commands
; action
; action
= action
->next
)
2363 struct cmd_list_element
*cmd
;
2365 QUIT
; /* allow user to bail out with ^C */
2366 action_exp
= action
->line
;
2367 while (isspace ((int) *action_exp
))
2370 /* The collection actions to be done while stepping are
2371 bracketed by the commands "while-stepping" and "end". */
2373 if (*action_exp
== '#') /* comment line */
2376 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2378 error (_("Bad action list item: %s"), action_exp
);
2380 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2381 stepping_actions
= 1;
2382 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2383 stepping_actions
= 0;
2384 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2386 /* Display the collected data.
2387 For the trap frame, display only what was collected at
2388 the trap. Likewise for stepping frames, display only
2389 what was collected while stepping. This means that the
2390 two boolean variables, STEPPING_FRAME and
2391 STEPPING_ACTIONS should be equal. */
2392 if (stepping_frame
== stepping_actions
)
2395 { /* repeat over a comma-separated list */
2396 QUIT
; /* allow user to bail out with ^C */
2397 if (*action_exp
== ',')
2399 while (isspace ((int) *action_exp
))
2402 next_comma
= strchr (action_exp
, ',');
2404 if (0 == strncasecmp (action_exp
, "$reg", 4))
2405 registers_info (NULL
, from_tty
);
2406 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2407 locals_info (NULL
, from_tty
);
2408 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2409 args_info (NULL
, from_tty
);
2414 make_cleanup (replace_comma
, next_comma
);
2417 printf_filtered ("%s = ", action_exp
);
2418 output_command (action_exp
, from_tty
);
2419 printf_filtered ("\n");
2423 action_exp
= next_comma
;
2425 while (action_exp
&& *action_exp
== ',');
2429 discard_cleanups (old_cleanups
);
2432 /* Encode a piece of a tracepoint's source-level definition in a form
2433 that is suitable for both protocol and saving in files. */
2434 /* This version does not do multiple encodes for long strings; it should
2435 return an offset to the next piece to encode. FIXME */
2438 encode_source_string (int tpnum
, ULONGEST addr
,
2439 char *srctype
, char *src
, char *buf
, int buf_size
)
2441 if (80 + strlen (srctype
) > buf_size
)
2442 error (_("Buffer too small for source encoding"));
2443 sprintf (buf
, "%x:%s:%s:%x:%x:",
2444 tpnum
, phex_nz (addr
, sizeof (addr
)), srctype
, 0, (int) strlen (src
));
2445 if (strlen (buf
) + strlen (src
) * 2 >= buf_size
)
2446 error (_("Source string too long for buffer"));
2447 bin2hex (src
, buf
+ strlen (buf
), 0);
2451 extern int trace_regblock_size
;
2453 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2454 non-zero, the save is performed on the target, otherwise GDB obtains all
2455 trace data and saves it locally. */
2458 trace_save (const char *filename
, int target_does_save
)
2460 struct cleanup
*cleanup
;
2462 struct trace_status
*ts
= current_trace_status ();
2465 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2466 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2468 struct uploaded_string
*cmd
;
2470 ULONGEST offset
= 0;
2471 #define MAX_TRACE_UPLOAD 2000
2472 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2475 /* If the target is to save the data to a file on its own, then just
2476 send the command and be done with it. */
2477 if (target_does_save
)
2479 err
= target_save_trace_data (filename
);
2481 error (_("Target failed to save trace data to '%s'."),
2486 /* Get the trace status first before opening the file, so if the
2487 target is losing, we can get out without touching files. */
2488 status
= target_get_trace_status (ts
);
2490 pathname
= tilde_expand (filename
);
2491 cleanup
= make_cleanup (xfree
, pathname
);
2493 fp
= fopen (pathname
, "w");
2495 error (_("Unable to open file '%s' for saving trace data (%s)"),
2496 filename
, safe_strerror (errno
));
2497 make_cleanup_fclose (fp
);
2499 /* Write a file header, with a high-bit-set char to indicate a
2500 binary file, plus a hint as what this file is, and a version
2501 number in case of future needs. */
2502 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2504 perror_with_name (pathname
);
2506 /* Write descriptive info. */
2508 /* Write out the size of a register block. */
2509 fprintf (fp
, "R %x\n", trace_regblock_size
);
2511 /* Write out status of the tracing run (aka "tstatus" info). */
2512 fprintf (fp
, "status %c;%s",
2513 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
2514 if (ts
->stop_reason
== tracepoint_error
)
2516 char *buf
= (char *) alloca (strlen (ts
->error_desc
) * 2 + 1);
2517 bin2hex ((gdb_byte
*) ts
->error_desc
, buf
, 0);
2518 fprintf (fp
, ":%s", buf
);
2520 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
2521 if (ts
->traceframe_count
>= 0)
2522 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
2523 if (ts
->traceframes_created
>= 0)
2524 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
2525 if (ts
->buffer_free
>= 0)
2526 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
2527 if (ts
->buffer_size
>= 0)
2528 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
2531 /* Note that we want to upload tracepoints and save those, rather
2532 than simply writing out the local ones, because the user may have
2533 changed tracepoints in GDB in preparation for a future tracing
2534 run, or maybe just mass-deleted all types of breakpoints as part
2535 of cleaning up. So as not to contaminate the session, leave the
2536 data in its uploaded form, don't make into real tracepoints. */
2538 /* Get trace state variables first, they may be checked when parsing
2539 uploaded commands. */
2541 target_upload_trace_state_variables (&uploaded_tsvs
);
2543 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2549 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
2550 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
2553 fprintf (fp
, "tsv %x:%s:%x:%s\n",
2554 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
2555 utsv
->builtin
, buf
);
2561 free_uploaded_tsvs (&uploaded_tsvs
);
2563 target_upload_tracepoints (&uploaded_tps
);
2565 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
2567 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
2568 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2569 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
2570 if (utp
->type
== bp_fast_tracepoint
)
2571 fprintf (fp
, ":F%x", utp
->orig_size
);
2573 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
2576 for (a
= 0; a
< utp
->numactions
; ++a
)
2577 fprintf (fp
, "tp A%x:%s:%s\n",
2578 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2580 for (a
= 0; a
< utp
->num_step_actions
; ++a
)
2581 fprintf (fp
, "tp S%x:%s:%s\n",
2582 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2583 utp
->step_actions
[a
]);
2586 encode_source_string (utp
->number
, utp
->addr
,
2587 "at", utp
->at_string
, buf
, MAX_TRACE_UPLOAD
);
2588 fprintf (fp
, "tp Z%s\n", buf
);
2590 if (utp
->cond_string
)
2592 encode_source_string (utp
->number
, utp
->addr
,
2593 "cond", utp
->cond_string
, buf
, MAX_TRACE_UPLOAD
);
2594 fprintf (fp
, "tp Z%s\n", buf
);
2596 for (cmd
= utp
->cmd_strings
; cmd
; cmd
= cmd
->next
)
2598 encode_source_string (utp
->number
, utp
->addr
, "cmd", cmd
->str
,
2599 buf
, MAX_TRACE_UPLOAD
);
2600 fprintf (fp
, "tp Z%s\n", buf
);
2604 free_uploaded_tps (&uploaded_tps
);
2606 /* Mark the end of the definition section. */
2609 /* Get and write the trace data proper. We ask for big blocks, in
2610 the hopes of efficiency, but will take less if the target has
2611 packet size limitations or some such. */
2614 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
2616 error (_("Failure to get requested trace buffer data"));
2617 /* No more data is forthcoming, we're done. */
2620 written
= fwrite (buf
, gotten
, 1, fp
);
2622 perror_with_name (pathname
);
2626 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
2627 written
= fwrite (&gotten
, 4, 1, fp
);
2629 perror_with_name (pathname
);
2631 do_cleanups (cleanup
);
2635 trace_save_command (char *args
, int from_tty
)
2637 int target_does_save
= 0;
2639 char *filename
= NULL
;
2640 struct cleanup
*back_to
;
2643 error_no_arg (_("file in which to save trace data"));
2645 argv
= gdb_buildargv (args
);
2646 back_to
= make_cleanup_freeargv (argv
);
2648 for (; *argv
; ++argv
)
2650 if (strcmp (*argv
, "-r") == 0)
2651 target_does_save
= 1;
2652 else if (**argv
== '-')
2653 error (_("unknown option `%s'"), *argv
);
2659 error_no_arg (_("file in which to save trace data"));
2661 trace_save (filename
, target_does_save
);
2664 printf_filtered (_("Trace data saved to file '%s'.\n"), args
);
2666 do_cleanups (back_to
);
2669 /* Tell the target what to do with an ongoing tracing run if GDB
2670 disconnects for some reason. */
2673 send_disconnected_tracing_value (int value
)
2675 target_set_disconnected_tracing (value
);
2679 set_disconnected_tracing (char *args
, int from_tty
,
2680 struct cmd_list_element
*c
)
2682 send_disconnected_tracing_value (disconnected_tracing
);
2686 set_circular_trace_buffer (char *args
, int from_tty
,
2687 struct cmd_list_element
*c
)
2689 target_set_circular_trace_buffer (circular_trace_buffer
);
2692 /* Convert the memory pointed to by mem into hex, placing result in buf.
2693 * Return a pointer to the last char put in buf (null)
2694 * "stolen" from sparc-stub.c
2697 static const char hexchars
[] = "0123456789abcdef";
2700 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2708 *buf
++ = hexchars
[ch
>> 4];
2709 *buf
++ = hexchars
[ch
& 0xf];
2718 get_traceframe_number (void)
2720 return traceframe_number
;
2723 /* Make the traceframe NUM be the current trace frame. Does nothing
2724 if NUM is already current. */
2727 set_traceframe_number (int num
)
2731 if (traceframe_number
== num
)
2733 /* Nothing to do. */
2737 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
2740 warning (_("could not change traceframe"));
2742 traceframe_number
= newnum
;
2744 /* Changing the traceframe changes our view of registers and of the
2746 registers_changed ();
2749 /* A cleanup used when switching away and back from tfind mode. */
2751 struct current_traceframe_cleanup
2753 /* The traceframe we were inspecting. */
2754 int traceframe_number
;
2758 do_restore_current_traceframe_cleanup (void *arg
)
2760 struct current_traceframe_cleanup
*old
= arg
;
2762 set_traceframe_number (old
->traceframe_number
);
2766 restore_current_traceframe_cleanup_dtor (void *arg
)
2768 struct current_traceframe_cleanup
*old
= arg
;
2774 make_cleanup_restore_current_traceframe (void)
2776 struct current_traceframe_cleanup
*old
;
2778 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
2779 old
->traceframe_number
= traceframe_number
;
2781 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
2782 restore_current_traceframe_cleanup_dtor
);
2785 /* Given a number and address, return an uploaded tracepoint with that
2786 number, creating if necessary. */
2788 struct uploaded_tp
*
2789 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
2791 struct uploaded_tp
*utp
;
2793 for (utp
= *utpp
; utp
; utp
= utp
->next
)
2794 if (utp
->number
== num
&& utp
->addr
== addr
)
2796 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
2797 memset (utp
, 0, sizeof (struct uploaded_tp
));
2806 free_uploaded_tps (struct uploaded_tp
**utpp
)
2808 struct uploaded_tp
*next_one
;
2812 next_one
= (*utpp
)->next
;
2818 /* Given a number and address, return an uploaded tracepoint with that
2819 number, creating if necessary. */
2821 struct uploaded_tsv
*
2822 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
2824 struct uploaded_tsv
*utsv
;
2826 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
2827 if (utsv
->number
== num
)
2829 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
2830 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
2832 utsv
->next
= *utsvp
;
2838 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
2840 struct uploaded_tsv
*next_one
;
2844 next_one
= (*utsvp
)->next
;
2850 /* Look for an existing tracepoint that seems similar enough to the
2851 uploaded one. Enablement isn't compared, because the user can
2852 toggle that freely, and may have done so in anticipation of the
2856 find_matching_tracepoint (struct uploaded_tp
*utp
)
2858 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
2860 struct breakpoint
*t
;
2861 struct bp_location
*loc
;
2863 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2865 if (t
->type
== utp
->type
2866 && t
->step_count
== utp
->step
2867 && t
->pass_count
== utp
->pass
2868 /* FIXME also test conditionals and actions */
2871 /* Scan the locations for an address match. */
2872 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2874 if (loc
->address
== utp
->addr
)
2882 /* Given a list of tracepoints uploaded from a target, attempt to
2883 match them up with existing tracepoints, and create new ones if not
2887 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
2889 struct uploaded_tp
*utp
;
2890 struct breakpoint
*t
;
2892 /* Look for GDB tracepoints that match up with our uploaded versions. */
2893 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
2895 t
= find_matching_tracepoint (utp
);
2897 printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
2898 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2901 t
= create_tracepoint_from_upload (utp
);
2903 printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
2904 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2906 printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
2907 utp
->number
, paddress (get_current_arch (), utp
->addr
));
2909 /* Whether found or created, record the number used by the
2910 target, to help with mapping target tracepoints back to their
2911 counterparts here. */
2913 t
->number_on_target
= utp
->number
;
2916 free_uploaded_tps (uploaded_tps
);
2919 /* Trace state variables don't have much to identify them beyond their
2920 name, so just use that to detect matches. */
2922 struct trace_state_variable
*
2923 find_matching_tsv (struct uploaded_tsv
*utsv
)
2928 return find_trace_state_variable (utsv
->name
);
2931 struct trace_state_variable
*
2932 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
2934 const char *namebase
;
2937 struct trace_state_variable
*tsv
;
2941 namebase
= utsv
->name
;
2942 sprintf (buf
, "%s", namebase
);
2947 sprintf (buf
, "%s_%d", namebase
, try_num
++);
2950 /* Fish for a name that is not in use. */
2951 /* (should check against all internal vars?) */
2952 while (find_trace_state_variable (buf
))
2953 sprintf (buf
, "%s_%d", namebase
, try_num
++);
2955 /* We have an available name, create the variable. */
2956 tsv
= create_trace_state_variable (xstrdup (buf
));
2957 tsv
->initial_value
= utsv
->initial_value
;
2958 tsv
->builtin
= utsv
->builtin
;
2963 /* Given a list of uploaded trace state variables, try to match them
2964 up with existing variables, or create additional ones. */
2967 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
2970 struct uploaded_tsv
*utsv
;
2971 struct trace_state_variable
*tsv
;
2974 /* Most likely some numbers will have to be reassigned as part of
2975 the merge, so clear them all in anticipation. */
2976 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2979 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2981 tsv
= find_matching_tsv (utsv
);
2983 printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
2984 tsv
->name
, utsv
->number
);
2987 tsv
= create_tsv_from_upload (utsv
);
2988 printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
2989 tsv
->name
, utsv
->number
);
2991 /* Give precedence to numberings that come from the target. */
2993 tsv
->number
= utsv
->number
;
2996 /* Renumber everything that didn't get a target-assigned number. */
2998 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2999 if (tsv
->number
> highest
)
3000 highest
= tsv
->number
;
3003 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
3004 if (tsv
->number
== 0)
3005 tsv
->number
= highest
++;
3007 free_uploaded_tsvs (uploaded_tsvs
);
3010 /* target tfile command */
3012 struct target_ops tfile_ops
;
3014 /* Fill in tfile_ops with its defined operations and properties. */
3016 #define TRACE_HEADER_SIZE 8
3018 char *trace_filename
;
3020 off_t trace_frames_offset
;
3023 int trace_regblock_size
;
3025 static void tfile_interp_line (char *line
,
3026 struct uploaded_tp
**utpp
,
3027 struct uploaded_tsv
**utsvp
);
3030 tfile_open (char *filename
, int from_tty
)
3033 struct cleanup
*old_chain
;
3036 char header
[TRACE_HEADER_SIZE
];
3037 char linebuf
[1000]; /* should be max remote packet size or so */
3039 int bytes
, i
, gotten
;
3040 struct trace_status
*ts
;
3041 struct uploaded_tp
*uploaded_tps
= NULL
;
3042 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3044 target_preopen (from_tty
);
3046 error (_("No trace file specified."));
3048 filename
= tilde_expand (filename
);
3049 if (!IS_ABSOLUTE_PATH(filename
))
3051 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
3056 old_chain
= make_cleanup (xfree
, filename
);
3058 flags
= O_BINARY
| O_LARGEFILE
;
3060 scratch_chan
= open (filename
, flags
, 0);
3061 if (scratch_chan
< 0)
3062 perror_with_name (filename
);
3064 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3066 discard_cleanups (old_chain
); /* Don't free filename any more */
3067 unpush_target (&tfile_ops
);
3069 push_target (&tfile_ops
);
3071 trace_filename
= xstrdup (filename
);
3072 trace_fd
= scratch_chan
;
3075 /* Read the file header and test for validity. */
3076 gotten
= read (trace_fd
, &header
, TRACE_HEADER_SIZE
);
3078 perror_with_name (trace_filename
);
3079 else if (gotten
< TRACE_HEADER_SIZE
)
3080 error (_("Premature end of file while reading trace file"));
3082 bytes
+= TRACE_HEADER_SIZE
;
3083 if (!(header
[0] == 0x7f
3084 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3085 error (_("File is not a valid trace file."));
3087 trace_regblock_size
= 0;
3088 ts
= current_trace_status ();
3089 /* We know we're working with a file. */
3091 /* Set defaults in case there is no status line. */
3092 ts
->running_known
= 0;
3093 ts
->stop_reason
= trace_stop_reason_unknown
;
3094 ts
->traceframe_count
= -1;
3095 ts
->buffer_free
= 0;
3097 /* Read through a section of newline-terminated lines that
3098 define things like tracepoints. */
3102 gotten
= read (trace_fd
, &byte
, 1);
3104 perror_with_name (trace_filename
);
3105 else if (gotten
< 1)
3106 error (_("Premature end of file while reading trace file"));
3111 /* Empty line marks end of the definition section. */
3116 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3119 linebuf
[i
++] = byte
;
3121 error (_("Excessively long lines in trace file"));
3124 /* Add the file's tracepoints and variables into the current mix. */
3126 /* Get trace state variables first, they may be checked when parsing
3127 uploaded commands. */
3128 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3130 merge_uploaded_tracepoints (&uploaded_tps
);
3132 /* Record the starting offset of the binary trace data. */
3133 trace_frames_offset
= bytes
;
3135 /* If we don't have a blocksize, we can't interpret the
3137 if (trace_regblock_size
== 0)
3138 error (_("No register block size recorded in trace file"));
3139 if (ts
->traceframe_count
<= 0)
3141 warning ("No traceframes present in this file.");
3145 #define TFILE_PID (1)
3146 inferior_appeared (current_inferior (), TFILE_PID
);
3147 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3148 add_thread_silent (inferior_ptid
);
3150 post_create_inferior (&tfile_ops
, from_tty
);
3153 /* FIXME this will get defined in MI patch submission */
3154 tfind_1 (tfind_number
, 0, 0, 0, 0);
3158 /* Interpret the given line from the definitions part of the trace
3162 tfile_interp_line (char *line
,
3163 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3167 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3170 trace_regblock_size
= strtol (p
, &p
, 16);
3172 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3174 p
+= strlen ("status ");
3175 parse_trace_status (p
, current_trace_status ());
3177 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3179 p
+= strlen ("tp ");
3180 parse_tracepoint_definition (p
, utpp
);
3182 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3184 p
+= strlen ("tsv ");
3185 parse_tsv_definition (p
, utsvp
);
3188 warning ("Ignoring trace file definition \"%s\"", line
);
3191 /* Parse the part of trace status syntax that is shared between
3192 the remote protocol and the trace file reader. */
3194 extern char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
3197 parse_trace_status (char *line
, struct trace_status
*ts
)
3199 char *p
= line
, *p1
, *p2
, *p_temp
;
3202 ts
->running_known
= 1;
3203 ts
->running
= (*p
++ == '1');
3204 ts
->stop_reason
= trace_stop_reason_unknown
;
3205 xfree (ts
->error_desc
);
3206 ts
->error_desc
= NULL
;
3207 ts
->traceframe_count
= -1;
3208 ts
->traceframes_created
= -1;
3209 ts
->buffer_free
= -1;
3210 ts
->buffer_size
= -1;
3214 p1
= strchr (p
, ':');
3216 error (_("Malformed trace status, at %s\n\
3217 Status line: '%s'\n"), p
, line
);
3218 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3220 p
= unpack_varlen_hex (++p1
, &val
);
3221 ts
->stop_reason
= trace_buffer_full
;
3223 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3225 p
= unpack_varlen_hex (++p1
, &val
);
3226 ts
->stop_reason
= trace_never_run
;
3228 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
], p1
- p
) == 0)
3230 p
= unpack_varlen_hex (++p1
, &val
);
3231 ts
->stop_reason
= tracepoint_passcount
;
3232 ts
->stopping_tracepoint
= val
;
3234 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3236 p
= unpack_varlen_hex (++p1
, &val
);
3237 ts
->stop_reason
= tstop_command
;
3239 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3241 p2
= strchr (++p1
, ':');
3246 ts
->error_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3247 end
= hex2bin (p1
, ts
->error_desc
, (p2
- p1
) / 2);
3248 ts
->error_desc
[end
] = '\0';
3251 ts
->error_desc
= xstrdup ("");
3253 p
= unpack_varlen_hex (++p2
, &val
);
3254 ts
->stopping_tracepoint
= val
;
3255 ts
->stop_reason
= tracepoint_error
;
3257 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3259 p
= unpack_varlen_hex (++p1
, &val
);
3260 ts
->traceframe_count
= val
;
3262 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3264 p
= unpack_varlen_hex (++p1
, &val
);
3265 ts
->traceframes_created
= val
;
3267 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3269 p
= unpack_varlen_hex (++p1
, &val
);
3270 ts
->buffer_free
= val
;
3272 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3274 p
= unpack_varlen_hex (++p1
, &val
);
3275 ts
->buffer_size
= val
;
3279 /* Silently skip unknown optional info. */
3280 p_temp
= strchr (p1
+ 1, ';');
3284 /* Must be at the end. */
3290 /* Given a line of text defining a part of a tracepoint, parse it into
3291 an "uploaded tracepoint". */
3294 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3298 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
, start
;
3299 int enabled
, i
, end
;
3301 char *cond
, *srctype
, *src
, *buf
;
3302 struct uploaded_tp
*utp
= NULL
;
3305 /* Both tracepoint and action definitions start with the same number
3306 and address sequence. */
3308 p
= unpack_varlen_hex (p
, &num
);
3309 p
++; /* skip a colon */
3310 p
= unpack_varlen_hex (p
, &addr
);
3311 p
++; /* skip a colon */
3314 enabled
= (*p
++ == 'E');
3315 p
++; /* skip a colon */
3316 p
= unpack_varlen_hex (p
, &step
);
3317 p
++; /* skip a colon */
3318 p
= unpack_varlen_hex (p
, &pass
);
3319 type
= bp_tracepoint
;
3321 /* Thumb through optional fields. */
3324 p
++; /* skip a colon */
3327 type
= bp_fast_tracepoint
;
3329 p
= unpack_varlen_hex (p
, &orig_size
);
3334 p
= unpack_varlen_hex (p
, &xlen
);
3335 p
++; /* skip a comma */
3336 cond
= (char *) xmalloc (2 * xlen
+ 1);
3337 strncpy (cond
, p
, 2 * xlen
);
3338 cond
[2 * xlen
] = '\0';
3342 warning (_("Unrecognized char '%c' in tracepoint definition, skipping rest"), *p
);
3344 utp
= get_uploaded_tp (num
, addr
, utpp
);
3346 utp
->enabled
= enabled
;
3351 else if (piece
== 'A')
3353 utp
= get_uploaded_tp (num
, addr
, utpp
);
3354 utp
->actions
[utp
->numactions
++] = xstrdup (p
);
3356 else if (piece
== 'S')
3358 utp
= get_uploaded_tp (num
, addr
, utpp
);
3359 utp
->step_actions
[utp
->num_step_actions
++] = xstrdup (p
);
3361 else if (piece
== 'Z')
3363 /* Parse a chunk of source form definition. */
3364 utp
= get_uploaded_tp (num
, addr
, utpp
);
3366 p
= strchr (p
, ':');
3367 p
++; /* skip a colon */
3368 p
= unpack_varlen_hex (p
, &start
);
3369 p
++; /* skip a colon */
3370 p
= unpack_varlen_hex (p
, &xlen
);
3371 p
++; /* skip a colon */
3373 buf
= alloca (strlen (line
));
3375 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3378 if (strncmp (srctype
, "at:", strlen ("at:")) == 0)
3379 utp
->at_string
= xstrdup (buf
);
3380 else if (strncmp (srctype
, "cond:", strlen ("cond:")) == 0)
3381 utp
->cond_string
= xstrdup (buf
);
3382 else if (strncmp (srctype
, "cmd:", strlen ("cmd:")) == 0)
3384 /* FIXME consider using a vector? */
3385 struct uploaded_string
*last
, *newlast
;
3386 newlast
= (struct uploaded_string
*) xmalloc (sizeof (struct uploaded_string
));
3387 newlast
->str
= xstrdup (buf
);
3388 newlast
->next
= NULL
;
3389 if (utp
->cmd_strings
)
3391 for (last
= utp
->cmd_strings
; last
->next
; last
= last
->next
)
3393 last
->next
= newlast
;
3396 utp
->cmd_strings
= newlast
;
3401 /* Don't error out, the target might be sending us optional
3402 info that we don't care about. */
3403 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece
);
3407 /* Convert a textual description of a trace state variable into an
3411 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3414 ULONGEST num
, initval
, builtin
;
3416 struct uploaded_tsv
*utsv
= NULL
;
3418 buf
= alloca (strlen (line
));
3421 p
= unpack_varlen_hex (p
, &num
);
3422 p
++; /* skip a colon */
3423 p
= unpack_varlen_hex (p
, &initval
);
3424 p
++; /* skip a colon */
3425 p
= unpack_varlen_hex (p
, &builtin
);
3426 p
++; /* skip a colon */
3427 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3430 utsv
= get_uploaded_tsv (num
, utsvp
);
3431 utsv
->initial_value
= initval
;
3432 utsv
->builtin
= builtin
;
3433 utsv
->name
= xstrdup (buf
);
3436 /* Close the trace file and generally clean up. */
3439 tfile_close (int quitting
)
3446 pid
= ptid_get_pid (inferior_ptid
);
3447 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
3448 exit_inferior_silent (pid
);
3453 xfree (trace_filename
);
3457 tfile_files_info (struct target_ops
*t
)
3459 /* (it would be useful to mention the name of the file) */
3460 printf_filtered ("Looking at a trace file.\n");
3463 /* The trace status for a file is that tracing can never be run. */
3466 tfile_get_trace_status (struct trace_status
*ts
)
3468 /* Other bits of trace status were collected as part of opening the
3469 trace files, so nothing to do here. */
3474 /* Given the position of a traceframe in the file, figure out what
3475 address the frame was collected at. This would normally be the
3476 value of a collected PC register, but if not available, we
3480 tfile_get_traceframe_address (off_t tframe_offset
)
3484 struct breakpoint
*tp
;
3485 off_t saved_offset
= cur_offset
;
3488 /* FIXME dig pc out of collected registers */
3490 /* Fall back to using tracepoint address. */
3491 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
3492 gotten
= read (trace_fd
, &tpnum
, 2);
3494 perror_with_name (trace_filename
);
3495 else if (gotten
< 2)
3496 error (_("Premature end of file while reading trace file"));
3498 tp
= get_tracepoint_by_number_on_target (tpnum
);
3499 /* FIXME this is a poor heuristic if multiple locations */
3501 addr
= tp
->loc
->address
;
3503 /* Restore our seek position. */
3504 cur_offset
= saved_offset
;
3505 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3509 /* Given a type of search and some parameters, scan the collection of
3510 traceframes in the file looking for a match. When found, return
3511 both the traceframe and tracepoint number, otherwise -1 for
3515 tfile_trace_find (enum trace_find_type type
, int num
,
3516 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
3519 int tfnum
= 0, found
= 0, gotten
;
3521 struct breakpoint
*tp
;
3522 off_t offset
, tframe_offset
;
3525 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
3526 offset
= trace_frames_offset
;
3529 tframe_offset
= offset
;
3530 gotten
= read (trace_fd
, &tpnum
, 2);
3532 perror_with_name (trace_filename
);
3533 else if (gotten
< 2)
3534 error (_("Premature end of file while reading trace file"));
3538 gotten
= read (trace_fd
, &data_size
, 4);
3540 perror_with_name (trace_filename
);
3541 else if (gotten
< 4)
3542 error (_("Premature end of file while reading trace file"));
3551 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3552 if (tfaddr
== addr1
)
3556 tp
= get_tracepoint (num
);
3557 if (tp
&& tpnum
== tp
->number_on_target
)
3561 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3562 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
3566 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3567 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
3571 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
3577 cur_offset
= offset
;
3578 cur_data_size
= data_size
;
3581 /* Skip past the traceframe's data. */
3582 lseek (trace_fd
, data_size
, SEEK_CUR
);
3583 offset
+= data_size
;
3584 /* Update our own count of traceframes. */
3587 /* Did not find what we were looking for. */
3593 /* Look for a block of saved registers in the traceframe, and get the
3594 requested register from it. */
3597 tfile_fetch_registers (struct target_ops
*ops
,
3598 struct regcache
*regcache
, int regno
)
3600 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3602 int i
, pos
, offset
, regn
, regsize
, gotten
;
3603 unsigned short mlen
;
3606 /* An uninitialized reg size says we're not going to be
3607 successful at getting register blocks. */
3608 if (!trace_regblock_size
)
3611 regs
= alloca (trace_regblock_size
);
3613 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3615 while (pos
< cur_data_size
)
3617 gotten
= read (trace_fd
, &block_type
, 1);
3619 perror_with_name (trace_filename
);
3620 else if (gotten
< 1)
3621 error (_("Premature end of file while reading trace file"));
3627 gotten
= read (trace_fd
, regs
, trace_regblock_size
);
3629 perror_with_name (trace_filename
);
3630 else if (gotten
< trace_regblock_size
)
3631 error (_("Premature end of file while reading trace file"));
3633 /* Assume the block is laid out in GDB register number order,
3634 each register with the size that it has in GDB. */
3636 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3638 regsize
= register_size (gdbarch
, regn
);
3639 /* Make sure we stay within block bounds. */
3640 if (offset
+ regsize
>= trace_regblock_size
)
3642 if (!regcache_valid_p (regcache
, regn
))
3646 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
3649 else if (regno
== -1)
3651 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
3658 lseek (trace_fd
, 8, SEEK_CUR
);
3659 gotten
= read (trace_fd
, &mlen
, 2);
3661 perror_with_name (trace_filename
);
3662 else if (gotten
< 2)
3663 error (_("Premature end of file while reading trace file"));
3664 lseek (trace_fd
, mlen
, SEEK_CUR
);
3665 pos
+= (8 + 2 + mlen
);
3668 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3672 error ("Unknown block type '%c' (0x%x) in trace frame",
3673 block_type
, block_type
);
3680 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3681 const char *annex
, gdb_byte
*readbuf
,
3682 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3687 unsigned short mlen
;
3689 /* We're only doing regular memory for now. */
3690 if (object
!= TARGET_OBJECT_MEMORY
)
3693 if (readbuf
== NULL
)
3694 error ("tfile_xfer_partial: trace file is read-only");
3696 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3698 while (pos
< cur_data_size
)
3700 gotten
= read (trace_fd
, &block_type
, 1);
3702 perror_with_name (trace_filename
);
3703 else if (gotten
< 1)
3704 error (_("Premature end of file while reading trace file"));
3709 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3710 pos
+= trace_regblock_size
;
3713 gotten
= read (trace_fd
, &maddr
, 8);
3715 perror_with_name (trace_filename
);
3716 else if (gotten
< 8)
3717 error (_("Premature end of file while reading trace file"));
3719 gotten
= read (trace_fd
, &mlen
, 2);
3721 perror_with_name (trace_filename
);
3722 else if (gotten
< 2)
3723 error (_("Premature end of file while reading trace file"));
3724 if (maddr
<= offset
&& (offset
+ len
) <= (maddr
+ mlen
))
3726 gotten
= read (trace_fd
, readbuf
, mlen
);
3728 perror_with_name (trace_filename
);
3729 else if (gotten
< mlen
)
3730 error (_("Premature end of file qwhile reading trace file"));
3734 lseek (trace_fd
, mlen
, SEEK_CUR
);
3735 pos
+= (8 + 2 + mlen
);
3738 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3742 error ("Unknown block type '%c' (0x%x) in traceframe",
3743 block_type
, block_type
);
3747 /* Indicate failure to find the requested memory block. */
3751 /* Iterate through the blocks of a trace frame, looking for a 'V'
3752 block with a matching tsv number. */
3755 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
3758 int pos
, vnum
, gotten
;
3759 unsigned short mlen
;
3761 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3763 while (pos
< cur_data_size
)
3765 gotten
= read (trace_fd
, &block_type
, 1);
3767 perror_with_name (trace_filename
);
3768 else if (gotten
< 1)
3769 error (_("Premature end of file while reading trace file"));
3774 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3775 pos
+= trace_regblock_size
;
3778 lseek (trace_fd
, 8, SEEK_CUR
);
3779 gotten
= read (trace_fd
, &mlen
, 2);
3781 perror_with_name (trace_filename
);
3782 else if (gotten
< 2)
3783 error (_("Premature end of file while reading trace file"));
3784 lseek (trace_fd
, mlen
, SEEK_CUR
);
3785 pos
+= (8 + 2 + mlen
);
3788 gotten
= read (trace_fd
, &vnum
, 4);
3790 perror_with_name (trace_filename
);
3791 else if (gotten
< 4)
3792 error (_("Premature end of file while reading trace file"));
3795 gotten
= read (trace_fd
, val
, 8);
3797 perror_with_name (trace_filename
);
3798 else if (gotten
< 8)
3799 error (_("Premature end of file while reading trace file"));
3802 lseek (trace_fd
, 8, SEEK_CUR
);
3806 error ("Unknown block type '%c' (0x%x) in traceframe",
3807 block_type
, block_type
);
3811 /* Didn't find anything. */
3816 tfile_has_memory (struct target_ops
*ops
)
3822 tfile_has_stack (struct target_ops
*ops
)
3828 tfile_has_registers (struct target_ops
*ops
)
3834 init_tfile_ops (void)
3836 tfile_ops
.to_shortname
= "tfile";
3837 tfile_ops
.to_longname
= "Local trace dump file";
3839 "Use a trace file as a target. Specify the filename of the trace file.";
3840 tfile_ops
.to_open
= tfile_open
;
3841 tfile_ops
.to_close
= tfile_close
;
3842 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
3843 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
3844 tfile_ops
.to_files_info
= tfile_files_info
;
3845 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
3846 tfile_ops
.to_trace_find
= tfile_trace_find
;
3847 tfile_ops
.to_get_trace_state_variable_value
= tfile_get_trace_state_variable_value
;
3848 /* core_stratum might seem more logical, but GDB doesn't like having
3849 more than one core_stratum vector. */
3850 tfile_ops
.to_stratum
= process_stratum
;
3851 tfile_ops
.to_has_memory
= tfile_has_memory
;
3852 tfile_ops
.to_has_stack
= tfile_has_stack
;
3853 tfile_ops
.to_has_registers
= tfile_has_registers
;
3854 tfile_ops
.to_magic
= OPS_MAGIC
;
3857 /* module initialization */
3859 _initialize_tracepoint (void)
3861 struct cmd_list_element
*c
;
3863 traceframe_number
= -1;
3864 tracepoint_number
= -1;
3866 if (tracepoint_list
.list
== NULL
)
3868 tracepoint_list
.listsize
= 128;
3869 tracepoint_list
.list
= xmalloc
3870 (tracepoint_list
.listsize
* sizeof (struct memrange
));
3872 if (tracepoint_list
.aexpr_list
== NULL
)
3874 tracepoint_list
.aexpr_listsize
= 128;
3875 tracepoint_list
.aexpr_list
= xmalloc
3876 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3879 if (stepping_list
.list
== NULL
)
3881 stepping_list
.listsize
= 128;
3882 stepping_list
.list
= xmalloc
3883 (stepping_list
.listsize
* sizeof (struct memrange
));
3886 if (stepping_list
.aexpr_list
== NULL
)
3888 stepping_list
.aexpr_listsize
= 128;
3889 stepping_list
.aexpr_list
= xmalloc
3890 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3893 add_info ("scope", scope_info
,
3894 _("List the variables local to a scope"));
3896 add_cmd ("tracepoints", class_trace
, NULL
,
3897 _("Tracing of program execution without stopping the program."),
3900 add_com ("tdump", class_trace
, trace_dump_command
,
3901 _("Print everything collected at the current tracepoint."));
3903 add_com ("tsave", class_trace
, trace_save_command
, _("\
3904 Save the trace data to a file.\n\
3905 Use the '-r' option to direct the target to save directly to the file,\n\
3906 using its own filesystem."));
3908 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
3909 Define a trace state variable.\n\
3910 Argument is a $-prefixed name, optionally followed\n\
3911 by '=' and an expression that sets the initial value\n\
3912 at the start of tracing."));
3913 set_cmd_completer (c
, expression_completer
);
3915 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
3916 Delete one or more trace state variables.\n\
3917 Arguments are the names of the variables to delete.\n\
3918 If no arguments are supplied, delete all variables."), &deletelist
);
3919 /* FIXME add a trace variable completer */
3921 add_info ("tvariables", tvariables_info
, _("\
3922 Status of trace state variables and their values.\n\
3925 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
3926 Select a trace frame;\n\
3927 No argument means forward by one frame; '-' means backward by one frame."),
3928 &tfindlist
, "tfind ", 1, &cmdlist
);
3930 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
3931 Select a trace frame whose PC is outside the given range (exclusive).\n\
3932 Usage: tfind outside addr1, addr2"),
3935 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
3936 Select a trace frame whose PC is in the given range (inclusive).\n\
3937 Usage: tfind range addr1,addr2"),
3940 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
3941 Select a trace frame by source line.\n\
3942 Argument can be a line number (with optional source file), \n\
3943 a function name, or '*' followed by an address.\n\
3944 Default argument is 'the next source line that was traced'."),
3947 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
3948 Select a trace frame by tracepoint number.\n\
3949 Default is the tracepoint for the current trace frame."),
3952 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
3953 Select a trace frame by PC.\n\
3954 Default is the current PC, or the PC of the current trace frame."),
3957 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
3958 Synonym for 'none'.\n\
3959 De-select any trace frame and resume 'live' debugging."),
3962 add_cmd ("none", class_trace
, trace_find_none_command
,
3963 _("De-select any trace frame and resume 'live' debugging."),
3966 add_cmd ("start", class_trace
, trace_find_start_command
,
3967 _("Select the first trace frame in the trace buffer."),
3970 add_com ("tstatus", class_trace
, trace_status_command
,
3971 _("Display the status of the current trace data collection."));
3973 add_com ("tstop", class_trace
, trace_stop_command
,
3974 _("Stop trace data collection."));
3976 add_com ("tstart", class_trace
, trace_start_command
,
3977 _("Start trace data collection."));
3979 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
3980 Ends a list of commands or actions.\n\
3981 Several GDB commands allow you to enter a list of commands or actions.\n\
3982 Entering \"end\" on a line by itself is the normal way to terminate\n\
3984 Note: the \"end\" command cannot be used at the gdb prompt."));
3986 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
3987 Specify single-stepping behavior at a tracepoint.\n\
3988 Argument is number of instructions to trace in single-step mode\n\
3989 following the tracepoint. This command is normally followed by\n\
3990 one or more \"collect\" commands, to specify what to collect\n\
3991 while single-stepping.\n\n\
3992 Note: this command can only be used in a tracepoint \"actions\" list."));
3994 add_com_alias ("ws", "while-stepping", class_alias
, 0);
3995 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
3997 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
3998 Specify one or more data items to be collected at a tracepoint.\n\
3999 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4000 collect all data (variables, registers) referenced by that expression.\n\
4001 Also accepts the following special arguments:\n\
4002 $regs -- all registers.\n\
4003 $args -- all function arguments.\n\
4004 $locals -- all variables local to the block/function scope.\n\
4005 Note: this command can only be used in a tracepoint \"actions\" list."));
4007 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
4008 Specify one or more expressions to be evaluated at a tracepoint.\n\
4009 Accepts a comma-separated list of (one or more) expressions.\n\
4010 The result of each evaluation will be discarded.\n\
4011 Note: this command can only be used in a tracepoint \"actions\" list."));
4013 add_com ("actions", class_trace
, trace_actions_command
, _("\
4014 Specify the actions to be taken at a tracepoint.\n\
4015 Tracepoint actions may include collecting of specified data, \n\
4016 single-stepping, or enabling/disabling other tracepoints, \n\
4017 depending on target's capabilities."));
4019 default_collect
= xstrdup ("");
4020 add_setshow_string_cmd ("default-collect", class_trace
,
4021 &default_collect
, _("\
4022 Set the list of expressions to collect by default"), _("\
4023 Show the list of expressions to collect by default"), NULL
,
4025 &setlist
, &showlist
);
4027 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
4028 &disconnected_tracing
, _("\
4029 Set whether tracing continues after GDB disconnects."), _("\
4030 Show whether tracing continues after GDB disconnects."), _("\
4031 Use this to continue a tracing run even if GDB disconnects\n\
4032 or detaches from the target. You can reconnect later and look at\n\
4033 trace data collected in the meantime."),
4034 set_disconnected_tracing
,
4039 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
4040 &circular_trace_buffer
, _("\
4041 Set target's use of circular trace buffer."), _("\
4042 Show target's use of circular trace buffer."), _("\
4043 Use this to make the trace buffer into a circular buffer,\n\
4044 which will discard traceframes (oldest first) instead of filling\n\
4045 up and stopping the trace run."),
4046 set_circular_trace_buffer
,
4053 add_target (&tfile_ops
);