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
);
926 printf_filtered ("Don't know LOC_UNRESOLVED %s\n",
927 SYMBOL_PRINT_NAME (sym
));
929 case LOC_OPTIMIZED_OUT
:
930 printf_filtered ("%s has been optimized out of existence.\n",
931 SYMBOL_PRINT_NAME (sym
));
939 /* Expressions are the most general case. */
942 struct agent_expr
*aexpr
;
943 struct cleanup
*old_chain1
= NULL
;
944 struct agent_reqs areqs
;
946 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
948 /* It can happen that the symbol is recorded as a computed
949 location, but it's been optimized away and doesn't actually
950 have a location expression. */
953 printf_filtered ("%s has been optimized out of existence.\n",
954 SYMBOL_PRINT_NAME (sym
));
958 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
960 ax_reqs (aexpr
, &areqs
);
961 if (areqs
.flaw
!= agent_flaw_none
)
962 error (_("malformed expression"));
964 if (areqs
.min_height
< 0)
965 error (_("gdb: Internal error: expression has min height < 0"));
966 if (areqs
.max_height
> 20)
967 error (_("expression too complicated, try simplifying"));
969 discard_cleanups (old_chain1
);
970 add_aexpr (collect
, aexpr
);
972 /* take care of the registers */
973 if (areqs
.reg_mask_len
> 0)
977 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
979 QUIT
; /* allow user to bail out with ^C */
980 if (areqs
.reg_mask
[ndx1
] != 0)
982 /* assume chars have 8 bits */
983 for (ndx2
= 0; ndx2
< 8; ndx2
++)
984 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
985 /* it's used -- record it */
986 add_register (collect
, ndx1
* 8 + ndx2
);
993 /* Add all locals (or args) symbols to collection list */
995 add_local_symbols (struct collection_list
*collect
,
996 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
997 long frame_regno
, long frame_offset
, int type
)
1000 struct block
*block
;
1001 struct dict_iterator iter
;
1004 block
= block_for_pc (pc
);
1007 QUIT
; /* allow user to bail out with ^C */
1008 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
1010 if (SYMBOL_IS_ARGUMENT (sym
)
1011 ? type
== 'A' /* collecting Arguments */
1012 : type
== 'L') /* collecting Locals */
1015 collect_symbol (collect
, sym
, gdbarch
,
1016 frame_regno
, frame_offset
, pc
);
1019 if (BLOCK_FUNCTION (block
))
1022 block
= BLOCK_SUPERBLOCK (block
);
1025 warning (_("No %s found in scope."),
1026 type
== 'L' ? "locals" : "args");
1029 /* worker function */
1031 clear_collection_list (struct collection_list
*list
)
1035 list
->next_memrange
= 0;
1036 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1038 free_agent_expr (list
->aexpr_list
[ndx
]);
1039 list
->aexpr_list
[ndx
] = NULL
;
1041 list
->next_aexpr_elt
= 0;
1042 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1045 /* reduce a collection list to string form (for gdb protocol) */
1047 stringify_collection_list (struct collection_list
*list
, char *string
)
1049 char temp_buf
[2048];
1053 char *(*str_list
)[];
1057 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1058 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1060 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1061 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1063 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1066 printf_filtered ("\nCollecting registers (mask): 0x");
1071 QUIT
; /* allow user to bail out with ^C */
1073 printf_filtered ("%02X", list
->regs_mask
[i
]);
1074 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1077 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1081 printf_filtered ("\n");
1082 if (list
->next_memrange
> 0 && info_verbose
)
1083 printf_filtered ("Collecting memranges: \n");
1084 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1086 QUIT
; /* allow user to bail out with ^C */
1087 sprintf_vma (tmp2
, list
->list
[i
].start
);
1090 printf_filtered ("(%d, %s, %ld)\n",
1093 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1095 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1097 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1104 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1106 /* The "%X" conversion specifier expects an unsigned argument,
1107 so passing -1 (memrange_absolute) to it directly gives you
1108 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1110 if (list
->list
[i
].type
== memrange_absolute
)
1111 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1113 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1116 count
+= strlen (end
);
1117 end
= temp_buf
+ count
;
1120 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1122 QUIT
; /* allow user to bail out with ^C */
1123 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1125 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1130 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1131 end
+= 10; /* 'X' + 8 hex digits + ',' */
1134 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1135 end
, list
->aexpr_list
[i
]->len
);
1136 count
+= 2 * list
->aexpr_list
[i
]->len
;
1141 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1146 (*str_list
)[ndx
] = NULL
;
1159 encode_actions_1 (struct command_line
*action
,
1160 struct breakpoint
*t
,
1161 struct bp_location
*tloc
,
1163 LONGEST frame_offset
,
1164 struct collection_list
*collect
,
1165 struct collection_list
*stepping_list
)
1168 struct expression
*exp
= NULL
;
1169 struct command_line
*actions
;
1171 struct value
*tempval
;
1172 struct cmd_list_element
*cmd
;
1173 struct agent_expr
*aexpr
;
1175 for (; action
; action
= action
->next
)
1177 QUIT
; /* allow user to bail out with ^C */
1178 action_exp
= action
->line
;
1179 while (isspace ((int) *action_exp
))
1182 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1184 error (_("Bad action list item: %s"), action_exp
);
1186 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1189 { /* repeat over a comma-separated list */
1190 QUIT
; /* allow user to bail out with ^C */
1191 while (isspace ((int) *action_exp
))
1194 if (0 == strncasecmp ("$reg", action_exp
, 4))
1196 for (i
= 0; i
< gdbarch_num_regs (t
->gdbarch
); i
++)
1197 add_register (collect
, i
);
1198 action_exp
= strchr (action_exp
, ','); /* more? */
1200 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1202 add_local_symbols (collect
,
1208 action_exp
= strchr (action_exp
, ','); /* more? */
1210 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1212 add_local_symbols (collect
,
1218 action_exp
= strchr (action_exp
, ','); /* more? */
1222 unsigned long addr
, len
;
1223 struct cleanup
*old_chain
= NULL
;
1224 struct cleanup
*old_chain1
= NULL
;
1225 struct agent_reqs areqs
;
1227 exp
= parse_exp_1 (&action_exp
,
1228 block_for_pc (tloc
->address
), 1);
1229 old_chain
= make_cleanup (free_current_contents
, &exp
);
1231 switch (exp
->elts
[0].opcode
)
1235 const char *name
= &exp
->elts
[2].string
;
1237 i
= user_reg_map_name_to_regnum (t
->gdbarch
,
1238 name
, strlen (name
));
1240 internal_error (__FILE__
, __LINE__
,
1241 _("Register $%s not available"),
1244 printf_filtered ("OP_REGISTER: ");
1245 add_register (collect
, i
);
1250 /* safe because we know it's a simple expression */
1251 tempval
= evaluate_expression (exp
);
1252 addr
= value_address (tempval
);
1253 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1254 add_memrange (collect
, memrange_absolute
, addr
, len
);
1258 collect_symbol (collect
,
1259 exp
->elts
[2].symbol
,
1266 default: /* full-fledged expression */
1267 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1269 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1271 ax_reqs (aexpr
, &areqs
);
1272 if (areqs
.flaw
!= agent_flaw_none
)
1273 error (_("malformed expression"));
1275 if (areqs
.min_height
< 0)
1276 error (_("gdb: Internal error: expression has min height < 0"));
1277 if (areqs
.max_height
> 20)
1278 error (_("expression too complicated, try simplifying"));
1280 discard_cleanups (old_chain1
);
1281 add_aexpr (collect
, aexpr
);
1283 /* take care of the registers */
1284 if (areqs
.reg_mask_len
> 0)
1289 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1291 QUIT
; /* allow user to bail out with ^C */
1292 if (areqs
.reg_mask
[ndx1
] != 0)
1294 /* assume chars have 8 bits */
1295 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1296 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1297 /* it's used -- record it */
1298 add_register (collect
,
1305 do_cleanups (old_chain
);
1308 while (action_exp
&& *action_exp
++ == ',');
1310 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1313 { /* repeat over a comma-separated list */
1314 QUIT
; /* allow user to bail out with ^C */
1315 while (isspace ((int) *action_exp
))
1319 unsigned long addr
, len
;
1320 struct cleanup
*old_chain
= NULL
;
1321 struct cleanup
*old_chain1
= NULL
;
1322 struct agent_reqs areqs
;
1324 exp
= parse_exp_1 (&action_exp
,
1325 block_for_pc (tloc
->address
), 1);
1326 old_chain
= make_cleanup (free_current_contents
, &exp
);
1328 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1329 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1331 ax_reqs (aexpr
, &areqs
);
1332 if (areqs
.flaw
!= agent_flaw_none
)
1333 error (_("malformed expression"));
1335 if (areqs
.min_height
< 0)
1336 error (_("gdb: Internal error: expression has min height < 0"));
1337 if (areqs
.max_height
> 20)
1338 error (_("expression too complicated, try simplifying"));
1340 discard_cleanups (old_chain1
);
1341 /* Even though we're not officially collecting, add
1342 to the collect list anyway. */
1343 add_aexpr (collect
, aexpr
);
1345 do_cleanups (old_chain
);
1348 while (action_exp
&& *action_exp
++ == ',');
1350 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1352 /* We check against nested while-stepping when setting
1353 breakpoint action, so no way to run into nested
1355 gdb_assert (stepping_list
);
1357 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
, frame_offset
,
1358 stepping_list
, NULL
);
1361 error (_("Invalid tracepoint command '%s'"), action
->line
);
1365 /* Render all actions into gdb protocol. */
1367 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1368 char ***tdp_actions
, char ***stepping_actions
)
1370 static char tdp_buff
[2048], step_buff
[2048];
1371 char *default_collect_line
= NULL
;
1372 struct command_line
*actions
;
1373 struct command_line
*default_collect_action
= NULL
;
1375 LONGEST frame_offset
;
1376 struct cleanup
*back_to
;
1378 back_to
= make_cleanup (null_cleanup
, NULL
);
1380 clear_collection_list (&tracepoint_list
);
1381 clear_collection_list (&stepping_list
);
1383 *tdp_actions
= NULL
;
1384 *stepping_actions
= NULL
;
1386 gdbarch_virtual_frame_pointer (t
->gdbarch
,
1387 t
->loc
->address
, &frame_reg
, &frame_offset
);
1389 actions
= t
->commands
->commands
;
1391 /* If there are default expressions to collect, make up a collect
1392 action and prepend to the action list to encode. Note that since
1393 validation is per-tracepoint (local var "xyz" might be valid for
1394 one tracepoint and not another, etc), we make up the action on
1395 the fly, and don't cache it. */
1396 if (*default_collect
)
1399 enum actionline_type linetype
;
1401 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1402 make_cleanup (xfree
, default_collect_line
);
1404 line
= default_collect_line
;
1405 linetype
= validate_actionline (&line
, t
);
1406 if (linetype
!= BADLINE
)
1408 default_collect_action
= xmalloc (sizeof (struct command_line
));
1409 make_cleanup (xfree
, default_collect_action
);
1410 default_collect_action
->next
= t
->commands
->commands
;
1411 default_collect_action
->line
= line
;
1412 actions
= default_collect_action
;
1415 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1416 &tracepoint_list
, &stepping_list
);
1418 memrange_sortmerge (&tracepoint_list
);
1419 memrange_sortmerge (&stepping_list
);
1421 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1423 *stepping_actions
= stringify_collection_list (&stepping_list
,
1426 do_cleanups (back_to
);
1430 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1432 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1434 collect
->aexpr_list
=
1435 xrealloc (collect
->aexpr_list
,
1436 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1437 collect
->aexpr_listsize
*= 2;
1439 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1440 collect
->next_aexpr_elt
++;
1445 start_tracing (void)
1448 VEC(breakpoint_p
) *tp_vec
= NULL
;
1450 struct breakpoint
*t
;
1451 struct trace_state_variable
*tsv
;
1452 int any_enabled
= 0;
1454 tp_vec
= all_tracepoints ();
1456 /* No point in tracing without any tracepoints... */
1457 if (VEC_length (breakpoint_p
, tp_vec
) == 0)
1459 VEC_free (breakpoint_p
, tp_vec
);
1460 error (_("No tracepoints defined, not starting trace"));
1463 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1465 if (t
->enable_state
== bp_enabled
)
1472 /* No point in tracing with only disabled tracepoints. */
1475 VEC_free (breakpoint_p
, tp_vec
);
1476 error (_("No tracepoints enabled, not starting trace"));
1479 target_trace_init ();
1481 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1483 t
->number_on_target
= 0;
1484 target_download_tracepoint (t
);
1485 t
->number_on_target
= t
->number
;
1487 VEC_free (breakpoint_p
, tp_vec
);
1489 /* Send down all the trace state variables too. */
1490 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1492 target_download_trace_state_variable (tsv
);
1495 /* Tell target to treat text-like sections as transparent. */
1496 target_trace_set_readonly_regions ();
1497 /* Set some mode flags. */
1498 target_set_disconnected_tracing (disconnected_tracing
);
1499 target_set_circular_trace_buffer (circular_trace_buffer
);
1501 /* Now insert traps and begin collecting data. */
1502 target_trace_start ();
1504 /* Reset our local state. */
1505 set_traceframe_num (-1);
1506 set_tracepoint_num (-1);
1507 set_traceframe_context (NULL
);
1508 current_trace_status()->running
= 1;
1513 Tell target to clear any previous trace experiment.
1514 Walk the list of tracepoints, and send them (and their actions)
1515 to the target. If no errors,
1516 Tell target to start a new trace experiment. */
1519 trace_start_command (char *args
, int from_tty
)
1521 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1528 trace_stop_command (char *args
, int from_tty
)
1536 target_trace_stop ();
1537 /* should change in response to reply? */
1538 current_trace_status ()->running
= 0;
1541 /* tstatus command */
1543 trace_status_command (char *args
, int from_tty
)
1545 struct trace_status
*ts
= current_trace_status ();
1548 status
= target_get_trace_status (ts
);
1553 printf_filtered (_("Using a trace file.\n"));
1556 printf_filtered (_("Trace can not be run on this target.\n"));
1561 if (!ts
->running_known
)
1563 printf_filtered (_("Run/stop status is unknown.\n"));
1565 else if (ts
->running
)
1567 printf_filtered (_("Trace is running on the target.\n"));
1568 if (disconnected_tracing
)
1569 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1571 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1575 switch (ts
->stop_reason
)
1577 case trace_never_run
:
1578 printf_filtered (_("No trace has been run on the target.\n"));
1581 printf_filtered (_("Trace stopped by a tstop command.\n"));
1583 case trace_buffer_full
:
1584 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1586 case trace_disconnected
:
1587 printf_filtered (_("Trace stopped because of disconnection.\n"));
1589 case tracepoint_passcount
:
1590 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1591 ts
->stopping_tracepoint
);
1593 case tracepoint_error
:
1594 if (ts
->stopping_tracepoint
)
1595 printf_filtered (_("Trace stopped by an error (%s, tracepoint %d).\n"),
1596 ts
->error_desc
, ts
->stopping_tracepoint
);
1598 printf_filtered (_("Trace stopped by an error (%s).\n"),
1601 case trace_stop_reason_unknown
:
1602 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1605 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1611 if (ts
->traceframes_created
>= 0
1612 && ts
->traceframe_count
!= ts
->traceframes_created
)
1614 printf_filtered (_("Buffer contains %d trace frames (of %d created total).\n"),
1615 ts
->traceframe_count
, ts
->traceframes_created
);
1617 else if (ts
->traceframe_count
>= 0)
1619 printf_filtered (_("Collected %d trace frames.\n"),
1620 ts
->traceframe_count
);
1623 if (ts
->buffer_free
>= 0)
1625 if (ts
->buffer_size
>= 0)
1627 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1628 ts
->buffer_free
, ts
->buffer_size
);
1629 if (ts
->buffer_size
> 0)
1630 printf_filtered (_(" (%d%% full)"),
1631 ((int) ((((long long) (ts
->buffer_size
1632 - ts
->buffer_free
)) * 100)
1633 / ts
->buffer_size
)));
1634 printf_filtered (_(".\n"));
1637 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1641 /* Now report on what we're doing with tfind. */
1642 if (traceframe_number
>= 0)
1643 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1644 traceframe_number
, tracepoint_number
);
1646 printf_filtered (_("Not looking at any trace frame.\n"));
1649 /* Report the trace status to uiout, in a way suitable for MI, and not
1650 suitable for CLI. If ON_STOP is true, suppress a few fields that
1651 are not meaningful in the -trace-stop response.
1653 The implementation is essentially parallel to trace_status_command, but
1654 merging them will result in unreadable code. */
1656 trace_status_mi (int on_stop
)
1658 struct trace_status
*ts
= current_trace_status ();
1660 char *string_status
;
1662 status
= target_get_trace_status (ts
);
1664 if (status
== -1 && !ts
->from_file
)
1666 ui_out_field_string (uiout
, "supported", "0");
1671 ui_out_field_string (uiout
, "supported", "file");
1673 ui_out_field_string (uiout
, "supported", "1");
1675 gdb_assert (ts
->running_known
);
1679 ui_out_field_string (uiout
, "running", "1");
1681 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1682 Given that the frontend gets the status either on -trace-stop, or from
1683 -trace-status after re-connection, it does not seem like this
1684 information is necessary for anything. It is not necessary for either
1685 figuring the vital state of the target nor for navigation of trace
1686 frames. If the frontend wants to show the current state is some
1687 configure dialog, it can request the value when such dialog is
1688 invoked by the user. */
1692 char *stop_reason
= NULL
;
1693 int stopping_tracepoint
= -1;
1696 ui_out_field_string (uiout
, "running", "0");
1698 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
1700 switch (ts
->stop_reason
)
1703 stop_reason
= "request";
1705 case trace_buffer_full
:
1706 stop_reason
= "overflow";
1708 case trace_disconnected
:
1709 stop_reason
= "disconnection";
1711 case tracepoint_passcount
:
1712 stop_reason
= "passcount";
1713 stopping_tracepoint
= ts
->stopping_tracepoint
;
1715 case tracepoint_error
:
1716 stop_reason
= "error";
1717 stopping_tracepoint
= ts
->stopping_tracepoint
;
1723 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
1724 if (stopping_tracepoint
!= -1)
1725 ui_out_field_int (uiout
, "stopping-tracepoint",
1726 stopping_tracepoint
);
1727 if (ts
->stop_reason
== tracepoint_error
)
1728 ui_out_field_string (uiout
, "error-description",
1735 if ((int) ts
->traceframe_count
!= -1)
1736 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
1737 if ((int) ts
->buffer_size
!= -1)
1738 ui_out_field_int (uiout
, "buffer-size", (int) ts
->buffer_size
);
1739 if ((int) ts
->buffer_free
!= -1)
1740 ui_out_field_int (uiout
, "buffer-free", (int) ts
->buffer_free
);
1745 disconnect_or_stop_tracing (int from_tty
)
1747 /* It can happen that the target that was tracing went away on its
1748 own, and we didn't notice. Get a status update, and if the
1749 current target doesn't even do tracing, then assume it's not
1751 if (target_get_trace_status (current_trace_status ()) < 0)
1752 current_trace_status ()->running
= 0;
1754 if (current_trace_status ()->running
&& from_tty
)
1756 int cont
= query (_("Trace is running. Continue tracing after detach? "));
1757 /* Note that we send the query result without affecting the
1758 user's setting of disconnected_tracing, so that the answer is
1760 send_disconnected_tracing_value (cont
);
1762 /* Also ensure that we do the equivalent of a tstop command if
1763 tracing is not to continue after the detach. */
1768 /* Also we want to be out of tfind mode, otherwise things can get
1769 confusing upon reconnection. Just use these calls instead of
1770 full tfind_1 behavior because we're in the middle of detaching,
1771 and there's no point to updating current stack frame etc. */
1772 set_traceframe_number (-1);
1773 set_traceframe_context (NULL
);
1776 /* Worker function for the various flavors of the tfind command. */
1778 tfind_1 (enum trace_find_type type
, int num
,
1779 ULONGEST addr1
, ULONGEST addr2
,
1782 int target_frameno
= -1, target_tracept
= -1;
1783 struct frame_id old_frame_id
;
1785 struct breakpoint
*tp
;
1787 old_frame_id
= get_frame_id (get_current_frame ());
1789 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
1792 if (type
== tfind_number
1794 && target_frameno
== -1)
1796 /* We told the target to get out of tfind mode, and it did. */
1798 else if (target_frameno
== -1)
1800 /* A request for a non-existant trace frame has failed.
1801 Our response will be different, depending on FROM_TTY:
1803 If FROM_TTY is true, meaning that this command was
1804 typed interactively by the user, then give an error
1805 and DO NOT change the state of traceframe_number etc.
1807 However if FROM_TTY is false, meaning that we're either
1808 in a script, a loop, or a user-defined command, then
1809 DON'T give an error, but DO change the state of
1810 traceframe_number etc. to invalid.
1812 The rationalle is that if you typed the command, you
1813 might just have committed a typo or something, and you'd
1814 like to NOT lose your current debugging state. However
1815 if you're in a user-defined command or especially in a
1816 loop, then you need a way to detect that the command
1817 failed WITHOUT aborting. This allows you to write
1818 scripts that search thru the trace buffer until the end,
1819 and then continue on to do something else. */
1822 error (_("Target failed to find requested trace frame."));
1826 printf_filtered ("End of trace buffer.\n");
1827 #if 0 /* dubious now? */
1828 /* The following will not recurse, since it's
1830 trace_find_command ("-1", from_tty
);
1835 tp
= get_tracepoint_by_number_on_target (target_tracept
);
1837 reinit_frame_cache ();
1838 registers_changed ();
1839 target_dcache_invalidate ();
1840 set_traceframe_num (target_frameno
);
1841 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
1842 if (target_frameno
== -1)
1843 set_traceframe_context (NULL
);
1845 set_traceframe_context (get_current_frame ());
1847 if (traceframe_number
>= 0)
1849 /* Use different branches for MI and CLI to make CLI messages
1851 if (ui_out_is_mi_like_p (uiout
))
1853 ui_out_field_string (uiout
, "found", "1");
1854 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
1855 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
1859 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
1860 traceframe_number
, tracepoint_number
);
1865 if (ui_out_is_mi_like_p (uiout
))
1866 ui_out_field_string (uiout
, "found", "0");
1868 printf_unfiltered (_("No trace frame found"));
1871 /* If we're in nonstop mode and getting out of looking at trace
1872 frames, there won't be any current frame to go back to and
1875 && (has_stack_frames () || traceframe_number
>= 0))
1877 enum print_what print_what
;
1879 /* NOTE: in immitation of the step command, try to determine
1880 whether we have made a transition from one function to
1881 another. If so, we'll print the "stack frame" (ie. the new
1882 function and it's arguments) -- otherwise we'll just show the
1885 if (frame_id_eq (old_frame_id
,
1886 get_frame_id (get_current_frame ())))
1887 print_what
= SRC_LINE
;
1889 print_what
= SRC_AND_LOC
;
1891 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
1896 /* trace_find_command takes a trace frame number n,
1897 sends "QTFrame:<n>" to the target,
1898 and accepts a reply that may contain several optional pieces
1899 of information: a frame number, a tracepoint number, and an
1900 indication of whether this is a trap frame or a stepping frame.
1902 The minimal response is just "OK" (which indicates that the
1903 target does not give us a frame number or a tracepoint number).
1904 Instead of that, the target may send us a string containing
1906 F<hexnum> (gives the selected frame number)
1907 T<hexnum> (gives the selected tracepoint number)
1912 trace_find_command (char *args
, int from_tty
)
1913 { /* this should only be called with a numeric argument */
1916 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1917 error ("May not look at trace frames while trace is running.");
1919 if (args
== 0 || *args
== 0)
1920 { /* TFIND with no args means find NEXT trace frame. */
1921 if (traceframe_number
== -1)
1922 frameno
= 0; /* "next" is first one */
1924 frameno
= traceframe_number
+ 1;
1926 else if (0 == strcmp (args
, "-"))
1928 if (traceframe_number
== -1)
1929 error (_("not debugging trace buffer"));
1930 else if (from_tty
&& traceframe_number
== 0)
1931 error (_("already at start of trace buffer"));
1933 frameno
= traceframe_number
- 1;
1935 /* A hack to work around eval's need for fp to have been collected. */
1936 else if (0 == strcmp (args
, "-1"))
1939 frameno
= parse_and_eval_long (args
);
1942 error (_("invalid input (%d is less than zero)"), frameno
);
1944 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
1949 trace_find_end_command (char *args
, int from_tty
)
1951 trace_find_command ("-1", from_tty
);
1956 trace_find_none_command (char *args
, int from_tty
)
1958 trace_find_command ("-1", from_tty
);
1963 trace_find_start_command (char *args
, int from_tty
)
1965 trace_find_command ("0", from_tty
);
1968 /* tfind pc command */
1970 trace_find_pc_command (char *args
, int from_tty
)
1975 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1976 error ("May not look at trace frames while trace is running.");
1978 if (args
== 0 || *args
== 0)
1979 pc
= regcache_read_pc (get_current_regcache ());
1981 pc
= parse_and_eval_address (args
);
1983 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
1986 /* tfind tracepoint command */
1988 trace_find_tracepoint_command (char *args
, int from_tty
)
1991 struct breakpoint
*tp
;
1993 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1994 error ("May not look at trace frames while trace is running.");
1996 if (args
== 0 || *args
== 0)
1998 if (tracepoint_number
== -1)
1999 error (_("No current tracepoint -- please supply an argument."));
2001 tdp
= tracepoint_number
; /* default is current TDP */
2004 tdp
= parse_and_eval_long (args
);
2006 /* If we have the tracepoint on hand, use the number that the
2007 target knows about (which may be different if we disconnected
2008 and reconnected). */
2009 tp
= get_tracepoint (tdp
);
2011 tdp
= tp
->number_on_target
;
2013 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
2016 /* TFIND LINE command:
2018 This command will take a sourceline for argument, just like BREAK
2019 or TRACE (ie. anything that "decode_line_1" can handle).
2021 With no argument, this command will find the next trace frame
2022 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2025 trace_find_line_command (char *args
, int from_tty
)
2027 static CORE_ADDR start_pc
, end_pc
;
2028 struct symtabs_and_lines sals
;
2029 struct symtab_and_line sal
;
2030 struct cleanup
*old_chain
;
2031 char startpc_str
[40], endpc_str
[40];
2033 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2034 error ("May not look at trace frames while trace is running.");
2036 if (args
== 0 || *args
== 0)
2038 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2040 sals
.sals
= (struct symtab_and_line
*)
2041 xmalloc (sizeof (struct symtab_and_line
));
2046 sals
= decode_line_spec (args
, 1);
2050 old_chain
= make_cleanup (xfree
, sals
.sals
);
2051 if (sal
.symtab
== 0)
2053 printf_filtered ("TFIND: No line number information available");
2056 /* This is useful for "info line *0x7f34". If we can't
2057 tell the user about a source line, at least let them
2058 have the symbolic address. */
2059 printf_filtered (" for address ");
2061 print_address (get_current_arch (), sal
.pc
, gdb_stdout
);
2062 printf_filtered (";\n -- will attempt to find by PC. \n");
2066 printf_filtered (".\n");
2067 return; /* No line, no PC; what can we do? */
2070 else if (sal
.line
> 0
2071 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2073 if (start_pc
== end_pc
)
2075 printf_filtered ("Line %d of \"%s\"",
2076 sal
.line
, sal
.symtab
->filename
);
2078 printf_filtered (" is at address ");
2079 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2081 printf_filtered (" but contains no code.\n");
2082 sal
= find_pc_line (start_pc
, 0);
2084 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2085 && start_pc
!= end_pc
)
2086 printf_filtered ("Attempting to find line %d instead.\n",
2089 error (_("Cannot find a good line."));
2093 /* Is there any case in which we get here, and have an address
2094 which the user would want to see? If we have debugging
2095 symbols and no line numbers? */
2096 error (_("Line number %d is out of range for \"%s\"."),
2097 sal
.line
, sal
.symtab
->filename
);
2099 /* Find within range of stated line. */
2101 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2103 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2104 do_cleanups (old_chain
);
2107 /* tfind range command */
2109 trace_find_range_command (char *args
, int from_tty
)
2111 static CORE_ADDR start
, stop
;
2112 char start_str
[40], stop_str
[40];
2115 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2116 error ("May not look at trace frames while trace is running.");
2118 if (args
== 0 || *args
== 0)
2119 { /* XXX FIXME: what should default behavior be? */
2120 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2124 if (0 != (tmp
= strchr (args
, ',')))
2126 *tmp
++ = '\0'; /* terminate start address */
2127 while (isspace ((int) *tmp
))
2129 start
= parse_and_eval_address (args
);
2130 stop
= parse_and_eval_address (tmp
);
2133 { /* no explicit end address? */
2134 start
= parse_and_eval_address (args
);
2135 stop
= start
+ 1; /* ??? */
2138 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2141 /* tfind outside command */
2143 trace_find_outside_command (char *args
, int from_tty
)
2145 CORE_ADDR start
, stop
;
2146 char start_str
[40], stop_str
[40];
2149 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2150 error ("May not look at trace frames while trace is running.");
2152 if (args
== 0 || *args
== 0)
2153 { /* XXX FIXME: what should default behavior be? */
2154 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2158 if (0 != (tmp
= strchr (args
, ',')))
2160 *tmp
++ = '\0'; /* terminate start address */
2161 while (isspace ((int) *tmp
))
2163 start
= parse_and_eval_address (args
);
2164 stop
= parse_and_eval_address (tmp
);
2167 { /* no explicit end address? */
2168 start
= parse_and_eval_address (args
);
2169 stop
= start
+ 1; /* ??? */
2172 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2175 /* info scope command: list the locals for a scope. */
2177 scope_info (char *args
, int from_tty
)
2179 struct symtabs_and_lines sals
;
2181 struct minimal_symbol
*msym
;
2182 struct block
*block
;
2183 char **canonical
, *symname
, *save_args
= args
;
2184 struct dict_iterator iter
;
2186 struct gdbarch
*gdbarch
;
2189 if (args
== 0 || *args
== 0)
2190 error (_("requires an argument (function, line or *addr) to define a scope"));
2192 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2193 if (sals
.nelts
== 0)
2194 return; /* presumably decode_line_1 has already warned */
2196 /* Resolve line numbers to PC */
2197 resolve_sal_pc (&sals
.sals
[0]);
2198 block
= block_for_pc (sals
.sals
[0].pc
);
2202 QUIT
; /* allow user to bail out with ^C */
2203 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2205 QUIT
; /* allow user to bail out with ^C */
2207 printf_filtered ("Scope for %s:\n", save_args
);
2210 symname
= SYMBOL_PRINT_NAME (sym
);
2211 if (symname
== NULL
|| *symname
== '\0')
2212 continue; /* probably botched, certainly useless */
2214 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2216 printf_filtered ("Symbol %s is ", symname
);
2217 switch (SYMBOL_CLASS (sym
))
2220 case LOC_UNDEF
: /* messed up symbol? */
2221 printf_filtered ("a bogus symbol, class %d.\n",
2222 SYMBOL_CLASS (sym
));
2223 count
--; /* don't count this one */
2226 printf_filtered ("a constant with value %ld (0x%lx)",
2227 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2229 case LOC_CONST_BYTES
:
2230 printf_filtered ("constant bytes: ");
2231 if (SYMBOL_TYPE (sym
))
2232 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2233 fprintf_filtered (gdb_stdout
, " %02x",
2234 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2237 printf_filtered ("in static storage at address ");
2238 printf_filtered ("%s", paddress (gdbarch
,
2239 SYMBOL_VALUE_ADDRESS (sym
)));
2242 /* GDBARCH is the architecture associated with the objfile
2243 the symbol is defined in; the target architecture may be
2244 different, and may provide additional registers. However,
2245 we do not know the target architecture at this point.
2246 We assume the objfile architecture will contain all the
2247 standard registers that occur in debug info in that
2249 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2251 if (SYMBOL_IS_ARGUMENT (sym
))
2252 printf_filtered ("an argument in register $%s",
2253 gdbarch_register_name (gdbarch
, regno
));
2255 printf_filtered ("a local variable in register $%s",
2256 gdbarch_register_name (gdbarch
, regno
));
2259 printf_filtered ("an argument at stack/frame offset %ld",
2260 SYMBOL_VALUE (sym
));
2263 printf_filtered ("a local variable at frame offset %ld",
2264 SYMBOL_VALUE (sym
));
2267 printf_filtered ("a reference argument at offset %ld",
2268 SYMBOL_VALUE (sym
));
2270 case LOC_REGPARM_ADDR
:
2271 /* Note comment at LOC_REGISTER. */
2272 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2273 printf_filtered ("the address of an argument, in register $%s",
2274 gdbarch_register_name (gdbarch
, regno
));
2277 printf_filtered ("a typedef.\n");
2280 printf_filtered ("a label at address ");
2281 printf_filtered ("%s", paddress (gdbarch
,
2282 SYMBOL_VALUE_ADDRESS (sym
)));
2285 printf_filtered ("a function at address ");
2286 printf_filtered ("%s",
2287 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2289 case LOC_UNRESOLVED
:
2290 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2293 printf_filtered ("Unresolved Static");
2296 printf_filtered ("static storage at address ");
2297 printf_filtered ("%s",
2298 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2301 case LOC_OPTIMIZED_OUT
:
2302 printf_filtered ("optimized out.\n");
2305 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, gdb_stdout
);
2308 if (SYMBOL_TYPE (sym
))
2309 printf_filtered (", length %d.\n",
2310 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2312 if (BLOCK_FUNCTION (block
))
2315 block
= BLOCK_SUPERBLOCK (block
);
2318 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2322 /* worker function (cleanup) */
2324 replace_comma (void *data
)
2332 trace_dump_command (char *args
, int from_tty
)
2334 struct regcache
*regcache
;
2335 struct gdbarch
*gdbarch
;
2336 struct breakpoint
*t
;
2337 struct command_line
*action
;
2338 char *action_exp
, *next_comma
;
2339 struct cleanup
*old_cleanups
;
2340 int stepping_actions
= 0;
2341 int stepping_frame
= 0;
2342 struct bp_location
*loc
;
2344 if (tracepoint_number
== -1)
2346 warning (_("No current trace frame."));
2350 t
= get_tracepoint (tracepoint_number
);
2353 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2356 old_cleanups
= make_cleanup (null_cleanup
, NULL
);
2358 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2359 tracepoint_number
, traceframe_number
);
2361 /* The current frame is a trap frame if the frame PC is equal
2362 to the tracepoint PC. If not, then the current frame was
2363 collected during single-stepping. */
2365 regcache
= get_current_regcache ();
2366 gdbarch
= get_regcache_arch (regcache
);
2368 /* If the traceframe's address matches any of the tracepoint's
2369 locations, assume it is a direct hit rather than a while-stepping
2370 frame. (FIXME this is not reliable, should record each frame's
2373 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2374 if (loc
->address
== regcache_read_pc (regcache
))
2377 for (action
= t
->commands
->commands
; action
; action
= action
->next
)
2379 struct cmd_list_element
*cmd
;
2381 QUIT
; /* allow user to bail out with ^C */
2382 action_exp
= action
->line
;
2383 while (isspace ((int) *action_exp
))
2386 /* The collection actions to be done while stepping are
2387 bracketed by the commands "while-stepping" and "end". */
2389 if (*action_exp
== '#') /* comment line */
2392 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2394 error (_("Bad action list item: %s"), action_exp
);
2396 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2397 stepping_actions
= 1;
2398 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2399 stepping_actions
= 0;
2400 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2402 /* Display the collected data.
2403 For the trap frame, display only what was collected at
2404 the trap. Likewise for stepping frames, display only
2405 what was collected while stepping. This means that the
2406 two boolean variables, STEPPING_FRAME and
2407 STEPPING_ACTIONS should be equal. */
2408 if (stepping_frame
== stepping_actions
)
2411 { /* repeat over a comma-separated list */
2412 QUIT
; /* allow user to bail out with ^C */
2413 if (*action_exp
== ',')
2415 while (isspace ((int) *action_exp
))
2418 next_comma
= strchr (action_exp
, ',');
2420 if (0 == strncasecmp (action_exp
, "$reg", 4))
2421 registers_info (NULL
, from_tty
);
2422 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2423 locals_info (NULL
, from_tty
);
2424 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2425 args_info (NULL
, from_tty
);
2430 make_cleanup (replace_comma
, next_comma
);
2433 printf_filtered ("%s = ", action_exp
);
2434 output_command (action_exp
, from_tty
);
2435 printf_filtered ("\n");
2439 action_exp
= next_comma
;
2441 while (action_exp
&& *action_exp
== ',');
2445 discard_cleanups (old_cleanups
);
2448 extern int trace_regblock_size
;
2450 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2451 non-zero, the save is performed on the target, otherwise GDB obtains all
2452 trace data and saves it locally. */
2455 trace_save (const char *filename
, int target_does_save
)
2457 struct cleanup
*cleanup
;
2459 struct trace_status
*ts
= current_trace_status ();
2462 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2463 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2466 ULONGEST offset
= 0;
2467 #define MAX_TRACE_UPLOAD 2000
2468 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2471 /* If the target is to save the data to a file on its own, then just
2472 send the command and be done with it. */
2473 if (target_does_save
)
2475 err
= target_save_trace_data (filename
);
2477 error (_("Target failed to save trace data to '%s'."),
2482 /* Get the trace status first before opening the file, so if the
2483 target is losing, we can get out without touching files. */
2484 status
= target_get_trace_status (ts
);
2486 pathname
= tilde_expand (filename
);
2487 cleanup
= make_cleanup (xfree
, pathname
);
2489 fp
= fopen (pathname
, "w");
2491 error (_("Unable to open file '%s' for saving trace data (%s)"),
2492 filename
, safe_strerror (errno
));
2493 make_cleanup_fclose (fp
);
2495 /* Write a file header, with a high-bit-set char to indicate a
2496 binary file, plus a hint as what this file is, and a version
2497 number in case of future needs. */
2498 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2500 perror_with_name (pathname
);
2502 /* Write descriptive info. */
2504 /* Write out the size of a register block. */
2505 fprintf (fp
, "R %x\n", trace_regblock_size
);
2507 /* Write out status of the tracing run (aka "tstatus" info). */
2508 fprintf (fp
, "status %c;%s",
2509 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
2510 if (ts
->stop_reason
== tracepoint_error
)
2512 char *buf
= (char *) alloca (strlen (ts
->error_desc
) * 2 + 1);
2513 bin2hex ((gdb_byte
*) ts
->error_desc
, buf
, 0);
2514 fprintf (fp
, ":%s", buf
);
2516 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
2517 if (ts
->traceframe_count
>= 0)
2518 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
2519 if (ts
->traceframes_created
>= 0)
2520 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
2521 if (ts
->buffer_free
>= 0)
2522 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
2523 if (ts
->buffer_size
>= 0)
2524 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
2527 /* Note that we want to upload tracepoints and save those, rather
2528 than simply writing out the local ones, because the user may have
2529 changed tracepoints in GDB in preparation for a future tracing
2530 run, or maybe just mass-deleted all types of breakpoints as part
2531 of cleaning up. So as not to contaminate the session, leave the
2532 data in its uploaded form, don't make into real tracepoints. */
2534 /* Get trace state variables first, they may be checked when parsing
2535 uploaded commands. */
2537 target_upload_trace_state_variables (&uploaded_tsvs
);
2539 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2545 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
2546 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
2549 fprintf (fp
, "tsv %x:%s:%x:%s\n",
2550 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
2551 utsv
->builtin
, buf
);
2557 free_uploaded_tsvs (&uploaded_tsvs
);
2559 target_upload_tracepoints (&uploaded_tps
);
2561 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
2563 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
2564 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2565 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
2566 if (utp
->type
== bp_fast_tracepoint
)
2567 fprintf (fp
, ":F%x", utp
->orig_size
);
2569 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
2572 for (a
= 0; a
< utp
->numactions
; ++a
)
2573 fprintf (fp
, "tp A%x:%s:%s\n",
2574 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2576 for (a
= 0; a
< utp
->num_step_actions
; ++a
)
2577 fprintf (fp
, "tp S%x:%s:%s\n",
2578 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2579 utp
->step_actions
[a
]);
2582 free_uploaded_tps (&uploaded_tps
);
2584 /* Mark the end of the definition section. */
2587 /* Get and write the trace data proper. We ask for big blocks, in
2588 the hopes of efficiency, but will take less if the target has
2589 packet size limitations or some such. */
2592 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
2594 error (_("Failure to get requested trace buffer data"));
2595 /* No more data is forthcoming, we're done. */
2598 written
= fwrite (buf
, gotten
, 1, fp
);
2599 if (written
< gotten
)
2600 perror_with_name (pathname
);
2604 /* Mark the end of trace data. */
2605 written
= fwrite (&gotten
, 4, 1, fp
);
2607 perror_with_name (pathname
);
2609 do_cleanups (cleanup
);
2613 trace_save_command (char *args
, int from_tty
)
2615 int target_does_save
= 0;
2617 char *filename
= NULL
;
2618 struct cleanup
*back_to
;
2621 error_no_arg (_("file in which to save trace data"));
2623 argv
= gdb_buildargv (args
);
2624 back_to
= make_cleanup_freeargv (argv
);
2626 for (; *argv
; ++argv
)
2628 if (strcmp (*argv
, "-r") == 0)
2629 target_does_save
= 1;
2630 else if (**argv
== '-')
2631 error (_("unknown option `%s'"), *argv
);
2637 error_no_arg (_("file in which to save trace data"));
2639 trace_save (filename
, target_does_save
);
2642 printf_filtered (_("Trace data saved to file '%s'.\n"), args
);
2644 do_cleanups (back_to
);
2647 /* Tell the target what to do with an ongoing tracing run if GDB
2648 disconnects for some reason. */
2651 send_disconnected_tracing_value (int value
)
2653 target_set_disconnected_tracing (value
);
2657 set_disconnected_tracing (char *args
, int from_tty
,
2658 struct cmd_list_element
*c
)
2660 send_disconnected_tracing_value (disconnected_tracing
);
2664 set_circular_trace_buffer (char *args
, int from_tty
,
2665 struct cmd_list_element
*c
)
2667 target_set_circular_trace_buffer (circular_trace_buffer
);
2670 /* Convert the memory pointed to by mem into hex, placing result in buf.
2671 * Return a pointer to the last char put in buf (null)
2672 * "stolen" from sparc-stub.c
2675 static const char hexchars
[] = "0123456789abcdef";
2678 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2686 *buf
++ = hexchars
[ch
>> 4];
2687 *buf
++ = hexchars
[ch
& 0xf];
2696 get_traceframe_number (void)
2698 return traceframe_number
;
2701 /* Make the traceframe NUM be the current trace frame. Does nothing
2702 if NUM is already current. */
2705 set_traceframe_number (int num
)
2709 if (traceframe_number
== num
)
2711 /* Nothing to do. */
2715 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
2718 warning (_("could not change traceframe"));
2720 traceframe_number
= newnum
;
2722 /* Changing the traceframe changes our view of registers and of the
2724 registers_changed ();
2727 /* A cleanup used when switching away and back from tfind mode. */
2729 struct current_traceframe_cleanup
2731 /* The traceframe we were inspecting. */
2732 int traceframe_number
;
2736 do_restore_current_traceframe_cleanup (void *arg
)
2738 struct current_traceframe_cleanup
*old
= arg
;
2740 set_traceframe_number (old
->traceframe_number
);
2744 restore_current_traceframe_cleanup_dtor (void *arg
)
2746 struct current_traceframe_cleanup
*old
= arg
;
2752 make_cleanup_restore_current_traceframe (void)
2754 struct current_traceframe_cleanup
*old
;
2756 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
2757 old
->traceframe_number
= traceframe_number
;
2759 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
2760 restore_current_traceframe_cleanup_dtor
);
2763 /* Given a number and address, return an uploaded tracepoint with that
2764 number, creating if necessary. */
2766 struct uploaded_tp
*
2767 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
2769 struct uploaded_tp
*utp
;
2771 for (utp
= *utpp
; utp
; utp
= utp
->next
)
2772 if (utp
->number
== num
&& utp
->addr
== addr
)
2774 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
2775 memset (utp
, 0, sizeof (struct uploaded_tp
));
2784 free_uploaded_tps (struct uploaded_tp
**utpp
)
2786 struct uploaded_tp
*next_one
;
2790 next_one
= (*utpp
)->next
;
2796 /* Given a number and address, return an uploaded tracepoint with that
2797 number, creating if necessary. */
2799 struct uploaded_tsv
*
2800 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
2802 struct uploaded_tsv
*utsv
;
2804 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
2805 if (utsv
->number
== num
)
2807 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
2808 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
2810 utsv
->next
= *utsvp
;
2816 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
2818 struct uploaded_tsv
*next_one
;
2822 next_one
= (*utsvp
)->next
;
2828 /* Look for an existing tracepoint that seems similar enough to the
2829 uploaded one. Enablement isn't compared, because the user can
2830 toggle that freely, and may have done so in anticipation of the
2834 find_matching_tracepoint (struct uploaded_tp
*utp
)
2836 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
2838 struct breakpoint
*t
;
2839 struct bp_location
*loc
;
2841 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2843 if (t
->type
== utp
->type
2844 && t
->step_count
== utp
->step
2845 && t
->pass_count
== utp
->pass
2846 /* FIXME also test conditionals and actions */
2849 /* Scan the locations for an address match. */
2850 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2852 if (loc
->address
== utp
->addr
)
2860 /* Given a list of tracepoints uploaded from a target, attempt to
2861 match them up with existing tracepoints, and create new ones if not
2865 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
2867 struct uploaded_tp
*utp
;
2868 struct breakpoint
*t
;
2870 /* Look for GDB tracepoints that match up with our uploaded versions. */
2871 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
2873 t
= find_matching_tracepoint (utp
);
2875 printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
2876 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2879 t
= create_tracepoint_from_upload (utp
);
2881 printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
2882 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2884 printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
2885 utp
->number
, paddress (get_current_arch (), utp
->addr
));
2887 /* Whether found or created, record the number used by the
2888 target, to help with mapping target tracepoints back to their
2889 counterparts here. */
2891 t
->number_on_target
= utp
->number
;
2894 free_uploaded_tps (uploaded_tps
);
2897 /* Trace state variables don't have much to identify them beyond their
2898 name, so just use that to detect matches. */
2900 struct trace_state_variable
*
2901 find_matching_tsv (struct uploaded_tsv
*utsv
)
2906 return find_trace_state_variable (utsv
->name
);
2909 struct trace_state_variable
*
2910 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
2912 const char *namebase
;
2915 struct trace_state_variable
*tsv
;
2919 namebase
= utsv
->name
;
2920 sprintf (buf
, "%s", namebase
);
2925 sprintf (buf
, "%s_%d", namebase
, try_num
++);
2928 /* Fish for a name that is not in use. */
2929 /* (should check against all internal vars?) */
2930 while (find_trace_state_variable (buf
))
2931 sprintf (buf
, "%s_%d", namebase
, try_num
++);
2933 /* We have an available name, create the variable. */
2934 tsv
= create_trace_state_variable (xstrdup (buf
));
2935 tsv
->initial_value
= utsv
->initial_value
;
2936 tsv
->builtin
= utsv
->builtin
;
2941 /* Given a list of uploaded trace state variables, try to match them
2942 up with existing variables, or create additional ones. */
2945 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
2948 struct uploaded_tsv
*utsv
;
2949 struct trace_state_variable
*tsv
;
2952 /* Most likely some numbers will have to be reassigned as part of
2953 the merge, so clear them all in anticipation. */
2954 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2957 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2959 tsv
= find_matching_tsv (utsv
);
2961 printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
2962 tsv
->name
, utsv
->number
);
2965 tsv
= create_tsv_from_upload (utsv
);
2966 printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
2967 tsv
->name
, utsv
->number
);
2969 /* Give precedence to numberings that come from the target. */
2971 tsv
->number
= utsv
->number
;
2974 /* Renumber everything that didn't get a target-assigned number. */
2976 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2977 if (tsv
->number
> highest
)
2978 highest
= tsv
->number
;
2981 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2982 if (tsv
->number
== 0)
2983 tsv
->number
= highest
++;
2985 free_uploaded_tsvs (uploaded_tsvs
);
2988 /* target tfile command */
2990 struct target_ops tfile_ops
;
2992 /* Fill in tfile_ops with its defined operations and properties. */
2994 #define TRACE_HEADER_SIZE 8
2996 char *trace_filename
;
2998 off_t trace_frames_offset
;
3001 int trace_regblock_size
;
3003 static void tfile_interp_line (char *line
,
3004 struct uploaded_tp
**utpp
,
3005 struct uploaded_tsv
**utsvp
);
3008 tfile_open (char *filename
, int from_tty
)
3011 struct cleanup
*old_chain
;
3014 char header
[TRACE_HEADER_SIZE
];
3015 char linebuf
[1000]; /* should be max remote packet size or so */
3017 int bytes
, i
, gotten
;
3018 struct trace_status
*ts
;
3019 struct uploaded_tp
*uploaded_tps
= NULL
;
3020 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3022 target_preopen (from_tty
);
3024 error (_("No trace file specified."));
3026 filename
= tilde_expand (filename
);
3027 if (!IS_ABSOLUTE_PATH(filename
))
3029 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
3034 old_chain
= make_cleanup (xfree
, filename
);
3036 flags
= O_BINARY
| O_LARGEFILE
;
3038 scratch_chan
= open (filename
, flags
, 0);
3039 if (scratch_chan
< 0)
3040 perror_with_name (filename
);
3042 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3044 discard_cleanups (old_chain
); /* Don't free filename any more */
3045 unpush_target (&tfile_ops
);
3047 push_target (&tfile_ops
);
3049 trace_filename
= xstrdup (filename
);
3050 trace_fd
= scratch_chan
;
3053 /* Read the file header and test for validity. */
3054 gotten
= read (trace_fd
, &header
, TRACE_HEADER_SIZE
);
3056 perror_with_name (trace_filename
);
3057 else if (gotten
< TRACE_HEADER_SIZE
)
3058 error (_("Premature end of file while reading trace file"));
3060 bytes
+= TRACE_HEADER_SIZE
;
3061 if (!(header
[0] == 0x7f
3062 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3063 error (_("File is not a valid trace file."));
3065 trace_regblock_size
= 0;
3066 ts
= current_trace_status ();
3067 /* We know we're working with a file. */
3069 /* Set defaults in case there is no status line. */
3070 ts
->running_known
= 0;
3071 ts
->stop_reason
= trace_stop_reason_unknown
;
3072 ts
->traceframe_count
= -1;
3073 ts
->buffer_free
= 0;
3075 /* Read through a section of newline-terminated lines that
3076 define things like tracepoints. */
3080 gotten
= read (trace_fd
, &byte
, 1);
3082 perror_with_name (trace_filename
);
3083 else if (gotten
< 1)
3084 error (_("Premature end of file while reading trace file"));
3089 /* Empty line marks end of the definition section. */
3094 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3097 linebuf
[i
++] = byte
;
3099 error (_("Excessively long lines in trace file"));
3102 /* Add the file's tracepoints and variables into the current mix. */
3104 /* Get trace state variables first, they may be checked when parsing
3105 uploaded commands. */
3106 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3108 merge_uploaded_tracepoints (&uploaded_tps
);
3110 /* Record the starting offset of the binary trace data. */
3111 trace_frames_offset
= bytes
;
3113 /* If we don't have a blocksize, we can't interpret the
3115 if (trace_regblock_size
== 0)
3116 error (_("No register block size recorded in trace file"));
3117 if (ts
->traceframe_count
<= 0)
3119 warning ("No traceframes present in this file.");
3123 #define TFILE_PID (1)
3124 inferior_appeared (current_inferior (), TFILE_PID
);
3125 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3126 add_thread_silent (inferior_ptid
);
3128 post_create_inferior (&tfile_ops
, from_tty
);
3131 /* FIXME this will get defined in MI patch submission */
3132 tfind_1 (tfind_number
, 0, 0, 0, 0);
3136 /* Interpret the given line from the definitions part of the trace
3140 tfile_interp_line (char *line
,
3141 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3145 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3148 trace_regblock_size
= strtol (p
, &p
, 16);
3150 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3152 p
+= strlen ("status ");
3153 parse_trace_status (p
, current_trace_status ());
3155 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3157 p
+= strlen ("tp ");
3158 parse_tracepoint_definition (p
, utpp
);
3160 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3162 p
+= strlen ("tsv ");
3163 parse_tsv_definition (p
, utsvp
);
3166 warning ("Ignoring trace file definition \"%s\"", line
);
3169 /* Parse the part of trace status syntax that is shared between
3170 the remote protocol and the trace file reader. */
3172 extern char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
3175 parse_trace_status (char *line
, struct trace_status
*ts
)
3177 char *p
= line
, *p1
, *p2
, *p_temp
;
3180 ts
->running_known
= 1;
3181 ts
->running
= (*p
++ == '1');
3182 ts
->stop_reason
= trace_stop_reason_unknown
;
3183 xfree (ts
->error_desc
);
3184 ts
->error_desc
= NULL
;
3185 ts
->traceframe_count
= -1;
3186 ts
->traceframes_created
= -1;
3187 ts
->buffer_free
= -1;
3188 ts
->buffer_size
= -1;
3192 p1
= strchr (p
, ':');
3194 error (_("Malformed trace status, at %s\n\
3195 Status line: '%s'\n"), p
, line
);
3196 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3198 p
= unpack_varlen_hex (++p1
, &val
);
3199 ts
->stop_reason
= trace_buffer_full
;
3201 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3203 p
= unpack_varlen_hex (++p1
, &val
);
3204 ts
->stop_reason
= trace_never_run
;
3206 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
], p1
- p
) == 0)
3208 p
= unpack_varlen_hex (++p1
, &val
);
3209 ts
->stop_reason
= tracepoint_passcount
;
3210 ts
->stopping_tracepoint
= val
;
3212 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3214 p
= unpack_varlen_hex (++p1
, &val
);
3215 ts
->stop_reason
= tstop_command
;
3217 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3219 p2
= strchr (++p1
, ':');
3224 ts
->error_desc
= xmalloc ((p2
- p1
) / 2 + 1);
3225 end
= hex2bin (p1
, ts
->error_desc
, (p2
- p1
) / 2);
3226 ts
->error_desc
[end
] = '\0';
3229 ts
->error_desc
= xstrdup ("");
3231 p
= unpack_varlen_hex (++p2
, &val
);
3232 ts
->stopping_tracepoint
= val
;
3233 ts
->stop_reason
= tracepoint_error
;
3235 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3237 p
= unpack_varlen_hex (++p1
, &val
);
3238 ts
->traceframe_count
= val
;
3240 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3242 p
= unpack_varlen_hex (++p1
, &val
);
3243 ts
->traceframes_created
= val
;
3245 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3247 p
= unpack_varlen_hex (++p1
, &val
);
3248 ts
->buffer_free
= val
;
3250 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3252 p
= unpack_varlen_hex (++p1
, &val
);
3253 ts
->buffer_size
= val
;
3257 /* Silently skip unknown optional info. */
3258 p_temp
= strchr (p1
+ 1, ';');
3262 /* Must be at the end. */
3268 /* Given a line of text defining a tracepoint or tracepoint action, parse
3269 it into an "uploaded tracepoint". */
3272 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3276 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
;
3280 struct uploaded_tp
*utp
= NULL
;
3283 /* Both tracepoint and action definitions start with the same number
3284 and address sequence. */
3286 p
= unpack_varlen_hex (p
, &num
);
3287 p
++; /* skip a colon */
3288 p
= unpack_varlen_hex (p
, &addr
);
3289 p
++; /* skip a colon */
3292 enabled
= (*p
++ == 'E');
3293 p
++; /* skip a colon */
3294 p
= unpack_varlen_hex (p
, &step
);
3295 p
++; /* skip a colon */
3296 p
= unpack_varlen_hex (p
, &pass
);
3297 type
= bp_tracepoint
;
3299 /* Thumb through optional fields. */
3302 p
++; /* skip a colon */
3305 type
= bp_fast_tracepoint
;
3307 p
= unpack_varlen_hex (p
, &orig_size
);
3312 p
= unpack_varlen_hex (p
, &xlen
);
3313 p
++; /* skip a comma */
3314 cond
= (char *) xmalloc (2 * xlen
+ 1);
3315 strncpy (cond
, p
, 2 * xlen
);
3316 cond
[2 * xlen
] = '\0';
3320 warning ("Unrecognized char '%c' in tracepoint definition, skipping rest", *p
);
3322 utp
= get_uploaded_tp (num
, addr
, utpp
);
3324 utp
->enabled
= enabled
;
3329 else if (piece
== 'A')
3331 utp
= get_uploaded_tp (num
, addr
, utpp
);
3332 utp
->actions
[utp
->numactions
++] = xstrdup (p
);
3334 else if (piece
== 'S')
3336 utp
= get_uploaded_tp (num
, addr
, utpp
);
3337 utp
->step_actions
[utp
->num_step_actions
++] = xstrdup (p
);
3341 error ("Invalid tracepoint piece");
3345 /* Convert a textual description of a trace state variable into an
3349 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3352 ULONGEST num
, initval
, builtin
;
3354 struct uploaded_tsv
*utsv
= NULL
;
3356 buf
= alloca (strlen (line
));
3359 p
= unpack_varlen_hex (p
, &num
);
3360 p
++; /* skip a colon */
3361 p
= unpack_varlen_hex (p
, &initval
);
3362 p
++; /* skip a colon */
3363 p
= unpack_varlen_hex (p
, &builtin
);
3364 p
++; /* skip a colon */
3365 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3368 utsv
= get_uploaded_tsv (num
, utsvp
);
3369 utsv
->initial_value
= initval
;
3370 utsv
->builtin
= builtin
;
3371 utsv
->name
= xstrdup (buf
);
3374 /* Close the trace file and generally clean up. */
3377 tfile_close (int quitting
)
3384 pid
= ptid_get_pid (inferior_ptid
);
3385 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
3386 exit_inferior_silent (pid
);
3391 xfree (trace_filename
);
3395 tfile_files_info (struct target_ops
*t
)
3397 /* (it would be useful to mention the name of the file) */
3398 printf_filtered ("Looking at a trace file.\n");
3401 /* The trace status for a file is that tracing can never be run. */
3404 tfile_get_trace_status (struct trace_status
*ts
)
3406 /* Other bits of trace status were collected as part of opening the
3407 trace files, so nothing to do here. */
3412 /* Given the position of a traceframe in the file, figure out what
3413 address the frame was collected at. This would normally be the
3414 value of a collected PC register, but if not available, we
3418 tfile_get_traceframe_address (off_t tframe_offset
)
3422 struct breakpoint
*tp
;
3423 off_t saved_offset
= cur_offset
;
3426 /* FIXME dig pc out of collected registers */
3428 /* Fall back to using tracepoint address. */
3429 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
3430 gotten
= read (trace_fd
, &tpnum
, 2);
3432 perror_with_name (trace_filename
);
3433 else if (gotten
< 2)
3434 error (_("Premature end of file while reading trace file"));
3436 tp
= get_tracepoint_by_number_on_target (tpnum
);
3437 /* FIXME this is a poor heuristic if multiple locations */
3439 addr
= tp
->loc
->address
;
3441 /* Restore our seek position. */
3442 cur_offset
= saved_offset
;
3443 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3447 /* Given a type of search and some parameters, scan the collection of
3448 traceframes in the file looking for a match. When found, return
3449 both the traceframe and tracepoint number, otherwise -1 for
3453 tfile_trace_find (enum trace_find_type type
, int num
,
3454 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
3457 int tfnum
= 0, found
= 0, gotten
;
3459 struct breakpoint
*tp
;
3460 off_t offset
, tframe_offset
;
3463 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
3464 offset
= trace_frames_offset
;
3467 tframe_offset
= offset
;
3468 gotten
= read (trace_fd
, &tpnum
, 2);
3470 perror_with_name (trace_filename
);
3471 else if (gotten
< 2)
3472 error (_("Premature end of file while reading trace file"));
3476 gotten
= read (trace_fd
, &data_size
, 4);
3478 perror_with_name (trace_filename
);
3479 else if (gotten
< 4)
3480 error (_("Premature end of file while reading trace file"));
3489 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3490 if (tfaddr
== addr1
)
3494 tp
= get_tracepoint (num
);
3495 if (tp
&& tpnum
== tp
->number_on_target
)
3499 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3500 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
3504 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3505 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
3509 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
3515 cur_offset
= offset
;
3516 cur_data_size
= data_size
;
3519 /* Skip past the traceframe's data. */
3520 lseek (trace_fd
, data_size
, SEEK_CUR
);
3521 offset
+= data_size
;
3522 /* Update our own count of traceframes. */
3525 /* Did not find what we were looking for. */
3531 /* Look for a block of saved registers in the traceframe, and get the
3532 requested register from it. */
3535 tfile_fetch_registers (struct target_ops
*ops
,
3536 struct regcache
*regcache
, int regno
)
3538 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3540 int i
, pos
, offset
, regn
, regsize
, gotten
;
3541 unsigned short mlen
;
3544 /* An uninitialized reg size says we're not going to be
3545 successful at getting register blocks. */
3546 if (!trace_regblock_size
)
3549 regs
= alloca (trace_regblock_size
);
3551 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3553 while (pos
< cur_data_size
)
3555 gotten
= read (trace_fd
, &block_type
, 1);
3557 perror_with_name (trace_filename
);
3558 else if (gotten
< 1)
3559 error (_("Premature end of file while reading trace file"));
3565 gotten
= read (trace_fd
, regs
, trace_regblock_size
);
3567 perror_with_name (trace_filename
);
3568 else if (gotten
< trace_regblock_size
)
3569 error (_("Premature end of file while reading trace file"));
3571 /* Assume the block is laid out in GDB register number order,
3572 each register with the size that it has in GDB. */
3574 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3576 regsize
= register_size (gdbarch
, regn
);
3577 /* Make sure we stay within block bounds. */
3578 if (offset
+ regsize
>= trace_regblock_size
)
3580 if (!regcache_valid_p (regcache
, regn
))
3584 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
3587 else if (regno
== -1)
3589 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
3596 lseek (trace_fd
, 8, SEEK_CUR
);
3597 gotten
= read (trace_fd
, &mlen
, 2);
3599 perror_with_name (trace_filename
);
3600 else if (gotten
< 2)
3601 error (_("Premature end of file while reading trace file"));
3602 lseek (trace_fd
, mlen
, SEEK_CUR
);
3603 pos
+= (8 + 2 + mlen
);
3606 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3610 error ("Unknown block type '%c' (0x%x) in trace frame",
3611 block_type
, block_type
);
3618 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3619 const char *annex
, gdb_byte
*readbuf
,
3620 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3625 unsigned short mlen
;
3627 /* We're only doing regular memory for now. */
3628 if (object
!= TARGET_OBJECT_MEMORY
)
3631 if (readbuf
== NULL
)
3632 error ("tfile_xfer_partial: trace file is read-only");
3634 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3636 while (pos
< cur_data_size
)
3638 gotten
= read (trace_fd
, &block_type
, 1);
3640 perror_with_name (trace_filename
);
3641 else if (gotten
< 1)
3642 error (_("Premature end of file while reading trace file"));
3647 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3648 pos
+= trace_regblock_size
;
3651 gotten
= read (trace_fd
, &maddr
, 8);
3653 perror_with_name (trace_filename
);
3654 else if (gotten
< 8)
3655 error (_("Premature end of file while reading trace file"));
3657 gotten
= read (trace_fd
, &mlen
, 2);
3659 perror_with_name (trace_filename
);
3660 else if (gotten
< 2)
3661 error (_("Premature end of file while reading trace file"));
3662 if (maddr
<= offset
&& (offset
+ len
) <= (maddr
+ mlen
))
3664 gotten
= read (trace_fd
, readbuf
, mlen
);
3666 perror_with_name (trace_filename
);
3667 else if (gotten
< mlen
)
3668 error (_("Premature end of file qwhile reading trace file"));
3672 lseek (trace_fd
, mlen
, SEEK_CUR
);
3673 pos
+= (8 + 2 + mlen
);
3676 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3680 error ("Unknown block type '%c' (0x%x) in traceframe",
3681 block_type
, block_type
);
3685 /* Indicate failure to find the requested memory block. */
3689 /* Iterate through the blocks of a trace frame, looking for a 'V'
3690 block with a matching tsv number. */
3693 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
3696 int pos
, vnum
, gotten
;
3697 unsigned short mlen
;
3699 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3701 while (pos
< cur_data_size
)
3703 gotten
= read (trace_fd
, &block_type
, 1);
3705 perror_with_name (trace_filename
);
3706 else if (gotten
< 1)
3707 error (_("Premature end of file while reading trace file"));
3712 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3713 pos
+= trace_regblock_size
;
3716 lseek (trace_fd
, 8, SEEK_CUR
);
3717 gotten
= read (trace_fd
, &mlen
, 2);
3719 perror_with_name (trace_filename
);
3720 else if (gotten
< 2)
3721 error (_("Premature end of file while reading trace file"));
3722 lseek (trace_fd
, mlen
, SEEK_CUR
);
3723 pos
+= (8 + 2 + mlen
);
3726 gotten
= read (trace_fd
, &vnum
, 4);
3728 perror_with_name (trace_filename
);
3729 else if (gotten
< 4)
3730 error (_("Premature end of file while reading trace file"));
3733 gotten
= read (trace_fd
, val
, 8);
3735 perror_with_name (trace_filename
);
3736 else if (gotten
< 8)
3737 error (_("Premature end of file while reading trace file"));
3740 lseek (trace_fd
, 8, SEEK_CUR
);
3744 error ("Unknown block type '%c' (0x%x) in traceframe",
3745 block_type
, block_type
);
3749 /* Didn't find anything. */
3754 tfile_has_memory (struct target_ops
*ops
)
3760 tfile_has_stack (struct target_ops
*ops
)
3766 tfile_has_registers (struct target_ops
*ops
)
3772 init_tfile_ops (void)
3774 tfile_ops
.to_shortname
= "tfile";
3775 tfile_ops
.to_longname
= "Local trace dump file";
3777 "Use a trace file as a target. Specify the filename of the trace file.";
3778 tfile_ops
.to_open
= tfile_open
;
3779 tfile_ops
.to_close
= tfile_close
;
3780 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
3781 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
3782 tfile_ops
.to_files_info
= tfile_files_info
;
3783 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
3784 tfile_ops
.to_trace_find
= tfile_trace_find
;
3785 tfile_ops
.to_get_trace_state_variable_value
= tfile_get_trace_state_variable_value
;
3786 /* core_stratum might seem more logical, but GDB doesn't like having
3787 more than one core_stratum vector. */
3788 tfile_ops
.to_stratum
= process_stratum
;
3789 tfile_ops
.to_has_memory
= tfile_has_memory
;
3790 tfile_ops
.to_has_stack
= tfile_has_stack
;
3791 tfile_ops
.to_has_registers
= tfile_has_registers
;
3792 tfile_ops
.to_magic
= OPS_MAGIC
;
3795 /* module initialization */
3797 _initialize_tracepoint (void)
3799 struct cmd_list_element
*c
;
3801 traceframe_number
= -1;
3802 tracepoint_number
= -1;
3804 if (tracepoint_list
.list
== NULL
)
3806 tracepoint_list
.listsize
= 128;
3807 tracepoint_list
.list
= xmalloc
3808 (tracepoint_list
.listsize
* sizeof (struct memrange
));
3810 if (tracepoint_list
.aexpr_list
== NULL
)
3812 tracepoint_list
.aexpr_listsize
= 128;
3813 tracepoint_list
.aexpr_list
= xmalloc
3814 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3817 if (stepping_list
.list
== NULL
)
3819 stepping_list
.listsize
= 128;
3820 stepping_list
.list
= xmalloc
3821 (stepping_list
.listsize
* sizeof (struct memrange
));
3824 if (stepping_list
.aexpr_list
== NULL
)
3826 stepping_list
.aexpr_listsize
= 128;
3827 stepping_list
.aexpr_list
= xmalloc
3828 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3831 add_info ("scope", scope_info
,
3832 _("List the variables local to a scope"));
3834 add_cmd ("tracepoints", class_trace
, NULL
,
3835 _("Tracing of program execution without stopping the program."),
3838 add_com ("tdump", class_trace
, trace_dump_command
,
3839 _("Print everything collected at the current tracepoint."));
3841 add_com ("tsave", class_trace
, trace_save_command
, _("\
3842 Save the trace data to a file.\n\
3843 Use the '-r' option to direct the target to save directly to the file,\n\
3844 using its own filesystem."));
3846 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
3847 Define a trace state variable.\n\
3848 Argument is a $-prefixed name, optionally followed\n\
3849 by '=' and an expression that sets the initial value\n\
3850 at the start of tracing."));
3851 set_cmd_completer (c
, expression_completer
);
3853 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
3854 Delete one or more trace state variables.\n\
3855 Arguments are the names of the variables to delete.\n\
3856 If no arguments are supplied, delete all variables."), &deletelist
);
3857 /* FIXME add a trace variable completer */
3859 add_info ("tvariables", tvariables_info
, _("\
3860 Status of trace state variables and their values.\n\
3863 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
3864 Select a trace frame;\n\
3865 No argument means forward by one frame; '-' means backward by one frame."),
3866 &tfindlist
, "tfind ", 1, &cmdlist
);
3868 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
3869 Select a trace frame whose PC is outside the given range (exclusive).\n\
3870 Usage: tfind outside addr1, addr2"),
3873 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
3874 Select a trace frame whose PC is in the given range (inclusive).\n\
3875 Usage: tfind range addr1,addr2"),
3878 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
3879 Select a trace frame by source line.\n\
3880 Argument can be a line number (with optional source file), \n\
3881 a function name, or '*' followed by an address.\n\
3882 Default argument is 'the next source line that was traced'."),
3885 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
3886 Select a trace frame by tracepoint number.\n\
3887 Default is the tracepoint for the current trace frame."),
3890 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
3891 Select a trace frame by PC.\n\
3892 Default is the current PC, or the PC of the current trace frame."),
3895 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
3896 Synonym for 'none'.\n\
3897 De-select any trace frame and resume 'live' debugging."),
3900 add_cmd ("none", class_trace
, trace_find_none_command
,
3901 _("De-select any trace frame and resume 'live' debugging."),
3904 add_cmd ("start", class_trace
, trace_find_start_command
,
3905 _("Select the first trace frame in the trace buffer."),
3908 add_com ("tstatus", class_trace
, trace_status_command
,
3909 _("Display the status of the current trace data collection."));
3911 add_com ("tstop", class_trace
, trace_stop_command
,
3912 _("Stop trace data collection."));
3914 add_com ("tstart", class_trace
, trace_start_command
,
3915 _("Start trace data collection."));
3917 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
3918 Ends a list of commands or actions.\n\
3919 Several GDB commands allow you to enter a list of commands or actions.\n\
3920 Entering \"end\" on a line by itself is the normal way to terminate\n\
3922 Note: the \"end\" command cannot be used at the gdb prompt."));
3924 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
3925 Specify single-stepping behavior at a tracepoint.\n\
3926 Argument is number of instructions to trace in single-step mode\n\
3927 following the tracepoint. This command is normally followed by\n\
3928 one or more \"collect\" commands, to specify what to collect\n\
3929 while single-stepping.\n\n\
3930 Note: this command can only be used in a tracepoint \"actions\" list."));
3932 add_com_alias ("ws", "while-stepping", class_alias
, 0);
3933 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
3935 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
3936 Specify one or more data items to be collected at a tracepoint.\n\
3937 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
3938 collect all data (variables, registers) referenced by that expression.\n\
3939 Also accepts the following special arguments:\n\
3940 $regs -- all registers.\n\
3941 $args -- all function arguments.\n\
3942 $locals -- all variables local to the block/function scope.\n\
3943 Note: this command can only be used in a tracepoint \"actions\" list."));
3945 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
3946 Specify one or more expressions to be evaluated at a tracepoint.\n\
3947 Accepts a comma-separated list of (one or more) expressions.\n\
3948 The result of each evaluation will be discarded.\n\
3949 Note: this command can only be used in a tracepoint \"actions\" list."));
3951 add_com ("actions", class_trace
, trace_actions_command
, _("\
3952 Specify the actions to be taken at a tracepoint.\n\
3953 Tracepoint actions may include collecting of specified data, \n\
3954 single-stepping, or enabling/disabling other tracepoints, \n\
3955 depending on target's capabilities."));
3957 default_collect
= xstrdup ("");
3958 add_setshow_string_cmd ("default-collect", class_trace
,
3959 &default_collect
, _("\
3960 Set the list of expressions to collect by default"), _("\
3961 Show the list of expressions to collect by default"), NULL
,
3963 &setlist
, &showlist
);
3965 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
3966 &disconnected_tracing
, _("\
3967 Set whether tracing continues after GDB disconnects."), _("\
3968 Show whether tracing continues after GDB disconnects."), _("\
3969 Use this to continue a tracing run even if GDB disconnects\n\
3970 or detaches from the target. You can reconnect later and look at\n\
3971 trace data collected in the meantime."),
3972 set_disconnected_tracing
,
3977 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
3978 &circular_trace_buffer
, _("\
3979 Set target's use of circular trace buffer."), _("\
3980 Show target's use of circular trace buffer."), _("\
3981 Use this to make the trace buffer into a circular buffer,\n\
3982 which will discard traceframes (oldest first) instead of filling\n\
3983 up and stopping the trace run."),
3984 set_circular_trace_buffer
,
3991 add_target (&tfile_ops
);