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 %llu 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
];
2348 error_no_arg (_("file in which to save trace data"));
2350 argv
= gdb_buildargv (args
);
2351 make_cleanup_freeargv (argv
);
2353 for (; *argv
; ++argv
)
2355 if (strcmp (*argv
, "-r") == 0)
2356 target_does_save
= 1;
2357 else if (**argv
== '-')
2358 error (_("unknown option `%s'"), *argv
);
2364 error_no_arg (_("file in which to save trace data"));
2366 /* If the target is to save the data to a file on its own, then just
2367 send the command and be done with it. */
2368 if (target_does_save
)
2370 err
= target_save_trace_data (filename
);
2372 error (_("Target failed to save trace data to '%s'."),
2377 /* Get the trace status first before opening the file, so if the
2378 target is losing, we can get out without touching files. */
2379 status
= target_get_trace_status (ts
);
2381 pathname
= tilde_expand (args
);
2382 cleanup
= make_cleanup (xfree
, pathname
);
2384 fp
= fopen (pathname
, "w");
2386 error (_("Unable to open file '%s' for saving trace data (%s)"),
2387 args
, safe_strerror (errno
));
2388 make_cleanup_fclose (fp
);
2390 /* Write a file header, with a high-bit-set char to indicate a
2391 binary file, plus a hint as what this file is, and a version
2392 number in case of future needs. */
2393 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2395 perror_with_name (pathname
);
2397 /* Write descriptive info. */
2399 /* Write out the size of a register block. */
2400 fprintf (fp
, "R %x\n", trace_regblock_size
);
2402 /* Write out status of the tracing run (aka "tstatus" info). */
2403 fprintf (fp
, "status %c;%s:%x;tframes:%x;tfree:%llx\n",
2404 (ts
->running
? '1' : '0'),
2405 stop_reason_names
[ts
->stop_reason
], ts
->stopping_tracepoint
,
2406 ts
->traceframe_count
, ts
->buffer_free
);
2408 /* Note that we want to upload tracepoints and save those, rather
2409 than simply writing out the local ones, because the user may have
2410 changed tracepoints in GDB in preparation for a future tracing
2411 run, or maybe just mass-deleted all types of breakpoints as part
2412 of cleaning up. So as not to contaminate the session, leave the
2413 data in its uploaded form, don't make into real tracepoints. */
2415 /* Get trace state variables first, they may be checked when parsing
2416 uploaded commands. */
2418 target_upload_trace_state_variables (&uploaded_tsvs
);
2420 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2426 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
2427 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
2430 fprintf (fp
, "tsv %x:%s:%x:%s\n",
2431 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
2432 utsv
->builtin
, buf
);
2438 free_uploaded_tsvs (&uploaded_tsvs
);
2440 target_upload_tracepoints (&uploaded_tps
);
2442 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
2444 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
2445 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2446 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
2447 if (utp
->type
== bp_fast_tracepoint
)
2448 fprintf (fp
, ":F%x", utp
->orig_size
);
2450 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
2453 for (a
= 0; a
< utp
->numactions
; ++a
)
2454 fprintf (fp
, "tp A%x:%s:%s\n",
2455 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2457 for (a
= 0; a
< utp
->num_step_actions
; ++a
)
2458 fprintf (fp
, "tp S%x:%s:%s\n",
2459 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2460 utp
->step_actions
[a
]);
2463 free_uploaded_tps (&uploaded_tps
);
2465 /* Mark the end of the definition section. */
2468 /* Get and write the trace data proper. We ask for big blocks, in
2469 the hopes of efficiency, but will take less if the target has
2470 packet size limitations or some such. */
2473 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
2475 error (_("Failure to get requested trace buffer data"));
2476 /* No more data is forthcoming, we're done. */
2479 written
= fwrite (buf
, gotten
, 1, fp
);
2480 if (written
< gotten
)
2481 perror_with_name (pathname
);
2485 /* Mark the end of trace data. */
2486 written
= fwrite (&gotten
, 4, 1, fp
);
2488 perror_with_name (pathname
);
2490 do_cleanups (cleanup
);
2492 printf_filtered (_("Trace data saved to file '%s'.\n"), args
);
2495 /* Tell the target what to do with an ongoing tracing run if GDB
2496 disconnects for some reason. */
2499 send_disconnected_tracing_value (int value
)
2501 target_set_disconnected_tracing (value
);
2505 set_disconnected_tracing (char *args
, int from_tty
,
2506 struct cmd_list_element
*c
)
2508 send_disconnected_tracing_value (disconnected_tracing
);
2511 /* Convert the memory pointed to by mem into hex, placing result in buf.
2512 * Return a pointer to the last char put in buf (null)
2513 * "stolen" from sparc-stub.c
2516 static const char hexchars
[] = "0123456789abcdef";
2519 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2527 *buf
++ = hexchars
[ch
>> 4];
2528 *buf
++ = hexchars
[ch
& 0xf];
2537 get_traceframe_number (void)
2539 return traceframe_number
;
2543 /* Given a number and address, return an uploaded tracepoint with that
2544 number, creating if necessary. */
2546 struct uploaded_tp
*
2547 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
2549 struct uploaded_tp
*utp
;
2551 for (utp
= *utpp
; utp
; utp
= utp
->next
)
2552 if (utp
->number
== num
&& utp
->addr
== addr
)
2554 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
2555 memset (utp
, 0, sizeof (struct uploaded_tp
));
2564 free_uploaded_tps (struct uploaded_tp
**utpp
)
2566 struct uploaded_tp
*next_one
;
2570 next_one
= (*utpp
)->next
;
2576 /* Given a number and address, return an uploaded tracepoint with that
2577 number, creating if necessary. */
2579 struct uploaded_tsv
*
2580 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
2582 struct uploaded_tsv
*utsv
;
2584 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
2585 if (utsv
->number
== num
)
2587 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
2588 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
2590 utsv
->next
= *utsvp
;
2596 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
2598 struct uploaded_tsv
*next_one
;
2602 next_one
= (*utsvp
)->next
;
2608 /* Look for an existing tracepoint that seems similar enough to the
2609 uploaded one. Enablement isn't compared, because the user can
2610 toggle that freely, and may have done so in anticipation of the
2614 find_matching_tracepoint (struct uploaded_tp
*utp
)
2616 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
2618 struct breakpoint
*t
;
2619 struct bp_location
*loc
;
2621 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2623 if (t
->type
== utp
->type
2624 && t
->step_count
== utp
->step
2625 && t
->pass_count
== utp
->pass
2626 /* FIXME also test conditionals and actions */
2629 /* Scan the locations for an address match. */
2630 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2632 if (loc
->address
== utp
->addr
)
2640 /* Given a list of tracepoints uploaded from a target, attempt to
2641 match them up with existing tracepoints, and create new ones if not
2645 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
2647 struct uploaded_tp
*utp
;
2648 struct breakpoint
*t
;
2650 /* Look for GDB tracepoints that match up with our uploaded versions. */
2651 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
2653 t
= find_matching_tracepoint (utp
);
2655 printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
2656 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2659 t
= create_tracepoint_from_upload (utp
);
2661 printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
2662 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2664 printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
2665 utp
->number
, paddress (get_current_arch (), utp
->addr
));
2667 /* Whether found or created, record the number used by the
2668 target, to help with mapping target tracepoints back to their
2669 counterparts here. */
2671 t
->number_on_target
= utp
->number
;
2674 free_uploaded_tps (uploaded_tps
);
2677 /* Trace state variables don't have much to identify them beyond their
2678 name, so just use that to detect matches. */
2680 struct trace_state_variable
*
2681 find_matching_tsv (struct uploaded_tsv
*utsv
)
2686 return find_trace_state_variable (utsv
->name
);
2689 struct trace_state_variable
*
2690 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
2692 const char *namebase
;
2695 struct trace_state_variable
*tsv
;
2699 namebase
= utsv
->name
;
2700 sprintf (buf
, "%s", namebase
);
2705 sprintf (buf
, "%s_%d", namebase
, try_num
++);
2708 /* Fish for a name that is not in use. */
2709 /* (should check against all internal vars?) */
2710 while (find_trace_state_variable (buf
))
2711 sprintf (buf
, "%s_%d", namebase
, try_num
++);
2713 /* We have an available name, create the variable. */
2714 tsv
= create_trace_state_variable (xstrdup (buf
));
2715 tsv
->initial_value
= utsv
->initial_value
;
2716 tsv
->builtin
= utsv
->builtin
;
2721 /* Given a list of uploaded trace state variables, try to match them
2722 up with existing variables, or create additional ones. */
2725 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
2728 struct uploaded_tsv
*utsv
;
2729 struct trace_state_variable
*tsv
;
2732 /* Most likely some numbers will have to be reassigned as part of
2733 the merge, so clear them all in anticipation. */
2734 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2737 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2739 tsv
= find_matching_tsv (utsv
);
2741 printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
2742 tsv
->name
, utsv
->number
);
2745 tsv
= create_tsv_from_upload (utsv
);
2746 printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
2747 tsv
->name
, utsv
->number
);
2749 /* Give precedence to numberings that come from the target. */
2751 tsv
->number
= utsv
->number
;
2754 /* Renumber everything that didn't get a target-assigned number. */
2756 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2757 if (tsv
->number
> highest
)
2758 highest
= tsv
->number
;
2761 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2762 if (tsv
->number
== 0)
2763 tsv
->number
= highest
++;
2765 free_uploaded_tsvs (uploaded_tsvs
);
2768 /* target tfile command */
2770 struct target_ops tfile_ops
;
2772 /* Fill in tfile_ops with its defined operations and properties. */
2774 #define TRACE_HEADER_SIZE 8
2776 char *trace_filename
;
2778 off_t trace_frames_offset
;
2781 int trace_regblock_size
;
2783 static void tfile_interp_line (char *line
,
2784 struct uploaded_tp
**utpp
,
2785 struct uploaded_tsv
**utsvp
);
2788 tfile_open (char *filename
, int from_tty
)
2791 struct cleanup
*old_chain
;
2794 char header
[TRACE_HEADER_SIZE
];
2795 char linebuf
[1000]; /* should be max remote packet size or so */
2797 int bytes
, i
, gotten
;
2798 struct trace_status
*ts
;
2799 struct uploaded_tp
*uploaded_tps
= NULL
;
2800 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
2802 target_preopen (from_tty
);
2804 error (_("No trace file specified."));
2806 filename
= tilde_expand (filename
);
2807 if (!IS_ABSOLUTE_PATH(filename
))
2809 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
2814 old_chain
= make_cleanup (xfree
, filename
);
2816 flags
= O_BINARY
| O_LARGEFILE
;
2818 scratch_chan
= open (filename
, flags
, 0);
2819 if (scratch_chan
< 0)
2820 perror_with_name (filename
);
2822 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
2824 discard_cleanups (old_chain
); /* Don't free filename any more */
2825 unpush_target (&tfile_ops
);
2827 push_target (&tfile_ops
);
2828 discard_cleanups (old_chain
);
2830 trace_filename
= xstrdup (filename
);
2831 trace_fd
= scratch_chan
;
2834 /* Read the file header and test for validity. */
2835 gotten
= read (trace_fd
, &header
, TRACE_HEADER_SIZE
);
2837 perror_with_name (trace_filename
);
2838 else if (gotten
< TRACE_HEADER_SIZE
)
2839 error (_("Premature end of file while reading trace file"));
2841 bytes
+= TRACE_HEADER_SIZE
;
2842 if (!(header
[0] == 0x7f
2843 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
2844 error (_("File is not a valid trace file."));
2846 trace_regblock_size
= 0;
2847 ts
= current_trace_status ();
2848 /* We know we're working with a file. */
2850 /* Set defaults in case there is no status line. */
2851 ts
->running_known
= 0;
2852 ts
->stop_reason
= trace_stop_reason_unknown
;
2853 ts
->traceframe_count
= -1;
2854 ts
->buffer_free
= 0;
2856 /* Read through a section of newline-terminated lines that
2857 define things like tracepoints. */
2861 gotten
= read (trace_fd
, &byte
, 1);
2863 perror_with_name (trace_filename
);
2864 else if (gotten
< 1)
2865 error (_("Premature end of file while reading trace file"));
2870 /* Empty line marks end of the definition section. */
2875 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
2878 linebuf
[i
++] = byte
;
2880 error (_("Excessively long lines in trace file"));
2883 /* Add the file's tracepoints and variables into the current mix. */
2885 merge_uploaded_tracepoints (&uploaded_tps
);
2887 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
2889 /* Record the starting offset of the binary trace data. */
2890 trace_frames_offset
= bytes
;
2892 /* If we don't have a blocksize, we can't interpret the
2894 if (trace_regblock_size
== 0)
2895 error (_("No register block size recorded in trace file"));
2896 if (ts
->traceframe_count
<= 0)
2898 warning ("No traceframes present in this file.");
2902 #define TFILE_PID (1)
2903 inferior_appeared (current_inferior (), TFILE_PID
);
2904 inferior_ptid
= pid_to_ptid (TFILE_PID
);
2905 add_thread_silent (inferior_ptid
);
2907 post_create_inferior (&tfile_ops
, from_tty
);
2910 /* FIXME this will get defined in MI patch submission */
2911 tfind_1 (tfind_number
, 0, 0, 0, 0);
2915 /* Interpret the given line from the definitions part of the trace
2919 tfile_interp_line (char *line
,
2920 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
2924 if (strncmp (p
, "R ", strlen ("R ")) == 0)
2927 trace_regblock_size
= strtol (p
, &p
, 16);
2929 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
2931 p
+= strlen ("status ");
2932 parse_trace_status (p
, current_trace_status ());
2934 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
2936 p
+= strlen ("tp ");
2937 parse_tracepoint_definition (p
, utpp
);
2939 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
2941 p
+= strlen ("tsv ");
2942 parse_tsv_definition (p
, utsvp
);
2945 warning ("Ignoring trace file definition \"%s\"", line
);
2948 /* Parse the part of trace status syntax that is shared between
2949 the remote protocol and the trace file reader. */
2951 extern char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
2954 parse_trace_status (char *line
, struct trace_status
*ts
)
2956 char *p
= line
, *p1
, *p_temp
;
2959 ts
->running_known
= 1;
2960 ts
->running
= (*p
++ == '1');
2961 ts
->stop_reason
= trace_stop_reason_unknown
;
2964 p1
= strchr (p
, ':');
2966 error (_("Malformed trace status, at %s\n\
2967 Status line: '%s'\n"), p
, line
);
2968 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
2970 p
= unpack_varlen_hex (++p1
, &val
);
2971 ts
->stop_reason
= trace_buffer_full
;
2973 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
2975 p
= unpack_varlen_hex (++p1
, &val
);
2976 ts
->stop_reason
= trace_never_run
;
2978 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
], p1
- p
) == 0)
2980 p
= unpack_varlen_hex (++p1
, &val
);
2981 ts
->stop_reason
= tracepoint_passcount
;
2982 ts
->stopping_tracepoint
= val
;
2984 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
2986 p
= unpack_varlen_hex (++p1
, &val
);
2987 ts
->stop_reason
= tstop_command
;
2989 if (strncmp (p
, "tframes", p1
- p
) == 0)
2991 p
= unpack_varlen_hex (++p1
, &val
);
2992 ts
->traceframe_count
= val
;
2994 if (strncmp (p
, "tfree", p1
- p
) == 0)
2996 p
= unpack_varlen_hex (++p1
, &val
);
2997 ts
->buffer_free
= val
;
3001 /* Silently skip unknown optional info. */
3002 p_temp
= strchr (p1
+ 1, ';');
3006 /* Must be at the end. */
3012 /* Given a line of text defining a tracepoint or tracepoint action, parse
3013 it into an "uploaded tracepoint". */
3016 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3020 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
;
3024 struct uploaded_tp
*utp
= NULL
;
3027 /* Both tracepoint and action definitions start with the same number
3028 and address sequence. */
3030 p
= unpack_varlen_hex (p
, &num
);
3031 p
++; /* skip a colon */
3032 p
= unpack_varlen_hex (p
, &addr
);
3033 p
++; /* skip a colon */
3036 enabled
= (*p
++ == 'E');
3037 p
++; /* skip a colon */
3038 p
= unpack_varlen_hex (p
, &step
);
3039 p
++; /* skip a colon */
3040 p
= unpack_varlen_hex (p
, &pass
);
3041 type
= bp_tracepoint
;
3043 /* Thumb through optional fields. */
3046 p
++; /* skip a colon */
3049 type
= bp_fast_tracepoint
;
3051 p
= unpack_varlen_hex (p
, &orig_size
);
3056 p
= unpack_varlen_hex (p
, &xlen
);
3057 p
++; /* skip a comma */
3058 cond
= (char *) xmalloc (2 * xlen
+ 1);
3059 strncpy (cond
, p
, 2 * xlen
);
3060 cond
[2 * xlen
] = '\0';
3064 warning ("Unrecognized char '%c' in tracepoint definition, skipping rest", *p
);
3066 utp
= get_uploaded_tp (num
, addr
, utpp
);
3068 utp
->enabled
= enabled
;
3073 else if (piece
== 'A')
3075 utp
= get_uploaded_tp (num
, addr
, utpp
);
3076 utp
->actions
[utp
->numactions
++] = xstrdup (p
);
3078 else if (piece
== 'S')
3080 utp
= get_uploaded_tp (num
, addr
, utpp
);
3081 utp
->step_actions
[utp
->num_step_actions
++] = xstrdup (p
);
3085 error ("Invalid tracepoint piece");
3089 /* Convert a textual description of a trace state variable into an
3093 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3096 ULONGEST num
, initval
, builtin
;
3098 struct uploaded_tsv
*utsv
= NULL
;
3100 buf
= alloca (strlen (line
));
3103 p
= unpack_varlen_hex (p
, &num
);
3104 p
++; /* skip a colon */
3105 p
= unpack_varlen_hex (p
, &initval
);
3106 p
++; /* skip a colon */
3107 p
= unpack_varlen_hex (p
, &builtin
);
3108 p
++; /* skip a colon */
3109 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3112 utsv
= get_uploaded_tsv (num
, utsvp
);
3113 utsv
->initial_value
= initval
;
3114 utsv
->builtin
= builtin
;
3115 utsv
->name
= xstrdup (buf
);
3118 /* Close the trace file and generally clean up. */
3121 tfile_close (int quitting
)
3128 pid
= ptid_get_pid (inferior_ptid
);
3129 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
3130 exit_inferior_silent (pid
);
3135 xfree (trace_filename
);
3139 tfile_files_info (struct target_ops
*t
)
3141 /* (it would be useful to mention the name of the file) */
3142 printf_filtered ("Looking at a trace file.\n");
3145 /* The trace status for a file is that tracing can never be run. */
3148 tfile_get_trace_status (struct trace_status
*ts
)
3150 /* Other bits of trace status were collected as part of opening the
3151 trace files, so nothing to do here. */
3156 /* Given the position of a traceframe in the file, figure out what
3157 address the frame was collected at. This would normally be the
3158 value of a collected PC register, but if not available, we
3162 tfile_get_traceframe_address (off_t tframe_offset
)
3166 struct breakpoint
*tp
;
3167 off_t saved_offset
= cur_offset
;
3170 /* FIXME dig pc out of collected registers */
3172 /* Fall back to using tracepoint address. */
3173 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
3174 gotten
= read (trace_fd
, &tpnum
, 2);
3176 perror_with_name (trace_filename
);
3177 else if (gotten
< 2)
3178 error (_("Premature end of file while reading trace file"));
3180 tp
= get_tracepoint_by_number_on_target (tpnum
);
3182 addr
= tp
->loc
->address
;
3184 /* Restore our seek position. */
3185 cur_offset
= saved_offset
;
3186 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3190 /* Given a type of search and some parameters, scan the collection of
3191 traceframes in the file looking for a match. When found, return
3192 both the traceframe and tracepoint number, otherwise -1 for
3196 tfile_trace_find (enum trace_find_type type
, int num
,
3197 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
3200 int tfnum
= 0, found
= 0, gotten
;
3202 struct breakpoint
*tp
;
3203 off_t offset
, tframe_offset
;
3206 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
3207 offset
= trace_frames_offset
;
3210 tframe_offset
= offset
;
3211 gotten
= read (trace_fd
, &tpnum
, 2);
3213 perror_with_name (trace_filename
);
3214 else if (gotten
< 2)
3215 error (_("Premature end of file while reading trace file"));
3219 gotten
= read (trace_fd
, &data_size
, 4);
3221 perror_with_name (trace_filename
);
3222 else if (gotten
< 4)
3223 error (_("Premature end of file while reading trace file"));
3232 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3233 if (tfaddr
== addr1
)
3237 tp
= get_tracepoint (num
);
3238 if (tp
&& tpnum
== tp
->number_on_target
)
3242 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3243 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
3247 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3248 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
3252 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
3256 printf_filtered ("Found traceframe %d.\n", tfnum
);
3259 cur_offset
= offset
;
3260 cur_data_size
= data_size
;
3263 /* Skip past the traceframe's data. */
3264 lseek (trace_fd
, data_size
, SEEK_CUR
);
3265 offset
+= data_size
;
3266 /* Update our own count of traceframes. */
3269 /* Did not find what we were looking for. */
3275 /* Look for a block of saved registers in the traceframe, and get the
3276 requested register from it. */
3279 tfile_fetch_registers (struct target_ops
*ops
,
3280 struct regcache
*regcache
, int regno
)
3282 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3284 int i
, pos
, offset
, regn
, regsize
, gotten
;
3285 unsigned short mlen
;
3288 /* An uninitialized reg size says we're not going to be
3289 successful at getting register blocks. */
3290 if (!trace_regblock_size
)
3293 regs
= alloca (trace_regblock_size
);
3295 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3297 while (pos
< cur_data_size
)
3299 gotten
= read (trace_fd
, &block_type
, 1);
3301 perror_with_name (trace_filename
);
3302 else if (gotten
< 1)
3303 error (_("Premature end of file while reading trace file"));
3309 gotten
= read (trace_fd
, regs
, trace_regblock_size
);
3311 perror_with_name (trace_filename
);
3312 else if (gotten
< trace_regblock_size
)
3313 error (_("Premature end of file while reading trace file"));
3315 /* Assume the block is laid out in GDB register number order,
3316 each register with the size that it has in GDB. */
3318 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3320 regsize
= register_size (gdbarch
, regn
);
3321 /* Make sure we stay within block bounds. */
3322 if (offset
+ regsize
>= trace_regblock_size
)
3324 if (!regcache_valid_p (regcache
, regn
))
3328 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
3331 else if (regno
== -1)
3333 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
3340 lseek (trace_fd
, 8, SEEK_CUR
);
3341 gotten
= read (trace_fd
, &mlen
, 2);
3343 perror_with_name (trace_filename
);
3344 else if (gotten
< 2)
3345 error (_("Premature end of file while reading trace file"));
3346 lseek (trace_fd
, mlen
, SEEK_CUR
);
3347 pos
+= (8 + 2 + mlen
);
3350 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3354 error ("Unknown block type '%c' (0x%x) in trace frame",
3355 block_type
, block_type
);
3362 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3363 const char *annex
, gdb_byte
*readbuf
,
3364 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3369 unsigned short mlen
;
3371 /* We're only doing regular memory for now. */
3372 if (object
!= TARGET_OBJECT_MEMORY
)
3375 if (readbuf
== NULL
)
3376 error ("tfile_xfer_partial: trace file is read-only");
3378 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3380 while (pos
< cur_data_size
)
3382 gotten
= read (trace_fd
, &block_type
, 1);
3384 perror_with_name (trace_filename
);
3385 else if (gotten
< 1)
3386 error (_("Premature end of file while reading trace file"));
3391 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3392 pos
+= trace_regblock_size
;
3395 gotten
= read (trace_fd
, &maddr
, 8);
3397 perror_with_name (trace_filename
);
3398 else if (gotten
< 8)
3399 error (_("Premature end of file while reading trace file"));
3401 gotten
= read (trace_fd
, &mlen
, 2);
3403 perror_with_name (trace_filename
);
3404 else if (gotten
< 2)
3405 error (_("Premature end of file while reading trace file"));
3406 if (maddr
<= offset
&& (offset
+ len
) <= (maddr
+ mlen
))
3408 gotten
= read (trace_fd
, readbuf
, mlen
);
3410 perror_with_name (trace_filename
);
3411 else if (gotten
< mlen
)
3412 error (_("Premature end of file qwhile reading trace file"));
3416 lseek (trace_fd
, mlen
, SEEK_CUR
);
3417 pos
+= (8 + 2 + mlen
);
3420 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3424 error ("Unknown block type '%c' (0x%x) in traceframe",
3425 block_type
, block_type
);
3429 /* Indicate failure to find the requested memory block. */
3433 /* Iterate through the blocks of a trace frame, looking for a 'V'
3434 block with a matching tsv number. */
3437 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
3440 int pos
, vnum
, gotten
;
3441 unsigned short mlen
;
3443 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3445 while (pos
< cur_data_size
)
3447 gotten
= read (trace_fd
, &block_type
, 1);
3449 perror_with_name (trace_filename
);
3450 else if (gotten
< 1)
3451 error (_("Premature end of file while reading trace file"));
3456 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3457 pos
+= trace_regblock_size
;
3460 lseek (trace_fd
, 8, SEEK_CUR
);
3461 gotten
= read (trace_fd
, &mlen
, 2);
3463 perror_with_name (trace_filename
);
3464 else if (gotten
< 2)
3465 error (_("Premature end of file while reading trace file"));
3466 lseek (trace_fd
, mlen
, SEEK_CUR
);
3467 pos
+= (8 + 2 + mlen
);
3470 gotten
= read (trace_fd
, &vnum
, 4);
3472 perror_with_name (trace_filename
);
3473 else if (gotten
< 4)
3474 error (_("Premature end of file while reading trace file"));
3477 gotten
= read (trace_fd
, val
, 8);
3479 perror_with_name (trace_filename
);
3480 else if (gotten
< 8)
3481 error (_("Premature end of file while reading trace file"));
3484 lseek (trace_fd
, 8, SEEK_CUR
);
3488 error ("Unknown block type '%c' (0x%x) in traceframe",
3489 block_type
, block_type
);
3493 /* Didn't find anything. */
3498 tfile_has_memory (struct target_ops
*ops
)
3504 tfile_has_stack (struct target_ops
*ops
)
3510 tfile_has_registers (struct target_ops
*ops
)
3516 init_tfile_ops (void)
3518 tfile_ops
.to_shortname
= "tfile";
3519 tfile_ops
.to_longname
= "Local trace dump file";
3521 "Use a trace file as a target. Specify the filename of the trace file.";
3522 tfile_ops
.to_open
= tfile_open
;
3523 tfile_ops
.to_close
= tfile_close
;
3524 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
3525 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
3526 tfile_ops
.to_files_info
= tfile_files_info
;
3527 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
3528 tfile_ops
.to_trace_find
= tfile_trace_find
;
3529 tfile_ops
.to_get_trace_state_variable_value
= tfile_get_trace_state_variable_value
;
3530 /* core_stratum might seem more logical, but GDB doesn't like having
3531 more than one core_stratum vector. */
3532 tfile_ops
.to_stratum
= process_stratum
;
3533 tfile_ops
.to_has_memory
= tfile_has_memory
;
3534 tfile_ops
.to_has_stack
= tfile_has_stack
;
3535 tfile_ops
.to_has_registers
= tfile_has_registers
;
3536 tfile_ops
.to_magic
= OPS_MAGIC
;
3539 /* module initialization */
3541 _initialize_tracepoint (void)
3543 struct cmd_list_element
*c
;
3545 traceframe_number
= -1;
3546 tracepoint_number
= -1;
3548 if (tracepoint_list
.list
== NULL
)
3550 tracepoint_list
.listsize
= 128;
3551 tracepoint_list
.list
= xmalloc
3552 (tracepoint_list
.listsize
* sizeof (struct memrange
));
3554 if (tracepoint_list
.aexpr_list
== NULL
)
3556 tracepoint_list
.aexpr_listsize
= 128;
3557 tracepoint_list
.aexpr_list
= xmalloc
3558 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3561 if (stepping_list
.list
== NULL
)
3563 stepping_list
.listsize
= 128;
3564 stepping_list
.list
= xmalloc
3565 (stepping_list
.listsize
* sizeof (struct memrange
));
3568 if (stepping_list
.aexpr_list
== NULL
)
3570 stepping_list
.aexpr_listsize
= 128;
3571 stepping_list
.aexpr_list
= xmalloc
3572 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3575 add_info ("scope", scope_info
,
3576 _("List the variables local to a scope"));
3578 add_cmd ("tracepoints", class_trace
, NULL
,
3579 _("Tracing of program execution without stopping the program."),
3582 add_com ("tdump", class_trace
, trace_dump_command
,
3583 _("Print everything collected at the current tracepoint."));
3585 add_com ("tsave", class_trace
, trace_save_command
, _("\
3586 Save the trace data to a file.\n\
3587 Use the '-r' option to direct the target to save directly to the file,\n\
3588 using its own filesystem."));
3590 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
3591 Define a trace state variable.\n\
3592 Argument is a $-prefixed name, optionally followed\n\
3593 by '=' and an expression that sets the initial value\n\
3594 at the start of tracing."));
3595 set_cmd_completer (c
, expression_completer
);
3597 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
3598 Delete one or more trace state variables.\n\
3599 Arguments are the names of the variables to delete.\n\
3600 If no arguments are supplied, delete all variables."), &deletelist
);
3601 /* FIXME add a trace variable completer */
3603 add_info ("tvariables", tvariables_info
, _("\
3604 Status of trace state variables and their values.\n\
3607 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
3608 Select a trace frame;\n\
3609 No argument means forward by one frame; '-' means backward by one frame."),
3610 &tfindlist
, "tfind ", 1, &cmdlist
);
3612 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
3613 Select a trace frame whose PC is outside the given range.\n\
3614 Usage: tfind outside addr1, addr2"),
3617 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
3618 Select a trace frame whose PC is in the given range.\n\
3619 Usage: tfind range addr1,addr2"),
3622 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
3623 Select a trace frame by source line.\n\
3624 Argument can be a line number (with optional source file), \n\
3625 a function name, or '*' followed by an address.\n\
3626 Default argument is 'the next source line that was traced'."),
3629 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
3630 Select a trace frame by tracepoint number.\n\
3631 Default is the tracepoint for the current trace frame."),
3634 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
3635 Select a trace frame by PC.\n\
3636 Default is the current PC, or the PC of the current trace frame."),
3639 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
3640 Synonym for 'none'.\n\
3641 De-select any trace frame and resume 'live' debugging."),
3644 add_cmd ("none", class_trace
, trace_find_none_command
,
3645 _("De-select any trace frame and resume 'live' debugging."),
3648 add_cmd ("start", class_trace
, trace_find_start_command
,
3649 _("Select the first trace frame in the trace buffer."),
3652 add_com ("tstatus", class_trace
, trace_status_command
,
3653 _("Display the status of the current trace data collection."));
3655 add_com ("tstop", class_trace
, trace_stop_command
,
3656 _("Stop trace data collection."));
3658 add_com ("tstart", class_trace
, trace_start_command
,
3659 _("Start trace data collection."));
3661 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
3662 Ends a list of commands or actions.\n\
3663 Several GDB commands allow you to enter a list of commands or actions.\n\
3664 Entering \"end\" on a line by itself is the normal way to terminate\n\
3666 Note: the \"end\" command cannot be used at the gdb prompt."));
3668 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
3669 Specify single-stepping behavior at a tracepoint.\n\
3670 Argument is number of instructions to trace in single-step mode\n\
3671 following the tracepoint. This command is normally followed by\n\
3672 one or more \"collect\" commands, to specify what to collect\n\
3673 while single-stepping.\n\n\
3674 Note: this command can only be used in a tracepoint \"actions\" list."));
3676 add_com_alias ("ws", "while-stepping", class_alias
, 0);
3677 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
3679 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
3680 Specify one or more data items to be collected at a tracepoint.\n\
3681 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
3682 collect all data (variables, registers) referenced by that expression.\n\
3683 Also accepts the following special arguments:\n\
3684 $regs -- all registers.\n\
3685 $args -- all function arguments.\n\
3686 $locals -- all variables local to the block/function scope.\n\
3687 Note: this command can only be used in a tracepoint \"actions\" list."));
3689 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
3690 Specify one or more expressions to be evaluated at a tracepoint.\n\
3691 Accepts a comma-separated list of (one or more) expressions.\n\
3692 The result of each evaluation will be discarded.\n\
3693 Note: this command can only be used in a tracepoint \"actions\" list."));
3695 add_com ("actions", class_trace
, trace_actions_command
, _("\
3696 Specify the actions to be taken at a tracepoint.\n\
3697 Tracepoint actions may include collecting of specified data, \n\
3698 single-stepping, or enabling/disabling other tracepoints, \n\
3699 depending on target's capabilities."));
3701 default_collect
= xstrdup ("");
3702 add_setshow_string_cmd ("default-collect", class_trace
,
3703 &default_collect
, _("\
3704 Set the list of expressions to collect by default"), _("\
3705 Show the list of expressions to collect by default"), NULL
,
3707 &setlist
, &showlist
);
3709 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
3710 &disconnected_tracing
, _("\
3711 Set whether tracing continues after GDB disconnects."), _("\
3712 Show whether tracing continues after GDB disconnects."), _("\
3713 Use this to continue a tracing run even if GDB disconnects\n\
3714 or detaches from the target. You can reconnect later and look at\n\
3715 trace data collected in the meantime."),
3716 set_disconnected_tracing
,
3723 add_target (&tfile_ops
);