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 trace_dump_command (char *, int);
169 /* support routines */
171 struct collection_list
;
172 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
173 static char *mem2hex (gdb_byte
*, char *, int);
174 static void add_register (struct collection_list
*collection
,
176 static struct cleanup
*make_cleanup_free_actions (struct breakpoint
*t
);
178 extern void send_disconnected_tracing_value (int value
);
180 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
181 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
184 extern void _initialize_tracepoint (void);
186 static struct trace_status trace_status
;
188 char *stop_reason_names
[] = {
197 struct trace_status
*
198 current_trace_status ()
200 return &trace_status
;
203 /* Set traceframe number to NUM. */
205 set_traceframe_num (int num
)
207 traceframe_number
= num
;
208 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
211 /* Set tracepoint number to NUM. */
213 set_tracepoint_num (int num
)
215 tracepoint_number
= num
;
216 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
219 /* Set externally visible debug variables for querying/printing
220 the traceframe context (line, function, file) */
223 set_traceframe_context (struct frame_info
*trace_frame
)
227 if (trace_frame
== NULL
) /* Cease debugging any trace buffers. */
230 traceframe_sal
.pc
= traceframe_sal
.line
= 0;
231 traceframe_sal
.symtab
= NULL
;
232 clear_internalvar (lookup_internalvar ("trace_func"));
233 clear_internalvar (lookup_internalvar ("trace_file"));
234 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
238 /* Save as globals for internal use. */
239 trace_pc
= get_frame_pc (trace_frame
);
240 traceframe_sal
= find_pc_line (trace_pc
, 0);
241 traceframe_fun
= find_pc_function (trace_pc
);
243 /* Save linenumber as "$trace_line", a debugger variable visible to
245 set_internalvar_integer (lookup_internalvar ("trace_line"),
246 traceframe_sal
.line
);
248 /* Save func name as "$trace_func", a debugger variable visible to
250 if (traceframe_fun
== NULL
251 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
252 clear_internalvar (lookup_internalvar ("trace_func"));
254 set_internalvar_string (lookup_internalvar ("trace_func"),
255 SYMBOL_LINKAGE_NAME (traceframe_fun
));
257 /* Save file name as "$trace_file", a debugger variable visible to
259 if (traceframe_sal
.symtab
== NULL
260 || traceframe_sal
.symtab
->filename
== NULL
)
261 clear_internalvar (lookup_internalvar ("trace_file"));
263 set_internalvar_string (lookup_internalvar ("trace_file"),
264 traceframe_sal
.symtab
->filename
);
267 /* Create a new trace state variable with the given name. */
269 struct trace_state_variable
*
270 create_trace_state_variable (const char *name
)
272 struct trace_state_variable tsv
;
274 memset (&tsv
, 0, sizeof (tsv
));
276 tsv
.number
= next_tsv_number
++;
277 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
280 /* Look for a trace state variable of the given name. */
282 struct trace_state_variable
*
283 find_trace_state_variable (const char *name
)
285 struct trace_state_variable
*tsv
;
288 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
289 if (strcmp (name
, tsv
->name
) == 0)
296 delete_trace_state_variable (const char *name
)
298 struct trace_state_variable
*tsv
;
301 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
302 if (strcmp (name
, tsv
->name
) == 0)
304 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
308 warning (_("No trace variable named \"$%s\", not deleting"), name
);
311 /* The 'tvariable' command collects a name and optional expression to
312 evaluate into an initial value. */
315 trace_variable_command (char *args
, int from_tty
)
317 struct expression
*expr
;
318 struct cleanup
*old_chain
;
319 struct internalvar
*intvar
= NULL
;
321 struct trace_state_variable
*tsv
;
324 error_no_arg (_("trace state variable name"));
326 /* All the possible valid arguments are expressions. */
327 expr
= parse_expression (args
);
328 old_chain
= make_cleanup (free_current_contents
, &expr
);
330 if (expr
->nelts
== 0)
331 error (_("No expression?"));
333 /* Only allow two syntaxes; "$name" and "$name=value". */
334 if (expr
->elts
[0].opcode
== OP_INTERNALVAR
)
336 intvar
= expr
->elts
[1].internalvar
;
338 else if (expr
->elts
[0].opcode
== BINOP_ASSIGN
339 && expr
->elts
[1].opcode
== OP_INTERNALVAR
)
341 intvar
= expr
->elts
[2].internalvar
;
342 initval
= value_as_long (evaluate_subexpression_type (expr
, 4));
345 error (_("Syntax must be $NAME [ = EXPR ]"));
348 error (_("No name given"));
350 if (strlen (internalvar_name (intvar
)) <= 0)
351 error (_("Must supply a non-empty variable name"));
353 /* If the variable already exists, just change its initial value. */
354 tsv
= find_trace_state_variable (internalvar_name (intvar
));
357 tsv
->initial_value
= initval
;
358 printf_filtered (_("Trace state variable $%s now has initial value %s.\n"),
359 tsv
->name
, plongest (tsv
->initial_value
));
363 /* Create a new variable. */
364 tsv
= create_trace_state_variable (internalvar_name (intvar
));
365 tsv
->initial_value
= initval
;
367 printf_filtered (_("Trace state variable $%s created, with initial value %s.\n"),
368 tsv
->name
, plongest (tsv
->initial_value
));
370 do_cleanups (old_chain
);
374 delete_trace_variable_command (char *args
, int from_tty
)
378 struct cleanup
*back_to
;
379 struct trace_state_variable
*tsv
;
383 if (query (_("Delete all trace state variables? ")))
384 VEC_free (tsv_s
, tvariables
);
389 argv
= gdb_buildargv (args
);
390 back_to
= make_cleanup_freeargv (argv
);
392 for (i
= 0; argv
[i
] != NULL
; i
++)
395 delete_trace_state_variable (argv
[i
] + 1);
397 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[i
]);
400 do_cleanups (back_to
);
405 /* List all the trace state variables. */
408 tvariables_info (char *args
, int from_tty
)
410 struct trace_state_variable
*tsv
;
415 if (VEC_length (tsv_s
, tvariables
) == 0)
417 printf_filtered (_("No trace state variables.\n"));
421 /* Try to acquire values from the target. */
422 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
423 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
426 printf_filtered (_("Name\t\t Initial\tCurrent\n"));
428 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
430 printf_filtered ("$%s", tsv
->name
);
431 print_spaces_filtered (17 - strlen (tsv
->name
), gdb_stdout
);
432 printf_filtered ("%s ", plongest (tsv
->initial_value
));
433 print_spaces_filtered (11 - strlen (plongest (tsv
->initial_value
)), gdb_stdout
);
434 if (tsv
->value_known
)
435 printf_filtered (" %s", plongest (tsv
->value
));
436 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
437 /* The value is/was defined, but we don't have it. */
438 printf_filtered (_(" <unknown>"));
440 /* It is not meaningful to ask about the value. */
441 printf_filtered (_(" <undefined>"));
442 printf_filtered ("\n");
446 /* ACTIONS functions: */
448 /* Prototypes for action-parsing utility commands */
449 static void read_actions (struct breakpoint
*);
451 /* The three functions:
452 collect_pseudocommand,
453 while_stepping_pseudocommand, and
454 end_actions_pseudocommand
455 are placeholders for "commands" that are actually ONLY to be used
456 within a tracepoint action list. If the actual function is ever called,
457 it means that somebody issued the "command" at the top level,
458 which is always an error. */
461 end_actions_pseudocommand (char *args
, int from_tty
)
463 error (_("This command cannot be used at the top level."));
467 while_stepping_pseudocommand (char *args
, int from_tty
)
469 error (_("This command can only be used in a tracepoint actions list."));
473 collect_pseudocommand (char *args
, int from_tty
)
475 error (_("This command can only be used in a tracepoint actions list."));
479 teval_pseudocommand (char *args
, int from_tty
)
481 error (_("This command can only be used in a tracepoint actions list."));
484 /* Enter a list of actions for a tracepoint. */
486 trace_actions_command (char *args
, int from_tty
)
488 struct breakpoint
*t
;
490 char *end_msg
= "End with a line saying just \"end\".";
492 t
= get_tracepoint_by_number (&args
, 0, 1);
495 sprintf (tmpbuf
, "Enter actions for tracepoint %d, one per line.",
500 if (deprecated_readline_begin_hook
)
501 (*deprecated_readline_begin_hook
) ("%s %s\n", tmpbuf
, end_msg
);
502 else if (input_from_terminal_p ())
503 printf_filtered ("%s\n%s\n", tmpbuf
, end_msg
);
507 t
->step_count
= 0; /* read_actions may set this */
510 if (deprecated_readline_end_hook
)
511 (*deprecated_readline_end_hook
) ();
512 /* tracepoints_changed () */
514 /* else just return */
517 /* worker function */
519 read_actions (struct breakpoint
*t
)
522 char *prompt1
= "> ", *prompt2
= " > ";
523 char *prompt
= prompt1
;
524 enum actionline_type linetype
;
525 extern FILE *instream
;
526 struct action_line
*next
= NULL
, *temp
;
527 struct cleanup
*old_chain
;
529 /* Control-C quits instantly if typed while in this loop
530 since it should not wait until the user types a newline. */
532 /* FIXME: kettenis/20010823: Something is wrong here. In this file
533 STOP_SIGNAL is never defined. So this code has been left out, at
534 least for quite a while now. Replacing STOP_SIGNAL with SIGTSTP
535 leads to compilation failures since the variable job_control
536 isn't declared. Leave this alone for now. */
539 signal (STOP_SIGNAL
, handle_stop_sig
);
541 old_chain
= make_cleanup_free_actions (t
);
544 /* Make sure that all output has been output. Some machines may
545 let you get away with leaving out some of the gdb_flush, but
548 gdb_flush (gdb_stdout
);
549 gdb_flush (gdb_stderr
);
551 if (deprecated_readline_hook
&& instream
== NULL
)
552 line
= (*deprecated_readline_hook
) (prompt
);
553 else if (instream
== stdin
&& ISATTY (instream
))
555 line
= gdb_readline_wrapper (prompt
);
556 if (line
&& *line
) /* add it to command history */
560 line
= gdb_readline (0);
564 line
= xstrdup ("end");
565 printf_filtered ("end\n");
568 linetype
= validate_actionline (&line
, t
);
569 if (linetype
== BADLINE
)
570 continue; /* already warned -- collect another line */
572 temp
= xmalloc (sizeof (struct action_line
));
576 if (next
== NULL
) /* first action for this tracepoint? */
577 t
->actions
= next
= temp
;
584 if (linetype
== STEPPING
) /* begin "while-stepping" */
586 if (prompt
== prompt2
)
588 warning (_("Already processing 'while-stepping'"));
592 prompt
= prompt2
; /* change prompt for stepping actions */
594 else if (linetype
== END
)
596 if (prompt
== prompt2
)
598 prompt
= prompt1
; /* end of single-stepping actions */
601 { /* end of actions */
602 if (t
->actions
->next
== NULL
)
604 /* An "end" all by itself with no other actions
605 means this tracepoint has no actions.
606 Discard empty list. */
615 signal (STOP_SIGNAL
, SIG_DFL
);
618 discard_cleanups (old_chain
);
621 /* worker function */
623 validate_actionline (char **line
, struct breakpoint
*t
)
625 struct cmd_list_element
*c
;
626 struct expression
*exp
= NULL
;
627 struct cleanup
*old_chain
= NULL
;
629 struct bp_location
*loc
;
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! */
676 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
679 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
680 old_chain
= make_cleanup (free_current_contents
, &exp
);
682 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
684 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
686 warning (_("constant %s (value %ld) will not be collected."),
687 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
688 SYMBOL_VALUE (exp
->elts
[2].symbol
));
691 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
693 warning (_("%s is optimized away and cannot be collected."),
694 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
699 /* We have something to collect, make sure that the expr to
700 bytecode translator can handle it and that it's not too
702 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
703 make_cleanup_free_agent_expr (aexpr
);
705 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
706 error (_("expression too complicated, try simplifying"));
708 ax_reqs (aexpr
, &areqs
);
709 (void) make_cleanup (xfree
, areqs
.reg_mask
);
711 if (areqs
.flaw
!= agent_flaw_none
)
712 error (_("malformed expression"));
714 if (areqs
.min_height
< 0)
715 error (_("gdb: Internal error: expression has min height < 0"));
717 if (areqs
.max_height
> 20)
718 error (_("expression too complicated, try simplifying"));
720 do_cleanups (old_chain
);
723 while (p
&& *p
++ == ',');
726 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
728 struct agent_expr
*aexpr
;
731 { /* repeat over a comma-separated list */
732 QUIT
; /* allow user to bail out with ^C */
733 while (isspace ((int) *p
))
737 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
740 /* Only expressions are allowed for this action. */
741 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
742 old_chain
= make_cleanup (free_current_contents
, &exp
);
744 /* We have something to evaluate, make sure that the expr to
745 bytecode translator can handle it and that it's not too
747 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
748 make_cleanup_free_agent_expr (aexpr
);
750 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
751 error (_("expression too complicated, try simplifying"));
753 do_cleanups (old_chain
);
756 while (p
&& *p
++ == ',');
759 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
761 char *steparg
; /* in case warning is necessary */
763 while (isspace ((int) *p
))
768 (t
->step_count
= strtol (p
, &p
, 0)) == 0)
770 warning (_("'%s': bad step-count; command ignored."), *line
);
775 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
779 warning (_("'%s' is not a supported tracepoint action."), *line
);
784 /* worker function */
786 free_actions (struct breakpoint
*t
)
788 struct action_line
*line
, *next
;
790 for (line
= t
->actions
; line
; line
= next
)
794 xfree (line
->action
);
801 do_free_actions_cleanup (void *t
)
806 static struct cleanup
*
807 make_cleanup_free_actions (struct breakpoint
*t
)
809 return make_cleanup (do_free_actions_cleanup
, t
);
813 memrange_absolute
= -1
818 int type
; /* memrange_absolute for absolute memory range,
819 else basereg number */
820 bfd_signed_vma start
;
824 struct collection_list
826 unsigned char regs_mask
[32]; /* room for up to 256 regs */
829 struct memrange
*list
;
830 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
832 struct agent_expr
**aexpr_list
;
835 tracepoint_list
, stepping_list
;
837 /* MEMRANGE functions: */
839 static int memrange_cmp (const void *, const void *);
841 /* compare memranges for qsort */
843 memrange_cmp (const void *va
, const void *vb
)
845 const struct memrange
*a
= va
, *b
= vb
;
847 if (a
->type
< b
->type
)
849 if (a
->type
> b
->type
)
851 if (a
->type
== memrange_absolute
)
853 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
855 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
860 if (a
->start
< b
->start
)
862 if (a
->start
> b
->start
)
868 /* Sort the memrange list using qsort, and merge adjacent memranges. */
870 memrange_sortmerge (struct collection_list
*memranges
)
874 qsort (memranges
->list
, memranges
->next_memrange
,
875 sizeof (struct memrange
), memrange_cmp
);
876 if (memranges
->next_memrange
> 0)
878 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
880 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
881 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
884 /* memrange b starts before memrange a ends; merge them. */
885 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
886 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
887 continue; /* next b, same a */
891 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
892 sizeof (struct memrange
));
894 memranges
->next_memrange
= a
+ 1;
898 /* Add a register to a collection list. */
900 add_register (struct collection_list
*collection
, unsigned int regno
)
903 printf_filtered ("collect register %d\n", regno
);
904 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
905 error (_("Internal: register number %d too large for tracepoint"),
907 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
910 /* Add a memrange to a collection list */
912 add_memrange (struct collection_list
*memranges
,
913 int type
, bfd_signed_vma base
,
918 printf_filtered ("(%d,", type
);
920 printf_filtered (",%ld)\n", len
);
923 /* type: memrange_absolute == memory, other n == basereg */
924 memranges
->list
[memranges
->next_memrange
].type
= type
;
925 /* base: addr if memory, offset if reg relative. */
926 memranges
->list
[memranges
->next_memrange
].start
= base
;
927 /* len: we actually save end (base + len) for convenience */
928 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
929 memranges
->next_memrange
++;
930 if (memranges
->next_memrange
>= memranges
->listsize
)
932 memranges
->listsize
*= 2;
933 memranges
->list
= xrealloc (memranges
->list
,
934 memranges
->listsize
);
937 if (type
!= memrange_absolute
) /* Better collect the base register! */
938 add_register (memranges
, type
);
941 /* Add a symbol to a collection list. */
943 collect_symbol (struct collection_list
*collect
,
945 struct gdbarch
*gdbarch
,
946 long frame_regno
, long frame_offset
,
951 bfd_signed_vma offset
;
953 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
954 switch (SYMBOL_CLASS (sym
))
957 printf_filtered ("%s: don't know symbol class %d\n",
958 SYMBOL_PRINT_NAME (sym
),
962 printf_filtered ("constant %s (value %ld) will not be collected.\n",
963 SYMBOL_PRINT_NAME (sym
), SYMBOL_VALUE (sym
));
966 offset
= SYMBOL_VALUE_ADDRESS (sym
);
971 sprintf_vma (tmp
, offset
);
972 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
973 SYMBOL_PRINT_NAME (sym
), len
,
976 add_memrange (collect
, memrange_absolute
, offset
, len
);
979 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
981 printf_filtered ("LOC_REG[parm] %s: ",
982 SYMBOL_PRINT_NAME (sym
));
983 add_register (collect
, reg
);
984 /* Check for doubles stored in two registers. */
985 /* FIXME: how about larger types stored in 3 or more regs? */
986 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
987 len
> register_size (gdbarch
, reg
))
988 add_register (collect
, reg
+ 1);
991 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
992 printf_filtered (" (will not collect %s)\n",
993 SYMBOL_PRINT_NAME (sym
));
997 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1000 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1001 SYMBOL_PRINT_NAME (sym
), len
);
1002 printf_vma (offset
);
1003 printf_filtered (" from frame ptr reg %d\n", reg
);
1005 add_memrange (collect
, reg
, offset
, len
);
1007 case LOC_REGPARM_ADDR
:
1008 reg
= SYMBOL_VALUE (sym
);
1012 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1013 SYMBOL_PRINT_NAME (sym
), len
);
1014 printf_vma (offset
);
1015 printf_filtered (" from reg %d\n", reg
);
1017 add_memrange (collect
, reg
, offset
, len
);
1021 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1024 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1025 SYMBOL_PRINT_NAME (sym
), len
);
1026 printf_vma (offset
);
1027 printf_filtered (" from frame ptr reg %d\n", reg
);
1029 add_memrange (collect
, reg
, offset
, len
);
1031 case LOC_UNRESOLVED
:
1032 printf_filtered ("Don't know LOC_UNRESOLVED %s\n",
1033 SYMBOL_PRINT_NAME (sym
));
1035 case LOC_OPTIMIZED_OUT
:
1036 printf_filtered ("%s has been optimized out of existence.\n",
1037 SYMBOL_PRINT_NAME (sym
));
1042 struct agent_expr
*aexpr
;
1043 struct cleanup
*old_chain1
= NULL
;
1044 struct agent_reqs areqs
;
1046 aexpr
= gen_trace_for_var (scope
, sym
);
1048 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1050 ax_reqs (aexpr
, &areqs
);
1051 if (areqs
.flaw
!= agent_flaw_none
)
1052 error (_("malformed expression"));
1054 if (areqs
.min_height
< 0)
1055 error (_("gdb: Internal error: expression has min height < 0"));
1056 if (areqs
.max_height
> 20)
1057 error (_("expression too complicated, try simplifying"));
1059 discard_cleanups (old_chain1
);
1060 add_aexpr (collect
, aexpr
);
1062 /* take care of the registers */
1063 if (areqs
.reg_mask_len
> 0)
1067 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1069 QUIT
; /* allow user to bail out with ^C */
1070 if (areqs
.reg_mask
[ndx1
] != 0)
1072 /* assume chars have 8 bits */
1073 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1074 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1075 /* it's used -- record it */
1076 add_register (collect
,
1086 /* Add all locals (or args) symbols to collection list */
1088 add_local_symbols (struct collection_list
*collect
,
1089 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1090 long frame_regno
, long frame_offset
, int type
)
1093 struct block
*block
;
1094 struct dict_iterator iter
;
1097 block
= block_for_pc (pc
);
1100 QUIT
; /* allow user to bail out with ^C */
1101 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
1103 if (SYMBOL_IS_ARGUMENT (sym
)
1104 ? type
== 'A' /* collecting Arguments */
1105 : type
== 'L') /* collecting Locals */
1108 collect_symbol (collect
, sym
, gdbarch
,
1109 frame_regno
, frame_offset
, pc
);
1112 if (BLOCK_FUNCTION (block
))
1115 block
= BLOCK_SUPERBLOCK (block
);
1118 warning (_("No %s found in scope."),
1119 type
== 'L' ? "locals" : "args");
1122 /* worker function */
1124 clear_collection_list (struct collection_list
*list
)
1128 list
->next_memrange
= 0;
1129 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1131 free_agent_expr (list
->aexpr_list
[ndx
]);
1132 list
->aexpr_list
[ndx
] = NULL
;
1134 list
->next_aexpr_elt
= 0;
1135 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1138 /* reduce a collection list to string form (for gdb protocol) */
1140 stringify_collection_list (struct collection_list
*list
, char *string
)
1142 char temp_buf
[2048];
1146 char *(*str_list
)[];
1150 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1151 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1153 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1154 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1156 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1159 printf_filtered ("\nCollecting registers (mask): 0x");
1164 QUIT
; /* allow user to bail out with ^C */
1166 printf_filtered ("%02X", list
->regs_mask
[i
]);
1167 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1170 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1174 printf_filtered ("\n");
1175 if (list
->next_memrange
> 0 && info_verbose
)
1176 printf_filtered ("Collecting memranges: \n");
1177 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1179 QUIT
; /* allow user to bail out with ^C */
1180 sprintf_vma (tmp2
, list
->list
[i
].start
);
1183 printf_filtered ("(%d, %s, %ld)\n",
1186 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1188 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1190 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1197 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1199 /* The "%X" conversion specifier expects an unsigned argument,
1200 so passing -1 (memrange_absolute) to it directly gives you
1201 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1203 if (list
->list
[i
].type
== memrange_absolute
)
1204 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1206 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1209 count
+= strlen (end
);
1210 end
= temp_buf
+ count
;
1213 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1215 QUIT
; /* allow user to bail out with ^C */
1216 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1218 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1223 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1224 end
+= 10; /* 'X' + 8 hex digits + ',' */
1227 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1228 end
, list
->aexpr_list
[i
]->len
);
1229 count
+= 2 * list
->aexpr_list
[i
]->len
;
1234 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1239 (*str_list
)[ndx
] = NULL
;
1250 /* Render all actions into gdb protocol. */
1252 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1253 char ***tdp_actions
, char ***stepping_actions
)
1255 static char tdp_buff
[2048], step_buff
[2048];
1257 struct expression
*exp
= NULL
;
1258 struct action_line
*action
;
1260 struct value
*tempval
;
1261 struct collection_list
*collect
;
1262 struct cmd_list_element
*cmd
;
1263 struct agent_expr
*aexpr
;
1265 LONGEST frame_offset
;
1266 char *default_collect_line
= NULL
;
1267 struct action_line
*default_collect_action
= NULL
;
1269 clear_collection_list (&tracepoint_list
);
1270 clear_collection_list (&stepping_list
);
1271 collect
= &tracepoint_list
;
1273 *tdp_actions
= NULL
;
1274 *stepping_actions
= NULL
;
1276 gdbarch_virtual_frame_pointer (t
->gdbarch
,
1277 tloc
->address
, &frame_reg
, &frame_offset
);
1279 action
= t
->actions
;
1281 /* If there are default expressions to collect, make up a collect
1282 action and prepend to the action list to encode. Note that since
1283 validation is per-tracepoint (local var "xyz" might be valid for
1284 one tracepoint and not another, etc), we make up the action on
1285 the fly, and don't cache it. */
1286 if (*default_collect
)
1289 enum actionline_type linetype
;
1291 default_collect_line
= xmalloc (12 + strlen (default_collect
));
1292 sprintf (default_collect_line
, "collect %s", default_collect
);
1293 line
= default_collect_line
;
1294 linetype
= validate_actionline (&line
, t
);
1295 if (linetype
!= BADLINE
)
1297 default_collect_action
= xmalloc (sizeof (struct action_line
));
1298 default_collect_action
->next
= t
->actions
;
1299 default_collect_action
->action
= line
;
1300 action
= default_collect_action
;
1304 for (; action
; action
= action
->next
)
1306 QUIT
; /* allow user to bail out with ^C */
1307 action_exp
= action
->action
;
1308 while (isspace ((int) *action_exp
))
1311 if (*action_exp
== '#') /* comment line */
1314 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1316 error (_("Bad action list item: %s"), action_exp
);
1318 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1321 { /* repeat over a comma-separated list */
1322 QUIT
; /* allow user to bail out with ^C */
1323 while (isspace ((int) *action_exp
))
1326 if (0 == strncasecmp ("$reg", action_exp
, 4))
1328 for (i
= 0; i
< gdbarch_num_regs (t
->gdbarch
); i
++)
1329 add_register (collect
, i
);
1330 action_exp
= strchr (action_exp
, ','); /* more? */
1332 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1334 add_local_symbols (collect
,
1340 action_exp
= strchr (action_exp
, ','); /* more? */
1342 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1344 add_local_symbols (collect
,
1350 action_exp
= strchr (action_exp
, ','); /* more? */
1354 unsigned long addr
, len
;
1355 struct cleanup
*old_chain
= NULL
;
1356 struct cleanup
*old_chain1
= NULL
;
1357 struct agent_reqs areqs
;
1359 exp
= parse_exp_1 (&action_exp
,
1360 block_for_pc (tloc
->address
), 1);
1361 old_chain
= make_cleanup (free_current_contents
, &exp
);
1363 switch (exp
->elts
[0].opcode
)
1367 const char *name
= &exp
->elts
[2].string
;
1369 i
= user_reg_map_name_to_regnum (t
->gdbarch
,
1370 name
, strlen (name
));
1372 internal_error (__FILE__
, __LINE__
,
1373 _("Register $%s not available"),
1376 printf_filtered ("OP_REGISTER: ");
1377 add_register (collect
, i
);
1382 /* safe because we know it's a simple expression */
1383 tempval
= evaluate_expression (exp
);
1384 addr
= value_address (tempval
);
1385 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1386 add_memrange (collect
, memrange_absolute
, addr
, len
);
1390 collect_symbol (collect
,
1391 exp
->elts
[2].symbol
,
1398 default: /* full-fledged expression */
1399 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1401 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1403 ax_reqs (aexpr
, &areqs
);
1404 if (areqs
.flaw
!= agent_flaw_none
)
1405 error (_("malformed expression"));
1407 if (areqs
.min_height
< 0)
1408 error (_("gdb: Internal error: expression has min height < 0"));
1409 if (areqs
.max_height
> 20)
1410 error (_("expression too complicated, try simplifying"));
1412 discard_cleanups (old_chain1
);
1413 add_aexpr (collect
, aexpr
);
1415 /* take care of the registers */
1416 if (areqs
.reg_mask_len
> 0)
1421 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1423 QUIT
; /* allow user to bail out with ^C */
1424 if (areqs
.reg_mask
[ndx1
] != 0)
1426 /* assume chars have 8 bits */
1427 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1428 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1429 /* it's used -- record it */
1430 add_register (collect
,
1437 do_cleanups (old_chain
);
1440 while (action_exp
&& *action_exp
++ == ',');
1442 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1445 { /* repeat over a comma-separated list */
1446 QUIT
; /* allow user to bail out with ^C */
1447 while (isspace ((int) *action_exp
))
1451 unsigned long addr
, len
;
1452 struct cleanup
*old_chain
= NULL
;
1453 struct cleanup
*old_chain1
= NULL
;
1454 struct agent_reqs areqs
;
1456 exp
= parse_exp_1 (&action_exp
,
1457 block_for_pc (tloc
->address
), 1);
1458 old_chain
= make_cleanup (free_current_contents
, &exp
);
1460 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1461 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1463 ax_reqs (aexpr
, &areqs
);
1464 if (areqs
.flaw
!= agent_flaw_none
)
1465 error (_("malformed expression"));
1467 if (areqs
.min_height
< 0)
1468 error (_("gdb: Internal error: expression has min height < 0"));
1469 if (areqs
.max_height
> 20)
1470 error (_("expression too complicated, try simplifying"));
1472 discard_cleanups (old_chain1
);
1473 /* Even though we're not officially collecting, add
1474 to the collect list anyway. */
1475 add_aexpr (collect
, aexpr
);
1477 do_cleanups (old_chain
);
1480 while (action_exp
&& *action_exp
++ == ',');
1482 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1484 collect
= &stepping_list
;
1486 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
1488 if (collect
== &stepping_list
) /* end stepping actions */
1489 collect
= &tracepoint_list
;
1491 break; /* end tracepoint actions */
1494 memrange_sortmerge (&tracepoint_list
);
1495 memrange_sortmerge (&stepping_list
);
1497 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1499 *stepping_actions
= stringify_collection_list (&stepping_list
,
1502 xfree (default_collect_line
);
1503 xfree (default_collect_action
);
1507 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1509 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1511 collect
->aexpr_list
=
1512 xrealloc (collect
->aexpr_list
,
1513 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1514 collect
->aexpr_listsize
*= 2;
1516 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1517 collect
->next_aexpr_elt
++;
1522 Tell target to clear any previous trace experiment.
1523 Walk the list of tracepoints, and send them (and their actions)
1524 to the target. If no errors,
1525 Tell target to start a new trace experiment. */
1528 trace_start_command (char *args
, int from_tty
)
1531 VEC(breakpoint_p
) *tp_vec
= NULL
;
1533 struct breakpoint
*t
;
1534 struct trace_state_variable
*tsv
;
1535 int any_downloaded
= 0;
1537 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1539 target_trace_init ();
1541 tp_vec
= all_tracepoints ();
1542 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1544 t
->number_on_target
= 0;
1545 target_download_tracepoint (t
);
1546 t
->number_on_target
= t
->number
;
1549 VEC_free (breakpoint_p
, tp_vec
);
1551 /* No point in tracing without any tracepoints... */
1552 if (!any_downloaded
)
1553 error ("No tracepoints downloaded, not starting trace");
1555 /* Send down all the trace state variables too. */
1556 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1558 target_download_trace_state_variable (tsv
);
1561 /* Tell target to treat text-like sections as transparent. */
1562 target_trace_set_readonly_regions ();
1564 /* Now insert traps and begin collecting data. */
1565 target_trace_start ();
1567 /* Reset our local state. */
1568 set_traceframe_num (-1);
1569 set_tracepoint_num (-1);
1570 set_traceframe_context (NULL
);
1571 current_trace_status()->running
= 1;
1576 trace_stop_command (char *args
, int from_tty
)
1584 target_trace_stop ();
1585 /* should change in response to reply? */
1586 current_trace_status ()->running
= 0;
1589 /* tstatus command */
1591 trace_status_command (char *args
, int from_tty
)
1593 struct trace_status
*ts
= current_trace_status ();
1596 status
= target_get_trace_status (ts
);
1601 printf_filtered (_("Using a trace file.\n"));
1604 printf_filtered (_("Trace can not be run on this target.\n"));
1609 if (!ts
->running_known
)
1611 printf_filtered (_("Run/stop status is unknown.\n"));
1613 else if (ts
->running
)
1615 printf_filtered (_("Trace is running on the target.\n"));
1616 if (disconnected_tracing
)
1617 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1619 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1623 switch (ts
->stop_reason
)
1625 case trace_never_run
:
1626 printf_filtered (_("No trace has been run on the target.\n"));
1629 printf_filtered (_("Trace stopped by a tstop command.\n"));
1631 case trace_buffer_full
:
1632 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1634 case trace_disconnected
:
1635 printf_filtered (_("Trace stopped because of disconnection.\n"));
1637 case tracepoint_passcount
:
1638 /* FIXME account for number on target */
1639 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1640 ts
->stopping_tracepoint
);
1642 case trace_stop_reason_unknown
:
1643 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1646 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1652 if (ts
->traceframe_count
>= 0)
1654 printf_filtered (_("Collected %d trace frames.\n"),
1655 ts
->traceframe_count
);
1658 if (ts
->buffer_free
)
1660 printf_filtered (_("Trace buffer has %llu bytes free.\n"),
1664 /* Now report on what we're doing with tfind. */
1665 if (traceframe_number
>= 0)
1666 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1667 traceframe_number
, tracepoint_number
);
1669 printf_filtered (_("Not looking at any trace frame.\n"));
1673 disconnect_or_stop_tracing (int from_tty
)
1675 /* It can happen that the target that was tracing went away on its
1676 own, and we didn't notice. Get a status update, and if the
1677 current target doesn't even do tracing, then assume it's not
1679 if (target_get_trace_status (current_trace_status ()) < 0)
1680 current_trace_status ()->running
= 0;
1682 if (current_trace_status ()->running
&& from_tty
)
1684 int cont
= query (_("Trace is running. Continue tracing after detach? "));
1685 /* Note that we send the query result without affecting the
1686 user's setting of disconnected_tracing, so that the answer is
1688 send_disconnected_tracing_value (cont
);
1690 /* Also ensure that we do the equivalent of a tstop command if
1691 tracing is not to continue after the detach. */
1697 /* Worker function for the various flavors of the tfind command. */
1699 finish_tfind_command (enum trace_find_type type
, int num
,
1700 ULONGEST addr1
, ULONGEST addr2
,
1703 int target_frameno
= -1, target_tracept
= -1;
1704 struct frame_id old_frame_id
;
1706 struct breakpoint
*tp
;
1708 old_frame_id
= get_frame_id (get_current_frame ());
1710 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
1713 if (type
== tfind_number
1715 && target_frameno
== -1)
1717 /* We told the target to get out of tfind mode, and it did. */
1719 else if (target_frameno
== -1)
1721 /* A request for a non-existant trace frame has failed.
1722 Our response will be different, depending on FROM_TTY:
1724 If FROM_TTY is true, meaning that this command was
1725 typed interactively by the user, then give an error
1726 and DO NOT change the state of traceframe_number etc.
1728 However if FROM_TTY is false, meaning that we're either
1729 in a script, a loop, or a user-defined command, then
1730 DON'T give an error, but DO change the state of
1731 traceframe_number etc. to invalid.
1733 The rationalle is that if you typed the command, you
1734 might just have committed a typo or something, and you'd
1735 like to NOT lose your current debugging state. However
1736 if you're in a user-defined command or especially in a
1737 loop, then you need a way to detect that the command
1738 failed WITHOUT aborting. This allows you to write
1739 scripts that search thru the trace buffer until the end,
1740 and then continue on to do something else. */
1743 error (_("Target failed to find requested trace frame."));
1747 printf_filtered ("End of trace buffer.\n");
1748 #if 0 /* dubious now? */
1749 /* The following will not recurse, since it's
1751 trace_find_command ("-1", from_tty
);
1756 tp
= get_tracepoint_by_number_on_target (target_tracept
);
1758 reinit_frame_cache ();
1759 registers_changed ();
1760 set_traceframe_num (target_frameno
);
1761 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
1762 if (target_frameno
== -1)
1763 set_traceframe_context (NULL
);
1765 set_traceframe_context (get_current_frame ());
1767 /* If we're in nonstop mode and getting out of looking at trace
1768 frames, there won't be any current frame to go back to and
1771 && (has_stack_frames () || traceframe_number
>= 0))
1773 enum print_what print_what
;
1775 /* NOTE: in immitation of the step command, try to determine
1776 whether we have made a transition from one function to
1777 another. If so, we'll print the "stack frame" (ie. the new
1778 function and it's arguments) -- otherwise we'll just show the
1781 if (frame_id_eq (old_frame_id
,
1782 get_frame_id (get_current_frame ())))
1783 print_what
= SRC_LINE
;
1785 print_what
= SRC_AND_LOC
;
1787 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
1792 /* trace_find_command takes a trace frame number n,
1793 sends "QTFrame:<n>" to the target,
1794 and accepts a reply that may contain several optional pieces
1795 of information: a frame number, a tracepoint number, and an
1796 indication of whether this is a trap frame or a stepping frame.
1798 The minimal response is just "OK" (which indicates that the
1799 target does not give us a frame number or a tracepoint number).
1800 Instead of that, the target may send us a string containing
1802 F<hexnum> (gives the selected frame number)
1803 T<hexnum> (gives the selected tracepoint number)
1808 trace_find_command (char *args
, int from_tty
)
1809 { /* this should only be called with a numeric argument */
1812 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1813 error ("May not look at trace frames while trace is running.");
1815 if (args
== 0 || *args
== 0)
1816 { /* TFIND with no args means find NEXT trace frame. */
1817 if (traceframe_number
== -1)
1818 frameno
= 0; /* "next" is first one */
1820 frameno
= traceframe_number
+ 1;
1822 else if (0 == strcmp (args
, "-"))
1824 if (traceframe_number
== -1)
1825 error (_("not debugging trace buffer"));
1826 else if (from_tty
&& traceframe_number
== 0)
1827 error (_("already at start of trace buffer"));
1829 frameno
= traceframe_number
- 1;
1831 /* A hack to work around eval's need for fp to have been collected. */
1832 else if (0 == strcmp (args
, "-1"))
1835 frameno
= parse_and_eval_long (args
);
1838 error (_("invalid input (%d is less than zero)"), frameno
);
1840 finish_tfind_command (tfind_number
, frameno
, 0, 0, from_tty
);
1845 trace_find_end_command (char *args
, int from_tty
)
1847 trace_find_command ("-1", from_tty
);
1852 trace_find_none_command (char *args
, int from_tty
)
1854 trace_find_command ("-1", from_tty
);
1859 trace_find_start_command (char *args
, int from_tty
)
1861 trace_find_command ("0", from_tty
);
1864 /* tfind pc command */
1866 trace_find_pc_command (char *args
, int from_tty
)
1871 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1872 error ("May not look at trace frames while trace is running.");
1874 if (args
== 0 || *args
== 0)
1875 pc
= regcache_read_pc (get_current_regcache ());
1877 pc
= parse_and_eval_address (args
);
1879 finish_tfind_command (tfind_pc
, 0, pc
, 0, from_tty
);
1882 /* tfind tracepoint command */
1884 trace_find_tracepoint_command (char *args
, int from_tty
)
1887 struct breakpoint
*tp
;
1889 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1890 error ("May not look at trace frames while trace is running.");
1892 if (args
== 0 || *args
== 0)
1894 if (tracepoint_number
== -1)
1895 error (_("No current tracepoint -- please supply an argument."));
1897 tdp
= tracepoint_number
; /* default is current TDP */
1900 tdp
= parse_and_eval_long (args
);
1902 /* If we have the tracepoint on hand, use the number that the
1903 target knows about (which may be different if we disconnected
1904 and reconnected). */
1905 tp
= get_tracepoint (tdp
);
1907 tdp
= tp
->number_on_target
;
1909 finish_tfind_command (tfind_tp
, tdp
, 0, 0, from_tty
);
1912 /* TFIND LINE command:
1914 This command will take a sourceline for argument, just like BREAK
1915 or TRACE (ie. anything that "decode_line_1" can handle).
1917 With no argument, this command will find the next trace frame
1918 corresponding to a source line OTHER THAN THE CURRENT ONE. */
1921 trace_find_line_command (char *args
, int from_tty
)
1923 static CORE_ADDR start_pc
, end_pc
;
1924 struct symtabs_and_lines sals
;
1925 struct symtab_and_line sal
;
1926 struct cleanup
*old_chain
;
1927 char startpc_str
[40], endpc_str
[40];
1929 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1930 error ("May not look at trace frames while trace is running.");
1932 if (args
== 0 || *args
== 0)
1934 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
1936 sals
.sals
= (struct symtab_and_line
*)
1937 xmalloc (sizeof (struct symtab_and_line
));
1942 sals
= decode_line_spec (args
, 1);
1946 old_chain
= make_cleanup (xfree
, sals
.sals
);
1947 if (sal
.symtab
== 0)
1949 printf_filtered ("TFIND: No line number information available");
1952 /* This is useful for "info line *0x7f34". If we can't
1953 tell the user about a source line, at least let them
1954 have the symbolic address. */
1955 printf_filtered (" for address ");
1957 print_address (get_current_arch (), sal
.pc
, gdb_stdout
);
1958 printf_filtered (";\n -- will attempt to find by PC. \n");
1962 printf_filtered (".\n");
1963 return; /* No line, no PC; what can we do? */
1966 else if (sal
.line
> 0
1967 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
1969 if (start_pc
== end_pc
)
1971 printf_filtered ("Line %d of \"%s\"",
1972 sal
.line
, sal
.symtab
->filename
);
1974 printf_filtered (" is at address ");
1975 print_address (get_current_arch (), start_pc
, gdb_stdout
);
1977 printf_filtered (" but contains no code.\n");
1978 sal
= find_pc_line (start_pc
, 0);
1980 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
1981 && start_pc
!= end_pc
)
1982 printf_filtered ("Attempting to find line %d instead.\n",
1985 error (_("Cannot find a good line."));
1989 /* Is there any case in which we get here, and have an address
1990 which the user would want to see? If we have debugging
1991 symbols and no line numbers? */
1992 error (_("Line number %d is out of range for \"%s\"."),
1993 sal
.line
, sal
.symtab
->filename
);
1995 /* Find within range of stated line. */
1997 finish_tfind_command (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
1999 finish_tfind_command (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2000 do_cleanups (old_chain
);
2003 /* tfind range command */
2005 trace_find_range_command (char *args
, int from_tty
)
2007 static CORE_ADDR start
, stop
;
2008 char start_str
[40], stop_str
[40];
2011 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2012 error ("May not look at trace frames while trace is running.");
2014 if (args
== 0 || *args
== 0)
2015 { /* XXX FIXME: what should default behavior be? */
2016 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2020 if (0 != (tmp
= strchr (args
, ',')))
2022 *tmp
++ = '\0'; /* terminate start address */
2023 while (isspace ((int) *tmp
))
2025 start
= parse_and_eval_address (args
);
2026 stop
= parse_and_eval_address (tmp
);
2029 { /* no explicit end address? */
2030 start
= parse_and_eval_address (args
);
2031 stop
= start
+ 1; /* ??? */
2034 finish_tfind_command (tfind_range
, 0, start
, stop
, from_tty
);
2037 /* tfind outside command */
2039 trace_find_outside_command (char *args
, int from_tty
)
2041 CORE_ADDR start
, stop
;
2042 char start_str
[40], stop_str
[40];
2045 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2046 error ("May not look at trace frames while trace is running.");
2048 if (args
== 0 || *args
== 0)
2049 { /* XXX FIXME: what should default behavior be? */
2050 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2054 if (0 != (tmp
= strchr (args
, ',')))
2056 *tmp
++ = '\0'; /* terminate start address */
2057 while (isspace ((int) *tmp
))
2059 start
= parse_and_eval_address (args
);
2060 stop
= parse_and_eval_address (tmp
);
2063 { /* no explicit end address? */
2064 start
= parse_and_eval_address (args
);
2065 stop
= start
+ 1; /* ??? */
2068 finish_tfind_command (tfind_outside
, 0, start
, stop
, from_tty
);
2071 /* info scope command: list the locals for a scope. */
2073 scope_info (char *args
, int from_tty
)
2075 struct symtabs_and_lines sals
;
2077 struct minimal_symbol
*msym
;
2078 struct block
*block
;
2079 char **canonical
, *symname
, *save_args
= args
;
2080 struct dict_iterator iter
;
2082 struct gdbarch
*gdbarch
;
2085 if (args
== 0 || *args
== 0)
2086 error (_("requires an argument (function, line or *addr) to define a scope"));
2088 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2089 if (sals
.nelts
== 0)
2090 return; /* presumably decode_line_1 has already warned */
2092 /* Resolve line numbers to PC */
2093 resolve_sal_pc (&sals
.sals
[0]);
2094 block
= block_for_pc (sals
.sals
[0].pc
);
2098 QUIT
; /* allow user to bail out with ^C */
2099 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2101 QUIT
; /* allow user to bail out with ^C */
2103 printf_filtered ("Scope for %s:\n", save_args
);
2106 symname
= SYMBOL_PRINT_NAME (sym
);
2107 if (symname
== NULL
|| *symname
== '\0')
2108 continue; /* probably botched, certainly useless */
2110 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2112 printf_filtered ("Symbol %s is ", symname
);
2113 switch (SYMBOL_CLASS (sym
))
2116 case LOC_UNDEF
: /* messed up symbol? */
2117 printf_filtered ("a bogus symbol, class %d.\n",
2118 SYMBOL_CLASS (sym
));
2119 count
--; /* don't count this one */
2122 printf_filtered ("a constant with value %ld (0x%lx)",
2123 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2125 case LOC_CONST_BYTES
:
2126 printf_filtered ("constant bytes: ");
2127 if (SYMBOL_TYPE (sym
))
2128 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2129 fprintf_filtered (gdb_stdout
, " %02x",
2130 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2133 printf_filtered ("in static storage at address ");
2134 printf_filtered ("%s", paddress (gdbarch
,
2135 SYMBOL_VALUE_ADDRESS (sym
)));
2138 /* GDBARCH is the architecture associated with the objfile
2139 the symbol is defined in; the target architecture may be
2140 different, and may provide additional registers. However,
2141 we do not know the target architecture at this point.
2142 We assume the objfile architecture will contain all the
2143 standard registers that occur in debug info in that
2145 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2147 if (SYMBOL_IS_ARGUMENT (sym
))
2148 printf_filtered ("an argument in register $%s",
2149 gdbarch_register_name (gdbarch
, regno
));
2151 printf_filtered ("a local variable in register $%s",
2152 gdbarch_register_name (gdbarch
, regno
));
2155 printf_filtered ("an argument at stack/frame offset %ld",
2156 SYMBOL_VALUE (sym
));
2159 printf_filtered ("a local variable at frame offset %ld",
2160 SYMBOL_VALUE (sym
));
2163 printf_filtered ("a reference argument at offset %ld",
2164 SYMBOL_VALUE (sym
));
2166 case LOC_REGPARM_ADDR
:
2167 /* Note comment at LOC_REGISTER. */
2168 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2169 printf_filtered ("the address of an argument, in register $%s",
2170 gdbarch_register_name (gdbarch
, regno
));
2173 printf_filtered ("a typedef.\n");
2176 printf_filtered ("a label at address ");
2177 printf_filtered ("%s", paddress (gdbarch
,
2178 SYMBOL_VALUE_ADDRESS (sym
)));
2181 printf_filtered ("a function at address ");
2182 printf_filtered ("%s",
2183 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2185 case LOC_UNRESOLVED
:
2186 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2189 printf_filtered ("Unresolved Static");
2192 printf_filtered ("static storage at address ");
2193 printf_filtered ("%s",
2194 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2197 case LOC_OPTIMIZED_OUT
:
2198 printf_filtered ("optimized out.\n");
2201 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, gdb_stdout
);
2204 if (SYMBOL_TYPE (sym
))
2205 printf_filtered (", length %d.\n",
2206 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2208 if (BLOCK_FUNCTION (block
))
2211 block
= BLOCK_SUPERBLOCK (block
);
2214 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2218 /* worker function (cleanup) */
2220 replace_comma (void *data
)
2228 trace_dump_command (char *args
, int from_tty
)
2230 struct regcache
*regcache
;
2231 struct gdbarch
*gdbarch
;
2232 struct breakpoint
*t
;
2233 struct action_line
*action
;
2234 char *action_exp
, *next_comma
;
2235 struct cleanup
*old_cleanups
;
2236 int stepping_actions
= 0;
2237 int stepping_frame
= 0;
2238 struct bp_location
*loc
;
2240 if (tracepoint_number
== -1)
2242 warning (_("No current trace frame."));
2246 t
= get_tracepoint (tracepoint_number
);
2249 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2252 old_cleanups
= make_cleanup (null_cleanup
, NULL
);
2254 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2255 tracepoint_number
, traceframe_number
);
2257 /* The current frame is a trap frame if the frame PC is equal
2258 to the tracepoint PC. If not, then the current frame was
2259 collected during single-stepping. */
2261 regcache
= get_current_regcache ();
2262 gdbarch
= get_regcache_arch (regcache
);
2264 /* If the traceframe's address matches any of the tracepoint's
2265 locations, assume it is a direct hit rather than a while-stepping
2266 frame. (FIXME this is not reliable, should record each frame's
2269 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2270 if (loc
->address
== regcache_read_pc (regcache
))
2273 for (action
= t
->actions
; action
; action
= action
->next
)
2275 struct cmd_list_element
*cmd
;
2277 QUIT
; /* allow user to bail out with ^C */
2278 action_exp
= action
->action
;
2279 while (isspace ((int) *action_exp
))
2282 /* The collection actions to be done while stepping are
2283 bracketed by the commands "while-stepping" and "end". */
2285 if (*action_exp
== '#') /* comment line */
2288 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2290 error (_("Bad action list item: %s"), action_exp
);
2292 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2293 stepping_actions
= 1;
2294 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2295 stepping_actions
= 0;
2296 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2298 /* Display the collected data.
2299 For the trap frame, display only what was collected at
2300 the trap. Likewise for stepping frames, display only
2301 what was collected while stepping. This means that the
2302 two boolean variables, STEPPING_FRAME and
2303 STEPPING_ACTIONS should be equal. */
2304 if (stepping_frame
== stepping_actions
)
2307 { /* repeat over a comma-separated list */
2308 QUIT
; /* allow user to bail out with ^C */
2309 if (*action_exp
== ',')
2311 while (isspace ((int) *action_exp
))
2314 next_comma
= strchr (action_exp
, ',');
2316 if (0 == strncasecmp (action_exp
, "$reg", 4))
2317 registers_info (NULL
, from_tty
);
2318 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2319 locals_info (NULL
, from_tty
);
2320 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2321 args_info (NULL
, from_tty
);
2326 make_cleanup (replace_comma
, next_comma
);
2329 printf_filtered ("%s = ", action_exp
);
2330 output_command (action_exp
, from_tty
);
2331 printf_filtered ("\n");
2335 action_exp
= next_comma
;
2337 while (action_exp
&& *action_exp
== ',');
2341 discard_cleanups (old_cleanups
);
2344 extern int trace_regblock_size
;
2347 trace_save_command (char *args
, int from_tty
)
2350 char *filename
= NULL
, *pathname
;
2351 int target_does_save
= 0;
2352 struct cleanup
*cleanup
;
2353 struct trace_status
*ts
= current_trace_status ();
2356 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2357 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2360 ULONGEST offset
= 0;
2361 #define MAX_TRACE_UPLOAD 2000
2362 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2366 error_no_arg (_("file in which to save trace data"));
2368 argv
= gdb_buildargv (args
);
2369 make_cleanup_freeargv (argv
);
2371 for (; *argv
; ++argv
)
2373 if (strcmp (*argv
, "-r") == 0)
2374 target_does_save
= 1;
2375 else if (**argv
== '-')
2376 error (_("unknown option `%s'"), *argv
);
2382 error_no_arg (_("file in which to save trace data"));
2384 /* If the target is to save the data to a file on its own, then just
2385 send the command and be done with it. */
2386 if (target_does_save
)
2388 err
= target_save_trace_data (filename
);
2390 error (_("Target failed to save trace data to '%s'."),
2395 /* Get the trace status first before opening the file, so if the
2396 target is losing, we can get out without touching files. */
2397 status
= target_get_trace_status (ts
);
2399 pathname
= tilde_expand (args
);
2400 cleanup
= make_cleanup (xfree
, pathname
);
2402 fp
= fopen (pathname
, "w");
2404 error (_("Unable to open file '%s' for saving trace data (%s)"),
2405 args
, safe_strerror (errno
));
2406 make_cleanup_fclose (fp
);
2408 /* Write a file header, with a high-bit-set char to indicate a
2409 binary file, plus a hint as what this file is, and a version
2410 number in case of future needs. */
2411 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2413 perror_with_name (pathname
);
2415 /* Write descriptive info. */
2417 /* Write out the size of a register block. */
2418 fprintf (fp
, "R %x\n", trace_regblock_size
);
2420 /* Write out status of the tracing run (aka "tstatus" info). */
2421 fprintf (fp
, "status %c;%s:%x;tframes:%x;tfree:%llx\n",
2422 (ts
->running
? '1' : '0'),
2423 stop_reason_names
[ts
->stop_reason
], ts
->stopping_tracepoint
,
2424 ts
->traceframe_count
, ts
->buffer_free
);
2426 /* Note that we want to upload tracepoints and save those, rather
2427 than simply writing out the local ones, because the user may have
2428 changed tracepoints in GDB in preparation for a future tracing
2429 run, or maybe just mass-deleted all types of breakpoints as part
2430 of cleaning up. So as not to contaminate the session, leave the
2431 data in its uploaded form, don't make into real tracepoints. */
2433 /* Get trace state variables first, they may be checked when parsing
2434 uploaded commands. */
2436 target_upload_trace_state_variables (&uploaded_tsvs
);
2438 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2444 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
2445 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
2448 fprintf (fp
, "tsv %x:%s:%x:%s\n",
2449 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
2450 utsv
->builtin
, buf
);
2456 free_uploaded_tsvs (&uploaded_tsvs
);
2458 target_upload_tracepoints (&uploaded_tps
);
2460 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
2462 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
2463 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2464 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
2465 if (utp
->type
== bp_fast_tracepoint
)
2466 fprintf (fp
, ":F%x", utp
->orig_size
);
2468 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
2471 for (a
= 0; a
< utp
->numactions
; ++a
)
2472 fprintf (fp
, "tp A%x:%s:%s\n",
2473 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2475 for (a
= 0; a
< utp
->num_step_actions
; ++a
)
2476 fprintf (fp
, "tp S%x:%s:%s\n",
2477 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2478 utp
->step_actions
[a
]);
2481 free_uploaded_tps (&uploaded_tps
);
2483 /* Mark the end of the definition section. */
2486 /* Get and write the trace data proper. We ask for big blocks, in
2487 the hopes of efficiency, but will take less if the target has
2488 packet size limitations or some such. */
2491 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
2493 error (_("Failure to get requested trace buffer data"));
2494 /* No more data is forthcoming, we're done. */
2497 written
= fwrite (buf
, gotten
, 1, fp
);
2498 if (written
< gotten
)
2499 perror_with_name (pathname
);
2503 /* Mark the end of trace data. */
2504 written
= fwrite (&gotten
, 4, 1, fp
);
2506 perror_with_name (pathname
);
2508 do_cleanups (cleanup
);
2510 printf_filtered (_("Trace data saved to file '%s'.\n"), args
);
2513 /* Tell the target what to do with an ongoing tracing run if GDB
2514 disconnects for some reason. */
2517 send_disconnected_tracing_value (int value
)
2519 target_set_disconnected_tracing (value
);
2523 set_disconnected_tracing (char *args
, int from_tty
,
2524 struct cmd_list_element
*c
)
2526 send_disconnected_tracing_value (disconnected_tracing
);
2529 /* Convert the memory pointed to by mem into hex, placing result in buf.
2530 * Return a pointer to the last char put in buf (null)
2531 * "stolen" from sparc-stub.c
2534 static const char hexchars
[] = "0123456789abcdef";
2537 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2545 *buf
++ = hexchars
[ch
>> 4];
2546 *buf
++ = hexchars
[ch
& 0xf];
2555 get_traceframe_number (void)
2557 return traceframe_number
;
2560 /* Make the traceframe NUM be the current trace frame. Does nothing
2561 if NUM is already current. */
2564 set_traceframe_number (int num
)
2568 if (traceframe_number
== num
)
2570 /* Nothing to do. */
2574 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
2577 warning (_("could not change traceframe"));
2579 traceframe_number
= newnum
;
2581 /* Changing the traceframe changes our view of registers and of the
2583 registers_changed ();
2586 /* A cleanup used when switching away and back from tfind mode. */
2588 struct current_traceframe_cleanup
2590 /* The traceframe we were inspecting. */
2591 int traceframe_number
;
2595 do_restore_current_traceframe_cleanup (void *arg
)
2597 struct current_traceframe_cleanup
*old
= arg
;
2599 set_traceframe_number (old
->traceframe_number
);
2603 restore_current_traceframe_cleanup_dtor (void *arg
)
2605 struct current_traceframe_cleanup
*old
= arg
;
2611 make_cleanup_restore_current_traceframe (void)
2613 struct current_traceframe_cleanup
*old
;
2615 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
2616 old
->traceframe_number
= traceframe_number
;
2618 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
2619 restore_current_traceframe_cleanup_dtor
);
2622 /* Given a number and address, return an uploaded tracepoint with that
2623 number, creating if necessary. */
2625 struct uploaded_tp
*
2626 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
2628 struct uploaded_tp
*utp
;
2630 for (utp
= *utpp
; utp
; utp
= utp
->next
)
2631 if (utp
->number
== num
&& utp
->addr
== addr
)
2633 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
2634 memset (utp
, 0, sizeof (struct uploaded_tp
));
2643 free_uploaded_tps (struct uploaded_tp
**utpp
)
2645 struct uploaded_tp
*next_one
;
2649 next_one
= (*utpp
)->next
;
2655 /* Given a number and address, return an uploaded tracepoint with that
2656 number, creating if necessary. */
2658 struct uploaded_tsv
*
2659 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
2661 struct uploaded_tsv
*utsv
;
2663 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
2664 if (utsv
->number
== num
)
2666 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
2667 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
2669 utsv
->next
= *utsvp
;
2675 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
2677 struct uploaded_tsv
*next_one
;
2681 next_one
= (*utsvp
)->next
;
2687 /* Look for an existing tracepoint that seems similar enough to the
2688 uploaded one. Enablement isn't compared, because the user can
2689 toggle that freely, and may have done so in anticipation of the
2693 find_matching_tracepoint (struct uploaded_tp
*utp
)
2695 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
2697 struct breakpoint
*t
;
2698 struct bp_location
*loc
;
2700 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2702 if (t
->type
== utp
->type
2703 && t
->step_count
== utp
->step
2704 && t
->pass_count
== utp
->pass
2705 /* FIXME also test conditionals and actions */
2708 /* Scan the locations for an address match. */
2709 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2711 if (loc
->address
== utp
->addr
)
2719 /* Given a list of tracepoints uploaded from a target, attempt to
2720 match them up with existing tracepoints, and create new ones if not
2724 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
2726 struct uploaded_tp
*utp
;
2727 struct breakpoint
*t
;
2729 /* Look for GDB tracepoints that match up with our uploaded versions. */
2730 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
2732 t
= find_matching_tracepoint (utp
);
2734 printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
2735 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2738 t
= create_tracepoint_from_upload (utp
);
2740 printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
2741 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2743 printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
2744 utp
->number
, paddress (get_current_arch (), utp
->addr
));
2746 /* Whether found or created, record the number used by the
2747 target, to help with mapping target tracepoints back to their
2748 counterparts here. */
2750 t
->number_on_target
= utp
->number
;
2753 free_uploaded_tps (uploaded_tps
);
2756 /* Trace state variables don't have much to identify them beyond their
2757 name, so just use that to detect matches. */
2759 struct trace_state_variable
*
2760 find_matching_tsv (struct uploaded_tsv
*utsv
)
2765 return find_trace_state_variable (utsv
->name
);
2768 struct trace_state_variable
*
2769 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
2771 const char *namebase
;
2774 struct trace_state_variable
*tsv
;
2778 namebase
= utsv
->name
;
2779 sprintf (buf
, "%s", namebase
);
2784 sprintf (buf
, "%s_%d", namebase
, try_num
++);
2787 /* Fish for a name that is not in use. */
2788 /* (should check against all internal vars?) */
2789 while (find_trace_state_variable (buf
))
2790 sprintf (buf
, "%s_%d", namebase
, try_num
++);
2792 /* We have an available name, create the variable. */
2793 tsv
= create_trace_state_variable (xstrdup (buf
));
2794 tsv
->initial_value
= utsv
->initial_value
;
2795 tsv
->builtin
= utsv
->builtin
;
2800 /* Given a list of uploaded trace state variables, try to match them
2801 up with existing variables, or create additional ones. */
2804 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
2807 struct uploaded_tsv
*utsv
;
2808 struct trace_state_variable
*tsv
;
2811 /* Most likely some numbers will have to be reassigned as part of
2812 the merge, so clear them all in anticipation. */
2813 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2816 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2818 tsv
= find_matching_tsv (utsv
);
2820 printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
2821 tsv
->name
, utsv
->number
);
2824 tsv
= create_tsv_from_upload (utsv
);
2825 printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
2826 tsv
->name
, utsv
->number
);
2828 /* Give precedence to numberings that come from the target. */
2830 tsv
->number
= utsv
->number
;
2833 /* Renumber everything that didn't get a target-assigned number. */
2835 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2836 if (tsv
->number
> highest
)
2837 highest
= tsv
->number
;
2840 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2841 if (tsv
->number
== 0)
2842 tsv
->number
= highest
++;
2844 free_uploaded_tsvs (uploaded_tsvs
);
2847 /* target tfile command */
2849 struct target_ops tfile_ops
;
2851 /* Fill in tfile_ops with its defined operations and properties. */
2853 #define TRACE_HEADER_SIZE 8
2855 char *trace_filename
;
2857 off_t trace_frames_offset
;
2860 int trace_regblock_size
;
2862 static void tfile_interp_line (char *line
,
2863 struct uploaded_tp
**utpp
,
2864 struct uploaded_tsv
**utsvp
);
2867 tfile_open (char *filename
, int from_tty
)
2870 struct cleanup
*old_chain
;
2873 char header
[TRACE_HEADER_SIZE
];
2874 char linebuf
[1000]; /* should be max remote packet size or so */
2876 int bytes
, i
, gotten
;
2877 struct trace_status
*ts
;
2878 struct uploaded_tp
*uploaded_tps
= NULL
;
2879 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
2881 target_preopen (from_tty
);
2883 error (_("No trace file specified."));
2885 filename
= tilde_expand (filename
);
2886 if (!IS_ABSOLUTE_PATH(filename
))
2888 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
2893 old_chain
= make_cleanup (xfree
, filename
);
2895 flags
= O_BINARY
| O_LARGEFILE
;
2897 scratch_chan
= open (filename
, flags
, 0);
2898 if (scratch_chan
< 0)
2899 perror_with_name (filename
);
2901 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
2903 discard_cleanups (old_chain
); /* Don't free filename any more */
2904 unpush_target (&tfile_ops
);
2906 push_target (&tfile_ops
);
2908 trace_filename
= xstrdup (filename
);
2909 trace_fd
= scratch_chan
;
2912 /* Read the file header and test for validity. */
2913 gotten
= read (trace_fd
, &header
, TRACE_HEADER_SIZE
);
2915 perror_with_name (trace_filename
);
2916 else if (gotten
< TRACE_HEADER_SIZE
)
2917 error (_("Premature end of file while reading trace file"));
2919 bytes
+= TRACE_HEADER_SIZE
;
2920 if (!(header
[0] == 0x7f
2921 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
2922 error (_("File is not a valid trace file."));
2924 trace_regblock_size
= 0;
2925 ts
= current_trace_status ();
2926 /* We know we're working with a file. */
2928 /* Set defaults in case there is no status line. */
2929 ts
->running_known
= 0;
2930 ts
->stop_reason
= trace_stop_reason_unknown
;
2931 ts
->traceframe_count
= -1;
2932 ts
->buffer_free
= 0;
2934 /* Read through a section of newline-terminated lines that
2935 define things like tracepoints. */
2939 gotten
= read (trace_fd
, &byte
, 1);
2941 perror_with_name (trace_filename
);
2942 else if (gotten
< 1)
2943 error (_("Premature end of file while reading trace file"));
2948 /* Empty line marks end of the definition section. */
2953 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
2956 linebuf
[i
++] = byte
;
2958 error (_("Excessively long lines in trace file"));
2961 /* Add the file's tracepoints and variables into the current mix. */
2963 /* Get trace state variables first, they may be checked when parsing
2964 uploaded commands. */
2965 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
2967 merge_uploaded_tracepoints (&uploaded_tps
);
2969 /* Record the starting offset of the binary trace data. */
2970 trace_frames_offset
= bytes
;
2972 /* If we don't have a blocksize, we can't interpret the
2974 if (trace_regblock_size
== 0)
2975 error (_("No register block size recorded in trace file"));
2976 if (ts
->traceframe_count
<= 0)
2978 warning ("No traceframes present in this file.");
2982 #define TFILE_PID (1)
2983 inferior_appeared (current_inferior (), TFILE_PID
);
2984 inferior_ptid
= pid_to_ptid (TFILE_PID
);
2985 add_thread_silent (inferior_ptid
);
2987 post_create_inferior (&tfile_ops
, from_tty
);
2990 /* FIXME this will get defined in MI patch submission */
2991 tfind_1 (tfind_number
, 0, 0, 0, 0);
2995 /* Interpret the given line from the definitions part of the trace
2999 tfile_interp_line (char *line
,
3000 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3004 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3007 trace_regblock_size
= strtol (p
, &p
, 16);
3009 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3011 p
+= strlen ("status ");
3012 parse_trace_status (p
, current_trace_status ());
3014 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3016 p
+= strlen ("tp ");
3017 parse_tracepoint_definition (p
, utpp
);
3019 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3021 p
+= strlen ("tsv ");
3022 parse_tsv_definition (p
, utsvp
);
3025 warning ("Ignoring trace file definition \"%s\"", line
);
3028 /* Parse the part of trace status syntax that is shared between
3029 the remote protocol and the trace file reader. */
3031 extern char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
3034 parse_trace_status (char *line
, struct trace_status
*ts
)
3036 char *p
= line
, *p1
, *p_temp
;
3039 ts
->running_known
= 1;
3040 ts
->running
= (*p
++ == '1');
3041 ts
->stop_reason
= trace_stop_reason_unknown
;
3044 p1
= strchr (p
, ':');
3046 error (_("Malformed trace status, at %s\n\
3047 Status line: '%s'\n"), p
, line
);
3048 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3050 p
= unpack_varlen_hex (++p1
, &val
);
3051 ts
->stop_reason
= trace_buffer_full
;
3053 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3055 p
= unpack_varlen_hex (++p1
, &val
);
3056 ts
->stop_reason
= trace_never_run
;
3058 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
], p1
- p
) == 0)
3060 p
= unpack_varlen_hex (++p1
, &val
);
3061 ts
->stop_reason
= tracepoint_passcount
;
3062 ts
->stopping_tracepoint
= val
;
3064 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3066 p
= unpack_varlen_hex (++p1
, &val
);
3067 ts
->stop_reason
= tstop_command
;
3069 if (strncmp (p
, "tframes", p1
- p
) == 0)
3071 p
= unpack_varlen_hex (++p1
, &val
);
3072 ts
->traceframe_count
= val
;
3074 if (strncmp (p
, "tfree", p1
- p
) == 0)
3076 p
= unpack_varlen_hex (++p1
, &val
);
3077 ts
->buffer_free
= val
;
3081 /* Silently skip unknown optional info. */
3082 p_temp
= strchr (p1
+ 1, ';');
3086 /* Must be at the end. */
3092 /* Given a line of text defining a tracepoint or tracepoint action, parse
3093 it into an "uploaded tracepoint". */
3096 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3100 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
;
3104 struct uploaded_tp
*utp
= NULL
;
3107 /* Both tracepoint and action definitions start with the same number
3108 and address sequence. */
3110 p
= unpack_varlen_hex (p
, &num
);
3111 p
++; /* skip a colon */
3112 p
= unpack_varlen_hex (p
, &addr
);
3113 p
++; /* skip a colon */
3116 enabled
= (*p
++ == 'E');
3117 p
++; /* skip a colon */
3118 p
= unpack_varlen_hex (p
, &step
);
3119 p
++; /* skip a colon */
3120 p
= unpack_varlen_hex (p
, &pass
);
3121 type
= bp_tracepoint
;
3123 /* Thumb through optional fields. */
3126 p
++; /* skip a colon */
3129 type
= bp_fast_tracepoint
;
3131 p
= unpack_varlen_hex (p
, &orig_size
);
3136 p
= unpack_varlen_hex (p
, &xlen
);
3137 p
++; /* skip a comma */
3138 cond
= (char *) xmalloc (2 * xlen
+ 1);
3139 strncpy (cond
, p
, 2 * xlen
);
3140 cond
[2 * xlen
] = '\0';
3144 warning ("Unrecognized char '%c' in tracepoint definition, skipping rest", *p
);
3146 utp
= get_uploaded_tp (num
, addr
, utpp
);
3148 utp
->enabled
= enabled
;
3153 else if (piece
== 'A')
3155 utp
= get_uploaded_tp (num
, addr
, utpp
);
3156 utp
->actions
[utp
->numactions
++] = xstrdup (p
);
3158 else if (piece
== 'S')
3160 utp
= get_uploaded_tp (num
, addr
, utpp
);
3161 utp
->step_actions
[utp
->num_step_actions
++] = xstrdup (p
);
3165 error ("Invalid tracepoint piece");
3169 /* Convert a textual description of a trace state variable into an
3173 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3176 ULONGEST num
, initval
, builtin
;
3178 struct uploaded_tsv
*utsv
= NULL
;
3180 buf
= alloca (strlen (line
));
3183 p
= unpack_varlen_hex (p
, &num
);
3184 p
++; /* skip a colon */
3185 p
= unpack_varlen_hex (p
, &initval
);
3186 p
++; /* skip a colon */
3187 p
= unpack_varlen_hex (p
, &builtin
);
3188 p
++; /* skip a colon */
3189 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3192 utsv
= get_uploaded_tsv (num
, utsvp
);
3193 utsv
->initial_value
= initval
;
3194 utsv
->builtin
= builtin
;
3195 utsv
->name
= xstrdup (buf
);
3198 /* Close the trace file and generally clean up. */
3201 tfile_close (int quitting
)
3208 pid
= ptid_get_pid (inferior_ptid
);
3209 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
3210 exit_inferior_silent (pid
);
3215 xfree (trace_filename
);
3219 tfile_files_info (struct target_ops
*t
)
3221 /* (it would be useful to mention the name of the file) */
3222 printf_filtered ("Looking at a trace file.\n");
3225 /* The trace status for a file is that tracing can never be run. */
3228 tfile_get_trace_status (struct trace_status
*ts
)
3230 /* Other bits of trace status were collected as part of opening the
3231 trace files, so nothing to do here. */
3236 /* Given the position of a traceframe in the file, figure out what
3237 address the frame was collected at. This would normally be the
3238 value of a collected PC register, but if not available, we
3242 tfile_get_traceframe_address (off_t tframe_offset
)
3246 struct breakpoint
*tp
;
3247 off_t saved_offset
= cur_offset
;
3250 /* FIXME dig pc out of collected registers */
3252 /* Fall back to using tracepoint address. */
3253 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
3254 gotten
= read (trace_fd
, &tpnum
, 2);
3256 perror_with_name (trace_filename
);
3257 else if (gotten
< 2)
3258 error (_("Premature end of file while reading trace file"));
3260 tp
= get_tracepoint_by_number_on_target (tpnum
);
3261 /* FIXME this is a poor heuristic if multiple locations */
3263 addr
= tp
->loc
->address
;
3265 /* Restore our seek position. */
3266 cur_offset
= saved_offset
;
3267 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3271 /* Given a type of search and some parameters, scan the collection of
3272 traceframes in the file looking for a match. When found, return
3273 both the traceframe and tracepoint number, otherwise -1 for
3277 tfile_trace_find (enum trace_find_type type
, int num
,
3278 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
3281 int tfnum
= 0, found
= 0, gotten
;
3283 struct breakpoint
*tp
;
3284 off_t offset
, tframe_offset
;
3287 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
3288 offset
= trace_frames_offset
;
3291 tframe_offset
= offset
;
3292 gotten
= read (trace_fd
, &tpnum
, 2);
3294 perror_with_name (trace_filename
);
3295 else if (gotten
< 2)
3296 error (_("Premature end of file while reading trace file"));
3300 gotten
= read (trace_fd
, &data_size
, 4);
3302 perror_with_name (trace_filename
);
3303 else if (gotten
< 4)
3304 error (_("Premature end of file while reading trace file"));
3313 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3314 if (tfaddr
== addr1
)
3318 tp
= get_tracepoint (num
);
3319 if (tp
&& tpnum
== tp
->number_on_target
)
3323 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3324 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
3328 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3329 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
3333 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
3337 printf_filtered ("Found traceframe %d.\n", tfnum
);
3340 cur_offset
= offset
;
3341 cur_data_size
= data_size
;
3344 /* Skip past the traceframe's data. */
3345 lseek (trace_fd
, data_size
, SEEK_CUR
);
3346 offset
+= data_size
;
3347 /* Update our own count of traceframes. */
3350 /* Did not find what we were looking for. */
3356 /* Look for a block of saved registers in the traceframe, and get the
3357 requested register from it. */
3360 tfile_fetch_registers (struct target_ops
*ops
,
3361 struct regcache
*regcache
, int regno
)
3363 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3365 int i
, pos
, offset
, regn
, regsize
, gotten
;
3366 unsigned short mlen
;
3369 /* An uninitialized reg size says we're not going to be
3370 successful at getting register blocks. */
3371 if (!trace_regblock_size
)
3374 regs
= alloca (trace_regblock_size
);
3376 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3378 while (pos
< cur_data_size
)
3380 gotten
= read (trace_fd
, &block_type
, 1);
3382 perror_with_name (trace_filename
);
3383 else if (gotten
< 1)
3384 error (_("Premature end of file while reading trace file"));
3390 gotten
= read (trace_fd
, regs
, trace_regblock_size
);
3392 perror_with_name (trace_filename
);
3393 else if (gotten
< trace_regblock_size
)
3394 error (_("Premature end of file while reading trace file"));
3396 /* Assume the block is laid out in GDB register number order,
3397 each register with the size that it has in GDB. */
3399 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3401 regsize
= register_size (gdbarch
, regn
);
3402 /* Make sure we stay within block bounds. */
3403 if (offset
+ regsize
>= trace_regblock_size
)
3405 if (!regcache_valid_p (regcache
, regn
))
3409 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
3412 else if (regno
== -1)
3414 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
3421 lseek (trace_fd
, 8, SEEK_CUR
);
3422 gotten
= read (trace_fd
, &mlen
, 2);
3424 perror_with_name (trace_filename
);
3425 else if (gotten
< 2)
3426 error (_("Premature end of file while reading trace file"));
3427 lseek (trace_fd
, mlen
, SEEK_CUR
);
3428 pos
+= (8 + 2 + mlen
);
3431 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3435 error ("Unknown block type '%c' (0x%x) in trace frame",
3436 block_type
, block_type
);
3443 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3444 const char *annex
, gdb_byte
*readbuf
,
3445 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3450 unsigned short mlen
;
3452 /* We're only doing regular memory for now. */
3453 if (object
!= TARGET_OBJECT_MEMORY
)
3456 if (readbuf
== NULL
)
3457 error ("tfile_xfer_partial: trace file is read-only");
3459 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3461 while (pos
< cur_data_size
)
3463 gotten
= read (trace_fd
, &block_type
, 1);
3465 perror_with_name (trace_filename
);
3466 else if (gotten
< 1)
3467 error (_("Premature end of file while reading trace file"));
3472 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3473 pos
+= trace_regblock_size
;
3476 gotten
= read (trace_fd
, &maddr
, 8);
3478 perror_with_name (trace_filename
);
3479 else if (gotten
< 8)
3480 error (_("Premature end of file while reading trace file"));
3482 gotten
= read (trace_fd
, &mlen
, 2);
3484 perror_with_name (trace_filename
);
3485 else if (gotten
< 2)
3486 error (_("Premature end of file while reading trace file"));
3487 if (maddr
<= offset
&& (offset
+ len
) <= (maddr
+ mlen
))
3489 gotten
= read (trace_fd
, readbuf
, mlen
);
3491 perror_with_name (trace_filename
);
3492 else if (gotten
< mlen
)
3493 error (_("Premature end of file qwhile reading trace file"));
3497 lseek (trace_fd
, mlen
, SEEK_CUR
);
3498 pos
+= (8 + 2 + mlen
);
3501 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3505 error ("Unknown block type '%c' (0x%x) in traceframe",
3506 block_type
, block_type
);
3510 /* Indicate failure to find the requested memory block. */
3514 /* Iterate through the blocks of a trace frame, looking for a 'V'
3515 block with a matching tsv number. */
3518 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
3521 int pos
, vnum
, gotten
;
3522 unsigned short mlen
;
3524 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3526 while (pos
< cur_data_size
)
3528 gotten
= read (trace_fd
, &block_type
, 1);
3530 perror_with_name (trace_filename
);
3531 else if (gotten
< 1)
3532 error (_("Premature end of file while reading trace file"));
3537 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3538 pos
+= trace_regblock_size
;
3541 lseek (trace_fd
, 8, SEEK_CUR
);
3542 gotten
= read (trace_fd
, &mlen
, 2);
3544 perror_with_name (trace_filename
);
3545 else if (gotten
< 2)
3546 error (_("Premature end of file while reading trace file"));
3547 lseek (trace_fd
, mlen
, SEEK_CUR
);
3548 pos
+= (8 + 2 + mlen
);
3551 gotten
= read (trace_fd
, &vnum
, 4);
3553 perror_with_name (trace_filename
);
3554 else if (gotten
< 4)
3555 error (_("Premature end of file while reading trace file"));
3558 gotten
= read (trace_fd
, val
, 8);
3560 perror_with_name (trace_filename
);
3561 else if (gotten
< 8)
3562 error (_("Premature end of file while reading trace file"));
3565 lseek (trace_fd
, 8, SEEK_CUR
);
3569 error ("Unknown block type '%c' (0x%x) in traceframe",
3570 block_type
, block_type
);
3574 /* Didn't find anything. */
3579 tfile_has_memory (struct target_ops
*ops
)
3585 tfile_has_stack (struct target_ops
*ops
)
3591 tfile_has_registers (struct target_ops
*ops
)
3597 init_tfile_ops (void)
3599 tfile_ops
.to_shortname
= "tfile";
3600 tfile_ops
.to_longname
= "Local trace dump file";
3602 "Use a trace file as a target. Specify the filename of the trace file.";
3603 tfile_ops
.to_open
= tfile_open
;
3604 tfile_ops
.to_close
= tfile_close
;
3605 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
3606 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
3607 tfile_ops
.to_files_info
= tfile_files_info
;
3608 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
3609 tfile_ops
.to_trace_find
= tfile_trace_find
;
3610 tfile_ops
.to_get_trace_state_variable_value
= tfile_get_trace_state_variable_value
;
3611 /* core_stratum might seem more logical, but GDB doesn't like having
3612 more than one core_stratum vector. */
3613 tfile_ops
.to_stratum
= process_stratum
;
3614 tfile_ops
.to_has_memory
= tfile_has_memory
;
3615 tfile_ops
.to_has_stack
= tfile_has_stack
;
3616 tfile_ops
.to_has_registers
= tfile_has_registers
;
3617 tfile_ops
.to_magic
= OPS_MAGIC
;
3620 /* module initialization */
3622 _initialize_tracepoint (void)
3624 struct cmd_list_element
*c
;
3626 traceframe_number
= -1;
3627 tracepoint_number
= -1;
3629 if (tracepoint_list
.list
== NULL
)
3631 tracepoint_list
.listsize
= 128;
3632 tracepoint_list
.list
= xmalloc
3633 (tracepoint_list
.listsize
* sizeof (struct memrange
));
3635 if (tracepoint_list
.aexpr_list
== NULL
)
3637 tracepoint_list
.aexpr_listsize
= 128;
3638 tracepoint_list
.aexpr_list
= xmalloc
3639 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3642 if (stepping_list
.list
== NULL
)
3644 stepping_list
.listsize
= 128;
3645 stepping_list
.list
= xmalloc
3646 (stepping_list
.listsize
* sizeof (struct memrange
));
3649 if (stepping_list
.aexpr_list
== NULL
)
3651 stepping_list
.aexpr_listsize
= 128;
3652 stepping_list
.aexpr_list
= xmalloc
3653 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3656 add_info ("scope", scope_info
,
3657 _("List the variables local to a scope"));
3659 add_cmd ("tracepoints", class_trace
, NULL
,
3660 _("Tracing of program execution without stopping the program."),
3663 add_com ("tdump", class_trace
, trace_dump_command
,
3664 _("Print everything collected at the current tracepoint."));
3666 add_com ("tsave", class_trace
, trace_save_command
, _("\
3667 Save the trace data to a file.\n\
3668 Use the '-r' option to direct the target to save directly to the file,\n\
3669 using its own filesystem."));
3671 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
3672 Define a trace state variable.\n\
3673 Argument is a $-prefixed name, optionally followed\n\
3674 by '=' and an expression that sets the initial value\n\
3675 at the start of tracing."));
3676 set_cmd_completer (c
, expression_completer
);
3678 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
3679 Delete one or more trace state variables.\n\
3680 Arguments are the names of the variables to delete.\n\
3681 If no arguments are supplied, delete all variables."), &deletelist
);
3682 /* FIXME add a trace variable completer */
3684 add_info ("tvariables", tvariables_info
, _("\
3685 Status of trace state variables and their values.\n\
3688 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
3689 Select a trace frame;\n\
3690 No argument means forward by one frame; '-' means backward by one frame."),
3691 &tfindlist
, "tfind ", 1, &cmdlist
);
3693 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
3694 Select a trace frame whose PC is outside the given range (exclusive).\n\
3695 Usage: tfind outside addr1, addr2"),
3698 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
3699 Select a trace frame whose PC is in the given range (inclusive).\n\
3700 Usage: tfind range addr1,addr2"),
3703 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
3704 Select a trace frame by source line.\n\
3705 Argument can be a line number (with optional source file), \n\
3706 a function name, or '*' followed by an address.\n\
3707 Default argument is 'the next source line that was traced'."),
3710 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
3711 Select a trace frame by tracepoint number.\n\
3712 Default is the tracepoint for the current trace frame."),
3715 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
3716 Select a trace frame by PC.\n\
3717 Default is the current PC, or the PC of the current trace frame."),
3720 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
3721 Synonym for 'none'.\n\
3722 De-select any trace frame and resume 'live' debugging."),
3725 add_cmd ("none", class_trace
, trace_find_none_command
,
3726 _("De-select any trace frame and resume 'live' debugging."),
3729 add_cmd ("start", class_trace
, trace_find_start_command
,
3730 _("Select the first trace frame in the trace buffer."),
3733 add_com ("tstatus", class_trace
, trace_status_command
,
3734 _("Display the status of the current trace data collection."));
3736 add_com ("tstop", class_trace
, trace_stop_command
,
3737 _("Stop trace data collection."));
3739 add_com ("tstart", class_trace
, trace_start_command
,
3740 _("Start trace data collection."));
3742 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
3743 Ends a list of commands or actions.\n\
3744 Several GDB commands allow you to enter a list of commands or actions.\n\
3745 Entering \"end\" on a line by itself is the normal way to terminate\n\
3747 Note: the \"end\" command cannot be used at the gdb prompt."));
3749 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
3750 Specify single-stepping behavior at a tracepoint.\n\
3751 Argument is number of instructions to trace in single-step mode\n\
3752 following the tracepoint. This command is normally followed by\n\
3753 one or more \"collect\" commands, to specify what to collect\n\
3754 while single-stepping.\n\n\
3755 Note: this command can only be used in a tracepoint \"actions\" list."));
3757 add_com_alias ("ws", "while-stepping", class_alias
, 0);
3758 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
3760 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
3761 Specify one or more data items to be collected at a tracepoint.\n\
3762 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
3763 collect all data (variables, registers) referenced by that expression.\n\
3764 Also accepts the following special arguments:\n\
3765 $regs -- all registers.\n\
3766 $args -- all function arguments.\n\
3767 $locals -- all variables local to the block/function scope.\n\
3768 Note: this command can only be used in a tracepoint \"actions\" list."));
3770 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
3771 Specify one or more expressions to be evaluated at a tracepoint.\n\
3772 Accepts a comma-separated list of (one or more) expressions.\n\
3773 The result of each evaluation will be discarded.\n\
3774 Note: this command can only be used in a tracepoint \"actions\" list."));
3776 add_com ("actions", class_trace
, trace_actions_command
, _("\
3777 Specify the actions to be taken at a tracepoint.\n\
3778 Tracepoint actions may include collecting of specified data, \n\
3779 single-stepping, or enabling/disabling other tracepoints, \n\
3780 depending on target's capabilities."));
3782 default_collect
= xstrdup ("");
3783 add_setshow_string_cmd ("default-collect", class_trace
,
3784 &default_collect
, _("\
3785 Set the list of expressions to collect by default"), _("\
3786 Show the list of expressions to collect by default"), NULL
,
3788 &setlist
, &showlist
);
3790 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
3791 &disconnected_tracing
, _("\
3792 Set whether tracing continues after GDB disconnects."), _("\
3793 Show whether tracing continues after GDB disconnects."), _("\
3794 Use this to continue a tracing run even if GDB disconnects\n\
3795 or detaches from the target. You can reconnect later and look at\n\
3796 trace data collected in the meantime."),
3797 set_disconnected_tracing
,
3804 add_target (&tfile_ops
);