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 /* ======= Important command functions: ======= */
157 static void trace_actions_command (char *, int);
158 static void trace_start_command (char *, int);
159 static void trace_stop_command (char *, int);
160 static void trace_status_command (char *, int);
161 static void trace_find_command (char *, int);
162 static void trace_find_pc_command (char *, int);
163 static void trace_find_tracepoint_command (char *, int);
164 static void trace_find_line_command (char *, int);
165 static void trace_find_range_command (char *, int);
166 static void trace_find_outside_command (char *, int);
167 static void tracepoint_save_command (char *, int);
168 static void trace_dump_command (char *, int);
170 /* support routines */
172 struct collection_list
;
173 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
174 static char *mem2hex (gdb_byte
*, char *, int);
175 static void add_register (struct collection_list
*collection
,
177 static struct cleanup
*make_cleanup_free_actions (struct breakpoint
*t
);
179 extern void send_disconnected_tracing_value (int value
);
181 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
182 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
185 extern void _initialize_tracepoint (void);
187 static struct trace_status trace_status
;
189 char *stop_reason_names
[] = {
198 struct trace_status
*
199 current_trace_status ()
201 return &trace_status
;
204 /* Set traceframe number to NUM. */
206 set_traceframe_num (int num
)
208 traceframe_number
= num
;
209 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
212 /* Set tracepoint number to NUM. */
214 set_tracepoint_num (int num
)
216 tracepoint_number
= num
;
217 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
220 /* Set externally visible debug variables for querying/printing
221 the traceframe context (line, function, file) */
224 set_traceframe_context (struct frame_info
*trace_frame
)
228 if (trace_frame
== NULL
) /* Cease debugging any trace buffers. */
231 traceframe_sal
.pc
= traceframe_sal
.line
= 0;
232 traceframe_sal
.symtab
= NULL
;
233 clear_internalvar (lookup_internalvar ("trace_func"));
234 clear_internalvar (lookup_internalvar ("trace_file"));
235 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
239 /* Save as globals for internal use. */
240 trace_pc
= get_frame_pc (trace_frame
);
241 traceframe_sal
= find_pc_line (trace_pc
, 0);
242 traceframe_fun
= find_pc_function (trace_pc
);
244 /* Save linenumber as "$trace_line", a debugger variable visible to
246 set_internalvar_integer (lookup_internalvar ("trace_line"),
247 traceframe_sal
.line
);
249 /* Save func name as "$trace_func", a debugger variable visible to
251 if (traceframe_fun
== NULL
252 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
253 clear_internalvar (lookup_internalvar ("trace_func"));
255 set_internalvar_string (lookup_internalvar ("trace_func"),
256 SYMBOL_LINKAGE_NAME (traceframe_fun
));
258 /* Save file name as "$trace_file", a debugger variable visible to
260 if (traceframe_sal
.symtab
== NULL
261 || traceframe_sal
.symtab
->filename
== NULL
)
262 clear_internalvar (lookup_internalvar ("trace_file"));
264 set_internalvar_string (lookup_internalvar ("trace_file"),
265 traceframe_sal
.symtab
->filename
);
268 /* Create a new trace state variable with the given name. */
270 struct trace_state_variable
*
271 create_trace_state_variable (const char *name
)
273 struct trace_state_variable tsv
;
275 memset (&tsv
, 0, sizeof (tsv
));
277 tsv
.number
= next_tsv_number
++;
278 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
281 /* Look for a trace state variable of the given name. */
283 struct trace_state_variable
*
284 find_trace_state_variable (const char *name
)
286 struct trace_state_variable
*tsv
;
289 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
290 if (strcmp (name
, tsv
->name
) == 0)
297 delete_trace_state_variable (const char *name
)
299 struct trace_state_variable
*tsv
;
302 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
303 if (strcmp (name
, tsv
->name
) == 0)
305 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
309 warning (_("No trace variable named \"$%s\", not deleting"), name
);
312 /* The 'tvariable' command collects a name and optional expression to
313 evaluate into an initial value. */
316 trace_variable_command (char *args
, int from_tty
)
318 struct expression
*expr
;
319 struct cleanup
*old_chain
;
320 struct internalvar
*intvar
= NULL
;
322 struct trace_state_variable
*tsv
;
325 error_no_arg (_("trace state variable name"));
327 /* All the possible valid arguments are expressions. */
328 expr
= parse_expression (args
);
329 old_chain
= make_cleanup (free_current_contents
, &expr
);
331 if (expr
->nelts
== 0)
332 error (_("No expression?"));
334 /* Only allow two syntaxes; "$name" and "$name=value". */
335 if (expr
->elts
[0].opcode
== OP_INTERNALVAR
)
337 intvar
= expr
->elts
[1].internalvar
;
339 else if (expr
->elts
[0].opcode
== BINOP_ASSIGN
340 && expr
->elts
[1].opcode
== OP_INTERNALVAR
)
342 intvar
= expr
->elts
[2].internalvar
;
343 initval
= value_as_long (evaluate_subexpression_type (expr
, 4));
346 error (_("Syntax must be $NAME [ = EXPR ]"));
349 error (_("No name given"));
351 if (strlen (internalvar_name (intvar
)) <= 0)
352 error (_("Must supply a non-empty variable name"));
354 /* If the variable already exists, just change its initial value. */
355 tsv
= find_trace_state_variable (internalvar_name (intvar
));
358 tsv
->initial_value
= initval
;
359 printf_filtered (_("Trace state variable $%s now has initial value %s.\n"),
360 tsv
->name
, plongest (tsv
->initial_value
));
364 /* Create a new variable. */
365 tsv
= create_trace_state_variable (internalvar_name (intvar
));
366 tsv
->initial_value
= initval
;
368 printf_filtered (_("Trace state variable $%s created, with initial value %s.\n"),
369 tsv
->name
, plongest (tsv
->initial_value
));
371 do_cleanups (old_chain
);
375 delete_trace_variable_command (char *args
, int from_tty
)
379 struct cleanup
*back_to
;
380 struct trace_state_variable
*tsv
;
384 if (query (_("Delete all trace state variables? ")))
385 VEC_free (tsv_s
, tvariables
);
390 argv
= gdb_buildargv (args
);
391 back_to
= make_cleanup_freeargv (argv
);
393 for (i
= 0; argv
[i
] != NULL
; i
++)
396 delete_trace_state_variable (argv
[i
] + 1);
398 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[i
]);
401 do_cleanups (back_to
);
406 /* List all the trace state variables. */
409 tvariables_info (char *args
, int from_tty
)
411 struct trace_state_variable
*tsv
;
416 if (VEC_length (tsv_s
, tvariables
) == 0)
418 printf_filtered (_("No trace state variables.\n"));
422 /* Try to acquire values from the target. */
423 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
424 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
427 printf_filtered (_("Name\t\t Initial\tCurrent\n"));
429 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
431 printf_filtered ("$%s", tsv
->name
);
432 print_spaces_filtered (17 - strlen (tsv
->name
), gdb_stdout
);
433 printf_filtered ("%s ", plongest (tsv
->initial_value
));
434 print_spaces_filtered (11 - strlen (plongest (tsv
->initial_value
)), gdb_stdout
);
435 if (tsv
->value_known
)
436 printf_filtered (" %s", plongest (tsv
->value
));
437 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
438 /* The value is/was defined, but we don't have it. */
439 printf_filtered (_(" <unknown>"));
441 /* It is not meaningful to ask about the value. */
442 printf_filtered (_(" <undefined>"));
443 printf_filtered ("\n");
447 /* ACTIONS functions: */
449 /* Prototypes for action-parsing utility commands */
450 static void read_actions (struct breakpoint
*);
452 /* The three functions:
453 collect_pseudocommand,
454 while_stepping_pseudocommand, and
455 end_actions_pseudocommand
456 are placeholders for "commands" that are actually ONLY to be used
457 within a tracepoint action list. If the actual function is ever called,
458 it means that somebody issued the "command" at the top level,
459 which is always an error. */
462 end_actions_pseudocommand (char *args
, int from_tty
)
464 error (_("This command cannot be used at the top level."));
468 while_stepping_pseudocommand (char *args
, int from_tty
)
470 error (_("This command can only be used in a tracepoint actions list."));
474 collect_pseudocommand (char *args
, int from_tty
)
476 error (_("This command can only be used in a tracepoint actions list."));
480 teval_pseudocommand (char *args
, int from_tty
)
482 error (_("This command can only be used in a tracepoint actions list."));
485 /* Enter a list of actions for a tracepoint. */
487 trace_actions_command (char *args
, int from_tty
)
489 struct breakpoint
*t
;
491 char *end_msg
= "End with a line saying just \"end\".";
493 t
= get_tracepoint_by_number (&args
, 0, 1);
496 sprintf (tmpbuf
, "Enter actions for tracepoint %d, one per line.",
501 if (deprecated_readline_begin_hook
)
502 (*deprecated_readline_begin_hook
) ("%s %s\n", tmpbuf
, end_msg
);
503 else if (input_from_terminal_p ())
504 printf_filtered ("%s\n%s\n", tmpbuf
, end_msg
);
508 t
->step_count
= 0; /* read_actions may set this */
511 if (deprecated_readline_end_hook
)
512 (*deprecated_readline_end_hook
) ();
513 /* tracepoints_changed () */
515 /* else just return */
518 /* worker function */
520 read_actions (struct breakpoint
*t
)
523 char *prompt1
= "> ", *prompt2
= " > ";
524 char *prompt
= prompt1
;
525 enum actionline_type linetype
;
526 extern FILE *instream
;
527 struct action_line
*next
= NULL
, *temp
;
528 struct cleanup
*old_chain
;
530 /* Control-C quits instantly if typed while in this loop
531 since it should not wait until the user types a newline. */
533 /* FIXME: kettenis/20010823: Something is wrong here. In this file
534 STOP_SIGNAL is never defined. So this code has been left out, at
535 least for quite a while now. Replacing STOP_SIGNAL with SIGTSTP
536 leads to compilation failures since the variable job_control
537 isn't declared. Leave this alone for now. */
540 signal (STOP_SIGNAL
, handle_stop_sig
);
542 old_chain
= make_cleanup_free_actions (t
);
545 /* Make sure that all output has been output. Some machines may
546 let you get away with leaving out some of the gdb_flush, but
549 gdb_flush (gdb_stdout
);
550 gdb_flush (gdb_stderr
);
552 if (deprecated_readline_hook
&& instream
== NULL
)
553 line
= (*deprecated_readline_hook
) (prompt
);
554 else if (instream
== stdin
&& ISATTY (instream
))
556 line
= gdb_readline_wrapper (prompt
);
557 if (line
&& *line
) /* add it to command history */
561 line
= gdb_readline (0);
565 line
= xstrdup ("end");
566 printf_filtered ("end\n");
569 linetype
= validate_actionline (&line
, t
);
570 if (linetype
== BADLINE
)
571 continue; /* already warned -- collect another line */
573 temp
= xmalloc (sizeof (struct action_line
));
577 if (next
== NULL
) /* first action for this tracepoint? */
578 t
->actions
= next
= temp
;
585 if (linetype
== STEPPING
) /* begin "while-stepping" */
587 if (prompt
== prompt2
)
589 warning (_("Already processing 'while-stepping'"));
593 prompt
= prompt2
; /* change prompt for stepping actions */
595 else if (linetype
== END
)
597 if (prompt
== prompt2
)
599 prompt
= prompt1
; /* end of single-stepping actions */
602 { /* end of actions */
603 if (t
->actions
->next
== NULL
)
605 /* An "end" all by itself with no other actions
606 means this tracepoint has no actions.
607 Discard empty list. */
616 signal (STOP_SIGNAL
, SIG_DFL
);
619 discard_cleanups (old_chain
);
622 /* worker function */
624 validate_actionline (char **line
, struct breakpoint
*t
)
626 struct cmd_list_element
*c
;
627 struct expression
*exp
= NULL
;
628 struct cleanup
*old_chain
= NULL
;
631 /* if EOF is typed, *line is NULL */
635 for (p
= *line
; isspace ((int) *p
);)
638 /* Symbol lookup etc. */
639 if (*p
== '\0') /* empty line: just prompt for another line. */
642 if (*p
== '#') /* comment line */
645 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
648 warning (_("'%s' is not an action that I know, or is ambiguous."),
653 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
655 struct agent_expr
*aexpr
;
656 struct agent_reqs areqs
;
659 { /* repeat over a comma-separated list */
660 QUIT
; /* allow user to bail out with ^C */
661 while (isspace ((int) *p
))
664 if (*p
== '$') /* look for special pseudo-symbols */
666 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
667 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
668 (0 == strncasecmp ("loc", p
+ 1, 3)))
673 /* else fall thru, treat p as an expression and parse it! */
675 exp
= parse_exp_1 (&p
, block_for_pc (t
->loc
->address
), 1);
676 old_chain
= make_cleanup (free_current_contents
, &exp
);
678 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
680 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
682 warning (_("constant %s (value %ld) will not be collected."),
683 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
684 SYMBOL_VALUE (exp
->elts
[2].symbol
));
687 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
689 warning (_("%s is optimized away and cannot be collected."),
690 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
695 /* We have something to collect, make sure that the expr to
696 bytecode translator can handle it and that it's not too
698 aexpr
= gen_trace_for_expr (t
->loc
->address
, exp
);
699 make_cleanup_free_agent_expr (aexpr
);
701 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
702 error (_("expression too complicated, try simplifying"));
704 ax_reqs (aexpr
, &areqs
);
705 (void) make_cleanup (xfree
, areqs
.reg_mask
);
707 if (areqs
.flaw
!= agent_flaw_none
)
708 error (_("malformed expression"));
710 if (areqs
.min_height
< 0)
711 error (_("gdb: Internal error: expression has min height < 0"));
713 if (areqs
.max_height
> 20)
714 error (_("expression too complicated, try simplifying"));
716 do_cleanups (old_chain
);
718 while (p
&& *p
++ == ',');
721 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
723 struct agent_expr
*aexpr
;
726 { /* repeat over a comma-separated list */
727 QUIT
; /* allow user to bail out with ^C */
728 while (isspace ((int) *p
))
731 /* Only expressions are allowed for this action. */
732 exp
= parse_exp_1 (&p
, block_for_pc (t
->loc
->address
), 1);
733 old_chain
= make_cleanup (free_current_contents
, &exp
);
735 /* We have something to evaluate, make sure that the expr to
736 bytecode translator can handle it and that it's not too
738 aexpr
= gen_eval_for_expr (t
->loc
->address
, exp
);
739 make_cleanup_free_agent_expr (aexpr
);
741 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
742 error (_("expression too complicated, try simplifying"));
744 do_cleanups (old_chain
);
746 while (p
&& *p
++ == ',');
749 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
751 char *steparg
; /* in case warning is necessary */
753 while (isspace ((int) *p
))
758 (t
->step_count
= strtol (p
, &p
, 0)) == 0)
760 warning (_("'%s': bad step-count; command ignored."), *line
);
765 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
769 warning (_("'%s' is not a supported tracepoint action."), *line
);
774 /* worker function */
776 free_actions (struct breakpoint
*t
)
778 struct action_line
*line
, *next
;
780 for (line
= t
->actions
; line
; line
= next
)
784 xfree (line
->action
);
791 do_free_actions_cleanup (void *t
)
796 static struct cleanup
*
797 make_cleanup_free_actions (struct breakpoint
*t
)
799 return make_cleanup (do_free_actions_cleanup
, t
);
803 memrange_absolute
= -1
808 int type
; /* memrange_absolute for absolute memory range,
809 else basereg number */
810 bfd_signed_vma start
;
814 struct collection_list
816 unsigned char regs_mask
[32]; /* room for up to 256 regs */
819 struct memrange
*list
;
820 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
822 struct agent_expr
**aexpr_list
;
825 tracepoint_list
, stepping_list
;
827 /* MEMRANGE functions: */
829 static int memrange_cmp (const void *, const void *);
831 /* compare memranges for qsort */
833 memrange_cmp (const void *va
, const void *vb
)
835 const struct memrange
*a
= va
, *b
= vb
;
837 if (a
->type
< b
->type
)
839 if (a
->type
> b
->type
)
841 if (a
->type
== memrange_absolute
)
843 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
845 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
850 if (a
->start
< b
->start
)
852 if (a
->start
> b
->start
)
858 /* Sort the memrange list using qsort, and merge adjacent memranges. */
860 memrange_sortmerge (struct collection_list
*memranges
)
864 qsort (memranges
->list
, memranges
->next_memrange
,
865 sizeof (struct memrange
), memrange_cmp
);
866 if (memranges
->next_memrange
> 0)
868 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
870 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
871 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
874 /* memrange b starts before memrange a ends; merge them. */
875 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
876 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
877 continue; /* next b, same a */
881 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
882 sizeof (struct memrange
));
884 memranges
->next_memrange
= a
+ 1;
888 /* Add a register to a collection list. */
890 add_register (struct collection_list
*collection
, unsigned int regno
)
893 printf_filtered ("collect register %d\n", regno
);
894 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
895 error (_("Internal: register number %d too large for tracepoint"),
897 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
900 /* Add a memrange to a collection list */
902 add_memrange (struct collection_list
*memranges
,
903 int type
, bfd_signed_vma base
,
908 printf_filtered ("(%d,", type
);
910 printf_filtered (",%ld)\n", len
);
913 /* type: memrange_absolute == memory, other n == basereg */
914 memranges
->list
[memranges
->next_memrange
].type
= type
;
915 /* base: addr if memory, offset if reg relative. */
916 memranges
->list
[memranges
->next_memrange
].start
= base
;
917 /* len: we actually save end (base + len) for convenience */
918 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
919 memranges
->next_memrange
++;
920 if (memranges
->next_memrange
>= memranges
->listsize
)
922 memranges
->listsize
*= 2;
923 memranges
->list
= xrealloc (memranges
->list
,
924 memranges
->listsize
);
927 if (type
!= memrange_absolute
) /* Better collect the base register! */
928 add_register (memranges
, type
);
931 /* Add a symbol to a collection list. */
933 collect_symbol (struct collection_list
*collect
,
935 struct gdbarch
*gdbarch
,
936 long frame_regno
, long frame_offset
,
941 bfd_signed_vma offset
;
943 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
944 switch (SYMBOL_CLASS (sym
))
947 printf_filtered ("%s: don't know symbol class %d\n",
948 SYMBOL_PRINT_NAME (sym
),
952 printf_filtered ("constant %s (value %ld) will not be collected.\n",
953 SYMBOL_PRINT_NAME (sym
), SYMBOL_VALUE (sym
));
956 offset
= SYMBOL_VALUE_ADDRESS (sym
);
961 sprintf_vma (tmp
, offset
);
962 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
963 SYMBOL_PRINT_NAME (sym
), len
,
966 add_memrange (collect
, memrange_absolute
, offset
, len
);
969 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
971 printf_filtered ("LOC_REG[parm] %s: ",
972 SYMBOL_PRINT_NAME (sym
));
973 add_register (collect
, reg
);
974 /* Check for doubles stored in two registers. */
975 /* FIXME: how about larger types stored in 3 or more regs? */
976 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
977 len
> register_size (gdbarch
, reg
))
978 add_register (collect
, reg
+ 1);
981 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
982 printf_filtered (" (will not collect %s)\n",
983 SYMBOL_PRINT_NAME (sym
));
987 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
990 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
991 SYMBOL_PRINT_NAME (sym
), len
);
993 printf_filtered (" from frame ptr reg %d\n", reg
);
995 add_memrange (collect
, reg
, offset
, len
);
997 case LOC_REGPARM_ADDR
:
998 reg
= SYMBOL_VALUE (sym
);
1002 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1003 SYMBOL_PRINT_NAME (sym
), len
);
1004 printf_vma (offset
);
1005 printf_filtered (" from reg %d\n", reg
);
1007 add_memrange (collect
, reg
, offset
, len
);
1011 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1014 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1015 SYMBOL_PRINT_NAME (sym
), len
);
1016 printf_vma (offset
);
1017 printf_filtered (" from frame ptr reg %d\n", reg
);
1019 add_memrange (collect
, reg
, offset
, len
);
1021 case LOC_UNRESOLVED
:
1022 printf_filtered ("Don't know LOC_UNRESOLVED %s\n",
1023 SYMBOL_PRINT_NAME (sym
));
1025 case LOC_OPTIMIZED_OUT
:
1026 printf_filtered ("%s has been optimized out of existence.\n",
1027 SYMBOL_PRINT_NAME (sym
));
1032 struct agent_expr
*aexpr
;
1033 struct cleanup
*old_chain1
= NULL
;
1034 struct agent_reqs areqs
;
1036 aexpr
= gen_trace_for_var (scope
, sym
);
1038 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1040 ax_reqs (aexpr
, &areqs
);
1041 if (areqs
.flaw
!= agent_flaw_none
)
1042 error (_("malformed expression"));
1044 if (areqs
.min_height
< 0)
1045 error (_("gdb: Internal error: expression has min height < 0"));
1046 if (areqs
.max_height
> 20)
1047 error (_("expression too complicated, try simplifying"));
1049 discard_cleanups (old_chain1
);
1050 add_aexpr (collect
, aexpr
);
1052 /* take care of the registers */
1053 if (areqs
.reg_mask_len
> 0)
1057 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1059 QUIT
; /* allow user to bail out with ^C */
1060 if (areqs
.reg_mask
[ndx1
] != 0)
1062 /* assume chars have 8 bits */
1063 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1064 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1065 /* it's used -- record it */
1066 add_register (collect
,
1076 /* Add all locals (or args) symbols to collection list */
1078 add_local_symbols (struct collection_list
*collect
,
1079 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1080 long frame_regno
, long frame_offset
, int type
)
1083 struct block
*block
;
1084 struct dict_iterator iter
;
1087 block
= block_for_pc (pc
);
1090 QUIT
; /* allow user to bail out with ^C */
1091 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
1093 if (SYMBOL_IS_ARGUMENT (sym
)
1094 ? type
== 'A' /* collecting Arguments */
1095 : type
== 'L') /* collecting Locals */
1098 collect_symbol (collect
, sym
, gdbarch
,
1099 frame_regno
, frame_offset
, pc
);
1102 if (BLOCK_FUNCTION (block
))
1105 block
= BLOCK_SUPERBLOCK (block
);
1108 warning (_("No %s found in scope."),
1109 type
== 'L' ? "locals" : "args");
1112 /* worker function */
1114 clear_collection_list (struct collection_list
*list
)
1118 list
->next_memrange
= 0;
1119 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1121 free_agent_expr (list
->aexpr_list
[ndx
]);
1122 list
->aexpr_list
[ndx
] = NULL
;
1124 list
->next_aexpr_elt
= 0;
1125 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1128 /* reduce a collection list to string form (for gdb protocol) */
1130 stringify_collection_list (struct collection_list
*list
, char *string
)
1132 char temp_buf
[2048];
1136 char *(*str_list
)[];
1140 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1141 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1143 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1144 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1146 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1149 printf_filtered ("\nCollecting registers (mask): 0x");
1154 QUIT
; /* allow user to bail out with ^C */
1156 printf_filtered ("%02X", list
->regs_mask
[i
]);
1157 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1160 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1164 printf_filtered ("\n");
1165 if (list
->next_memrange
> 0 && info_verbose
)
1166 printf_filtered ("Collecting memranges: \n");
1167 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1169 QUIT
; /* allow user to bail out with ^C */
1170 sprintf_vma (tmp2
, list
->list
[i
].start
);
1173 printf_filtered ("(%d, %s, %ld)\n",
1176 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1178 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1180 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1187 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1189 /* The "%X" conversion specifier expects an unsigned argument,
1190 so passing -1 (memrange_absolute) to it directly gives you
1191 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1193 if (list
->list
[i
].type
== memrange_absolute
)
1194 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1196 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1199 count
+= strlen (end
);
1200 end
= temp_buf
+ count
;
1203 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1205 QUIT
; /* allow user to bail out with ^C */
1206 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1208 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1213 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1214 end
+= 10; /* 'X' + 8 hex digits + ',' */
1217 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1218 end
, list
->aexpr_list
[i
]->len
);
1219 count
+= 2 * list
->aexpr_list
[i
]->len
;
1224 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1229 (*str_list
)[ndx
] = NULL
;
1240 /* Render all actions into gdb protocol. */
1242 encode_actions (struct breakpoint
*t
, char ***tdp_actions
,
1243 char ***stepping_actions
)
1245 static char tdp_buff
[2048], step_buff
[2048];
1247 struct expression
*exp
= NULL
;
1248 struct action_line
*action
;
1250 struct value
*tempval
;
1251 struct collection_list
*collect
;
1252 struct cmd_list_element
*cmd
;
1253 struct agent_expr
*aexpr
;
1255 LONGEST frame_offset
;
1256 char *default_collect_line
= NULL
;
1257 struct action_line
*default_collect_action
= NULL
;
1259 clear_collection_list (&tracepoint_list
);
1260 clear_collection_list (&stepping_list
);
1261 collect
= &tracepoint_list
;
1263 *tdp_actions
= NULL
;
1264 *stepping_actions
= NULL
;
1266 gdbarch_virtual_frame_pointer (t
->gdbarch
,
1267 t
->loc
->address
, &frame_reg
, &frame_offset
);
1269 action
= t
->actions
;
1271 /* If there are default expressions to collect, make up a collect
1272 action and prepend to the action list to encode. Note that since
1273 validation is per-tracepoint (local var "xyz" might be valid for
1274 one tracepoint and not another, etc), we make up the action on
1275 the fly, and don't cache it. */
1276 if (*default_collect
)
1279 enum actionline_type linetype
;
1281 default_collect_line
= xmalloc (12 + strlen (default_collect
));
1282 sprintf (default_collect_line
, "collect %s", default_collect
);
1283 line
= default_collect_line
;
1284 linetype
= validate_actionline (&line
, t
);
1285 if (linetype
!= BADLINE
)
1287 default_collect_action
= xmalloc (sizeof (struct action_line
));
1288 default_collect_action
->next
= t
->actions
;
1289 default_collect_action
->action
= line
;
1290 action
= default_collect_action
;
1294 for (; action
; action
= action
->next
)
1296 QUIT
; /* allow user to bail out with ^C */
1297 action_exp
= action
->action
;
1298 while (isspace ((int) *action_exp
))
1301 if (*action_exp
== '#') /* comment line */
1304 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1306 error (_("Bad action list item: %s"), action_exp
);
1308 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1311 { /* repeat over a comma-separated list */
1312 QUIT
; /* allow user to bail out with ^C */
1313 while (isspace ((int) *action_exp
))
1316 if (0 == strncasecmp ("$reg", action_exp
, 4))
1318 for (i
= 0; i
< gdbarch_num_regs (t
->gdbarch
); i
++)
1319 add_register (collect
, i
);
1320 action_exp
= strchr (action_exp
, ','); /* more? */
1322 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1324 add_local_symbols (collect
,
1330 action_exp
= strchr (action_exp
, ','); /* more? */
1332 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1334 add_local_symbols (collect
,
1340 action_exp
= strchr (action_exp
, ','); /* more? */
1344 unsigned long addr
, len
;
1345 struct cleanup
*old_chain
= NULL
;
1346 struct cleanup
*old_chain1
= NULL
;
1347 struct agent_reqs areqs
;
1349 exp
= parse_exp_1 (&action_exp
,
1350 block_for_pc (t
->loc
->address
), 1);
1351 old_chain
= make_cleanup (free_current_contents
, &exp
);
1353 switch (exp
->elts
[0].opcode
)
1357 const char *name
= &exp
->elts
[2].string
;
1359 i
= user_reg_map_name_to_regnum (t
->gdbarch
,
1360 name
, strlen (name
));
1362 internal_error (__FILE__
, __LINE__
,
1363 _("Register $%s not available"),
1366 printf_filtered ("OP_REGISTER: ");
1367 add_register (collect
, i
);
1372 /* safe because we know it's a simple expression */
1373 tempval
= evaluate_expression (exp
);
1374 addr
= value_address (tempval
);
1375 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1376 add_memrange (collect
, memrange_absolute
, addr
, len
);
1380 collect_symbol (collect
,
1381 exp
->elts
[2].symbol
,
1388 default: /* full-fledged expression */
1389 aexpr
= gen_trace_for_expr (t
->loc
->address
, exp
);
1391 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1393 ax_reqs (aexpr
, &areqs
);
1394 if (areqs
.flaw
!= agent_flaw_none
)
1395 error (_("malformed expression"));
1397 if (areqs
.min_height
< 0)
1398 error (_("gdb: Internal error: expression has min height < 0"));
1399 if (areqs
.max_height
> 20)
1400 error (_("expression too complicated, try simplifying"));
1402 discard_cleanups (old_chain1
);
1403 add_aexpr (collect
, aexpr
);
1405 /* take care of the registers */
1406 if (areqs
.reg_mask_len
> 0)
1411 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1413 QUIT
; /* allow user to bail out with ^C */
1414 if (areqs
.reg_mask
[ndx1
] != 0)
1416 /* assume chars have 8 bits */
1417 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1418 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1419 /* it's used -- record it */
1420 add_register (collect
,
1427 do_cleanups (old_chain
);
1430 while (action_exp
&& *action_exp
++ == ',');
1432 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1435 { /* repeat over a comma-separated list */
1436 QUIT
; /* allow user to bail out with ^C */
1437 while (isspace ((int) *action_exp
))
1441 unsigned long addr
, len
;
1442 struct cleanup
*old_chain
= NULL
;
1443 struct cleanup
*old_chain1
= NULL
;
1444 struct agent_reqs areqs
;
1446 exp
= parse_exp_1 (&action_exp
,
1447 block_for_pc (t
->loc
->address
), 1);
1448 old_chain
= make_cleanup (free_current_contents
, &exp
);
1450 aexpr
= gen_eval_for_expr (t
->loc
->address
, exp
);
1451 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1453 ax_reqs (aexpr
, &areqs
);
1454 if (areqs
.flaw
!= agent_flaw_none
)
1455 error (_("malformed expression"));
1457 if (areqs
.min_height
< 0)
1458 error (_("gdb: Internal error: expression has min height < 0"));
1459 if (areqs
.max_height
> 20)
1460 error (_("expression too complicated, try simplifying"));
1462 discard_cleanups (old_chain1
);
1463 /* Even though we're not officially collecting, add
1464 to the collect list anyway. */
1465 add_aexpr (collect
, aexpr
);
1467 do_cleanups (old_chain
);
1470 while (action_exp
&& *action_exp
++ == ',');
1472 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1474 collect
= &stepping_list
;
1476 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
1478 if (collect
== &stepping_list
) /* end stepping actions */
1479 collect
= &tracepoint_list
;
1481 break; /* end tracepoint actions */
1484 memrange_sortmerge (&tracepoint_list
);
1485 memrange_sortmerge (&stepping_list
);
1487 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1489 *stepping_actions
= stringify_collection_list (&stepping_list
,
1492 xfree (default_collect_line
);
1493 xfree (default_collect_action
);
1497 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1499 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1501 collect
->aexpr_list
=
1502 xrealloc (collect
->aexpr_list
,
1503 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1504 collect
->aexpr_listsize
*= 2;
1506 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1507 collect
->next_aexpr_elt
++;
1512 Tell target to clear any previous trace experiment.
1513 Walk the list of tracepoints, and send them (and their actions)
1514 to the target. If no errors,
1515 Tell target to start a new trace experiment. */
1518 trace_start_command (char *args
, int from_tty
)
1521 VEC(breakpoint_p
) *tp_vec
= NULL
;
1523 struct breakpoint
*t
;
1524 struct trace_state_variable
*tsv
;
1525 int any_downloaded
= 0;
1527 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1529 target_trace_init ();
1531 tp_vec
= all_tracepoints ();
1532 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1534 t
->number_on_target
= 0;
1535 target_download_tracepoint (t
);
1536 t
->number_on_target
= t
->number
;
1539 VEC_free (breakpoint_p
, tp_vec
);
1541 /* No point in tracing without any tracepoints... */
1542 if (!any_downloaded
)
1543 error ("No tracepoints downloaded, not starting trace");
1545 /* Send down all the trace state variables too. */
1546 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1548 target_download_trace_state_variable (tsv
);
1551 /* Tell target to treat text-like sections as transparent. */
1552 target_trace_set_readonly_regions ();
1554 /* Now insert traps and begin collecting data. */
1555 target_trace_start ();
1557 /* Reset our local state. */
1558 set_traceframe_num (-1);
1559 set_tracepoint_num (-1);
1560 set_traceframe_context (NULL
);
1561 current_trace_status()->running
= 1;
1566 trace_stop_command (char *args
, int from_tty
)
1574 target_trace_stop ();
1575 /* should change in response to reply? */
1576 current_trace_status ()->running
= 0;
1579 /* tstatus command */
1581 trace_status_command (char *args
, int from_tty
)
1583 struct trace_status
*ts
= current_trace_status ();
1586 status
= target_get_trace_status (ts
);
1591 printf_filtered (_("Using a trace file.\n"));
1594 printf_filtered (_("Trace can not be run on this target.\n"));
1599 if (!ts
->running_known
)
1601 printf_filtered (_("Run/stop status is unknown.\n"));
1603 else if (ts
->running
)
1605 printf_filtered (_("Trace is running on the target.\n"));
1606 if (disconnected_tracing
)
1607 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1609 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1613 switch (ts
->stop_reason
)
1615 case trace_never_run
:
1616 printf_filtered (_("No trace has been run on the target.\n"));
1619 printf_filtered (_("Trace stopped by a tstop command.\n"));
1621 case trace_buffer_full
:
1622 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1624 case trace_disconnected
:
1625 printf_filtered (_("Trace stopped because of disconnection.\n"));
1627 case tracepoint_passcount
:
1628 /* FIXME account for number on target */
1629 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1630 ts
->stopping_tracepoint
);
1632 case trace_stop_reason_unknown
:
1633 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1636 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1642 if (ts
->traceframe_count
>= 0)
1644 printf_filtered (_("Collected %d trace frames.\n"),
1645 ts
->traceframe_count
);
1648 if (ts
->buffer_free
)
1650 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1654 /* Now report on what we're doing with tfind. */
1655 if (traceframe_number
>= 0)
1656 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1657 traceframe_number
, tracepoint_number
);
1659 printf_filtered (_("Not looking at any trace frame.\n"));
1663 disconnect_or_stop_tracing (int from_tty
)
1665 /* It can happen that the target that was tracing went away on its
1666 own, and we didn't notice. Get a status update, and if the
1667 current target doesn't even do tracing, then assume it's not
1669 if (target_get_trace_status (current_trace_status ()) < 0)
1670 current_trace_status ()->running
= 0;
1672 if (current_trace_status ()->running
&& from_tty
)
1674 int cont
= query (_("Trace is running. Continue tracing after detach? "));
1675 /* Note that we send the query result without affecting the
1676 user's setting of disconnected_tracing, so that the answer is
1678 send_disconnected_tracing_value (cont
);
1680 /* Also ensure that we do the equivalent of a tstop command if
1681 tracing is not to continue after the detach. */
1687 /* Worker function for the various flavors of the tfind command. */
1689 finish_tfind_command (enum trace_find_type type
, int num
,
1690 ULONGEST addr1
, ULONGEST addr2
,
1693 int target_frameno
= -1, target_tracept
= -1;
1694 struct frame_id old_frame_id
;
1696 struct breakpoint
*tp
;
1698 old_frame_id
= get_frame_id (get_current_frame ());
1700 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
1703 if (type
== tfind_number
1705 && target_frameno
== -1)
1707 /* We told the target to get out of tfind mode, and it did. */
1709 else if (target_frameno
== -1)
1711 /* A request for a non-existant trace frame has failed.
1712 Our response will be different, depending on FROM_TTY:
1714 If FROM_TTY is true, meaning that this command was
1715 typed interactively by the user, then give an error
1716 and DO NOT change the state of traceframe_number etc.
1718 However if FROM_TTY is false, meaning that we're either
1719 in a script, a loop, or a user-defined command, then
1720 DON'T give an error, but DO change the state of
1721 traceframe_number etc. to invalid.
1723 The rationalle is that if you typed the command, you
1724 might just have committed a typo or something, and you'd
1725 like to NOT lose your current debugging state. However
1726 if you're in a user-defined command or especially in a
1727 loop, then you need a way to detect that the command
1728 failed WITHOUT aborting. This allows you to write
1729 scripts that search thru the trace buffer until the end,
1730 and then continue on to do something else. */
1733 error (_("Target failed to find requested trace frame."));
1737 printf_filtered ("End of trace buffer.\n");
1738 #if 0 /* dubious now? */
1739 /* The following will not recurse, since it's
1741 trace_find_command ("-1", from_tty
);
1746 tp
= get_tracepoint_by_number_on_target (target_tracept
);
1748 reinit_frame_cache ();
1749 registers_changed ();
1750 set_traceframe_num (target_frameno
);
1751 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
1752 if (target_frameno
== -1)
1753 set_traceframe_context (NULL
);
1755 set_traceframe_context (get_current_frame ());
1757 /* If we're in nonstop mode and getting out of looking at trace
1758 frames, there won't be any current frame to go back to and
1761 && (has_stack_frames () || traceframe_number
>= 0))
1763 enum print_what print_what
;
1765 /* NOTE: in immitation of the step command, try to determine
1766 whether we have made a transition from one function to
1767 another. If so, we'll print the "stack frame" (ie. the new
1768 function and it's arguments) -- otherwise we'll just show the
1771 if (frame_id_eq (old_frame_id
,
1772 get_frame_id (get_current_frame ())))
1773 print_what
= SRC_LINE
;
1775 print_what
= SRC_AND_LOC
;
1777 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
1782 /* trace_find_command takes a trace frame number n,
1783 sends "QTFrame:<n>" to the target,
1784 and accepts a reply that may contain several optional pieces
1785 of information: a frame number, a tracepoint number, and an
1786 indication of whether this is a trap frame or a stepping frame.
1788 The minimal response is just "OK" (which indicates that the
1789 target does not give us a frame number or a tracepoint number).
1790 Instead of that, the target may send us a string containing
1792 F<hexnum> (gives the selected frame number)
1793 T<hexnum> (gives the selected tracepoint number)
1798 trace_find_command (char *args
, int from_tty
)
1799 { /* this should only be called with a numeric argument */
1802 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1803 error ("May not look at trace frames while trace is running.");
1805 if (args
== 0 || *args
== 0)
1806 { /* TFIND with no args means find NEXT trace frame. */
1807 if (traceframe_number
== -1)
1808 frameno
= 0; /* "next" is first one */
1810 frameno
= traceframe_number
+ 1;
1812 else if (0 == strcmp (args
, "-"))
1814 if (traceframe_number
== -1)
1815 error (_("not debugging trace buffer"));
1816 else if (from_tty
&& traceframe_number
== 0)
1817 error (_("already at start of trace buffer"));
1819 frameno
= traceframe_number
- 1;
1821 /* A hack to work around eval's need for fp to have been collected. */
1822 else if (0 == strcmp (args
, "-1"))
1825 frameno
= parse_and_eval_long (args
);
1828 error (_("invalid input (%d is less than zero)"), frameno
);
1830 finish_tfind_command (tfind_number
, frameno
, 0, 0, from_tty
);
1835 trace_find_end_command (char *args
, int from_tty
)
1837 trace_find_command ("-1", from_tty
);
1842 trace_find_none_command (char *args
, int from_tty
)
1844 trace_find_command ("-1", from_tty
);
1849 trace_find_start_command (char *args
, int from_tty
)
1851 trace_find_command ("0", from_tty
);
1854 /* tfind pc command */
1856 trace_find_pc_command (char *args
, int from_tty
)
1861 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1862 error ("May not look at trace frames while trace is running.");
1864 if (args
== 0 || *args
== 0)
1865 pc
= regcache_read_pc (get_current_regcache ());
1867 pc
= parse_and_eval_address (args
);
1869 finish_tfind_command (tfind_pc
, 0, pc
, 0, from_tty
);
1872 /* tfind tracepoint command */
1874 trace_find_tracepoint_command (char *args
, int from_tty
)
1877 struct breakpoint
*tp
;
1879 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1880 error ("May not look at trace frames while trace is running.");
1882 if (args
== 0 || *args
== 0)
1884 if (tracepoint_number
== -1)
1885 error (_("No current tracepoint -- please supply an argument."));
1887 tdp
= tracepoint_number
; /* default is current TDP */
1890 tdp
= parse_and_eval_long (args
);
1892 /* If we have the tracepoint on hand, use the number that the
1893 target knows about (which may be different if we disconnected
1894 and reconnected). */
1895 tp
= get_tracepoint (tdp
);
1897 tdp
= tp
->number_on_target
;
1899 finish_tfind_command (tfind_tp
, tdp
, 0, 0, from_tty
);
1902 /* TFIND LINE command:
1904 This command will take a sourceline for argument, just like BREAK
1905 or TRACE (ie. anything that "decode_line_1" can handle).
1907 With no argument, this command will find the next trace frame
1908 corresponding to a source line OTHER THAN THE CURRENT ONE. */
1911 trace_find_line_command (char *args
, int from_tty
)
1913 static CORE_ADDR start_pc
, end_pc
;
1914 struct symtabs_and_lines sals
;
1915 struct symtab_and_line sal
;
1916 struct cleanup
*old_chain
;
1917 char startpc_str
[40], endpc_str
[40];
1919 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1920 error ("May not look at trace frames while trace is running.");
1922 if (args
== 0 || *args
== 0)
1924 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
1926 sals
.sals
= (struct symtab_and_line
*)
1927 xmalloc (sizeof (struct symtab_and_line
));
1932 sals
= decode_line_spec (args
, 1);
1936 old_chain
= make_cleanup (xfree
, sals
.sals
);
1937 if (sal
.symtab
== 0)
1939 printf_filtered ("TFIND: No line number information available");
1942 /* This is useful for "info line *0x7f34". If we can't
1943 tell the user about a source line, at least let them
1944 have the symbolic address. */
1945 printf_filtered (" for address ");
1947 print_address (get_current_arch (), sal
.pc
, gdb_stdout
);
1948 printf_filtered (";\n -- will attempt to find by PC. \n");
1952 printf_filtered (".\n");
1953 return; /* No line, no PC; what can we do? */
1956 else if (sal
.line
> 0
1957 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
1959 if (start_pc
== end_pc
)
1961 printf_filtered ("Line %d of \"%s\"",
1962 sal
.line
, sal
.symtab
->filename
);
1964 printf_filtered (" is at address ");
1965 print_address (get_current_arch (), start_pc
, gdb_stdout
);
1967 printf_filtered (" but contains no code.\n");
1968 sal
= find_pc_line (start_pc
, 0);
1970 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
1971 && start_pc
!= end_pc
)
1972 printf_filtered ("Attempting to find line %d instead.\n",
1975 error (_("Cannot find a good line."));
1979 /* Is there any case in which we get here, and have an address
1980 which the user would want to see? If we have debugging
1981 symbols and no line numbers? */
1982 error (_("Line number %d is out of range for \"%s\"."),
1983 sal
.line
, sal
.symtab
->filename
);
1985 /* Find within range of stated line. */
1987 finish_tfind_command (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
1989 finish_tfind_command (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
1990 do_cleanups (old_chain
);
1993 /* tfind range command */
1995 trace_find_range_command (char *args
, int from_tty
)
1997 static CORE_ADDR start
, stop
;
1998 char start_str
[40], stop_str
[40];
2001 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2002 error ("May not look at trace frames while trace is running.");
2004 if (args
== 0 || *args
== 0)
2005 { /* XXX FIXME: what should default behavior be? */
2006 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2010 if (0 != (tmp
= strchr (args
, ',')))
2012 *tmp
++ = '\0'; /* terminate start address */
2013 while (isspace ((int) *tmp
))
2015 start
= parse_and_eval_address (args
);
2016 stop
= parse_and_eval_address (tmp
);
2019 { /* no explicit end address? */
2020 start
= parse_and_eval_address (args
);
2021 stop
= start
+ 1; /* ??? */
2024 finish_tfind_command (tfind_range
, 0, start
, stop
, from_tty
);
2027 /* tfind outside command */
2029 trace_find_outside_command (char *args
, int from_tty
)
2031 CORE_ADDR start
, stop
;
2032 char start_str
[40], stop_str
[40];
2035 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2036 error ("May not look at trace frames while trace is running.");
2038 if (args
== 0 || *args
== 0)
2039 { /* XXX FIXME: what should default behavior be? */
2040 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2044 if (0 != (tmp
= strchr (args
, ',')))
2046 *tmp
++ = '\0'; /* terminate start address */
2047 while (isspace ((int) *tmp
))
2049 start
= parse_and_eval_address (args
);
2050 stop
= parse_and_eval_address (tmp
);
2053 { /* no explicit end address? */
2054 start
= parse_and_eval_address (args
);
2055 stop
= start
+ 1; /* ??? */
2058 finish_tfind_command (tfind_outside
, 0, start
, stop
, from_tty
);
2061 /* info scope command: list the locals for a scope. */
2063 scope_info (char *args
, int from_tty
)
2065 struct symtabs_and_lines sals
;
2067 struct minimal_symbol
*msym
;
2068 struct block
*block
;
2069 char **canonical
, *symname
, *save_args
= args
;
2070 struct dict_iterator iter
;
2072 struct gdbarch
*gdbarch
;
2075 if (args
== 0 || *args
== 0)
2076 error (_("requires an argument (function, line or *addr) to define a scope"));
2078 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2079 if (sals
.nelts
== 0)
2080 return; /* presumably decode_line_1 has already warned */
2082 /* Resolve line numbers to PC */
2083 resolve_sal_pc (&sals
.sals
[0]);
2084 block
= block_for_pc (sals
.sals
[0].pc
);
2088 QUIT
; /* allow user to bail out with ^C */
2089 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2091 QUIT
; /* allow user to bail out with ^C */
2093 printf_filtered ("Scope for %s:\n", save_args
);
2096 symname
= SYMBOL_PRINT_NAME (sym
);
2097 if (symname
== NULL
|| *symname
== '\0')
2098 continue; /* probably botched, certainly useless */
2100 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2102 printf_filtered ("Symbol %s is ", symname
);
2103 switch (SYMBOL_CLASS (sym
))
2106 case LOC_UNDEF
: /* messed up symbol? */
2107 printf_filtered ("a bogus symbol, class %d.\n",
2108 SYMBOL_CLASS (sym
));
2109 count
--; /* don't count this one */
2112 printf_filtered ("a constant with value %ld (0x%lx)",
2113 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2115 case LOC_CONST_BYTES
:
2116 printf_filtered ("constant bytes: ");
2117 if (SYMBOL_TYPE (sym
))
2118 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2119 fprintf_filtered (gdb_stdout
, " %02x",
2120 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2123 printf_filtered ("in static storage at address ");
2124 printf_filtered ("%s", paddress (gdbarch
,
2125 SYMBOL_VALUE_ADDRESS (sym
)));
2128 /* GDBARCH is the architecture associated with the objfile
2129 the symbol is defined in; the target architecture may be
2130 different, and may provide additional registers. However,
2131 we do not know the target architecture at this point.
2132 We assume the objfile architecture will contain all the
2133 standard registers that occur in debug info in that
2135 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2137 if (SYMBOL_IS_ARGUMENT (sym
))
2138 printf_filtered ("an argument in register $%s",
2139 gdbarch_register_name (gdbarch
, regno
));
2141 printf_filtered ("a local variable in register $%s",
2142 gdbarch_register_name (gdbarch
, regno
));
2145 printf_filtered ("an argument at stack/frame offset %ld",
2146 SYMBOL_VALUE (sym
));
2149 printf_filtered ("a local variable at frame offset %ld",
2150 SYMBOL_VALUE (sym
));
2153 printf_filtered ("a reference argument at offset %ld",
2154 SYMBOL_VALUE (sym
));
2156 case LOC_REGPARM_ADDR
:
2157 /* Note comment at LOC_REGISTER. */
2158 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2159 printf_filtered ("the address of an argument, in register $%s",
2160 gdbarch_register_name (gdbarch
, regno
));
2163 printf_filtered ("a typedef.\n");
2166 printf_filtered ("a label at address ");
2167 printf_filtered ("%s", paddress (gdbarch
,
2168 SYMBOL_VALUE_ADDRESS (sym
)));
2171 printf_filtered ("a function at address ");
2172 printf_filtered ("%s",
2173 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2175 case LOC_UNRESOLVED
:
2176 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2179 printf_filtered ("Unresolved Static");
2182 printf_filtered ("static storage at address ");
2183 printf_filtered ("%s",
2184 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2187 case LOC_OPTIMIZED_OUT
:
2188 printf_filtered ("optimized out.\n");
2191 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, gdb_stdout
);
2194 if (SYMBOL_TYPE (sym
))
2195 printf_filtered (", length %d.\n",
2196 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2198 if (BLOCK_FUNCTION (block
))
2201 block
= BLOCK_SUPERBLOCK (block
);
2204 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2208 /* worker function (cleanup) */
2210 replace_comma (void *data
)
2218 trace_dump_command (char *args
, int from_tty
)
2220 struct regcache
*regcache
;
2221 struct gdbarch
*gdbarch
;
2222 struct breakpoint
*t
;
2223 struct action_line
*action
;
2224 char *action_exp
, *next_comma
;
2225 struct cleanup
*old_cleanups
;
2226 int stepping_actions
= 0;
2227 int stepping_frame
= 0;
2229 if (tracepoint_number
== -1)
2231 warning (_("No current trace frame."));
2235 t
= get_tracepoint (tracepoint_number
);
2238 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2241 old_cleanups
= make_cleanup (null_cleanup
, NULL
);
2243 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2244 tracepoint_number
, traceframe_number
);
2246 /* The current frame is a trap frame if the frame PC is equal
2247 to the tracepoint PC. If not, then the current frame was
2248 collected during single-stepping. */
2250 regcache
= get_current_regcache ();
2251 gdbarch
= get_regcache_arch (regcache
);
2253 stepping_frame
= (t
->loc
->address
!= (regcache_read_pc (regcache
)));
2255 for (action
= t
->actions
; action
; action
= action
->next
)
2257 struct cmd_list_element
*cmd
;
2259 QUIT
; /* allow user to bail out with ^C */
2260 action_exp
= action
->action
;
2261 while (isspace ((int) *action_exp
))
2264 /* The collection actions to be done while stepping are
2265 bracketed by the commands "while-stepping" and "end". */
2267 if (*action_exp
== '#') /* comment line */
2270 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2272 error (_("Bad action list item: %s"), action_exp
);
2274 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2275 stepping_actions
= 1;
2276 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2277 stepping_actions
= 0;
2278 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2280 /* Display the collected data.
2281 For the trap frame, display only what was collected at
2282 the trap. Likewise for stepping frames, display only
2283 what was collected while stepping. This means that the
2284 two boolean variables, STEPPING_FRAME and
2285 STEPPING_ACTIONS should be equal. */
2286 if (stepping_frame
== stepping_actions
)
2289 { /* repeat over a comma-separated list */
2290 QUIT
; /* allow user to bail out with ^C */
2291 if (*action_exp
== ',')
2293 while (isspace ((int) *action_exp
))
2296 next_comma
= strchr (action_exp
, ',');
2298 if (0 == strncasecmp (action_exp
, "$reg", 4))
2299 registers_info (NULL
, from_tty
);
2300 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2301 locals_info (NULL
, from_tty
);
2302 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2303 args_info (NULL
, from_tty
);
2308 make_cleanup (replace_comma
, next_comma
);
2311 printf_filtered ("%s = ", action_exp
);
2312 output_command (action_exp
, from_tty
);
2313 printf_filtered ("\n");
2317 action_exp
= next_comma
;
2319 while (action_exp
&& *action_exp
== ',');
2323 discard_cleanups (old_cleanups
);
2326 extern int trace_regblock_size
;
2329 trace_save_command (char *args
, int from_tty
)
2332 char *filename
= NULL
, *pathname
;
2333 int target_does_save
= 0;
2334 struct cleanup
*cleanup
;
2335 struct trace_status
*ts
= current_trace_status ();
2338 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2339 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2342 ULONGEST offset
= 0;
2343 #define MAX_TRACE_UPLOAD 2000
2344 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2347 error_no_arg (_("file in which to save trace data"));
2349 argv
= gdb_buildargv (args
);
2350 make_cleanup_freeargv (argv
);
2352 for (; *argv
; ++argv
)
2354 if (strcmp (*argv
, "-r") == 0)
2355 target_does_save
= 1;
2356 else if (**argv
== '-')
2357 error (_("unknown option `%s'"), *argv
);
2363 error_no_arg (_("file in which to save trace data"));
2365 /* If the target is to save the data to a file on its own, then just
2366 send the command and be done with it. */
2367 if (target_does_save
)
2369 err
= target_save_trace_data (filename
);
2371 error (_("Target failed to save trace data to '%s'."),
2376 /* Get the trace status first before opening the file, so if the
2377 target is losing, we can get out without touching files. */
2378 status
= target_get_trace_status (ts
);
2380 pathname
= tilde_expand (args
);
2381 cleanup
= make_cleanup (xfree
, pathname
);
2383 fp
= fopen (pathname
, "w");
2385 error (_("Unable to open file '%s' for saving trace data (%s)"),
2386 args
, safe_strerror (errno
));
2387 make_cleanup_fclose (fp
);
2389 /* Write a file header, with a high-bit-set char to indicate a
2390 binary file, plus a hint as what this file is, and a version
2391 number in case of future needs. */
2392 fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2394 /* Write descriptive info. */
2396 /* Write out the size of a register block. */
2397 fprintf (fp
, "R %x\n", trace_regblock_size
);
2399 /* Write out status of the tracing run (aka "tstatus" info). */
2400 fprintf (fp
, "status %c;%s:%x;tframes:%x;tfree:%x\n",
2401 (ts
->running
? '1' : '0'),
2402 stop_reason_names
[ts
->stop_reason
], ts
->stopping_tracepoint
,
2403 ts
->traceframe_count
, (unsigned int) ts
->buffer_free
);
2405 /* Note that we want to upload tracepoints and save those, rather
2406 than simply writing out the local ones, because the user may have
2407 changed tracepoints in GDB in preparation for a future tracing
2408 run, or maybe just mass-deleted all types of breakpoints as part
2409 of cleaning up. So as not to contaminate the session, leave the
2410 data in its uploaded form, don't make into real tracepoints. */
2412 /* Get trace state variables first, they may be checked when parsing
2413 uploaded commands. */
2415 target_upload_trace_state_variables (&uploaded_tsvs
);
2417 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2423 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
2424 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
2427 fprintf (fp
, "tsv %x:%s:%x:%s\n",
2428 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
2429 utsv
->builtin
, buf
);
2435 free_uploaded_tsvs (&uploaded_tsvs
);
2437 target_upload_tracepoints (&uploaded_tps
);
2439 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
2441 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
2442 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2443 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
2444 if (utp
->type
== bp_fast_tracepoint
)
2445 fprintf (fp
, ":F%x", utp
->orig_size
);
2447 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
2450 for (a
= 0; a
< utp
->numactions
; ++a
)
2451 fprintf (fp
, "tp A%x:%s:%s\n",
2452 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2454 for (a
= 0; a
< utp
->num_step_actions
; ++a
)
2455 fprintf (fp
, "tp S%x:%s:%s\n",
2456 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2457 utp
->step_actions
[a
]);
2460 free_uploaded_tps (&uploaded_tps
);
2462 /* Mark the end of the definition section. */
2465 /* Get and write the trace data proper. We ask for big blocks, in
2466 the hopes of efficiency, but will take less if the target has
2467 packet size limitations or some such. */
2470 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
2472 error (_("Failure to get requested trace buffer data"));
2473 /* No more data is forthcoming, we're done. */
2476 fwrite (buf
, gotten
, 1, fp
);
2480 /* Mark the end of trace data. */
2481 fwrite (&gotten
, 4, 1, fp
);
2483 do_cleanups (cleanup
);
2485 printf_filtered (_("Trace data saved to file '%s'.\n"), args
);
2488 /* Tell the target what to do with an ongoing tracing run if GDB
2489 disconnects for some reason. */
2492 send_disconnected_tracing_value (int value
)
2494 target_set_disconnected_tracing (value
);
2498 set_disconnected_tracing (char *args
, int from_tty
,
2499 struct cmd_list_element
*c
)
2501 send_disconnected_tracing_value (disconnected_tracing
);
2504 /* Convert the memory pointed to by mem into hex, placing result in buf.
2505 * Return a pointer to the last char put in buf (null)
2506 * "stolen" from sparc-stub.c
2509 static const char hexchars
[] = "0123456789abcdef";
2512 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2520 *buf
++ = hexchars
[ch
>> 4];
2521 *buf
++ = hexchars
[ch
& 0xf];
2530 get_traceframe_number (void)
2532 return traceframe_number
;
2536 /* Given a number and address, return an uploaded tracepoint with that
2537 number, creating if necessary. */
2539 struct uploaded_tp
*
2540 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
2542 struct uploaded_tp
*utp
;
2544 for (utp
= *utpp
; utp
; utp
= utp
->next
)
2545 if (utp
->number
== num
&& utp
->addr
== addr
)
2547 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
2548 memset (utp
, 0, sizeof (struct uploaded_tp
));
2557 free_uploaded_tps (struct uploaded_tp
**utpp
)
2559 struct uploaded_tp
*next_one
;
2563 next_one
= (*utpp
)->next
;
2569 /* Given a number and address, return an uploaded tracepoint with that
2570 number, creating if necessary. */
2572 struct uploaded_tsv
*
2573 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
2575 struct uploaded_tsv
*utsv
;
2577 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
2578 if (utsv
->number
== num
)
2580 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
2581 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
2583 utsv
->next
= *utsvp
;
2589 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
2591 struct uploaded_tsv
*next_one
;
2595 next_one
= (*utsvp
)->next
;
2601 /* Look for an existing tracepoint that seems similar enough to the
2602 uploaded one. Enablement isn't compared, because the user can
2603 toggle that freely, and may have done so in anticipation of the
2607 find_matching_tracepoint (struct uploaded_tp
*utp
)
2609 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
2611 struct breakpoint
*t
;
2612 struct bp_location
*loc
;
2614 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2616 if (t
->type
== utp
->type
2617 && t
->step_count
== utp
->step
2618 && t
->pass_count
== utp
->pass
2619 /* FIXME also test conditionals and actions */
2622 /* Scan the locations for an address match. */
2623 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2625 if (loc
->address
== utp
->addr
)
2633 /* Given a list of tracepoints uploaded from a target, attempt to
2634 match them up with existing tracepoints, and create new ones if not
2638 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
2640 struct uploaded_tp
*utp
;
2641 struct breakpoint
*t
;
2643 /* Look for GDB tracepoints that match up with our uploaded versions. */
2644 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
2646 t
= find_matching_tracepoint (utp
);
2648 printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
2649 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2652 t
= create_tracepoint_from_upload (utp
);
2654 printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
2655 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2657 printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
2658 utp
->number
, paddress (get_current_arch (), utp
->addr
));
2660 /* Whether found or created, record the number used by the
2661 target, to help with mapping target tracepoints back to their
2662 counterparts here. */
2664 t
->number_on_target
= utp
->number
;
2667 free_uploaded_tps (uploaded_tps
);
2670 /* Trace state variables don't have much to identify them beyond their
2671 name, so just use that to detect matches. */
2673 struct trace_state_variable
*
2674 find_matching_tsv (struct uploaded_tsv
*utsv
)
2679 return find_trace_state_variable (utsv
->name
);
2682 struct trace_state_variable
*
2683 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
2685 const char *namebase
;
2688 struct trace_state_variable
*tsv
;
2692 namebase
= utsv
->name
;
2693 sprintf (buf
, "%s", namebase
);
2698 sprintf (buf
, "%s_%d", namebase
, try_num
++);
2701 /* Fish for a name that is not in use. */
2702 /* (should check against all internal vars?) */
2703 while (find_trace_state_variable (buf
))
2704 sprintf (buf
, "%s_%d", namebase
, try_num
++);
2706 /* We have an available name, create the variable. */
2707 tsv
= create_trace_state_variable (xstrdup (buf
));
2708 tsv
->initial_value
= utsv
->initial_value
;
2709 tsv
->builtin
= utsv
->builtin
;
2714 /* Given a list of uploaded trace state variables, try to match them
2715 up with existing variables, or create additional ones. */
2718 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
2721 struct uploaded_tsv
*utsv
;
2722 struct trace_state_variable
*tsv
;
2725 /* Most likely some numbers will have to be reassigned as part of
2726 the merge, so clear them all in anticipation. */
2727 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2730 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2732 tsv
= find_matching_tsv (utsv
);
2734 printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
2735 tsv
->name
, utsv
->number
);
2738 tsv
= create_tsv_from_upload (utsv
);
2739 printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
2740 tsv
->name
, utsv
->number
);
2742 /* Give precedence to numberings that come from the target. */
2744 tsv
->number
= utsv
->number
;
2747 /* Renumber everything that didn't get a target-assigned number. */
2749 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2750 if (tsv
->number
> highest
)
2751 highest
= tsv
->number
;
2754 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2755 if (tsv
->number
== 0)
2756 tsv
->number
= highest
++;
2758 free_uploaded_tsvs (uploaded_tsvs
);
2761 /* target tfile command */
2763 struct target_ops tfile_ops
;
2765 /* Fill in tfile_ops with its defined operations and properties. */
2767 #define TRACE_HEADER_SIZE 8
2770 off_t trace_frames_offset
;
2773 int trace_regblock_size
;
2775 static void tfile_interp_line (char *line
,
2776 struct uploaded_tp
**utpp
,
2777 struct uploaded_tsv
**utsvp
);
2780 tfile_open (char *filename
, int from_tty
)
2783 struct cleanup
*old_chain
;
2786 char header
[TRACE_HEADER_SIZE
];
2787 char linebuf
[1000]; /* should be max remote packet size or so */
2790 struct trace_status
*ts
;
2791 struct uploaded_tp
*uploaded_tps
= NULL
;
2792 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
2794 target_preopen (from_tty
);
2796 error (_("No trace file specified."));
2798 filename
= tilde_expand (filename
);
2799 if (!IS_ABSOLUTE_PATH(filename
))
2801 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
2806 old_chain
= make_cleanup (xfree
, filename
);
2808 flags
= O_BINARY
| O_LARGEFILE
;
2810 scratch_chan
= open (filename
, flags
, 0);
2811 if (scratch_chan
< 0)
2812 perror_with_name (filename
);
2814 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
2816 discard_cleanups (old_chain
); /* Don't free filename any more */
2817 unpush_target (&tfile_ops
);
2819 push_target (&tfile_ops
);
2820 discard_cleanups (old_chain
);
2822 trace_fd
= scratch_chan
;
2825 /* Read the file header and test for validity. */
2826 read (trace_fd
, &header
, TRACE_HEADER_SIZE
);
2827 bytes
+= TRACE_HEADER_SIZE
;
2828 if (!(header
[0] == 0x7f
2829 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
2830 error (_("File is not a valid trace file."));
2832 trace_regblock_size
= 0;
2833 ts
= current_trace_status ();
2834 /* We know we're working with a file. */
2836 /* Set defaults in case there is no status line. */
2837 ts
->running_known
= 0;
2838 ts
->stop_reason
= trace_stop_reason_unknown
;
2839 ts
->traceframe_count
= -1;
2840 ts
->buffer_free
= 0;
2842 /* Read through a section of newline-terminated lines that
2843 define things like tracepoints. */
2847 read (trace_fd
, &byte
, 1);
2851 /* Empty line marks end of the definition section. */
2856 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
2859 linebuf
[i
++] = byte
;
2861 error (_("Excessively long lines in trace file"));
2864 /* Add the file's tracepoints and variables into the current mix. */
2866 merge_uploaded_tracepoints (&uploaded_tps
);
2868 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
2870 /* Record the starting offset of the binary trace data. */
2871 trace_frames_offset
= bytes
;
2873 /* If we don't have a blocksize, we can't interpret the
2875 if (trace_regblock_size
== 0)
2876 error (_("No register block size recorded in trace file"));
2877 if (ts
->traceframe_count
<= 0)
2879 warning ("No traceframes present in this file.");
2883 #define TFILE_PID (1)
2884 inferior_appeared (current_inferior (), TFILE_PID
);
2885 inferior_ptid
= pid_to_ptid (TFILE_PID
);
2886 add_thread_silent (inferior_ptid
);
2888 post_create_inferior (&tfile_ops
, from_tty
);
2891 /* FIXME this will get defined in MI patch submission */
2892 tfind_1 (tfind_number
, 0, 0, 0, 0);
2896 /* Interpret the given line from the definitions part of the trace
2900 tfile_interp_line (char *line
,
2901 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
2905 if (strncmp (p
, "R ", strlen ("R ")) == 0)
2908 trace_regblock_size
= strtol (p
, &p
, 16);
2910 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
2912 p
+= strlen ("status ");
2913 parse_trace_status (p
, current_trace_status ());
2915 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
2917 p
+= strlen ("tp ");
2918 parse_tracepoint_definition (p
, utpp
);
2920 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
2922 p
+= strlen ("tsv ");
2923 parse_tsv_definition (p
, utsvp
);
2926 warning ("Ignoring trace file definition \"%s\"", line
);
2929 /* Parse the part of trace status syntax that is shared between
2930 the remote protocol and the trace file reader. */
2932 extern char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
2935 parse_trace_status (char *line
, struct trace_status
*ts
)
2937 char *p
= line
, *p1
, *p_temp
;
2940 ts
->running_known
= 1;
2941 ts
->running
= (*p
++ == '1');
2942 ts
->stop_reason
= trace_stop_reason_unknown
;
2945 p1
= strchr (p
, ':');
2947 error (_("Malformed trace status, at %s\n\
2948 Status line: '%s'\n"), p
, line
);
2949 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
2951 p
= unpack_varlen_hex (++p1
, &val
);
2952 ts
->stop_reason
= trace_buffer_full
;
2954 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
2956 p
= unpack_varlen_hex (++p1
, &val
);
2957 ts
->stop_reason
= trace_never_run
;
2959 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
], p1
- p
) == 0)
2961 p
= unpack_varlen_hex (++p1
, &val
);
2962 ts
->stop_reason
= tracepoint_passcount
;
2963 ts
->stopping_tracepoint
= val
;
2965 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
2967 p
= unpack_varlen_hex (++p1
, &val
);
2968 ts
->stop_reason
= tstop_command
;
2970 if (strncmp (p
, "tframes", p1
- p
) == 0)
2972 p
= unpack_varlen_hex (++p1
, &val
);
2973 ts
->traceframe_count
= val
;
2975 if (strncmp (p
, "tfree", p1
- p
) == 0)
2977 p
= unpack_varlen_hex (++p1
, &val
);
2978 ts
->buffer_free
= val
;
2982 /* Silently skip unknown optional info. */
2983 p_temp
= strchr (p1
+ 1, ';');
2987 /* Must be at the end. */
2993 /* Given a line of text defining a tracepoint or tracepoint action, parse
2994 it into an "uploaded tracepoint". */
2997 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3001 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
;
3005 struct uploaded_tp
*utp
= NULL
;
3008 /* Both tracepoint and action definitions start with the same number
3009 and address sequence. */
3011 p
= unpack_varlen_hex (p
, &num
);
3012 p
++; /* skip a colon */
3013 p
= unpack_varlen_hex (p
, &addr
);
3014 p
++; /* skip a colon */
3017 enabled
= (*p
++ == 'E');
3018 p
++; /* skip a colon */
3019 p
= unpack_varlen_hex (p
, &step
);
3020 p
++; /* skip a colon */
3021 p
= unpack_varlen_hex (p
, &pass
);
3022 type
= bp_tracepoint
;
3024 /* Thumb through optional fields. */
3027 p
++; /* skip a colon */
3030 type
= bp_fast_tracepoint
;
3032 p
= unpack_varlen_hex (p
, &orig_size
);
3037 p
= unpack_varlen_hex (p
, &xlen
);
3038 p
++; /* skip a comma */
3039 cond
= (char *) xmalloc (2 * xlen
+ 1);
3040 strncpy (cond
, p
, 2 * xlen
);
3041 cond
[2 * xlen
] = '\0';
3045 warning ("Unrecognized char '%c' in tracepoint definition, skipping rest", *p
);
3047 utp
= get_uploaded_tp (num
, addr
, utpp
);
3049 utp
->enabled
= enabled
;
3054 else if (piece
== 'A')
3056 utp
= get_uploaded_tp (num
, addr
, utpp
);
3057 utp
->actions
[utp
->numactions
++] = xstrdup (p
);
3059 else if (piece
== 'S')
3061 utp
= get_uploaded_tp (num
, addr
, utpp
);
3062 utp
->step_actions
[utp
->num_step_actions
++] = xstrdup (p
);
3066 error ("Invalid tracepoint piece");
3070 /* Convert a textual description of a trace state variable into an
3074 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3077 ULONGEST num
, initval
, builtin
;
3079 struct uploaded_tsv
*utsv
= NULL
;
3081 buf
= alloca (strlen (line
));
3084 p
= unpack_varlen_hex (p
, &num
);
3085 p
++; /* skip a colon */
3086 p
= unpack_varlen_hex (p
, &initval
);
3087 p
++; /* skip a colon */
3088 p
= unpack_varlen_hex (p
, &builtin
);
3089 p
++; /* skip a colon */
3090 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3093 utsv
= get_uploaded_tsv (num
, utsvp
);
3094 utsv
->initial_value
= initval
;
3095 utsv
->builtin
= builtin
;
3096 utsv
->name
= xstrdup (buf
);
3099 /* Close the trace file and generally clean up. */
3102 tfile_close (int quitting
)
3109 pid
= ptid_get_pid (inferior_ptid
);
3110 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
3111 exit_inferior_silent (pid
);
3118 tfile_files_info (struct target_ops
*t
)
3120 /* (it would be useful to mention the name of the file) */
3121 printf_filtered ("Looking at a trace file.\n");
3124 /* The trace status for a file is that tracing can never be run. */
3127 tfile_get_trace_status (struct trace_status
*ts
)
3129 /* Other bits of trace status were collected as part of opening the
3130 trace files, so nothing to do here. */
3135 /* Given the position of a traceframe in the file, figure out what
3136 address the frame was collected at. This would normally be the
3137 value of a collected PC register, but if not available, we
3141 tfile_get_traceframe_address (off_t tframe_offset
)
3145 struct breakpoint
*tp
;
3146 off_t saved_offset
= cur_offset
;
3148 /* FIXME dig pc out of collected registers */
3150 /* Fall back to using tracepoint address. */
3151 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
3152 read (trace_fd
, &tpnum
, 2);
3153 tp
= get_tracepoint_by_number_on_target (tpnum
);
3155 addr
= tp
->loc
->address
;
3157 /* Restore our seek position. */
3158 cur_offset
= saved_offset
;
3159 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3163 /* Given a type of search and some parameters, scan the collection of
3164 traceframes in the file looking for a match. When found, return
3165 both the traceframe and tracepoint number, otherwise -1 for
3169 tfile_trace_find (enum trace_find_type type
, int num
,
3170 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
3173 int tfnum
= 0, found
= 0;
3175 struct breakpoint
*tp
;
3176 off_t offset
, tframe_offset
;
3179 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
3180 offset
= trace_frames_offset
;
3183 tframe_offset
= offset
;
3184 read (trace_fd
, &tpnum
, 2);
3188 read (trace_fd
, &data_size
, 4);
3197 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3198 if (tfaddr
== addr1
)
3202 tp
= get_tracepoint (num
);
3203 if (tp
&& tpnum
== tp
->number_on_target
)
3207 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3208 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
3212 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3213 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
3217 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
3221 printf_filtered ("Found traceframe %d.\n", tfnum
);
3224 cur_offset
= offset
;
3225 cur_data_size
= data_size
;
3228 /* Skip past the traceframe's data. */
3229 lseek (trace_fd
, data_size
, SEEK_CUR
);
3230 offset
+= data_size
;
3231 /* Update our own count of traceframes. */
3234 /* Did not find what we were looking for. */
3240 /* Look for a block of saved registers in the traceframe, and get the
3241 requested register from it. */
3244 tfile_fetch_registers (struct target_ops
*ops
,
3245 struct regcache
*regcache
, int regno
)
3247 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3249 int i
, pos
, offset
, regn
, regsize
;
3250 unsigned short mlen
;
3253 /* An uninitialized reg size says we're not going to be
3254 successful at getting register blocks. */
3255 if (!trace_regblock_size
)
3258 regs
= alloca (trace_regblock_size
);
3260 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3262 while (pos
< cur_data_size
)
3264 read (trace_fd
, &block_type
, 1);
3269 read (trace_fd
, regs
, trace_regblock_size
);
3270 /* Assume the block is laid out in GDB register number order,
3271 each register with the size that it has in GDB. */
3273 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3275 regsize
= register_size (gdbarch
, regn
);
3276 /* Make sure we stay within block bounds. */
3277 if (offset
+ regsize
>= trace_regblock_size
)
3279 if (!regcache_valid_p (regcache
, regn
))
3283 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
3286 else if (regno
== -1)
3288 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
3295 lseek (trace_fd
, 8, SEEK_CUR
);
3296 read (trace_fd
, &mlen
, 2);
3297 lseek (trace_fd
, mlen
, SEEK_CUR
);
3298 pos
+= (8 + 2 + mlen
);
3301 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3305 error ("Unknown block type '%c' (0x%x) in trace frame",
3306 block_type
, block_type
);
3313 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3314 const char *annex
, gdb_byte
*readbuf
,
3315 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3320 unsigned short mlen
;
3322 /* We're only doing regular memory for now. */
3323 if (object
!= TARGET_OBJECT_MEMORY
)
3326 if (readbuf
== NULL
)
3327 error ("tfile_xfer_partial: trace file is read-only");
3329 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3331 while (pos
< cur_data_size
)
3333 read (trace_fd
, &block_type
, 1);
3338 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3339 pos
+= trace_regblock_size
;
3342 read (trace_fd
, &maddr
, 8);
3343 read (trace_fd
, &mlen
, 2);
3344 if (maddr
<= offset
&& (offset
+ len
) <= (maddr
+ mlen
))
3346 read (trace_fd
, readbuf
, mlen
);
3349 lseek (trace_fd
, mlen
, SEEK_CUR
);
3350 pos
+= (8 + 2 + mlen
);
3353 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3357 error ("Unknown block type '%c' (0x%x) in traceframe",
3358 block_type
, block_type
);
3362 /* Indicate failure to find the requested memory block. */
3366 /* Iterate through the blocks of a trace frame, looking for a 'V'
3367 block with a matching tsv number. */
3370 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
3374 unsigned short mlen
;
3376 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3378 while (pos
< cur_data_size
)
3380 read (trace_fd
, &block_type
, 1);
3385 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3386 pos
+= trace_regblock_size
;
3389 lseek (trace_fd
, 8, SEEK_CUR
);
3390 read (trace_fd
, &mlen
, 2);
3391 lseek (trace_fd
, mlen
, SEEK_CUR
);
3392 pos
+= (8 + 2 + mlen
);
3395 read (trace_fd
, &vnum
, 4);
3398 read (trace_fd
, val
, 8);
3401 lseek (trace_fd
, 8, SEEK_CUR
);
3405 error ("Unknown block type '%c' (0x%x) in traceframe",
3406 block_type
, block_type
);
3410 /* Didn't find anything. */
3415 tfile_has_memory (struct target_ops
*ops
)
3421 tfile_has_stack (struct target_ops
*ops
)
3427 tfile_has_registers (struct target_ops
*ops
)
3433 init_tfile_ops (void)
3435 tfile_ops
.to_shortname
= "tfile";
3436 tfile_ops
.to_longname
= "Local trace dump file";
3438 "Use a trace file as a target. Specify the filename of the trace file.";
3439 tfile_ops
.to_open
= tfile_open
;
3440 tfile_ops
.to_close
= tfile_close
;
3441 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
3442 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
3443 tfile_ops
.to_files_info
= tfile_files_info
;
3444 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
3445 tfile_ops
.to_trace_find
= tfile_trace_find
;
3446 tfile_ops
.to_get_trace_state_variable_value
= tfile_get_trace_state_variable_value
;
3447 /* core_stratum might seem more logical, but GDB doesn't like having
3448 more than one core_stratum vector. */
3449 tfile_ops
.to_stratum
= process_stratum
;
3450 tfile_ops
.to_has_memory
= tfile_has_memory
;
3451 tfile_ops
.to_has_stack
= tfile_has_stack
;
3452 tfile_ops
.to_has_registers
= tfile_has_registers
;
3453 tfile_ops
.to_magic
= OPS_MAGIC
;
3456 /* module initialization */
3458 _initialize_tracepoint (void)
3460 struct cmd_list_element
*c
;
3462 traceframe_number
= -1;
3463 tracepoint_number
= -1;
3465 if (tracepoint_list
.list
== NULL
)
3467 tracepoint_list
.listsize
= 128;
3468 tracepoint_list
.list
= xmalloc
3469 (tracepoint_list
.listsize
* sizeof (struct memrange
));
3471 if (tracepoint_list
.aexpr_list
== NULL
)
3473 tracepoint_list
.aexpr_listsize
= 128;
3474 tracepoint_list
.aexpr_list
= xmalloc
3475 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3478 if (stepping_list
.list
== NULL
)
3480 stepping_list
.listsize
= 128;
3481 stepping_list
.list
= xmalloc
3482 (stepping_list
.listsize
* sizeof (struct memrange
));
3485 if (stepping_list
.aexpr_list
== NULL
)
3487 stepping_list
.aexpr_listsize
= 128;
3488 stepping_list
.aexpr_list
= xmalloc
3489 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3492 add_info ("scope", scope_info
,
3493 _("List the variables local to a scope"));
3495 add_cmd ("tracepoints", class_trace
, NULL
,
3496 _("Tracing of program execution without stopping the program."),
3499 add_com ("tdump", class_trace
, trace_dump_command
,
3500 _("Print everything collected at the current tracepoint."));
3502 add_com ("tsave", class_trace
, trace_save_command
, _("\
3503 Save the trace data to a file.\n\
3504 Use the '-r' option to direct the target to save directly to the file,\n\
3505 using its own filesystem."));
3507 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
3508 Define a trace state variable.\n\
3509 Argument is a $-prefixed name, optionally followed\n\
3510 by '=' and an expression that sets the initial value\n\
3511 at the start of tracing."));
3512 set_cmd_completer (c
, expression_completer
);
3514 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
3515 Delete one or more trace state variables.\n\
3516 Arguments are the names of the variables to delete.\n\
3517 If no arguments are supplied, delete all variables."), &deletelist
);
3518 /* FIXME add a trace variable completer */
3520 add_info ("tvariables", tvariables_info
, _("\
3521 Status of trace state variables and their values.\n\
3524 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
3525 Select a trace frame;\n\
3526 No argument means forward by one frame; '-' means backward by one frame."),
3527 &tfindlist
, "tfind ", 1, &cmdlist
);
3529 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
3530 Select a trace frame whose PC is outside the given range.\n\
3531 Usage: tfind outside addr1, addr2"),
3534 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
3535 Select a trace frame whose PC is in the given range.\n\
3536 Usage: tfind range addr1,addr2"),
3539 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
3540 Select a trace frame by source line.\n\
3541 Argument can be a line number (with optional source file), \n\
3542 a function name, or '*' followed by an address.\n\
3543 Default argument is 'the next source line that was traced'."),
3546 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
3547 Select a trace frame by tracepoint number.\n\
3548 Default is the tracepoint for the current trace frame."),
3551 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
3552 Select a trace frame by PC.\n\
3553 Default is the current PC, or the PC of the current trace frame."),
3556 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
3557 Synonym for 'none'.\n\
3558 De-select any trace frame and resume 'live' debugging."),
3561 add_cmd ("none", class_trace
, trace_find_none_command
,
3562 _("De-select any trace frame and resume 'live' debugging."),
3565 add_cmd ("start", class_trace
, trace_find_start_command
,
3566 _("Select the first trace frame in the trace buffer."),
3569 add_com ("tstatus", class_trace
, trace_status_command
,
3570 _("Display the status of the current trace data collection."));
3572 add_com ("tstop", class_trace
, trace_stop_command
,
3573 _("Stop trace data collection."));
3575 add_com ("tstart", class_trace
, trace_start_command
,
3576 _("Start trace data collection."));
3578 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
3579 Ends a list of commands or actions.\n\
3580 Several GDB commands allow you to enter a list of commands or actions.\n\
3581 Entering \"end\" on a line by itself is the normal way to terminate\n\
3583 Note: the \"end\" command cannot be used at the gdb prompt."));
3585 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
3586 Specify single-stepping behavior at a tracepoint.\n\
3587 Argument is number of instructions to trace in single-step mode\n\
3588 following the tracepoint. This command is normally followed by\n\
3589 one or more \"collect\" commands, to specify what to collect\n\
3590 while single-stepping.\n\n\
3591 Note: this command can only be used in a tracepoint \"actions\" list."));
3593 add_com_alias ("ws", "while-stepping", class_alias
, 0);
3594 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
3596 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
3597 Specify one or more data items to be collected at a tracepoint.\n\
3598 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
3599 collect all data (variables, registers) referenced by that expression.\n\
3600 Also accepts the following special arguments:\n\
3601 $regs -- all registers.\n\
3602 $args -- all function arguments.\n\
3603 $locals -- all variables local to the block/function scope.\n\
3604 Note: this command can only be used in a tracepoint \"actions\" list."));
3606 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
3607 Specify one or more expressions to be evaluated at a tracepoint.\n\
3608 Accepts a comma-separated list of (one or more) expressions.\n\
3609 The result of each evaluation will be discarded.\n\
3610 Note: this command can only be used in a tracepoint \"actions\" list."));
3612 add_com ("actions", class_trace
, trace_actions_command
, _("\
3613 Specify the actions to be taken at a tracepoint.\n\
3614 Tracepoint actions may include collecting of specified data, \n\
3615 single-stepping, or enabling/disabling other tracepoints, \n\
3616 depending on target's capabilities."));
3618 default_collect
= xstrdup ("");
3619 add_setshow_string_cmd ("default-collect", class_trace
,
3620 &default_collect
, _("\
3621 Set the list of expressions to collect by default"), _("\
3622 Show the list of expressions to collect by default"), NULL
,
3624 &setlist
, &showlist
);
3626 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
3627 &disconnected_tracing
, _("\
3628 Set whether tracing continues after GDB disconnects."), _("\
3629 Show whether tracing continues after GDB disconnects."), _("\
3630 Use this to continue a tracing run even if GDB disconnects\n\
3631 or detaches from the target. You can reconnect later and look at\n\
3632 trace data collected in the meantime."),
3633 set_disconnected_tracing
,
3640 add_target (&tfile_ops
);