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 /* Ensure this is never NULL. */
206 if (!trace_status
.error_desc
)
207 trace_status
.error_desc
= "";
208 return &trace_status
;
211 /* Set traceframe number to NUM. */
213 set_traceframe_num (int num
)
215 traceframe_number
= num
;
216 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
219 /* Set tracepoint number to NUM. */
221 set_tracepoint_num (int num
)
223 tracepoint_number
= num
;
224 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
227 /* Set externally visible debug variables for querying/printing
228 the traceframe context (line, function, file) */
231 set_traceframe_context (struct frame_info
*trace_frame
)
235 if (trace_frame
== NULL
) /* Cease debugging any trace buffers. */
238 traceframe_sal
.pc
= traceframe_sal
.line
= 0;
239 traceframe_sal
.symtab
= NULL
;
240 clear_internalvar (lookup_internalvar ("trace_func"));
241 clear_internalvar (lookup_internalvar ("trace_file"));
242 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
246 /* Save as globals for internal use. */
247 trace_pc
= get_frame_pc (trace_frame
);
248 traceframe_sal
= find_pc_line (trace_pc
, 0);
249 traceframe_fun
= find_pc_function (trace_pc
);
251 /* Save linenumber as "$trace_line", a debugger variable visible to
253 set_internalvar_integer (lookup_internalvar ("trace_line"),
254 traceframe_sal
.line
);
256 /* Save func name as "$trace_func", a debugger variable visible to
258 if (traceframe_fun
== NULL
259 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
260 clear_internalvar (lookup_internalvar ("trace_func"));
262 set_internalvar_string (lookup_internalvar ("trace_func"),
263 SYMBOL_LINKAGE_NAME (traceframe_fun
));
265 /* Save file name as "$trace_file", a debugger variable visible to
267 if (traceframe_sal
.symtab
== NULL
268 || traceframe_sal
.symtab
->filename
== NULL
)
269 clear_internalvar (lookup_internalvar ("trace_file"));
271 set_internalvar_string (lookup_internalvar ("trace_file"),
272 traceframe_sal
.symtab
->filename
);
275 /* Create a new trace state variable with the given name. */
277 struct trace_state_variable
*
278 create_trace_state_variable (const char *name
)
280 struct trace_state_variable tsv
;
282 memset (&tsv
, 0, sizeof (tsv
));
283 tsv
.name
= xstrdup (name
);
284 tsv
.number
= next_tsv_number
++;
285 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
288 /* Look for a trace state variable of the given name. */
290 struct trace_state_variable
*
291 find_trace_state_variable (const char *name
)
293 struct trace_state_variable
*tsv
;
296 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
297 if (strcmp (name
, tsv
->name
) == 0)
304 delete_trace_state_variable (const char *name
)
306 struct trace_state_variable
*tsv
;
309 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
310 if (strcmp (name
, tsv
->name
) == 0)
312 xfree ((void *)tsv
->name
);
313 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
317 warning (_("No trace variable named \"$%s\", not deleting"), name
);
320 /* The 'tvariable' command collects a name and optional expression to
321 evaluate into an initial value. */
324 trace_variable_command (char *args
, int from_tty
)
326 struct expression
*expr
;
327 struct cleanup
*old_chain
;
328 struct internalvar
*intvar
= NULL
;
330 struct trace_state_variable
*tsv
;
333 error_no_arg (_("trace state variable name"));
335 /* All the possible valid arguments are expressions. */
336 expr
= parse_expression (args
);
337 old_chain
= make_cleanup (free_current_contents
, &expr
);
339 if (expr
->nelts
== 0)
340 error (_("No expression?"));
342 /* Only allow two syntaxes; "$name" and "$name=value". */
343 if (expr
->elts
[0].opcode
== OP_INTERNALVAR
)
345 intvar
= expr
->elts
[1].internalvar
;
347 else if (expr
->elts
[0].opcode
== BINOP_ASSIGN
348 && expr
->elts
[1].opcode
== OP_INTERNALVAR
)
350 intvar
= expr
->elts
[2].internalvar
;
351 initval
= value_as_long (evaluate_subexpression_type (expr
, 4));
354 error (_("Syntax must be $NAME [ = EXPR ]"));
357 error (_("No name given"));
359 if (strlen (internalvar_name (intvar
)) <= 0)
360 error (_("Must supply a non-empty variable name"));
362 /* If the variable already exists, just change its initial value. */
363 tsv
= find_trace_state_variable (internalvar_name (intvar
));
366 tsv
->initial_value
= initval
;
367 printf_filtered (_("Trace state variable $%s now has initial value %s.\n"),
368 tsv
->name
, plongest (tsv
->initial_value
));
372 /* Create a new variable. */
373 tsv
= create_trace_state_variable (internalvar_name (intvar
));
374 tsv
->initial_value
= initval
;
376 printf_filtered (_("Trace state variable $%s created, with initial value %s.\n"),
377 tsv
->name
, plongest (tsv
->initial_value
));
379 do_cleanups (old_chain
);
383 delete_trace_variable_command (char *args
, int from_tty
)
387 struct cleanup
*back_to
;
388 struct trace_state_variable
*tsv
;
392 if (query (_("Delete all trace state variables? ")))
393 VEC_free (tsv_s
, tvariables
);
398 argv
= gdb_buildargv (args
);
399 back_to
= make_cleanup_freeargv (argv
);
401 for (i
= 0; argv
[i
] != NULL
; i
++)
404 delete_trace_state_variable (argv
[i
] + 1);
406 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[i
]);
409 do_cleanups (back_to
);
415 tvariables_info_1 (void)
417 struct trace_state_variable
*tsv
;
420 struct cleanup
*back_to
;
422 if (VEC_length (tsv_s
, tvariables
) == 0 && !ui_out_is_mi_like_p (uiout
))
424 printf_filtered (_("No trace state variables.\n"));
428 /* Try to acquire values from the target. */
429 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
, ++count
)
430 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
433 back_to
= make_cleanup_ui_out_table_begin_end (uiout
, 3,
434 count
, "trace-variables");
435 ui_out_table_header (uiout
, 15, ui_left
, "name", "Name");
436 ui_out_table_header (uiout
, 11, ui_left
, "initial", "Initial");
437 ui_out_table_header (uiout
, 11, ui_left
, "current", "Current");
439 ui_out_table_body (uiout
);
441 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
443 struct cleanup
*back_to2
;
447 back_to2
= make_cleanup_ui_out_tuple_begin_end (uiout
, "variable");
449 name
= concat ("$", tsv
->name
, NULL
);
450 make_cleanup (xfree
, name
);
451 ui_out_field_string (uiout
, "name", name
);
452 ui_out_field_string (uiout
, "initial", plongest (tsv
->initial_value
));
454 if (tsv
->value_known
)
455 c
= plongest (tsv
->value
);
456 else if (ui_out_is_mi_like_p (uiout
))
457 /* For MI, we prefer not to use magic string constants, but rather
458 omit the field completely. The difference between unknown and
459 undefined does not seem important enough to represent. */
461 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
462 /* The value is/was defined, but we don't have it. */
465 /* It is not meaningful to ask about the value. */
468 ui_out_field_string (uiout
, "current", c
);
469 ui_out_text (uiout
, "\n");
471 do_cleanups (back_to2
);
474 do_cleanups (back_to
);
477 /* List all the trace state variables. */
480 tvariables_info (char *args
, int from_tty
)
482 tvariables_info_1 ();
485 /* ACTIONS functions: */
487 /* The three functions:
488 collect_pseudocommand,
489 while_stepping_pseudocommand, and
490 end_actions_pseudocommand
491 are placeholders for "commands" that are actually ONLY to be used
492 within a tracepoint action list. If the actual function is ever called,
493 it means that somebody issued the "command" at the top level,
494 which is always an error. */
497 end_actions_pseudocommand (char *args
, int from_tty
)
499 error (_("This command cannot be used at the top level."));
503 while_stepping_pseudocommand (char *args
, int from_tty
)
505 error (_("This command can only be used in a tracepoint actions list."));
509 collect_pseudocommand (char *args
, int from_tty
)
511 error (_("This command can only be used in a tracepoint actions list."));
515 teval_pseudocommand (char *args
, int from_tty
)
517 error (_("This command can only be used in a tracepoint actions list."));
520 /* Enter a list of actions for a tracepoint. */
522 trace_actions_command (char *args
, int from_tty
)
524 struct breakpoint
*t
;
525 struct command_line
*l
;
527 t
= get_tracepoint_by_number (&args
, 0, 1);
531 xstrprintf ("Enter actions for tracepoint %d, one per line.",
533 struct cleanup
*cleanups
= make_cleanup (xfree
, tmpbuf
);
535 l
= read_command_lines (tmpbuf
, from_tty
, 1, check_tracepoint_command
, t
);
536 do_cleanups (cleanups
);
537 breakpoint_set_commands (t
, l
);
539 /* else just return */
542 /* worker function */
544 validate_actionline (char **line
, struct breakpoint
*t
)
546 struct cmd_list_element
*c
;
547 struct expression
*exp
= NULL
;
548 struct cleanup
*old_chain
= NULL
;
550 struct bp_location
*loc
;
552 /* if EOF is typed, *line is NULL */
556 for (p
= *line
; isspace ((int) *p
);)
559 /* Symbol lookup etc. */
560 if (*p
== '\0') /* empty line: just prompt for another line. */
563 if (*p
== '#') /* comment line */
566 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
569 warning (_("'%s' is not an action that I know, or is ambiguous."),
574 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
576 struct agent_expr
*aexpr
;
577 struct agent_reqs areqs
;
580 { /* repeat over a comma-separated list */
581 QUIT
; /* allow user to bail out with ^C */
582 while (isspace ((int) *p
))
585 if (*p
== '$') /* look for special pseudo-symbols */
587 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
588 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
589 (0 == strncasecmp ("loc", p
+ 1, 3)))
594 /* else fall thru, treat p as an expression and parse it! */
597 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
600 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
601 old_chain
= make_cleanup (free_current_contents
, &exp
);
603 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
605 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
607 warning (_("constant %s (value %ld) will not be collected."),
608 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
609 SYMBOL_VALUE (exp
->elts
[2].symbol
));
612 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
614 warning (_("%s is optimized away and cannot be collected."),
615 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
620 /* We have something to collect, make sure that the expr to
621 bytecode translator can handle it and that it's not too
623 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
624 make_cleanup_free_agent_expr (aexpr
);
626 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
627 error (_("expression too complicated, try simplifying"));
629 ax_reqs (aexpr
, &areqs
);
630 (void) make_cleanup (xfree
, areqs
.reg_mask
);
632 if (areqs
.flaw
!= agent_flaw_none
)
633 error (_("malformed expression"));
635 if (areqs
.min_height
< 0)
636 error (_("gdb: Internal error: expression has min height < 0"));
638 if (areqs
.max_height
> 20)
639 error (_("expression too complicated, try simplifying"));
641 do_cleanups (old_chain
);
644 while (p
&& *p
++ == ',');
647 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
649 struct agent_expr
*aexpr
;
652 { /* repeat over a comma-separated list */
653 QUIT
; /* allow user to bail out with ^C */
654 while (isspace ((int) *p
))
658 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
661 /* Only expressions are allowed for this action. */
662 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
663 old_chain
= make_cleanup (free_current_contents
, &exp
);
665 /* We have something to evaluate, make sure that the expr to
666 bytecode translator can handle it and that it's not too
668 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
669 make_cleanup_free_agent_expr (aexpr
);
671 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
672 error (_("expression too complicated, try simplifying"));
674 do_cleanups (old_chain
);
677 while (p
&& *p
++ == ',');
680 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
682 char *steparg
; /* in case warning is necessary */
684 while (isspace ((int) *p
))
689 (t
->step_count
= strtol (p
, &p
, 0)) == 0)
691 error (_("'%s': bad step-count."), *line
);
695 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
699 error (_("'%s' is not a supported tracepoint action."), *line
);
704 memrange_absolute
= -1
709 int type
; /* memrange_absolute for absolute memory range,
710 else basereg number */
711 bfd_signed_vma start
;
715 struct collection_list
717 unsigned char regs_mask
[32]; /* room for up to 256 regs */
720 struct memrange
*list
;
721 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
723 struct agent_expr
**aexpr_list
;
726 tracepoint_list
, stepping_list
;
728 /* MEMRANGE functions: */
730 static int memrange_cmp (const void *, const void *);
732 /* compare memranges for qsort */
734 memrange_cmp (const void *va
, const void *vb
)
736 const struct memrange
*a
= va
, *b
= vb
;
738 if (a
->type
< b
->type
)
740 if (a
->type
> b
->type
)
742 if (a
->type
== memrange_absolute
)
744 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
746 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
751 if (a
->start
< b
->start
)
753 if (a
->start
> b
->start
)
759 /* Sort the memrange list using qsort, and merge adjacent memranges. */
761 memrange_sortmerge (struct collection_list
*memranges
)
765 qsort (memranges
->list
, memranges
->next_memrange
,
766 sizeof (struct memrange
), memrange_cmp
);
767 if (memranges
->next_memrange
> 0)
769 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
771 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
772 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
775 /* memrange b starts before memrange a ends; merge them. */
776 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
777 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
778 continue; /* next b, same a */
782 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
783 sizeof (struct memrange
));
785 memranges
->next_memrange
= a
+ 1;
789 /* Add a register to a collection list. */
791 add_register (struct collection_list
*collection
, unsigned int regno
)
794 printf_filtered ("collect register %d\n", regno
);
795 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
796 error (_("Internal: register number %d too large for tracepoint"),
798 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
801 /* Add a memrange to a collection list */
803 add_memrange (struct collection_list
*memranges
,
804 int type
, bfd_signed_vma base
,
809 printf_filtered ("(%d,", type
);
811 printf_filtered (",%ld)\n", len
);
814 /* type: memrange_absolute == memory, other n == basereg */
815 memranges
->list
[memranges
->next_memrange
].type
= type
;
816 /* base: addr if memory, offset if reg relative. */
817 memranges
->list
[memranges
->next_memrange
].start
= base
;
818 /* len: we actually save end (base + len) for convenience */
819 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
820 memranges
->next_memrange
++;
821 if (memranges
->next_memrange
>= memranges
->listsize
)
823 memranges
->listsize
*= 2;
824 memranges
->list
= xrealloc (memranges
->list
,
825 memranges
->listsize
);
828 if (type
!= memrange_absolute
) /* Better collect the base register! */
829 add_register (memranges
, type
);
832 /* Add a symbol to a collection list. */
834 collect_symbol (struct collection_list
*collect
,
836 struct gdbarch
*gdbarch
,
837 long frame_regno
, long frame_offset
,
842 bfd_signed_vma offset
;
843 int treat_as_expr
= 0;
845 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
846 switch (SYMBOL_CLASS (sym
))
849 printf_filtered ("%s: don't know symbol class %d\n",
850 SYMBOL_PRINT_NAME (sym
),
854 printf_filtered ("constant %s (value %ld) will not be collected.\n",
855 SYMBOL_PRINT_NAME (sym
), SYMBOL_VALUE (sym
));
858 offset
= SYMBOL_VALUE_ADDRESS (sym
);
863 sprintf_vma (tmp
, offset
);
864 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
865 SYMBOL_PRINT_NAME (sym
), len
,
868 /* A struct may be a C++ class with static fields, go to general
869 expression handling. */
870 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
873 add_memrange (collect
, memrange_absolute
, offset
, len
);
876 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
878 printf_filtered ("LOC_REG[parm] %s: ",
879 SYMBOL_PRINT_NAME (sym
));
880 add_register (collect
, reg
);
881 /* Check for doubles stored in two registers. */
882 /* FIXME: how about larger types stored in 3 or more regs? */
883 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
884 len
> register_size (gdbarch
, reg
))
885 add_register (collect
, reg
+ 1);
888 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
889 printf_filtered (" (will not collect %s)\n",
890 SYMBOL_PRINT_NAME (sym
));
894 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
897 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
898 SYMBOL_PRINT_NAME (sym
), len
);
900 printf_filtered (" from frame ptr reg %d\n", reg
);
902 add_memrange (collect
, reg
, offset
, len
);
904 case LOC_REGPARM_ADDR
:
905 reg
= SYMBOL_VALUE (sym
);
909 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
910 SYMBOL_PRINT_NAME (sym
), len
);
912 printf_filtered (" from reg %d\n", reg
);
914 add_memrange (collect
, reg
, offset
, len
);
918 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
921 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
922 SYMBOL_PRINT_NAME (sym
), len
);
924 printf_filtered (" from frame ptr reg %d\n", reg
);
926 add_memrange (collect
, reg
, offset
, len
);
929 printf_filtered ("Don't know LOC_UNRESOLVED %s\n",
930 SYMBOL_PRINT_NAME (sym
));
932 case LOC_OPTIMIZED_OUT
:
933 printf_filtered ("%s has been optimized out of existence.\n",
934 SYMBOL_PRINT_NAME (sym
));
942 /* Expressions are the most general case. */
945 struct agent_expr
*aexpr
;
946 struct cleanup
*old_chain1
= NULL
;
947 struct agent_reqs areqs
;
949 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
951 /* It can happen that the symbol is recorded as a computed
952 location, but it's been optimized away and doesn't actually
953 have a location expression. */
956 printf_filtered ("%s has been optimized out of existence.\n",
957 SYMBOL_PRINT_NAME (sym
));
961 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
963 ax_reqs (aexpr
, &areqs
);
964 if (areqs
.flaw
!= agent_flaw_none
)
965 error (_("malformed expression"));
967 if (areqs
.min_height
< 0)
968 error (_("gdb: Internal error: expression has min height < 0"));
969 if (areqs
.max_height
> 20)
970 error (_("expression too complicated, try simplifying"));
972 discard_cleanups (old_chain1
);
973 add_aexpr (collect
, aexpr
);
975 /* take care of the registers */
976 if (areqs
.reg_mask_len
> 0)
980 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
982 QUIT
; /* allow user to bail out with ^C */
983 if (areqs
.reg_mask
[ndx1
] != 0)
985 /* assume chars have 8 bits */
986 for (ndx2
= 0; ndx2
< 8; ndx2
++)
987 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
988 /* it's used -- record it */
989 add_register (collect
, ndx1
* 8 + ndx2
);
996 /* Add all locals (or args) symbols to collection list */
998 add_local_symbols (struct collection_list
*collect
,
999 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1000 long frame_regno
, long frame_offset
, int type
)
1003 struct block
*block
;
1004 struct dict_iterator iter
;
1007 block
= block_for_pc (pc
);
1010 QUIT
; /* allow user to bail out with ^C */
1011 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
1013 if (SYMBOL_IS_ARGUMENT (sym
)
1014 ? type
== 'A' /* collecting Arguments */
1015 : type
== 'L') /* collecting Locals */
1018 collect_symbol (collect
, sym
, gdbarch
,
1019 frame_regno
, frame_offset
, pc
);
1022 if (BLOCK_FUNCTION (block
))
1025 block
= BLOCK_SUPERBLOCK (block
);
1028 warning (_("No %s found in scope."),
1029 type
== 'L' ? "locals" : "args");
1032 /* worker function */
1034 clear_collection_list (struct collection_list
*list
)
1038 list
->next_memrange
= 0;
1039 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1041 free_agent_expr (list
->aexpr_list
[ndx
]);
1042 list
->aexpr_list
[ndx
] = NULL
;
1044 list
->next_aexpr_elt
= 0;
1045 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1048 /* reduce a collection list to string form (for gdb protocol) */
1050 stringify_collection_list (struct collection_list
*list
, char *string
)
1052 char temp_buf
[2048];
1056 char *(*str_list
)[];
1060 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1061 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1063 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1064 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1066 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1069 printf_filtered ("\nCollecting registers (mask): 0x");
1074 QUIT
; /* allow user to bail out with ^C */
1076 printf_filtered ("%02X", list
->regs_mask
[i
]);
1077 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1080 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1084 printf_filtered ("\n");
1085 if (list
->next_memrange
> 0 && info_verbose
)
1086 printf_filtered ("Collecting memranges: \n");
1087 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1089 QUIT
; /* allow user to bail out with ^C */
1090 sprintf_vma (tmp2
, list
->list
[i
].start
);
1093 printf_filtered ("(%d, %s, %ld)\n",
1096 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1098 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1100 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1107 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1109 /* The "%X" conversion specifier expects an unsigned argument,
1110 so passing -1 (memrange_absolute) to it directly gives you
1111 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1113 if (list
->list
[i
].type
== memrange_absolute
)
1114 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1116 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1119 count
+= strlen (end
);
1120 end
= temp_buf
+ count
;
1123 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1125 QUIT
; /* allow user to bail out with ^C */
1126 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1128 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1133 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1134 end
+= 10; /* 'X' + 8 hex digits + ',' */
1137 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1138 end
, list
->aexpr_list
[i
]->len
);
1139 count
+= 2 * list
->aexpr_list
[i
]->len
;
1144 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1149 (*str_list
)[ndx
] = NULL
;
1162 encode_actions_1 (struct command_line
*action
,
1163 struct breakpoint
*t
,
1164 struct bp_location
*tloc
,
1166 LONGEST frame_offset
,
1167 struct collection_list
*collect
,
1168 struct collection_list
*stepping_list
)
1171 struct expression
*exp
= NULL
;
1172 struct command_line
*actions
;
1174 struct value
*tempval
;
1175 struct cmd_list_element
*cmd
;
1176 struct agent_expr
*aexpr
;
1178 for (; action
; action
= action
->next
)
1180 QUIT
; /* allow user to bail out with ^C */
1181 action_exp
= action
->line
;
1182 while (isspace ((int) *action_exp
))
1185 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1187 error (_("Bad action list item: %s"), action_exp
);
1189 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1192 { /* repeat over a comma-separated list */
1193 QUIT
; /* allow user to bail out with ^C */
1194 while (isspace ((int) *action_exp
))
1197 if (0 == strncasecmp ("$reg", action_exp
, 4))
1199 for (i
= 0; i
< gdbarch_num_regs (t
->gdbarch
); i
++)
1200 add_register (collect
, i
);
1201 action_exp
= strchr (action_exp
, ','); /* more? */
1203 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1205 add_local_symbols (collect
,
1211 action_exp
= strchr (action_exp
, ','); /* more? */
1213 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1215 add_local_symbols (collect
,
1221 action_exp
= strchr (action_exp
, ','); /* more? */
1225 unsigned long addr
, len
;
1226 struct cleanup
*old_chain
= NULL
;
1227 struct cleanup
*old_chain1
= NULL
;
1228 struct agent_reqs areqs
;
1230 exp
= parse_exp_1 (&action_exp
,
1231 block_for_pc (tloc
->address
), 1);
1232 old_chain
= make_cleanup (free_current_contents
, &exp
);
1234 switch (exp
->elts
[0].opcode
)
1238 const char *name
= &exp
->elts
[2].string
;
1240 i
= user_reg_map_name_to_regnum (t
->gdbarch
,
1241 name
, strlen (name
));
1243 internal_error (__FILE__
, __LINE__
,
1244 _("Register $%s not available"),
1247 printf_filtered ("OP_REGISTER: ");
1248 add_register (collect
, i
);
1253 /* safe because we know it's a simple expression */
1254 tempval
= evaluate_expression (exp
);
1255 addr
= value_address (tempval
);
1256 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1257 add_memrange (collect
, memrange_absolute
, addr
, len
);
1261 collect_symbol (collect
,
1262 exp
->elts
[2].symbol
,
1269 default: /* full-fledged expression */
1270 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1272 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1274 ax_reqs (aexpr
, &areqs
);
1275 if (areqs
.flaw
!= agent_flaw_none
)
1276 error (_("malformed expression"));
1278 if (areqs
.min_height
< 0)
1279 error (_("gdb: Internal error: expression has min height < 0"));
1280 if (areqs
.max_height
> 20)
1281 error (_("expression too complicated, try simplifying"));
1283 discard_cleanups (old_chain1
);
1284 add_aexpr (collect
, aexpr
);
1286 /* take care of the registers */
1287 if (areqs
.reg_mask_len
> 0)
1292 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1294 QUIT
; /* allow user to bail out with ^C */
1295 if (areqs
.reg_mask
[ndx1
] != 0)
1297 /* assume chars have 8 bits */
1298 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1299 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1300 /* it's used -- record it */
1301 add_register (collect
,
1308 do_cleanups (old_chain
);
1311 while (action_exp
&& *action_exp
++ == ',');
1313 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1316 { /* repeat over a comma-separated list */
1317 QUIT
; /* allow user to bail out with ^C */
1318 while (isspace ((int) *action_exp
))
1322 unsigned long addr
, len
;
1323 struct cleanup
*old_chain
= NULL
;
1324 struct cleanup
*old_chain1
= NULL
;
1325 struct agent_reqs areqs
;
1327 exp
= parse_exp_1 (&action_exp
,
1328 block_for_pc (tloc
->address
), 1);
1329 old_chain
= make_cleanup (free_current_contents
, &exp
);
1331 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1332 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1334 ax_reqs (aexpr
, &areqs
);
1335 if (areqs
.flaw
!= agent_flaw_none
)
1336 error (_("malformed expression"));
1338 if (areqs
.min_height
< 0)
1339 error (_("gdb: Internal error: expression has min height < 0"));
1340 if (areqs
.max_height
> 20)
1341 error (_("expression too complicated, try simplifying"));
1343 discard_cleanups (old_chain1
);
1344 /* Even though we're not officially collecting, add
1345 to the collect list anyway. */
1346 add_aexpr (collect
, aexpr
);
1348 do_cleanups (old_chain
);
1351 while (action_exp
&& *action_exp
++ == ',');
1353 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1355 /* We check against nested while-stepping when setting
1356 breakpoint action, so no way to run into nested
1358 gdb_assert (stepping_list
);
1360 encode_actions_1 (action
->body_list
[0], t
, tloc
, frame_reg
, frame_offset
,
1361 stepping_list
, NULL
);
1364 error (_("Invalid tracepoint command '%s'"), action
->line
);
1368 /* Render all actions into gdb protocol. */
1370 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1371 char ***tdp_actions
, char ***stepping_actions
)
1373 static char tdp_buff
[2048], step_buff
[2048];
1374 char *default_collect_line
= NULL
;
1375 struct command_line
*actions
;
1376 struct command_line
*default_collect_action
= NULL
;
1378 LONGEST frame_offset
;
1379 struct cleanup
*back_to
;
1381 back_to
= make_cleanup (null_cleanup
, NULL
);
1383 clear_collection_list (&tracepoint_list
);
1384 clear_collection_list (&stepping_list
);
1386 *tdp_actions
= NULL
;
1387 *stepping_actions
= NULL
;
1389 gdbarch_virtual_frame_pointer (t
->gdbarch
,
1390 t
->loc
->address
, &frame_reg
, &frame_offset
);
1392 actions
= t
->commands
->commands
;
1394 /* If there are default expressions to collect, make up a collect
1395 action and prepend to the action list to encode. Note that since
1396 validation is per-tracepoint (local var "xyz" might be valid for
1397 one tracepoint and not another, etc), we make up the action on
1398 the fly, and don't cache it. */
1399 if (*default_collect
)
1402 enum actionline_type linetype
;
1404 default_collect_line
= xstrprintf ("collect %s", default_collect
);
1405 make_cleanup (xfree
, default_collect_line
);
1407 line
= default_collect_line
;
1408 linetype
= validate_actionline (&line
, t
);
1409 if (linetype
!= BADLINE
)
1411 default_collect_action
= xmalloc (sizeof (struct command_line
));
1412 make_cleanup (xfree
, default_collect_action
);
1413 default_collect_action
->next
= t
->commands
->commands
;
1414 default_collect_action
->line
= line
;
1415 actions
= default_collect_action
;
1418 encode_actions_1 (actions
, t
, tloc
, frame_reg
, frame_offset
,
1419 &tracepoint_list
, &stepping_list
);
1421 memrange_sortmerge (&tracepoint_list
);
1422 memrange_sortmerge (&stepping_list
);
1424 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1426 *stepping_actions
= stringify_collection_list (&stepping_list
,
1429 do_cleanups (back_to
);
1433 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1435 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1437 collect
->aexpr_list
=
1438 xrealloc (collect
->aexpr_list
,
1439 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1440 collect
->aexpr_listsize
*= 2;
1442 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1443 collect
->next_aexpr_elt
++;
1448 start_tracing (void)
1451 VEC(breakpoint_p
) *tp_vec
= NULL
;
1453 struct breakpoint
*t
;
1454 struct trace_state_variable
*tsv
;
1455 int any_downloaded
= 0;
1457 target_trace_init ();
1459 tp_vec
= all_tracepoints ();
1460 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1462 t
->number_on_target
= 0;
1463 target_download_tracepoint (t
);
1464 t
->number_on_target
= t
->number
;
1467 VEC_free (breakpoint_p
, tp_vec
);
1469 /* No point in tracing without any tracepoints... */
1470 if (!any_downloaded
)
1471 error ("No tracepoints downloaded, not starting trace");
1473 /* Send down all the trace state variables too. */
1474 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1476 target_download_trace_state_variable (tsv
);
1479 /* Tell target to treat text-like sections as transparent. */
1480 target_trace_set_readonly_regions ();
1481 /* Set some mode flags. */
1482 target_set_disconnected_tracing (disconnected_tracing
);
1483 target_set_circular_trace_buffer (circular_trace_buffer
);
1485 /* Now insert traps and begin collecting data. */
1486 target_trace_start ();
1488 /* Reset our local state. */
1489 set_traceframe_num (-1);
1490 set_tracepoint_num (-1);
1491 set_traceframe_context (NULL
);
1492 current_trace_status()->running
= 1;
1497 Tell target to clear any previous trace experiment.
1498 Walk the list of tracepoints, and send them (and their actions)
1499 to the target. If no errors,
1500 Tell target to start a new trace experiment. */
1503 trace_start_command (char *args
, int from_tty
)
1505 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1512 trace_stop_command (char *args
, int from_tty
)
1520 target_trace_stop ();
1521 /* should change in response to reply? */
1522 current_trace_status ()->running
= 0;
1525 /* tstatus command */
1527 trace_status_command (char *args
, int from_tty
)
1529 struct trace_status
*ts
= current_trace_status ();
1532 status
= target_get_trace_status (ts
);
1537 printf_filtered (_("Using a trace file.\n"));
1540 printf_filtered (_("Trace can not be run on this target.\n"));
1545 if (!ts
->running_known
)
1547 printf_filtered (_("Run/stop status is unknown.\n"));
1549 else if (ts
->running
)
1551 printf_filtered (_("Trace is running on the target.\n"));
1552 if (disconnected_tracing
)
1553 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1555 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1559 switch (ts
->stop_reason
)
1561 case trace_never_run
:
1562 printf_filtered (_("No trace has been run on the target.\n"));
1565 printf_filtered (_("Trace stopped by a tstop command.\n"));
1567 case trace_buffer_full
:
1568 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1570 case trace_disconnected
:
1571 printf_filtered (_("Trace stopped because of disconnection.\n"));
1573 case tracepoint_passcount
:
1574 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1575 ts
->stopping_tracepoint
);
1577 case tracepoint_error
:
1578 if (ts
->stopping_tracepoint
)
1579 printf_filtered (_("Trace stopped by an error (%s, tracepoint %d).\n"),
1580 ts
->error_desc
, ts
->stopping_tracepoint
);
1582 printf_filtered (_("Trace stopped by an error (%s).\n"),
1585 case trace_stop_reason_unknown
:
1586 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1589 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1595 if (ts
->traceframes_created
>= 0
1596 && ts
->traceframe_count
!= ts
->traceframes_created
)
1598 printf_filtered (_("Buffer contains %d trace frames (of %d created total).\n"),
1599 ts
->traceframe_count
, ts
->traceframes_created
);
1601 else if (ts
->traceframe_count
>= 0)
1603 printf_filtered (_("Collected %d trace frames.\n"),
1604 ts
->traceframe_count
);
1607 if (ts
->buffer_free
>= 0)
1609 if (ts
->buffer_size
>= 0)
1611 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1612 ts
->buffer_free
, ts
->buffer_size
);
1613 if (ts
->buffer_size
> 0)
1614 printf_filtered (_(" (%d%% full)"),
1615 ((int) ((((long long) (ts
->buffer_size
1616 - ts
->buffer_free
)) * 100)
1617 / ts
->buffer_size
)));
1618 printf_filtered (_(".\n"));
1621 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1625 /* Now report on what we're doing with tfind. */
1626 if (traceframe_number
>= 0)
1627 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1628 traceframe_number
, tracepoint_number
);
1630 printf_filtered (_("Not looking at any trace frame.\n"));
1633 /* Report the trace status to uiout, in a way suitable for MI, and not
1634 suitable for CLI. If ON_STOP is true, suppress a few fields that
1635 are not meaningful in the -trace-stop response.
1637 The implementation is essentially parallel to trace_status_command, but
1638 merging them will result in unreadable code. */
1640 trace_status_mi (int on_stop
)
1642 struct trace_status
*ts
= current_trace_status ();
1644 char *string_status
;
1646 status
= target_get_trace_status (ts
);
1648 if (status
== -1 && !ts
->from_file
)
1650 ui_out_field_string (uiout
, "supported", "0");
1655 ui_out_field_string (uiout
, "supported", "file");
1657 ui_out_field_string (uiout
, "supported", "1");
1659 gdb_assert (ts
->running_known
);
1663 ui_out_field_string (uiout
, "running", "1");
1665 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1666 Given that the frontend gets the status either on -trace-stop, or from
1667 -trace-status after re-connection, it does not seem like this
1668 information is necessary for anything. It is not necessary for either
1669 figuring the vital state of the target nor for navigation of trace
1670 frames. If the frontend wants to show the current state is some
1671 configure dialog, it can request the value when such dialog is
1672 invoked by the user. */
1676 char *stop_reason
= NULL
;
1677 int stopping_tracepoint
= -1;
1680 ui_out_field_string (uiout
, "running", "0");
1682 if (ts
->stop_reason
!= trace_stop_reason_unknown
)
1684 switch (ts
->stop_reason
)
1687 stop_reason
= "request";
1689 case trace_buffer_full
:
1690 stop_reason
= "overflow";
1692 case trace_disconnected
:
1693 stop_reason
= "disconnection";
1695 case tracepoint_passcount
:
1696 stop_reason
= "passcount";
1697 stopping_tracepoint
= ts
->stopping_tracepoint
;
1699 case tracepoint_error
:
1700 stop_reason
= "error";
1701 stopping_tracepoint
= ts
->stopping_tracepoint
;
1707 ui_out_field_string (uiout
, "stop-reason", stop_reason
);
1708 if (stopping_tracepoint
!= -1)
1709 ui_out_field_int (uiout
, "stopping-tracepoint",
1710 stopping_tracepoint
);
1711 if (ts
->stop_reason
== tracepoint_error
)
1712 ui_out_field_string (uiout
, "error-description",
1719 if ((int) ts
->traceframe_count
!= -1)
1720 ui_out_field_int (uiout
, "frames", ts
->traceframe_count
);
1721 if ((int) ts
->buffer_size
!= -1)
1722 ui_out_field_int (uiout
, "buffer-size", (int) ts
->buffer_size
);
1723 if ((int) ts
->buffer_free
!= -1)
1724 ui_out_field_int (uiout
, "buffer-free", (int) ts
->buffer_free
);
1729 disconnect_or_stop_tracing (int from_tty
)
1731 /* It can happen that the target that was tracing went away on its
1732 own, and we didn't notice. Get a status update, and if the
1733 current target doesn't even do tracing, then assume it's not
1735 if (target_get_trace_status (current_trace_status ()) < 0)
1736 current_trace_status ()->running
= 0;
1738 if (current_trace_status ()->running
&& from_tty
)
1740 int cont
= query (_("Trace is running. Continue tracing after detach? "));
1741 /* Note that we send the query result without affecting the
1742 user's setting of disconnected_tracing, so that the answer is
1744 send_disconnected_tracing_value (cont
);
1746 /* Also ensure that we do the equivalent of a tstop command if
1747 tracing is not to continue after the detach. */
1753 /* Worker function for the various flavors of the tfind command. */
1755 tfind_1 (enum trace_find_type type
, int num
,
1756 ULONGEST addr1
, ULONGEST addr2
,
1759 int target_frameno
= -1, target_tracept
= -1;
1760 struct frame_id old_frame_id
;
1762 struct breakpoint
*tp
;
1764 old_frame_id
= get_frame_id (get_current_frame ());
1766 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
1769 if (type
== tfind_number
1771 && target_frameno
== -1)
1773 /* We told the target to get out of tfind mode, and it did. */
1775 else if (target_frameno
== -1)
1777 /* A request for a non-existant trace frame has failed.
1778 Our response will be different, depending on FROM_TTY:
1780 If FROM_TTY is true, meaning that this command was
1781 typed interactively by the user, then give an error
1782 and DO NOT change the state of traceframe_number etc.
1784 However if FROM_TTY is false, meaning that we're either
1785 in a script, a loop, or a user-defined command, then
1786 DON'T give an error, but DO change the state of
1787 traceframe_number etc. to invalid.
1789 The rationalle is that if you typed the command, you
1790 might just have committed a typo or something, and you'd
1791 like to NOT lose your current debugging state. However
1792 if you're in a user-defined command or especially in a
1793 loop, then you need a way to detect that the command
1794 failed WITHOUT aborting. This allows you to write
1795 scripts that search thru the trace buffer until the end,
1796 and then continue on to do something else. */
1799 error (_("Target failed to find requested trace frame."));
1803 printf_filtered ("End of trace buffer.\n");
1804 #if 0 /* dubious now? */
1805 /* The following will not recurse, since it's
1807 trace_find_command ("-1", from_tty
);
1812 tp
= get_tracepoint_by_number_on_target (target_tracept
);
1814 reinit_frame_cache ();
1815 registers_changed ();
1816 target_dcache_invalidate ();
1817 set_traceframe_num (target_frameno
);
1818 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
1819 if (target_frameno
== -1)
1820 set_traceframe_context (NULL
);
1822 set_traceframe_context (get_current_frame ());
1824 if (traceframe_number
>= 0)
1826 /* Use different branches for MI and CLI to make CLI messages
1828 if (ui_out_is_mi_like_p (uiout
))
1830 ui_out_field_string (uiout
, "found", "1");
1831 ui_out_field_int (uiout
, "tracepoint", tracepoint_number
);
1832 ui_out_field_int (uiout
, "traceframe", traceframe_number
);
1836 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
1837 traceframe_number
, tracepoint_number
);
1842 if (ui_out_is_mi_like_p (uiout
))
1843 ui_out_field_string (uiout
, "found", "0");
1845 printf_unfiltered (_("No trace frame found"));
1848 /* If we're in nonstop mode and getting out of looking at trace
1849 frames, there won't be any current frame to go back to and
1852 && (has_stack_frames () || traceframe_number
>= 0))
1854 enum print_what print_what
;
1856 /* NOTE: in immitation of the step command, try to determine
1857 whether we have made a transition from one function to
1858 another. If so, we'll print the "stack frame" (ie. the new
1859 function and it's arguments) -- otherwise we'll just show the
1862 if (frame_id_eq (old_frame_id
,
1863 get_frame_id (get_current_frame ())))
1864 print_what
= SRC_LINE
;
1866 print_what
= SRC_AND_LOC
;
1868 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
1873 /* trace_find_command takes a trace frame number n,
1874 sends "QTFrame:<n>" to the target,
1875 and accepts a reply that may contain several optional pieces
1876 of information: a frame number, a tracepoint number, and an
1877 indication of whether this is a trap frame or a stepping frame.
1879 The minimal response is just "OK" (which indicates that the
1880 target does not give us a frame number or a tracepoint number).
1881 Instead of that, the target may send us a string containing
1883 F<hexnum> (gives the selected frame number)
1884 T<hexnum> (gives the selected tracepoint number)
1889 trace_find_command (char *args
, int from_tty
)
1890 { /* this should only be called with a numeric argument */
1893 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1894 error ("May not look at trace frames while trace is running.");
1896 if (args
== 0 || *args
== 0)
1897 { /* TFIND with no args means find NEXT trace frame. */
1898 if (traceframe_number
== -1)
1899 frameno
= 0; /* "next" is first one */
1901 frameno
= traceframe_number
+ 1;
1903 else if (0 == strcmp (args
, "-"))
1905 if (traceframe_number
== -1)
1906 error (_("not debugging trace buffer"));
1907 else if (from_tty
&& traceframe_number
== 0)
1908 error (_("already at start of trace buffer"));
1910 frameno
= traceframe_number
- 1;
1912 /* A hack to work around eval's need for fp to have been collected. */
1913 else if (0 == strcmp (args
, "-1"))
1916 frameno
= parse_and_eval_long (args
);
1919 error (_("invalid input (%d is less than zero)"), frameno
);
1921 tfind_1 (tfind_number
, frameno
, 0, 0, from_tty
);
1926 trace_find_end_command (char *args
, int from_tty
)
1928 trace_find_command ("-1", from_tty
);
1933 trace_find_none_command (char *args
, int from_tty
)
1935 trace_find_command ("-1", from_tty
);
1940 trace_find_start_command (char *args
, int from_tty
)
1942 trace_find_command ("0", from_tty
);
1945 /* tfind pc command */
1947 trace_find_pc_command (char *args
, int from_tty
)
1952 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1953 error ("May not look at trace frames while trace is running.");
1955 if (args
== 0 || *args
== 0)
1956 pc
= regcache_read_pc (get_current_regcache ());
1958 pc
= parse_and_eval_address (args
);
1960 tfind_1 (tfind_pc
, 0, pc
, 0, from_tty
);
1963 /* tfind tracepoint command */
1965 trace_find_tracepoint_command (char *args
, int from_tty
)
1968 struct breakpoint
*tp
;
1970 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1971 error ("May not look at trace frames while trace is running.");
1973 if (args
== 0 || *args
== 0)
1975 if (tracepoint_number
== -1)
1976 error (_("No current tracepoint -- please supply an argument."));
1978 tdp
= tracepoint_number
; /* default is current TDP */
1981 tdp
= parse_and_eval_long (args
);
1983 /* If we have the tracepoint on hand, use the number that the
1984 target knows about (which may be different if we disconnected
1985 and reconnected). */
1986 tp
= get_tracepoint (tdp
);
1988 tdp
= tp
->number_on_target
;
1990 tfind_1 (tfind_tp
, tdp
, 0, 0, from_tty
);
1993 /* TFIND LINE command:
1995 This command will take a sourceline for argument, just like BREAK
1996 or TRACE (ie. anything that "decode_line_1" can handle).
1998 With no argument, this command will find the next trace frame
1999 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2002 trace_find_line_command (char *args
, int from_tty
)
2004 static CORE_ADDR start_pc
, end_pc
;
2005 struct symtabs_and_lines sals
;
2006 struct symtab_and_line sal
;
2007 struct cleanup
*old_chain
;
2008 char startpc_str
[40], endpc_str
[40];
2010 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2011 error ("May not look at trace frames while trace is running.");
2013 if (args
== 0 || *args
== 0)
2015 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2017 sals
.sals
= (struct symtab_and_line
*)
2018 xmalloc (sizeof (struct symtab_and_line
));
2023 sals
= decode_line_spec (args
, 1);
2027 old_chain
= make_cleanup (xfree
, sals
.sals
);
2028 if (sal
.symtab
== 0)
2030 printf_filtered ("TFIND: No line number information available");
2033 /* This is useful for "info line *0x7f34". If we can't
2034 tell the user about a source line, at least let them
2035 have the symbolic address. */
2036 printf_filtered (" for address ");
2038 print_address (get_current_arch (), sal
.pc
, gdb_stdout
);
2039 printf_filtered (";\n -- will attempt to find by PC. \n");
2043 printf_filtered (".\n");
2044 return; /* No line, no PC; what can we do? */
2047 else if (sal
.line
> 0
2048 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2050 if (start_pc
== end_pc
)
2052 printf_filtered ("Line %d of \"%s\"",
2053 sal
.line
, sal
.symtab
->filename
);
2055 printf_filtered (" is at address ");
2056 print_address (get_current_arch (), start_pc
, gdb_stdout
);
2058 printf_filtered (" but contains no code.\n");
2059 sal
= find_pc_line (start_pc
, 0);
2061 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2062 && start_pc
!= end_pc
)
2063 printf_filtered ("Attempting to find line %d instead.\n",
2066 error (_("Cannot find a good line."));
2070 /* Is there any case in which we get here, and have an address
2071 which the user would want to see? If we have debugging
2072 symbols and no line numbers? */
2073 error (_("Line number %d is out of range for \"%s\"."),
2074 sal
.line
, sal
.symtab
->filename
);
2076 /* Find within range of stated line. */
2078 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2080 tfind_1 (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2081 do_cleanups (old_chain
);
2084 /* tfind range command */
2086 trace_find_range_command (char *args
, int from_tty
)
2088 static CORE_ADDR start
, stop
;
2089 char start_str
[40], stop_str
[40];
2092 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2093 error ("May not look at trace frames while trace is running.");
2095 if (args
== 0 || *args
== 0)
2096 { /* XXX FIXME: what should default behavior be? */
2097 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2101 if (0 != (tmp
= strchr (args
, ',')))
2103 *tmp
++ = '\0'; /* terminate start address */
2104 while (isspace ((int) *tmp
))
2106 start
= parse_and_eval_address (args
);
2107 stop
= parse_and_eval_address (tmp
);
2110 { /* no explicit end address? */
2111 start
= parse_and_eval_address (args
);
2112 stop
= start
+ 1; /* ??? */
2115 tfind_1 (tfind_range
, 0, start
, stop
, from_tty
);
2118 /* tfind outside command */
2120 trace_find_outside_command (char *args
, int from_tty
)
2122 CORE_ADDR start
, stop
;
2123 char start_str
[40], stop_str
[40];
2126 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2127 error ("May not look at trace frames while trace is running.");
2129 if (args
== 0 || *args
== 0)
2130 { /* XXX FIXME: what should default behavior be? */
2131 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2135 if (0 != (tmp
= strchr (args
, ',')))
2137 *tmp
++ = '\0'; /* terminate start address */
2138 while (isspace ((int) *tmp
))
2140 start
= parse_and_eval_address (args
);
2141 stop
= parse_and_eval_address (tmp
);
2144 { /* no explicit end address? */
2145 start
= parse_and_eval_address (args
);
2146 stop
= start
+ 1; /* ??? */
2149 tfind_1 (tfind_outside
, 0, start
, stop
, from_tty
);
2152 /* info scope command: list the locals for a scope. */
2154 scope_info (char *args
, int from_tty
)
2156 struct symtabs_and_lines sals
;
2158 struct minimal_symbol
*msym
;
2159 struct block
*block
;
2160 char **canonical
, *symname
, *save_args
= args
;
2161 struct dict_iterator iter
;
2163 struct gdbarch
*gdbarch
;
2166 if (args
== 0 || *args
== 0)
2167 error (_("requires an argument (function, line or *addr) to define a scope"));
2169 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2170 if (sals
.nelts
== 0)
2171 return; /* presumably decode_line_1 has already warned */
2173 /* Resolve line numbers to PC */
2174 resolve_sal_pc (&sals
.sals
[0]);
2175 block
= block_for_pc (sals
.sals
[0].pc
);
2179 QUIT
; /* allow user to bail out with ^C */
2180 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2182 QUIT
; /* allow user to bail out with ^C */
2184 printf_filtered ("Scope for %s:\n", save_args
);
2187 symname
= SYMBOL_PRINT_NAME (sym
);
2188 if (symname
== NULL
|| *symname
== '\0')
2189 continue; /* probably botched, certainly useless */
2191 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2193 printf_filtered ("Symbol %s is ", symname
);
2194 switch (SYMBOL_CLASS (sym
))
2197 case LOC_UNDEF
: /* messed up symbol? */
2198 printf_filtered ("a bogus symbol, class %d.\n",
2199 SYMBOL_CLASS (sym
));
2200 count
--; /* don't count this one */
2203 printf_filtered ("a constant with value %ld (0x%lx)",
2204 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2206 case LOC_CONST_BYTES
:
2207 printf_filtered ("constant bytes: ");
2208 if (SYMBOL_TYPE (sym
))
2209 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2210 fprintf_filtered (gdb_stdout
, " %02x",
2211 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2214 printf_filtered ("in static storage at address ");
2215 printf_filtered ("%s", paddress (gdbarch
,
2216 SYMBOL_VALUE_ADDRESS (sym
)));
2219 /* GDBARCH is the architecture associated with the objfile
2220 the symbol is defined in; the target architecture may be
2221 different, and may provide additional registers. However,
2222 we do not know the target architecture at this point.
2223 We assume the objfile architecture will contain all the
2224 standard registers that occur in debug info in that
2226 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2228 if (SYMBOL_IS_ARGUMENT (sym
))
2229 printf_filtered ("an argument in register $%s",
2230 gdbarch_register_name (gdbarch
, regno
));
2232 printf_filtered ("a local variable in register $%s",
2233 gdbarch_register_name (gdbarch
, regno
));
2236 printf_filtered ("an argument at stack/frame offset %ld",
2237 SYMBOL_VALUE (sym
));
2240 printf_filtered ("a local variable at frame offset %ld",
2241 SYMBOL_VALUE (sym
));
2244 printf_filtered ("a reference argument at offset %ld",
2245 SYMBOL_VALUE (sym
));
2247 case LOC_REGPARM_ADDR
:
2248 /* Note comment at LOC_REGISTER. */
2249 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2250 printf_filtered ("the address of an argument, in register $%s",
2251 gdbarch_register_name (gdbarch
, regno
));
2254 printf_filtered ("a typedef.\n");
2257 printf_filtered ("a label at address ");
2258 printf_filtered ("%s", paddress (gdbarch
,
2259 SYMBOL_VALUE_ADDRESS (sym
)));
2262 printf_filtered ("a function at address ");
2263 printf_filtered ("%s",
2264 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2266 case LOC_UNRESOLVED
:
2267 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2270 printf_filtered ("Unresolved Static");
2273 printf_filtered ("static storage at address ");
2274 printf_filtered ("%s",
2275 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2278 case LOC_OPTIMIZED_OUT
:
2279 printf_filtered ("optimized out.\n");
2282 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, gdb_stdout
);
2285 if (SYMBOL_TYPE (sym
))
2286 printf_filtered (", length %d.\n",
2287 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2289 if (BLOCK_FUNCTION (block
))
2292 block
= BLOCK_SUPERBLOCK (block
);
2295 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2299 /* worker function (cleanup) */
2301 replace_comma (void *data
)
2309 trace_dump_command (char *args
, int from_tty
)
2311 struct regcache
*regcache
;
2312 struct gdbarch
*gdbarch
;
2313 struct breakpoint
*t
;
2314 struct command_line
*action
;
2315 char *action_exp
, *next_comma
;
2316 struct cleanup
*old_cleanups
;
2317 int stepping_actions
= 0;
2318 int stepping_frame
= 0;
2319 struct bp_location
*loc
;
2321 if (tracepoint_number
== -1)
2323 warning (_("No current trace frame."));
2327 t
= get_tracepoint (tracepoint_number
);
2330 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2333 old_cleanups
= make_cleanup (null_cleanup
, NULL
);
2335 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2336 tracepoint_number
, traceframe_number
);
2338 /* The current frame is a trap frame if the frame PC is equal
2339 to the tracepoint PC. If not, then the current frame was
2340 collected during single-stepping. */
2342 regcache
= get_current_regcache ();
2343 gdbarch
= get_regcache_arch (regcache
);
2345 /* If the traceframe's address matches any of the tracepoint's
2346 locations, assume it is a direct hit rather than a while-stepping
2347 frame. (FIXME this is not reliable, should record each frame's
2350 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2351 if (loc
->address
== regcache_read_pc (regcache
))
2354 for (action
= t
->commands
->commands
; action
; action
= action
->next
)
2356 struct cmd_list_element
*cmd
;
2358 QUIT
; /* allow user to bail out with ^C */
2359 action_exp
= action
->line
;
2360 while (isspace ((int) *action_exp
))
2363 /* The collection actions to be done while stepping are
2364 bracketed by the commands "while-stepping" and "end". */
2366 if (*action_exp
== '#') /* comment line */
2369 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2371 error (_("Bad action list item: %s"), action_exp
);
2373 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2374 stepping_actions
= 1;
2375 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2376 stepping_actions
= 0;
2377 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2379 /* Display the collected data.
2380 For the trap frame, display only what was collected at
2381 the trap. Likewise for stepping frames, display only
2382 what was collected while stepping. This means that the
2383 two boolean variables, STEPPING_FRAME and
2384 STEPPING_ACTIONS should be equal. */
2385 if (stepping_frame
== stepping_actions
)
2388 { /* repeat over a comma-separated list */
2389 QUIT
; /* allow user to bail out with ^C */
2390 if (*action_exp
== ',')
2392 while (isspace ((int) *action_exp
))
2395 next_comma
= strchr (action_exp
, ',');
2397 if (0 == strncasecmp (action_exp
, "$reg", 4))
2398 registers_info (NULL
, from_tty
);
2399 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2400 locals_info (NULL
, from_tty
);
2401 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2402 args_info (NULL
, from_tty
);
2407 make_cleanup (replace_comma
, next_comma
);
2410 printf_filtered ("%s = ", action_exp
);
2411 output_command (action_exp
, from_tty
);
2412 printf_filtered ("\n");
2416 action_exp
= next_comma
;
2418 while (action_exp
&& *action_exp
== ',');
2422 discard_cleanups (old_cleanups
);
2425 extern int trace_regblock_size
;
2427 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2428 non-zero, the save is performed on the target, otherwise GDB obtains all
2429 trace data and saves it locally. */
2432 trace_save (const char *filename
, int target_does_save
)
2434 struct cleanup
*cleanup
;
2436 struct trace_status
*ts
= current_trace_status ();
2439 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2440 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2443 ULONGEST offset
= 0;
2444 #define MAX_TRACE_UPLOAD 2000
2445 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2448 /* If the target is to save the data to a file on its own, then just
2449 send the command and be done with it. */
2450 if (target_does_save
)
2452 err
= target_save_trace_data (filename
);
2454 error (_("Target failed to save trace data to '%s'."),
2459 /* Get the trace status first before opening the file, so if the
2460 target is losing, we can get out without touching files. */
2461 status
= target_get_trace_status (ts
);
2463 pathname
= tilde_expand (filename
);
2464 cleanup
= make_cleanup (xfree
, pathname
);
2466 fp
= fopen (pathname
, "w");
2468 error (_("Unable to open file '%s' for saving trace data (%s)"),
2469 filename
, safe_strerror (errno
));
2470 make_cleanup_fclose (fp
);
2472 /* Write a file header, with a high-bit-set char to indicate a
2473 binary file, plus a hint as what this file is, and a version
2474 number in case of future needs. */
2475 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2477 perror_with_name (pathname
);
2479 /* Write descriptive info. */
2481 /* Write out the size of a register block. */
2482 fprintf (fp
, "R %x\n", trace_regblock_size
);
2484 /* Write out status of the tracing run (aka "tstatus" info). */
2485 fprintf (fp
, "status %c;%s",
2486 (ts
->running
? '1' : '0'), stop_reason_names
[ts
->stop_reason
]);
2487 /* Encode the error message in hex, might have weird chars. */
2488 if (ts
->stop_reason
== tracepoint_error
)
2490 char *buf
= (char *) alloca (strlen (ts
->error_desc
) * 2 + 1);
2491 bin2hex ((gdb_byte
*) ts
->error_desc
, buf
, 0);
2492 fprintf (fp
, ":X%s", buf
);
2494 fprintf (fp
, ":%x", ts
->stopping_tracepoint
);
2495 if (ts
->traceframe_count
>= 0)
2496 fprintf (fp
, ";tframes:%x", ts
->traceframe_count
);
2497 if (ts
->traceframes_created
>= 0)
2498 fprintf (fp
, ";tcreated:%x", ts
->traceframes_created
);
2499 if (ts
->buffer_free
>= 0)
2500 fprintf (fp
, ";tfree:%x", ts
->buffer_free
);
2501 if (ts
->buffer_size
>= 0)
2502 fprintf (fp
, ";tsize:%x", ts
->buffer_size
);
2505 /* Note that we want to upload tracepoints and save those, rather
2506 than simply writing out the local ones, because the user may have
2507 changed tracepoints in GDB in preparation for a future tracing
2508 run, or maybe just mass-deleted all types of breakpoints as part
2509 of cleaning up. So as not to contaminate the session, leave the
2510 data in its uploaded form, don't make into real tracepoints. */
2512 /* Get trace state variables first, they may be checked when parsing
2513 uploaded commands. */
2515 target_upload_trace_state_variables (&uploaded_tsvs
);
2517 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2523 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
2524 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
2527 fprintf (fp
, "tsv %x:%s:%x:%s\n",
2528 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
2529 utsv
->builtin
, buf
);
2535 free_uploaded_tsvs (&uploaded_tsvs
);
2537 target_upload_tracepoints (&uploaded_tps
);
2539 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
2541 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
2542 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2543 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
2544 if (utp
->type
== bp_fast_tracepoint
)
2545 fprintf (fp
, ":F%x", utp
->orig_size
);
2547 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
2550 for (a
= 0; a
< utp
->numactions
; ++a
)
2551 fprintf (fp
, "tp A%x:%s:%s\n",
2552 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2554 for (a
= 0; a
< utp
->num_step_actions
; ++a
)
2555 fprintf (fp
, "tp S%x:%s:%s\n",
2556 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2557 utp
->step_actions
[a
]);
2560 free_uploaded_tps (&uploaded_tps
);
2562 /* Mark the end of the definition section. */
2565 /* Get and write the trace data proper. We ask for big blocks, in
2566 the hopes of efficiency, but will take less if the target has
2567 packet size limitations or some such. */
2570 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
2572 error (_("Failure to get requested trace buffer data"));
2573 /* No more data is forthcoming, we're done. */
2576 written
= fwrite (buf
, gotten
, 1, fp
);
2577 if (written
< gotten
)
2578 perror_with_name (pathname
);
2582 /* Mark the end of trace data. */
2583 written
= fwrite (&gotten
, 4, 1, fp
);
2585 perror_with_name (pathname
);
2587 do_cleanups (cleanup
);
2591 trace_save_command (char *args
, int from_tty
)
2593 int target_does_save
= 0;
2595 char *filename
= NULL
;
2596 struct cleanup
*back_to
;
2599 error_no_arg (_("file in which to save trace data"));
2601 argv
= gdb_buildargv (args
);
2602 back_to
= make_cleanup_freeargv (argv
);
2604 for (; *argv
; ++argv
)
2606 if (strcmp (*argv
, "-r") == 0)
2607 target_does_save
= 1;
2608 else if (**argv
== '-')
2609 error (_("unknown option `%s'"), *argv
);
2615 error_no_arg (_("file in which to save trace data"));
2617 trace_save (filename
, target_does_save
);
2620 printf_filtered (_("Trace data saved to file '%s'.\n"), args
);
2622 do_cleanups (back_to
);
2625 /* Tell the target what to do with an ongoing tracing run if GDB
2626 disconnects for some reason. */
2629 send_disconnected_tracing_value (int value
)
2631 target_set_disconnected_tracing (value
);
2635 set_disconnected_tracing (char *args
, int from_tty
,
2636 struct cmd_list_element
*c
)
2638 send_disconnected_tracing_value (disconnected_tracing
);
2642 set_circular_trace_buffer (char *args
, int from_tty
,
2643 struct cmd_list_element
*c
)
2645 target_set_circular_trace_buffer (circular_trace_buffer
);
2648 /* Convert the memory pointed to by mem into hex, placing result in buf.
2649 * Return a pointer to the last char put in buf (null)
2650 * "stolen" from sparc-stub.c
2653 static const char hexchars
[] = "0123456789abcdef";
2656 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2664 *buf
++ = hexchars
[ch
>> 4];
2665 *buf
++ = hexchars
[ch
& 0xf];
2674 get_traceframe_number (void)
2676 return traceframe_number
;
2679 /* Make the traceframe NUM be the current trace frame. Does nothing
2680 if NUM is already current. */
2683 set_traceframe_number (int num
)
2687 if (traceframe_number
== num
)
2689 /* Nothing to do. */
2693 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
2696 warning (_("could not change traceframe"));
2698 traceframe_number
= newnum
;
2700 /* Changing the traceframe changes our view of registers and of the
2702 registers_changed ();
2705 /* A cleanup used when switching away and back from tfind mode. */
2707 struct current_traceframe_cleanup
2709 /* The traceframe we were inspecting. */
2710 int traceframe_number
;
2714 do_restore_current_traceframe_cleanup (void *arg
)
2716 struct current_traceframe_cleanup
*old
= arg
;
2718 set_traceframe_number (old
->traceframe_number
);
2722 restore_current_traceframe_cleanup_dtor (void *arg
)
2724 struct current_traceframe_cleanup
*old
= arg
;
2730 make_cleanup_restore_current_traceframe (void)
2732 struct current_traceframe_cleanup
*old
;
2734 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
2735 old
->traceframe_number
= traceframe_number
;
2737 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
2738 restore_current_traceframe_cleanup_dtor
);
2741 /* Given a number and address, return an uploaded tracepoint with that
2742 number, creating if necessary. */
2744 struct uploaded_tp
*
2745 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
2747 struct uploaded_tp
*utp
;
2749 for (utp
= *utpp
; utp
; utp
= utp
->next
)
2750 if (utp
->number
== num
&& utp
->addr
== addr
)
2752 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
2753 memset (utp
, 0, sizeof (struct uploaded_tp
));
2762 free_uploaded_tps (struct uploaded_tp
**utpp
)
2764 struct uploaded_tp
*next_one
;
2768 next_one
= (*utpp
)->next
;
2774 /* Given a number and address, return an uploaded tracepoint with that
2775 number, creating if necessary. */
2777 struct uploaded_tsv
*
2778 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
2780 struct uploaded_tsv
*utsv
;
2782 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
2783 if (utsv
->number
== num
)
2785 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
2786 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
2788 utsv
->next
= *utsvp
;
2794 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
2796 struct uploaded_tsv
*next_one
;
2800 next_one
= (*utsvp
)->next
;
2806 /* Look for an existing tracepoint that seems similar enough to the
2807 uploaded one. Enablement isn't compared, because the user can
2808 toggle that freely, and may have done so in anticipation of the
2812 find_matching_tracepoint (struct uploaded_tp
*utp
)
2814 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
2816 struct breakpoint
*t
;
2817 struct bp_location
*loc
;
2819 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2821 if (t
->type
== utp
->type
2822 && t
->step_count
== utp
->step
2823 && t
->pass_count
== utp
->pass
2824 /* FIXME also test conditionals and actions */
2827 /* Scan the locations for an address match. */
2828 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2830 if (loc
->address
== utp
->addr
)
2838 /* Given a list of tracepoints uploaded from a target, attempt to
2839 match them up with existing tracepoints, and create new ones if not
2843 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
2845 struct uploaded_tp
*utp
;
2846 struct breakpoint
*t
;
2848 /* Look for GDB tracepoints that match up with our uploaded versions. */
2849 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
2851 t
= find_matching_tracepoint (utp
);
2853 printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
2854 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2857 t
= create_tracepoint_from_upload (utp
);
2859 printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
2860 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2862 printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
2863 utp
->number
, paddress (get_current_arch (), utp
->addr
));
2865 /* Whether found or created, record the number used by the
2866 target, to help with mapping target tracepoints back to their
2867 counterparts here. */
2869 t
->number_on_target
= utp
->number
;
2872 free_uploaded_tps (uploaded_tps
);
2875 /* Trace state variables don't have much to identify them beyond their
2876 name, so just use that to detect matches. */
2878 struct trace_state_variable
*
2879 find_matching_tsv (struct uploaded_tsv
*utsv
)
2884 return find_trace_state_variable (utsv
->name
);
2887 struct trace_state_variable
*
2888 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
2890 const char *namebase
;
2893 struct trace_state_variable
*tsv
;
2897 namebase
= utsv
->name
;
2898 sprintf (buf
, "%s", namebase
);
2903 sprintf (buf
, "%s_%d", namebase
, try_num
++);
2906 /* Fish for a name that is not in use. */
2907 /* (should check against all internal vars?) */
2908 while (find_trace_state_variable (buf
))
2909 sprintf (buf
, "%s_%d", namebase
, try_num
++);
2911 /* We have an available name, create the variable. */
2912 tsv
= create_trace_state_variable (xstrdup (buf
));
2913 tsv
->initial_value
= utsv
->initial_value
;
2914 tsv
->builtin
= utsv
->builtin
;
2919 /* Given a list of uploaded trace state variables, try to match them
2920 up with existing variables, or create additional ones. */
2923 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
2926 struct uploaded_tsv
*utsv
;
2927 struct trace_state_variable
*tsv
;
2930 /* Most likely some numbers will have to be reassigned as part of
2931 the merge, so clear them all in anticipation. */
2932 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2935 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2937 tsv
= find_matching_tsv (utsv
);
2939 printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
2940 tsv
->name
, utsv
->number
);
2943 tsv
= create_tsv_from_upload (utsv
);
2944 printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
2945 tsv
->name
, utsv
->number
);
2947 /* Give precedence to numberings that come from the target. */
2949 tsv
->number
= utsv
->number
;
2952 /* Renumber everything that didn't get a target-assigned number. */
2954 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2955 if (tsv
->number
> highest
)
2956 highest
= tsv
->number
;
2959 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2960 if (tsv
->number
== 0)
2961 tsv
->number
= highest
++;
2963 free_uploaded_tsvs (uploaded_tsvs
);
2966 /* target tfile command */
2968 struct target_ops tfile_ops
;
2970 /* Fill in tfile_ops with its defined operations and properties. */
2972 #define TRACE_HEADER_SIZE 8
2974 char *trace_filename
;
2976 off_t trace_frames_offset
;
2979 int trace_regblock_size
;
2981 static void tfile_interp_line (char *line
,
2982 struct uploaded_tp
**utpp
,
2983 struct uploaded_tsv
**utsvp
);
2986 tfile_open (char *filename
, int from_tty
)
2989 struct cleanup
*old_chain
;
2992 char header
[TRACE_HEADER_SIZE
];
2993 char linebuf
[1000]; /* should be max remote packet size or so */
2995 int bytes
, i
, gotten
;
2996 struct trace_status
*ts
;
2997 struct uploaded_tp
*uploaded_tps
= NULL
;
2998 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
3000 target_preopen (from_tty
);
3002 error (_("No trace file specified."));
3004 filename
= tilde_expand (filename
);
3005 if (!IS_ABSOLUTE_PATH(filename
))
3007 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
3012 old_chain
= make_cleanup (xfree
, filename
);
3014 flags
= O_BINARY
| O_LARGEFILE
;
3016 scratch_chan
= open (filename
, flags
, 0);
3017 if (scratch_chan
< 0)
3018 perror_with_name (filename
);
3020 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3022 discard_cleanups (old_chain
); /* Don't free filename any more */
3023 unpush_target (&tfile_ops
);
3025 push_target (&tfile_ops
);
3027 trace_filename
= xstrdup (filename
);
3028 trace_fd
= scratch_chan
;
3031 /* Read the file header and test for validity. */
3032 gotten
= read (trace_fd
, &header
, TRACE_HEADER_SIZE
);
3034 perror_with_name (trace_filename
);
3035 else if (gotten
< TRACE_HEADER_SIZE
)
3036 error (_("Premature end of file while reading trace file"));
3038 bytes
+= TRACE_HEADER_SIZE
;
3039 if (!(header
[0] == 0x7f
3040 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
3041 error (_("File is not a valid trace file."));
3043 trace_regblock_size
= 0;
3044 ts
= current_trace_status ();
3045 /* We know we're working with a file. */
3047 /* Set defaults in case there is no status line. */
3048 ts
->running_known
= 0;
3049 ts
->stop_reason
= trace_stop_reason_unknown
;
3050 ts
->traceframe_count
= -1;
3051 ts
->buffer_free
= 0;
3053 /* Read through a section of newline-terminated lines that
3054 define things like tracepoints. */
3058 gotten
= read (trace_fd
, &byte
, 1);
3060 perror_with_name (trace_filename
);
3061 else if (gotten
< 1)
3062 error (_("Premature end of file while reading trace file"));
3067 /* Empty line marks end of the definition section. */
3072 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
3075 linebuf
[i
++] = byte
;
3077 error (_("Excessively long lines in trace file"));
3080 /* Add the file's tracepoints and variables into the current mix. */
3082 /* Get trace state variables first, they may be checked when parsing
3083 uploaded commands. */
3084 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
3086 merge_uploaded_tracepoints (&uploaded_tps
);
3088 /* Record the starting offset of the binary trace data. */
3089 trace_frames_offset
= bytes
;
3091 /* If we don't have a blocksize, we can't interpret the
3093 if (trace_regblock_size
== 0)
3094 error (_("No register block size recorded in trace file"));
3095 if (ts
->traceframe_count
<= 0)
3097 warning ("No traceframes present in this file.");
3101 #define TFILE_PID (1)
3102 inferior_appeared (current_inferior (), TFILE_PID
);
3103 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3104 add_thread_silent (inferior_ptid
);
3106 post_create_inferior (&tfile_ops
, from_tty
);
3109 /* FIXME this will get defined in MI patch submission */
3110 tfind_1 (tfind_number
, 0, 0, 0, 0);
3114 /* Interpret the given line from the definitions part of the trace
3118 tfile_interp_line (char *line
,
3119 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3123 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3126 trace_regblock_size
= strtol (p
, &p
, 16);
3128 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3130 p
+= strlen ("status ");
3131 parse_trace_status (p
, current_trace_status ());
3133 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3135 p
+= strlen ("tp ");
3136 parse_tracepoint_definition (p
, utpp
);
3138 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3140 p
+= strlen ("tsv ");
3141 parse_tsv_definition (p
, utsvp
);
3144 warning ("Ignoring trace file definition \"%s\"", line
);
3147 /* Parse the part of trace status syntax that is shared between
3148 the remote protocol and the trace file reader. */
3150 extern char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
3153 parse_trace_status (char *line
, struct trace_status
*ts
)
3155 char *p
= line
, *p1
, *p2
, *p_temp
;
3158 ts
->running_known
= 1;
3159 ts
->running
= (*p
++ == '1');
3160 ts
->stop_reason
= trace_stop_reason_unknown
;
3161 ts
->error_desc
= "";
3162 ts
->traceframe_count
= -1;
3163 ts
->traceframes_created
= -1;
3164 ts
->buffer_free
= -1;
3165 ts
->buffer_size
= -1;
3169 p1
= strchr (p
, ':');
3171 error (_("Malformed trace status, at %s\n\
3172 Status line: '%s'\n"), p
, line
);
3173 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3175 p
= unpack_varlen_hex (++p1
, &val
);
3176 ts
->stop_reason
= trace_buffer_full
;
3178 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3180 p
= unpack_varlen_hex (++p1
, &val
);
3181 ts
->stop_reason
= trace_never_run
;
3183 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
], p1
- p
) == 0)
3185 p
= unpack_varlen_hex (++p1
, &val
);
3186 ts
->stop_reason
= tracepoint_passcount
;
3187 ts
->stopping_tracepoint
= val
;
3189 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3191 p
= unpack_varlen_hex (++p1
, &val
);
3192 ts
->stop_reason
= tstop_command
;
3194 else if (strncmp (p
, stop_reason_names
[tracepoint_error
], p1
- p
) == 0)
3196 p2
= strchr (++p1
, ':');
3200 ts
->error_desc
= (char *) xmalloc (p2
- p1
+ 1);
3201 /* See if we're doing plain text or hex encoding. */
3205 end
= hex2bin (p1
, ts
->error_desc
, (p2
- p1
) / 2);
3209 memcpy (ts
->error_desc
, p1
, p2
- p1
);
3212 ts
->error_desc
[end
] = '\0';
3214 p
= unpack_varlen_hex (++p2
, &val
);
3215 ts
->stopping_tracepoint
= val
;
3216 ts
->stop_reason
= tracepoint_error
;
3218 else if (strncmp (p
, "tframes", p1
- p
) == 0)
3220 p
= unpack_varlen_hex (++p1
, &val
);
3221 ts
->traceframe_count
= val
;
3223 else if (strncmp (p
, "tcreated", p1
- p
) == 0)
3225 p
= unpack_varlen_hex (++p1
, &val
);
3226 ts
->traceframes_created
= val
;
3228 else if (strncmp (p
, "tfree", p1
- p
) == 0)
3230 p
= unpack_varlen_hex (++p1
, &val
);
3231 ts
->buffer_free
= val
;
3233 else if (strncmp (p
, "tsize", p1
- p
) == 0)
3235 p
= unpack_varlen_hex (++p1
, &val
);
3236 ts
->buffer_size
= val
;
3240 /* Silently skip unknown optional info. */
3241 p_temp
= strchr (p1
+ 1, ';');
3245 /* Must be at the end. */
3251 /* Given a line of text defining a tracepoint or tracepoint action, parse
3252 it into an "uploaded tracepoint". */
3255 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3259 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
;
3263 struct uploaded_tp
*utp
= NULL
;
3266 /* Both tracepoint and action definitions start with the same number
3267 and address sequence. */
3269 p
= unpack_varlen_hex (p
, &num
);
3270 p
++; /* skip a colon */
3271 p
= unpack_varlen_hex (p
, &addr
);
3272 p
++; /* skip a colon */
3275 enabled
= (*p
++ == 'E');
3276 p
++; /* skip a colon */
3277 p
= unpack_varlen_hex (p
, &step
);
3278 p
++; /* skip a colon */
3279 p
= unpack_varlen_hex (p
, &pass
);
3280 type
= bp_tracepoint
;
3282 /* Thumb through optional fields. */
3285 p
++; /* skip a colon */
3288 type
= bp_fast_tracepoint
;
3290 p
= unpack_varlen_hex (p
, &orig_size
);
3295 p
= unpack_varlen_hex (p
, &xlen
);
3296 p
++; /* skip a comma */
3297 cond
= (char *) xmalloc (2 * xlen
+ 1);
3298 strncpy (cond
, p
, 2 * xlen
);
3299 cond
[2 * xlen
] = '\0';
3303 warning ("Unrecognized char '%c' in tracepoint definition, skipping rest", *p
);
3305 utp
= get_uploaded_tp (num
, addr
, utpp
);
3307 utp
->enabled
= enabled
;
3312 else if (piece
== 'A')
3314 utp
= get_uploaded_tp (num
, addr
, utpp
);
3315 utp
->actions
[utp
->numactions
++] = xstrdup (p
);
3317 else if (piece
== 'S')
3319 utp
= get_uploaded_tp (num
, addr
, utpp
);
3320 utp
->step_actions
[utp
->num_step_actions
++] = xstrdup (p
);
3324 error ("Invalid tracepoint piece");
3328 /* Convert a textual description of a trace state variable into an
3332 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3335 ULONGEST num
, initval
, builtin
;
3337 struct uploaded_tsv
*utsv
= NULL
;
3339 buf
= alloca (strlen (line
));
3342 p
= unpack_varlen_hex (p
, &num
);
3343 p
++; /* skip a colon */
3344 p
= unpack_varlen_hex (p
, &initval
);
3345 p
++; /* skip a colon */
3346 p
= unpack_varlen_hex (p
, &builtin
);
3347 p
++; /* skip a colon */
3348 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3351 utsv
= get_uploaded_tsv (num
, utsvp
);
3352 utsv
->initial_value
= initval
;
3353 utsv
->builtin
= builtin
;
3354 utsv
->name
= xstrdup (buf
);
3357 /* Close the trace file and generally clean up. */
3360 tfile_close (int quitting
)
3367 pid
= ptid_get_pid (inferior_ptid
);
3368 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
3369 exit_inferior_silent (pid
);
3374 xfree (trace_filename
);
3378 tfile_files_info (struct target_ops
*t
)
3380 /* (it would be useful to mention the name of the file) */
3381 printf_filtered ("Looking at a trace file.\n");
3384 /* The trace status for a file is that tracing can never be run. */
3387 tfile_get_trace_status (struct trace_status
*ts
)
3389 /* Other bits of trace status were collected as part of opening the
3390 trace files, so nothing to do here. */
3395 /* Given the position of a traceframe in the file, figure out what
3396 address the frame was collected at. This would normally be the
3397 value of a collected PC register, but if not available, we
3401 tfile_get_traceframe_address (off_t tframe_offset
)
3405 struct breakpoint
*tp
;
3406 off_t saved_offset
= cur_offset
;
3409 /* FIXME dig pc out of collected registers */
3411 /* Fall back to using tracepoint address. */
3412 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
3413 gotten
= read (trace_fd
, &tpnum
, 2);
3415 perror_with_name (trace_filename
);
3416 else if (gotten
< 2)
3417 error (_("Premature end of file while reading trace file"));
3419 tp
= get_tracepoint_by_number_on_target (tpnum
);
3420 /* FIXME this is a poor heuristic if multiple locations */
3422 addr
= tp
->loc
->address
;
3424 /* Restore our seek position. */
3425 cur_offset
= saved_offset
;
3426 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3430 /* Given a type of search and some parameters, scan the collection of
3431 traceframes in the file looking for a match. When found, return
3432 both the traceframe and tracepoint number, otherwise -1 for
3436 tfile_trace_find (enum trace_find_type type
, int num
,
3437 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
3440 int tfnum
= 0, found
= 0, gotten
;
3442 struct breakpoint
*tp
;
3443 off_t offset
, tframe_offset
;
3446 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
3447 offset
= trace_frames_offset
;
3450 tframe_offset
= offset
;
3451 gotten
= read (trace_fd
, &tpnum
, 2);
3453 perror_with_name (trace_filename
);
3454 else if (gotten
< 2)
3455 error (_("Premature end of file while reading trace file"));
3459 gotten
= read (trace_fd
, &data_size
, 4);
3461 perror_with_name (trace_filename
);
3462 else if (gotten
< 4)
3463 error (_("Premature end of file while reading trace file"));
3472 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3473 if (tfaddr
== addr1
)
3477 tp
= get_tracepoint (num
);
3478 if (tp
&& tpnum
== tp
->number_on_target
)
3482 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3483 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
3487 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3488 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
3492 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
3498 cur_offset
= offset
;
3499 cur_data_size
= data_size
;
3502 /* Skip past the traceframe's data. */
3503 lseek (trace_fd
, data_size
, SEEK_CUR
);
3504 offset
+= data_size
;
3505 /* Update our own count of traceframes. */
3508 /* Did not find what we were looking for. */
3514 /* Look for a block of saved registers in the traceframe, and get the
3515 requested register from it. */
3518 tfile_fetch_registers (struct target_ops
*ops
,
3519 struct regcache
*regcache
, int regno
)
3521 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3523 int i
, pos
, offset
, regn
, regsize
, gotten
;
3524 unsigned short mlen
;
3527 /* An uninitialized reg size says we're not going to be
3528 successful at getting register blocks. */
3529 if (!trace_regblock_size
)
3532 regs
= alloca (trace_regblock_size
);
3534 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3536 while (pos
< cur_data_size
)
3538 gotten
= read (trace_fd
, &block_type
, 1);
3540 perror_with_name (trace_filename
);
3541 else if (gotten
< 1)
3542 error (_("Premature end of file while reading trace file"));
3548 gotten
= read (trace_fd
, regs
, trace_regblock_size
);
3550 perror_with_name (trace_filename
);
3551 else if (gotten
< trace_regblock_size
)
3552 error (_("Premature end of file while reading trace file"));
3554 /* Assume the block is laid out in GDB register number order,
3555 each register with the size that it has in GDB. */
3557 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3559 regsize
= register_size (gdbarch
, regn
);
3560 /* Make sure we stay within block bounds. */
3561 if (offset
+ regsize
>= trace_regblock_size
)
3563 if (!regcache_valid_p (regcache
, regn
))
3567 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
3570 else if (regno
== -1)
3572 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
3579 lseek (trace_fd
, 8, SEEK_CUR
);
3580 gotten
= read (trace_fd
, &mlen
, 2);
3582 perror_with_name (trace_filename
);
3583 else if (gotten
< 2)
3584 error (_("Premature end of file while reading trace file"));
3585 lseek (trace_fd
, mlen
, SEEK_CUR
);
3586 pos
+= (8 + 2 + mlen
);
3589 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3593 error ("Unknown block type '%c' (0x%x) in trace frame",
3594 block_type
, block_type
);
3601 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3602 const char *annex
, gdb_byte
*readbuf
,
3603 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3608 unsigned short mlen
;
3610 /* We're only doing regular memory for now. */
3611 if (object
!= TARGET_OBJECT_MEMORY
)
3614 if (readbuf
== NULL
)
3615 error ("tfile_xfer_partial: trace file is read-only");
3617 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3619 while (pos
< cur_data_size
)
3621 gotten
= read (trace_fd
, &block_type
, 1);
3623 perror_with_name (trace_filename
);
3624 else if (gotten
< 1)
3625 error (_("Premature end of file while reading trace file"));
3630 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3631 pos
+= trace_regblock_size
;
3634 gotten
= read (trace_fd
, &maddr
, 8);
3636 perror_with_name (trace_filename
);
3637 else if (gotten
< 8)
3638 error (_("Premature end of file while reading trace file"));
3640 gotten
= read (trace_fd
, &mlen
, 2);
3642 perror_with_name (trace_filename
);
3643 else if (gotten
< 2)
3644 error (_("Premature end of file while reading trace file"));
3645 if (maddr
<= offset
&& (offset
+ len
) <= (maddr
+ mlen
))
3647 gotten
= read (trace_fd
, readbuf
, mlen
);
3649 perror_with_name (trace_filename
);
3650 else if (gotten
< mlen
)
3651 error (_("Premature end of file qwhile reading trace file"));
3655 lseek (trace_fd
, mlen
, SEEK_CUR
);
3656 pos
+= (8 + 2 + mlen
);
3659 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3663 error ("Unknown block type '%c' (0x%x) in traceframe",
3664 block_type
, block_type
);
3668 /* Indicate failure to find the requested memory block. */
3672 /* Iterate through the blocks of a trace frame, looking for a 'V'
3673 block with a matching tsv number. */
3676 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
3679 int pos
, vnum
, gotten
;
3680 unsigned short mlen
;
3682 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3684 while (pos
< cur_data_size
)
3686 gotten
= read (trace_fd
, &block_type
, 1);
3688 perror_with_name (trace_filename
);
3689 else if (gotten
< 1)
3690 error (_("Premature end of file while reading trace file"));
3695 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3696 pos
+= trace_regblock_size
;
3699 lseek (trace_fd
, 8, SEEK_CUR
);
3700 gotten
= read (trace_fd
, &mlen
, 2);
3702 perror_with_name (trace_filename
);
3703 else if (gotten
< 2)
3704 error (_("Premature end of file while reading trace file"));
3705 lseek (trace_fd
, mlen
, SEEK_CUR
);
3706 pos
+= (8 + 2 + mlen
);
3709 gotten
= read (trace_fd
, &vnum
, 4);
3711 perror_with_name (trace_filename
);
3712 else if (gotten
< 4)
3713 error (_("Premature end of file while reading trace file"));
3716 gotten
= read (trace_fd
, val
, 8);
3718 perror_with_name (trace_filename
);
3719 else if (gotten
< 8)
3720 error (_("Premature end of file while reading trace file"));
3723 lseek (trace_fd
, 8, SEEK_CUR
);
3727 error ("Unknown block type '%c' (0x%x) in traceframe",
3728 block_type
, block_type
);
3732 /* Didn't find anything. */
3737 tfile_has_memory (struct target_ops
*ops
)
3743 tfile_has_stack (struct target_ops
*ops
)
3749 tfile_has_registers (struct target_ops
*ops
)
3755 init_tfile_ops (void)
3757 tfile_ops
.to_shortname
= "tfile";
3758 tfile_ops
.to_longname
= "Local trace dump file";
3760 "Use a trace file as a target. Specify the filename of the trace file.";
3761 tfile_ops
.to_open
= tfile_open
;
3762 tfile_ops
.to_close
= tfile_close
;
3763 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
3764 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
3765 tfile_ops
.to_files_info
= tfile_files_info
;
3766 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
3767 tfile_ops
.to_trace_find
= tfile_trace_find
;
3768 tfile_ops
.to_get_trace_state_variable_value
= tfile_get_trace_state_variable_value
;
3769 /* core_stratum might seem more logical, but GDB doesn't like having
3770 more than one core_stratum vector. */
3771 tfile_ops
.to_stratum
= process_stratum
;
3772 tfile_ops
.to_has_memory
= tfile_has_memory
;
3773 tfile_ops
.to_has_stack
= tfile_has_stack
;
3774 tfile_ops
.to_has_registers
= tfile_has_registers
;
3775 tfile_ops
.to_magic
= OPS_MAGIC
;
3778 /* module initialization */
3780 _initialize_tracepoint (void)
3782 struct cmd_list_element
*c
;
3784 traceframe_number
= -1;
3785 tracepoint_number
= -1;
3787 if (tracepoint_list
.list
== NULL
)
3789 tracepoint_list
.listsize
= 128;
3790 tracepoint_list
.list
= xmalloc
3791 (tracepoint_list
.listsize
* sizeof (struct memrange
));
3793 if (tracepoint_list
.aexpr_list
== NULL
)
3795 tracepoint_list
.aexpr_listsize
= 128;
3796 tracepoint_list
.aexpr_list
= xmalloc
3797 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3800 if (stepping_list
.list
== NULL
)
3802 stepping_list
.listsize
= 128;
3803 stepping_list
.list
= xmalloc
3804 (stepping_list
.listsize
* sizeof (struct memrange
));
3807 if (stepping_list
.aexpr_list
== NULL
)
3809 stepping_list
.aexpr_listsize
= 128;
3810 stepping_list
.aexpr_list
= xmalloc
3811 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3814 add_info ("scope", scope_info
,
3815 _("List the variables local to a scope"));
3817 add_cmd ("tracepoints", class_trace
, NULL
,
3818 _("Tracing of program execution without stopping the program."),
3821 add_com ("tdump", class_trace
, trace_dump_command
,
3822 _("Print everything collected at the current tracepoint."));
3824 add_com ("tsave", class_trace
, trace_save_command
, _("\
3825 Save the trace data to a file.\n\
3826 Use the '-r' option to direct the target to save directly to the file,\n\
3827 using its own filesystem."));
3829 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
3830 Define a trace state variable.\n\
3831 Argument is a $-prefixed name, optionally followed\n\
3832 by '=' and an expression that sets the initial value\n\
3833 at the start of tracing."));
3834 set_cmd_completer (c
, expression_completer
);
3836 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
3837 Delete one or more trace state variables.\n\
3838 Arguments are the names of the variables to delete.\n\
3839 If no arguments are supplied, delete all variables."), &deletelist
);
3840 /* FIXME add a trace variable completer */
3842 add_info ("tvariables", tvariables_info
, _("\
3843 Status of trace state variables and their values.\n\
3846 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
3847 Select a trace frame;\n\
3848 No argument means forward by one frame; '-' means backward by one frame."),
3849 &tfindlist
, "tfind ", 1, &cmdlist
);
3851 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
3852 Select a trace frame whose PC is outside the given range (exclusive).\n\
3853 Usage: tfind outside addr1, addr2"),
3856 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
3857 Select a trace frame whose PC is in the given range (inclusive).\n\
3858 Usage: tfind range addr1,addr2"),
3861 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
3862 Select a trace frame by source line.\n\
3863 Argument can be a line number (with optional source file), \n\
3864 a function name, or '*' followed by an address.\n\
3865 Default argument is 'the next source line that was traced'."),
3868 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
3869 Select a trace frame by tracepoint number.\n\
3870 Default is the tracepoint for the current trace frame."),
3873 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
3874 Select a trace frame by PC.\n\
3875 Default is the current PC, or the PC of the current trace frame."),
3878 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
3879 Synonym for 'none'.\n\
3880 De-select any trace frame and resume 'live' debugging."),
3883 add_cmd ("none", class_trace
, trace_find_none_command
,
3884 _("De-select any trace frame and resume 'live' debugging."),
3887 add_cmd ("start", class_trace
, trace_find_start_command
,
3888 _("Select the first trace frame in the trace buffer."),
3891 add_com ("tstatus", class_trace
, trace_status_command
,
3892 _("Display the status of the current trace data collection."));
3894 add_com ("tstop", class_trace
, trace_stop_command
,
3895 _("Stop trace data collection."));
3897 add_com ("tstart", class_trace
, trace_start_command
,
3898 _("Start trace data collection."));
3900 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
3901 Ends a list of commands or actions.\n\
3902 Several GDB commands allow you to enter a list of commands or actions.\n\
3903 Entering \"end\" on a line by itself is the normal way to terminate\n\
3905 Note: the \"end\" command cannot be used at the gdb prompt."));
3907 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
3908 Specify single-stepping behavior at a tracepoint.\n\
3909 Argument is number of instructions to trace in single-step mode\n\
3910 following the tracepoint. This command is normally followed by\n\
3911 one or more \"collect\" commands, to specify what to collect\n\
3912 while single-stepping.\n\n\
3913 Note: this command can only be used in a tracepoint \"actions\" list."));
3915 add_com_alias ("ws", "while-stepping", class_alias
, 0);
3916 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
3918 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
3919 Specify one or more data items to be collected at a tracepoint.\n\
3920 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
3921 collect all data (variables, registers) referenced by that expression.\n\
3922 Also accepts the following special arguments:\n\
3923 $regs -- all registers.\n\
3924 $args -- all function arguments.\n\
3925 $locals -- all variables local to the block/function scope.\n\
3926 Note: this command can only be used in a tracepoint \"actions\" list."));
3928 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
3929 Specify one or more expressions to be evaluated at a tracepoint.\n\
3930 Accepts a comma-separated list of (one or more) expressions.\n\
3931 The result of each evaluation will be discarded.\n\
3932 Note: this command can only be used in a tracepoint \"actions\" list."));
3934 add_com ("actions", class_trace
, trace_actions_command
, _("\
3935 Specify the actions to be taken at a tracepoint.\n\
3936 Tracepoint actions may include collecting of specified data, \n\
3937 single-stepping, or enabling/disabling other tracepoints, \n\
3938 depending on target's capabilities."));
3940 default_collect
= xstrdup ("");
3941 add_setshow_string_cmd ("default-collect", class_trace
,
3942 &default_collect
, _("\
3943 Set the list of expressions to collect by default"), _("\
3944 Show the list of expressions to collect by default"), NULL
,
3946 &setlist
, &showlist
);
3948 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
3949 &disconnected_tracing
, _("\
3950 Set whether tracing continues after GDB disconnects."), _("\
3951 Show whether tracing continues after GDB disconnects."), _("\
3952 Use this to continue a tracing run even if GDB disconnects\n\
3953 or detaches from the target. You can reconnect later and look at\n\
3954 trace data collected in the meantime."),
3955 set_disconnected_tracing
,
3960 add_setshow_boolean_cmd ("circular-trace-buffer", no_class
,
3961 &circular_trace_buffer
, _("\
3962 Set target's use of circular trace buffer."), _("\
3963 Show target's use of circular trace buffer."), _("\
3964 Use this to make the trace buffer into a circular buffer,\n\
3965 which will discard traceframes (oldest first) instead of filling\n\
3966 up and stopping the trace run."),
3967 set_circular_trace_buffer
,
3974 add_target (&tfile_ops
);