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
;
952 int treat_as_expr
= 0;
954 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
955 switch (SYMBOL_CLASS (sym
))
958 printf_filtered ("%s: don't know symbol class %d\n",
959 SYMBOL_PRINT_NAME (sym
),
963 printf_filtered ("constant %s (value %ld) will not be collected.\n",
964 SYMBOL_PRINT_NAME (sym
), SYMBOL_VALUE (sym
));
967 offset
= SYMBOL_VALUE_ADDRESS (sym
);
972 sprintf_vma (tmp
, offset
);
973 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
974 SYMBOL_PRINT_NAME (sym
), len
,
977 /* A struct may be a C++ class with static fields, go to general
978 expression handling. */
979 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
982 add_memrange (collect
, memrange_absolute
, offset
, len
);
985 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
987 printf_filtered ("LOC_REG[parm] %s: ",
988 SYMBOL_PRINT_NAME (sym
));
989 add_register (collect
, reg
);
990 /* Check for doubles stored in two registers. */
991 /* FIXME: how about larger types stored in 3 or more regs? */
992 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
993 len
> register_size (gdbarch
, reg
))
994 add_register (collect
, reg
+ 1);
997 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
998 printf_filtered (" (will not collect %s)\n",
999 SYMBOL_PRINT_NAME (sym
));
1003 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1006 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1007 SYMBOL_PRINT_NAME (sym
), len
);
1008 printf_vma (offset
);
1009 printf_filtered (" from frame ptr reg %d\n", reg
);
1011 add_memrange (collect
, reg
, offset
, len
);
1013 case LOC_REGPARM_ADDR
:
1014 reg
= SYMBOL_VALUE (sym
);
1018 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1019 SYMBOL_PRINT_NAME (sym
), len
);
1020 printf_vma (offset
);
1021 printf_filtered (" from reg %d\n", reg
);
1023 add_memrange (collect
, reg
, offset
, len
);
1027 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1030 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1031 SYMBOL_PRINT_NAME (sym
), len
);
1032 printf_vma (offset
);
1033 printf_filtered (" from frame ptr reg %d\n", reg
);
1035 add_memrange (collect
, reg
, offset
, len
);
1037 case LOC_UNRESOLVED
:
1038 printf_filtered ("Don't know LOC_UNRESOLVED %s\n",
1039 SYMBOL_PRINT_NAME (sym
));
1041 case LOC_OPTIMIZED_OUT
:
1042 printf_filtered ("%s has been optimized out of existence.\n",
1043 SYMBOL_PRINT_NAME (sym
));
1051 /* Expressions are the most general case. */
1054 struct agent_expr
*aexpr
;
1055 struct cleanup
*old_chain1
= NULL
;
1056 struct agent_reqs areqs
;
1058 aexpr
= gen_trace_for_var (scope
, gdbarch
, sym
);
1060 /* It can happen that the symbol is recorded as a computed
1061 location, but it's been optimized away and doesn't actually
1062 have a location expression. */
1065 printf_filtered ("%s has been optimized out of existence.\n",
1066 SYMBOL_PRINT_NAME (sym
));
1070 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1072 ax_reqs (aexpr
, &areqs
);
1073 if (areqs
.flaw
!= agent_flaw_none
)
1074 error (_("malformed expression"));
1076 if (areqs
.min_height
< 0)
1077 error (_("gdb: Internal error: expression has min height < 0"));
1078 if (areqs
.max_height
> 20)
1079 error (_("expression too complicated, try simplifying"));
1081 discard_cleanups (old_chain1
);
1082 add_aexpr (collect
, aexpr
);
1084 /* take care of the registers */
1085 if (areqs
.reg_mask_len
> 0)
1089 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1091 QUIT
; /* allow user to bail out with ^C */
1092 if (areqs
.reg_mask
[ndx1
] != 0)
1094 /* assume chars have 8 bits */
1095 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1096 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1097 /* it's used -- record it */
1098 add_register (collect
, ndx1
* 8 + ndx2
);
1105 /* Add all locals (or args) symbols to collection list */
1107 add_local_symbols (struct collection_list
*collect
,
1108 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1109 long frame_regno
, long frame_offset
, int type
)
1112 struct block
*block
;
1113 struct dict_iterator iter
;
1116 block
= block_for_pc (pc
);
1119 QUIT
; /* allow user to bail out with ^C */
1120 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
1122 if (SYMBOL_IS_ARGUMENT (sym
)
1123 ? type
== 'A' /* collecting Arguments */
1124 : type
== 'L') /* collecting Locals */
1127 collect_symbol (collect
, sym
, gdbarch
,
1128 frame_regno
, frame_offset
, pc
);
1131 if (BLOCK_FUNCTION (block
))
1134 block
= BLOCK_SUPERBLOCK (block
);
1137 warning (_("No %s found in scope."),
1138 type
== 'L' ? "locals" : "args");
1141 /* worker function */
1143 clear_collection_list (struct collection_list
*list
)
1147 list
->next_memrange
= 0;
1148 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1150 free_agent_expr (list
->aexpr_list
[ndx
]);
1151 list
->aexpr_list
[ndx
] = NULL
;
1153 list
->next_aexpr_elt
= 0;
1154 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1157 /* reduce a collection list to string form (for gdb protocol) */
1159 stringify_collection_list (struct collection_list
*list
, char *string
)
1161 char temp_buf
[2048];
1165 char *(*str_list
)[];
1169 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1170 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1172 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1173 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1175 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1178 printf_filtered ("\nCollecting registers (mask): 0x");
1183 QUIT
; /* allow user to bail out with ^C */
1185 printf_filtered ("%02X", list
->regs_mask
[i
]);
1186 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1189 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1193 printf_filtered ("\n");
1194 if (list
->next_memrange
> 0 && info_verbose
)
1195 printf_filtered ("Collecting memranges: \n");
1196 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1198 QUIT
; /* allow user to bail out with ^C */
1199 sprintf_vma (tmp2
, list
->list
[i
].start
);
1202 printf_filtered ("(%d, %s, %ld)\n",
1205 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1207 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1209 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1216 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1218 /* The "%X" conversion specifier expects an unsigned argument,
1219 so passing -1 (memrange_absolute) to it directly gives you
1220 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1222 if (list
->list
[i
].type
== memrange_absolute
)
1223 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1225 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1228 count
+= strlen (end
);
1229 end
= temp_buf
+ count
;
1232 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1234 QUIT
; /* allow user to bail out with ^C */
1235 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1237 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1242 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1243 end
+= 10; /* 'X' + 8 hex digits + ',' */
1246 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1247 end
, list
->aexpr_list
[i
]->len
);
1248 count
+= 2 * list
->aexpr_list
[i
]->len
;
1253 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1258 (*str_list
)[ndx
] = NULL
;
1269 /* Render all actions into gdb protocol. */
1271 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1272 char ***tdp_actions
, char ***stepping_actions
)
1274 static char tdp_buff
[2048], step_buff
[2048];
1276 struct expression
*exp
= NULL
;
1277 struct action_line
*action
;
1279 struct value
*tempval
;
1280 struct collection_list
*collect
;
1281 struct cmd_list_element
*cmd
;
1282 struct agent_expr
*aexpr
;
1284 LONGEST frame_offset
;
1285 char *default_collect_line
= NULL
;
1286 struct action_line
*default_collect_action
= NULL
;
1288 clear_collection_list (&tracepoint_list
);
1289 clear_collection_list (&stepping_list
);
1290 collect
= &tracepoint_list
;
1292 *tdp_actions
= NULL
;
1293 *stepping_actions
= NULL
;
1295 gdbarch_virtual_frame_pointer (t
->gdbarch
,
1296 tloc
->address
, &frame_reg
, &frame_offset
);
1298 action
= t
->actions
;
1300 /* If there are default expressions to collect, make up a collect
1301 action and prepend to the action list to encode. Note that since
1302 validation is per-tracepoint (local var "xyz" might be valid for
1303 one tracepoint and not another, etc), we make up the action on
1304 the fly, and don't cache it. */
1305 if (*default_collect
)
1308 enum actionline_type linetype
;
1310 default_collect_line
= xmalloc (12 + strlen (default_collect
));
1311 sprintf (default_collect_line
, "collect %s", default_collect
);
1312 line
= default_collect_line
;
1313 linetype
= validate_actionline (&line
, t
);
1314 if (linetype
!= BADLINE
)
1316 default_collect_action
= xmalloc (sizeof (struct action_line
));
1317 default_collect_action
->next
= t
->actions
;
1318 default_collect_action
->action
= line
;
1319 action
= default_collect_action
;
1323 for (; action
; action
= action
->next
)
1325 QUIT
; /* allow user to bail out with ^C */
1326 action_exp
= action
->action
;
1327 while (isspace ((int) *action_exp
))
1330 if (*action_exp
== '#') /* comment line */
1333 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1335 error (_("Bad action list item: %s"), action_exp
);
1337 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1340 { /* repeat over a comma-separated list */
1341 QUIT
; /* allow user to bail out with ^C */
1342 while (isspace ((int) *action_exp
))
1345 if (0 == strncasecmp ("$reg", action_exp
, 4))
1347 for (i
= 0; i
< gdbarch_num_regs (t
->gdbarch
); i
++)
1348 add_register (collect
, i
);
1349 action_exp
= strchr (action_exp
, ','); /* more? */
1351 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1353 add_local_symbols (collect
,
1359 action_exp
= strchr (action_exp
, ','); /* more? */
1361 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1363 add_local_symbols (collect
,
1369 action_exp
= strchr (action_exp
, ','); /* more? */
1373 unsigned long addr
, len
;
1374 struct cleanup
*old_chain
= NULL
;
1375 struct cleanup
*old_chain1
= NULL
;
1376 struct agent_reqs areqs
;
1378 exp
= parse_exp_1 (&action_exp
,
1379 block_for_pc (tloc
->address
), 1);
1380 old_chain
= make_cleanup (free_current_contents
, &exp
);
1382 switch (exp
->elts
[0].opcode
)
1386 const char *name
= &exp
->elts
[2].string
;
1388 i
= user_reg_map_name_to_regnum (t
->gdbarch
,
1389 name
, strlen (name
));
1391 internal_error (__FILE__
, __LINE__
,
1392 _("Register $%s not available"),
1395 printf_filtered ("OP_REGISTER: ");
1396 add_register (collect
, i
);
1401 /* safe because we know it's a simple expression */
1402 tempval
= evaluate_expression (exp
);
1403 addr
= value_address (tempval
);
1404 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1405 add_memrange (collect
, memrange_absolute
, addr
, len
);
1409 collect_symbol (collect
,
1410 exp
->elts
[2].symbol
,
1417 default: /* full-fledged expression */
1418 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1420 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1422 ax_reqs (aexpr
, &areqs
);
1423 if (areqs
.flaw
!= agent_flaw_none
)
1424 error (_("malformed expression"));
1426 if (areqs
.min_height
< 0)
1427 error (_("gdb: Internal error: expression has min height < 0"));
1428 if (areqs
.max_height
> 20)
1429 error (_("expression too complicated, try simplifying"));
1431 discard_cleanups (old_chain1
);
1432 add_aexpr (collect
, aexpr
);
1434 /* take care of the registers */
1435 if (areqs
.reg_mask_len
> 0)
1440 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1442 QUIT
; /* allow user to bail out with ^C */
1443 if (areqs
.reg_mask
[ndx1
] != 0)
1445 /* assume chars have 8 bits */
1446 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1447 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1448 /* it's used -- record it */
1449 add_register (collect
,
1456 do_cleanups (old_chain
);
1459 while (action_exp
&& *action_exp
++ == ',');
1461 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1464 { /* repeat over a comma-separated list */
1465 QUIT
; /* allow user to bail out with ^C */
1466 while (isspace ((int) *action_exp
))
1470 unsigned long addr
, len
;
1471 struct cleanup
*old_chain
= NULL
;
1472 struct cleanup
*old_chain1
= NULL
;
1473 struct agent_reqs areqs
;
1475 exp
= parse_exp_1 (&action_exp
,
1476 block_for_pc (tloc
->address
), 1);
1477 old_chain
= make_cleanup (free_current_contents
, &exp
);
1479 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1480 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1482 ax_reqs (aexpr
, &areqs
);
1483 if (areqs
.flaw
!= agent_flaw_none
)
1484 error (_("malformed expression"));
1486 if (areqs
.min_height
< 0)
1487 error (_("gdb: Internal error: expression has min height < 0"));
1488 if (areqs
.max_height
> 20)
1489 error (_("expression too complicated, try simplifying"));
1491 discard_cleanups (old_chain1
);
1492 /* Even though we're not officially collecting, add
1493 to the collect list anyway. */
1494 add_aexpr (collect
, aexpr
);
1496 do_cleanups (old_chain
);
1499 while (action_exp
&& *action_exp
++ == ',');
1501 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1503 collect
= &stepping_list
;
1505 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
1507 if (collect
== &stepping_list
) /* end stepping actions */
1508 collect
= &tracepoint_list
;
1510 break; /* end tracepoint actions */
1513 memrange_sortmerge (&tracepoint_list
);
1514 memrange_sortmerge (&stepping_list
);
1516 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1518 *stepping_actions
= stringify_collection_list (&stepping_list
,
1521 xfree (default_collect_line
);
1522 xfree (default_collect_action
);
1526 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1528 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1530 collect
->aexpr_list
=
1531 xrealloc (collect
->aexpr_list
,
1532 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1533 collect
->aexpr_listsize
*= 2;
1535 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1536 collect
->next_aexpr_elt
++;
1541 Tell target to clear any previous trace experiment.
1542 Walk the list of tracepoints, and send them (and their actions)
1543 to the target. If no errors,
1544 Tell target to start a new trace experiment. */
1547 trace_start_command (char *args
, int from_tty
)
1550 VEC(breakpoint_p
) *tp_vec
= NULL
;
1552 struct breakpoint
*t
;
1553 struct trace_state_variable
*tsv
;
1554 int any_downloaded
= 0;
1556 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1558 target_trace_init ();
1560 tp_vec
= all_tracepoints ();
1561 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1563 t
->number_on_target
= 0;
1564 target_download_tracepoint (t
);
1565 t
->number_on_target
= t
->number
;
1568 VEC_free (breakpoint_p
, tp_vec
);
1570 /* No point in tracing without any tracepoints... */
1571 if (!any_downloaded
)
1572 error ("No tracepoints downloaded, not starting trace");
1574 /* Send down all the trace state variables too. */
1575 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1577 target_download_trace_state_variable (tsv
);
1580 /* Tell target to treat text-like sections as transparent. */
1581 target_trace_set_readonly_regions ();
1583 /* Now insert traps and begin collecting data. */
1584 target_trace_start ();
1586 /* Reset our local state. */
1587 set_traceframe_num (-1);
1588 set_tracepoint_num (-1);
1589 set_traceframe_context (NULL
);
1590 current_trace_status()->running
= 1;
1595 trace_stop_command (char *args
, int from_tty
)
1603 target_trace_stop ();
1604 /* should change in response to reply? */
1605 current_trace_status ()->running
= 0;
1608 /* tstatus command */
1610 trace_status_command (char *args
, int from_tty
)
1612 struct trace_status
*ts
= current_trace_status ();
1615 status
= target_get_trace_status (ts
);
1620 printf_filtered (_("Using a trace file.\n"));
1623 printf_filtered (_("Trace can not be run on this target.\n"));
1628 if (!ts
->running_known
)
1630 printf_filtered (_("Run/stop status is unknown.\n"));
1632 else if (ts
->running
)
1634 printf_filtered (_("Trace is running on the target.\n"));
1635 if (disconnected_tracing
)
1636 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1638 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1642 switch (ts
->stop_reason
)
1644 case trace_never_run
:
1645 printf_filtered (_("No trace has been run on the target.\n"));
1648 printf_filtered (_("Trace stopped by a tstop command.\n"));
1650 case trace_buffer_full
:
1651 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1653 case trace_disconnected
:
1654 printf_filtered (_("Trace stopped because of disconnection.\n"));
1656 case tracepoint_passcount
:
1657 /* FIXME account for number on target */
1658 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1659 ts
->stopping_tracepoint
);
1661 case trace_stop_reason_unknown
:
1662 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1665 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1671 if (ts
->traceframe_count
>= 0)
1673 printf_filtered (_("Collected %d trace frames.\n"),
1674 ts
->traceframe_count
);
1677 if (ts
->buffer_free
)
1679 printf_filtered (_("Trace buffer has %llu bytes free.\n"),
1683 /* Now report on what we're doing with tfind. */
1684 if (traceframe_number
>= 0)
1685 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1686 traceframe_number
, tracepoint_number
);
1688 printf_filtered (_("Not looking at any trace frame.\n"));
1692 disconnect_or_stop_tracing (int from_tty
)
1694 /* It can happen that the target that was tracing went away on its
1695 own, and we didn't notice. Get a status update, and if the
1696 current target doesn't even do tracing, then assume it's not
1698 if (target_get_trace_status (current_trace_status ()) < 0)
1699 current_trace_status ()->running
= 0;
1701 if (current_trace_status ()->running
&& from_tty
)
1703 int cont
= query (_("Trace is running. Continue tracing after detach? "));
1704 /* Note that we send the query result without affecting the
1705 user's setting of disconnected_tracing, so that the answer is
1707 send_disconnected_tracing_value (cont
);
1709 /* Also ensure that we do the equivalent of a tstop command if
1710 tracing is not to continue after the detach. */
1716 /* Worker function for the various flavors of the tfind command. */
1718 finish_tfind_command (enum trace_find_type type
, int num
,
1719 ULONGEST addr1
, ULONGEST addr2
,
1722 int target_frameno
= -1, target_tracept
= -1;
1723 struct frame_id old_frame_id
;
1725 struct breakpoint
*tp
;
1727 old_frame_id
= get_frame_id (get_current_frame ());
1729 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
1732 if (type
== tfind_number
1734 && target_frameno
== -1)
1736 /* We told the target to get out of tfind mode, and it did. */
1738 else if (target_frameno
== -1)
1740 /* A request for a non-existant trace frame has failed.
1741 Our response will be different, depending on FROM_TTY:
1743 If FROM_TTY is true, meaning that this command was
1744 typed interactively by the user, then give an error
1745 and DO NOT change the state of traceframe_number etc.
1747 However if FROM_TTY is false, meaning that we're either
1748 in a script, a loop, or a user-defined command, then
1749 DON'T give an error, but DO change the state of
1750 traceframe_number etc. to invalid.
1752 The rationalle is that if you typed the command, you
1753 might just have committed a typo or something, and you'd
1754 like to NOT lose your current debugging state. However
1755 if you're in a user-defined command or especially in a
1756 loop, then you need a way to detect that the command
1757 failed WITHOUT aborting. This allows you to write
1758 scripts that search thru the trace buffer until the end,
1759 and then continue on to do something else. */
1762 error (_("Target failed to find requested trace frame."));
1766 printf_filtered ("End of trace buffer.\n");
1767 #if 0 /* dubious now? */
1768 /* The following will not recurse, since it's
1770 trace_find_command ("-1", from_tty
);
1775 tp
= get_tracepoint_by_number_on_target (target_tracept
);
1777 reinit_frame_cache ();
1778 registers_changed ();
1779 target_dcache_invalidate ();
1780 set_traceframe_num (target_frameno
);
1781 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
1782 if (target_frameno
== -1)
1783 set_traceframe_context (NULL
);
1785 set_traceframe_context (get_current_frame ());
1787 /* If we're in nonstop mode and getting out of looking at trace
1788 frames, there won't be any current frame to go back to and
1791 && (has_stack_frames () || traceframe_number
>= 0))
1793 enum print_what print_what
;
1795 /* NOTE: in immitation of the step command, try to determine
1796 whether we have made a transition from one function to
1797 another. If so, we'll print the "stack frame" (ie. the new
1798 function and it's arguments) -- otherwise we'll just show the
1801 if (frame_id_eq (old_frame_id
,
1802 get_frame_id (get_current_frame ())))
1803 print_what
= SRC_LINE
;
1805 print_what
= SRC_AND_LOC
;
1807 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
1812 /* trace_find_command takes a trace frame number n,
1813 sends "QTFrame:<n>" to the target,
1814 and accepts a reply that may contain several optional pieces
1815 of information: a frame number, a tracepoint number, and an
1816 indication of whether this is a trap frame or a stepping frame.
1818 The minimal response is just "OK" (which indicates that the
1819 target does not give us a frame number or a tracepoint number).
1820 Instead of that, the target may send us a string containing
1822 F<hexnum> (gives the selected frame number)
1823 T<hexnum> (gives the selected tracepoint number)
1828 trace_find_command (char *args
, int from_tty
)
1829 { /* this should only be called with a numeric argument */
1832 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1833 error ("May not look at trace frames while trace is running.");
1835 if (args
== 0 || *args
== 0)
1836 { /* TFIND with no args means find NEXT trace frame. */
1837 if (traceframe_number
== -1)
1838 frameno
= 0; /* "next" is first one */
1840 frameno
= traceframe_number
+ 1;
1842 else if (0 == strcmp (args
, "-"))
1844 if (traceframe_number
== -1)
1845 error (_("not debugging trace buffer"));
1846 else if (from_tty
&& traceframe_number
== 0)
1847 error (_("already at start of trace buffer"));
1849 frameno
= traceframe_number
- 1;
1851 /* A hack to work around eval's need for fp to have been collected. */
1852 else if (0 == strcmp (args
, "-1"))
1855 frameno
= parse_and_eval_long (args
);
1858 error (_("invalid input (%d is less than zero)"), frameno
);
1860 finish_tfind_command (tfind_number
, frameno
, 0, 0, from_tty
);
1865 trace_find_end_command (char *args
, int from_tty
)
1867 trace_find_command ("-1", from_tty
);
1872 trace_find_none_command (char *args
, int from_tty
)
1874 trace_find_command ("-1", from_tty
);
1879 trace_find_start_command (char *args
, int from_tty
)
1881 trace_find_command ("0", from_tty
);
1884 /* tfind pc command */
1886 trace_find_pc_command (char *args
, int from_tty
)
1891 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1892 error ("May not look at trace frames while trace is running.");
1894 if (args
== 0 || *args
== 0)
1895 pc
= regcache_read_pc (get_current_regcache ());
1897 pc
= parse_and_eval_address (args
);
1899 finish_tfind_command (tfind_pc
, 0, pc
, 0, from_tty
);
1902 /* tfind tracepoint command */
1904 trace_find_tracepoint_command (char *args
, int from_tty
)
1907 struct breakpoint
*tp
;
1909 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1910 error ("May not look at trace frames while trace is running.");
1912 if (args
== 0 || *args
== 0)
1914 if (tracepoint_number
== -1)
1915 error (_("No current tracepoint -- please supply an argument."));
1917 tdp
= tracepoint_number
; /* default is current TDP */
1920 tdp
= parse_and_eval_long (args
);
1922 /* If we have the tracepoint on hand, use the number that the
1923 target knows about (which may be different if we disconnected
1924 and reconnected). */
1925 tp
= get_tracepoint (tdp
);
1927 tdp
= tp
->number_on_target
;
1929 finish_tfind_command (tfind_tp
, tdp
, 0, 0, from_tty
);
1932 /* TFIND LINE command:
1934 This command will take a sourceline for argument, just like BREAK
1935 or TRACE (ie. anything that "decode_line_1" can handle).
1937 With no argument, this command will find the next trace frame
1938 corresponding to a source line OTHER THAN THE CURRENT ONE. */
1941 trace_find_line_command (char *args
, int from_tty
)
1943 static CORE_ADDR start_pc
, end_pc
;
1944 struct symtabs_and_lines sals
;
1945 struct symtab_and_line sal
;
1946 struct cleanup
*old_chain
;
1947 char startpc_str
[40], endpc_str
[40];
1949 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1950 error ("May not look at trace frames while trace is running.");
1952 if (args
== 0 || *args
== 0)
1954 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
1956 sals
.sals
= (struct symtab_and_line
*)
1957 xmalloc (sizeof (struct symtab_and_line
));
1962 sals
= decode_line_spec (args
, 1);
1966 old_chain
= make_cleanup (xfree
, sals
.sals
);
1967 if (sal
.symtab
== 0)
1969 printf_filtered ("TFIND: No line number information available");
1972 /* This is useful for "info line *0x7f34". If we can't
1973 tell the user about a source line, at least let them
1974 have the symbolic address. */
1975 printf_filtered (" for address ");
1977 print_address (get_current_arch (), sal
.pc
, gdb_stdout
);
1978 printf_filtered (";\n -- will attempt to find by PC. \n");
1982 printf_filtered (".\n");
1983 return; /* No line, no PC; what can we do? */
1986 else if (sal
.line
> 0
1987 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
1989 if (start_pc
== end_pc
)
1991 printf_filtered ("Line %d of \"%s\"",
1992 sal
.line
, sal
.symtab
->filename
);
1994 printf_filtered (" is at address ");
1995 print_address (get_current_arch (), start_pc
, gdb_stdout
);
1997 printf_filtered (" but contains no code.\n");
1998 sal
= find_pc_line (start_pc
, 0);
2000 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
2001 && start_pc
!= end_pc
)
2002 printf_filtered ("Attempting to find line %d instead.\n",
2005 error (_("Cannot find a good line."));
2009 /* Is there any case in which we get here, and have an address
2010 which the user would want to see? If we have debugging
2011 symbols and no line numbers? */
2012 error (_("Line number %d is out of range for \"%s\"."),
2013 sal
.line
, sal
.symtab
->filename
);
2015 /* Find within range of stated line. */
2017 finish_tfind_command (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2019 finish_tfind_command (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2020 do_cleanups (old_chain
);
2023 /* tfind range command */
2025 trace_find_range_command (char *args
, int from_tty
)
2027 static CORE_ADDR start
, stop
;
2028 char start_str
[40], stop_str
[40];
2031 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2032 error ("May not look at trace frames while trace is running.");
2034 if (args
== 0 || *args
== 0)
2035 { /* XXX FIXME: what should default behavior be? */
2036 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2040 if (0 != (tmp
= strchr (args
, ',')))
2042 *tmp
++ = '\0'; /* terminate start address */
2043 while (isspace ((int) *tmp
))
2045 start
= parse_and_eval_address (args
);
2046 stop
= parse_and_eval_address (tmp
);
2049 { /* no explicit end address? */
2050 start
= parse_and_eval_address (args
);
2051 stop
= start
+ 1; /* ??? */
2054 finish_tfind_command (tfind_range
, 0, start
, stop
, from_tty
);
2057 /* tfind outside command */
2059 trace_find_outside_command (char *args
, int from_tty
)
2061 CORE_ADDR start
, stop
;
2062 char start_str
[40], stop_str
[40];
2065 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2066 error ("May not look at trace frames while trace is running.");
2068 if (args
== 0 || *args
== 0)
2069 { /* XXX FIXME: what should default behavior be? */
2070 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2074 if (0 != (tmp
= strchr (args
, ',')))
2076 *tmp
++ = '\0'; /* terminate start address */
2077 while (isspace ((int) *tmp
))
2079 start
= parse_and_eval_address (args
);
2080 stop
= parse_and_eval_address (tmp
);
2083 { /* no explicit end address? */
2084 start
= parse_and_eval_address (args
);
2085 stop
= start
+ 1; /* ??? */
2088 finish_tfind_command (tfind_outside
, 0, start
, stop
, from_tty
);
2091 /* info scope command: list the locals for a scope. */
2093 scope_info (char *args
, int from_tty
)
2095 struct symtabs_and_lines sals
;
2097 struct minimal_symbol
*msym
;
2098 struct block
*block
;
2099 char **canonical
, *symname
, *save_args
= args
;
2100 struct dict_iterator iter
;
2102 struct gdbarch
*gdbarch
;
2105 if (args
== 0 || *args
== 0)
2106 error (_("requires an argument (function, line or *addr) to define a scope"));
2108 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2109 if (sals
.nelts
== 0)
2110 return; /* presumably decode_line_1 has already warned */
2112 /* Resolve line numbers to PC */
2113 resolve_sal_pc (&sals
.sals
[0]);
2114 block
= block_for_pc (sals
.sals
[0].pc
);
2118 QUIT
; /* allow user to bail out with ^C */
2119 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2121 QUIT
; /* allow user to bail out with ^C */
2123 printf_filtered ("Scope for %s:\n", save_args
);
2126 symname
= SYMBOL_PRINT_NAME (sym
);
2127 if (symname
== NULL
|| *symname
== '\0')
2128 continue; /* probably botched, certainly useless */
2130 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2132 printf_filtered ("Symbol %s is ", symname
);
2133 switch (SYMBOL_CLASS (sym
))
2136 case LOC_UNDEF
: /* messed up symbol? */
2137 printf_filtered ("a bogus symbol, class %d.\n",
2138 SYMBOL_CLASS (sym
));
2139 count
--; /* don't count this one */
2142 printf_filtered ("a constant with value %ld (0x%lx)",
2143 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2145 case LOC_CONST_BYTES
:
2146 printf_filtered ("constant bytes: ");
2147 if (SYMBOL_TYPE (sym
))
2148 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2149 fprintf_filtered (gdb_stdout
, " %02x",
2150 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2153 printf_filtered ("in static storage at address ");
2154 printf_filtered ("%s", paddress (gdbarch
,
2155 SYMBOL_VALUE_ADDRESS (sym
)));
2158 /* GDBARCH is the architecture associated with the objfile
2159 the symbol is defined in; the target architecture may be
2160 different, and may provide additional registers. However,
2161 we do not know the target architecture at this point.
2162 We assume the objfile architecture will contain all the
2163 standard registers that occur in debug info in that
2165 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2167 if (SYMBOL_IS_ARGUMENT (sym
))
2168 printf_filtered ("an argument in register $%s",
2169 gdbarch_register_name (gdbarch
, regno
));
2171 printf_filtered ("a local variable in register $%s",
2172 gdbarch_register_name (gdbarch
, regno
));
2175 printf_filtered ("an argument at stack/frame offset %ld",
2176 SYMBOL_VALUE (sym
));
2179 printf_filtered ("a local variable at frame offset %ld",
2180 SYMBOL_VALUE (sym
));
2183 printf_filtered ("a reference argument at offset %ld",
2184 SYMBOL_VALUE (sym
));
2186 case LOC_REGPARM_ADDR
:
2187 /* Note comment at LOC_REGISTER. */
2188 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2189 printf_filtered ("the address of an argument, in register $%s",
2190 gdbarch_register_name (gdbarch
, regno
));
2193 printf_filtered ("a typedef.\n");
2196 printf_filtered ("a label at address ");
2197 printf_filtered ("%s", paddress (gdbarch
,
2198 SYMBOL_VALUE_ADDRESS (sym
)));
2201 printf_filtered ("a function at address ");
2202 printf_filtered ("%s",
2203 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2205 case LOC_UNRESOLVED
:
2206 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2209 printf_filtered ("Unresolved Static");
2212 printf_filtered ("static storage at address ");
2213 printf_filtered ("%s",
2214 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2217 case LOC_OPTIMIZED_OUT
:
2218 printf_filtered ("optimized out.\n");
2221 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, gdb_stdout
);
2224 if (SYMBOL_TYPE (sym
))
2225 printf_filtered (", length %d.\n",
2226 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2228 if (BLOCK_FUNCTION (block
))
2231 block
= BLOCK_SUPERBLOCK (block
);
2234 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2238 /* worker function (cleanup) */
2240 replace_comma (void *data
)
2248 trace_dump_command (char *args
, int from_tty
)
2250 struct regcache
*regcache
;
2251 struct gdbarch
*gdbarch
;
2252 struct breakpoint
*t
;
2253 struct action_line
*action
;
2254 char *action_exp
, *next_comma
;
2255 struct cleanup
*old_cleanups
;
2256 int stepping_actions
= 0;
2257 int stepping_frame
= 0;
2258 struct bp_location
*loc
;
2260 if (tracepoint_number
== -1)
2262 warning (_("No current trace frame."));
2266 t
= get_tracepoint (tracepoint_number
);
2269 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2272 old_cleanups
= make_cleanup (null_cleanup
, NULL
);
2274 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2275 tracepoint_number
, traceframe_number
);
2277 /* The current frame is a trap frame if the frame PC is equal
2278 to the tracepoint PC. If not, then the current frame was
2279 collected during single-stepping. */
2281 regcache
= get_current_regcache ();
2282 gdbarch
= get_regcache_arch (regcache
);
2284 /* If the traceframe's address matches any of the tracepoint's
2285 locations, assume it is a direct hit rather than a while-stepping
2286 frame. (FIXME this is not reliable, should record each frame's
2289 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2290 if (loc
->address
== regcache_read_pc (regcache
))
2293 for (action
= t
->actions
; action
; action
= action
->next
)
2295 struct cmd_list_element
*cmd
;
2297 QUIT
; /* allow user to bail out with ^C */
2298 action_exp
= action
->action
;
2299 while (isspace ((int) *action_exp
))
2302 /* The collection actions to be done while stepping are
2303 bracketed by the commands "while-stepping" and "end". */
2305 if (*action_exp
== '#') /* comment line */
2308 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2310 error (_("Bad action list item: %s"), action_exp
);
2312 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2313 stepping_actions
= 1;
2314 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2315 stepping_actions
= 0;
2316 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2318 /* Display the collected data.
2319 For the trap frame, display only what was collected at
2320 the trap. Likewise for stepping frames, display only
2321 what was collected while stepping. This means that the
2322 two boolean variables, STEPPING_FRAME and
2323 STEPPING_ACTIONS should be equal. */
2324 if (stepping_frame
== stepping_actions
)
2327 { /* repeat over a comma-separated list */
2328 QUIT
; /* allow user to bail out with ^C */
2329 if (*action_exp
== ',')
2331 while (isspace ((int) *action_exp
))
2334 next_comma
= strchr (action_exp
, ',');
2336 if (0 == strncasecmp (action_exp
, "$reg", 4))
2337 registers_info (NULL
, from_tty
);
2338 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2339 locals_info (NULL
, from_tty
);
2340 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2341 args_info (NULL
, from_tty
);
2346 make_cleanup (replace_comma
, next_comma
);
2349 printf_filtered ("%s = ", action_exp
);
2350 output_command (action_exp
, from_tty
);
2351 printf_filtered ("\n");
2355 action_exp
= next_comma
;
2357 while (action_exp
&& *action_exp
== ',');
2361 discard_cleanups (old_cleanups
);
2364 extern int trace_regblock_size
;
2367 trace_save_command (char *args
, int from_tty
)
2370 char *filename
= NULL
, *pathname
;
2371 int target_does_save
= 0;
2372 struct cleanup
*cleanup
;
2373 struct trace_status
*ts
= current_trace_status ();
2376 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2377 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2380 ULONGEST offset
= 0;
2381 #define MAX_TRACE_UPLOAD 2000
2382 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2386 error_no_arg (_("file in which to save trace data"));
2388 argv
= gdb_buildargv (args
);
2389 make_cleanup_freeargv (argv
);
2391 for (; *argv
; ++argv
)
2393 if (strcmp (*argv
, "-r") == 0)
2394 target_does_save
= 1;
2395 else if (**argv
== '-')
2396 error (_("unknown option `%s'"), *argv
);
2402 error_no_arg (_("file in which to save trace data"));
2404 /* If the target is to save the data to a file on its own, then just
2405 send the command and be done with it. */
2406 if (target_does_save
)
2408 err
= target_save_trace_data (filename
);
2410 error (_("Target failed to save trace data to '%s'."),
2415 /* Get the trace status first before opening the file, so if the
2416 target is losing, we can get out without touching files. */
2417 status
= target_get_trace_status (ts
);
2419 pathname
= tilde_expand (args
);
2420 cleanup
= make_cleanup (xfree
, pathname
);
2422 fp
= fopen (pathname
, "w");
2424 error (_("Unable to open file '%s' for saving trace data (%s)"),
2425 args
, safe_strerror (errno
));
2426 make_cleanup_fclose (fp
);
2428 /* Write a file header, with a high-bit-set char to indicate a
2429 binary file, plus a hint as what this file is, and a version
2430 number in case of future needs. */
2431 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2433 perror_with_name (pathname
);
2435 /* Write descriptive info. */
2437 /* Write out the size of a register block. */
2438 fprintf (fp
, "R %x\n", trace_regblock_size
);
2440 /* Write out status of the tracing run (aka "tstatus" info). */
2441 fprintf (fp
, "status %c;%s:%x;tframes:%x;tfree:%llx\n",
2442 (ts
->running
? '1' : '0'),
2443 stop_reason_names
[ts
->stop_reason
], ts
->stopping_tracepoint
,
2444 ts
->traceframe_count
, ts
->buffer_free
);
2446 /* Note that we want to upload tracepoints and save those, rather
2447 than simply writing out the local ones, because the user may have
2448 changed tracepoints in GDB in preparation for a future tracing
2449 run, or maybe just mass-deleted all types of breakpoints as part
2450 of cleaning up. So as not to contaminate the session, leave the
2451 data in its uploaded form, don't make into real tracepoints. */
2453 /* Get trace state variables first, they may be checked when parsing
2454 uploaded commands. */
2456 target_upload_trace_state_variables (&uploaded_tsvs
);
2458 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2464 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
2465 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
2468 fprintf (fp
, "tsv %x:%s:%x:%s\n",
2469 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
2470 utsv
->builtin
, buf
);
2476 free_uploaded_tsvs (&uploaded_tsvs
);
2478 target_upload_tracepoints (&uploaded_tps
);
2480 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
2482 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
2483 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2484 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
2485 if (utp
->type
== bp_fast_tracepoint
)
2486 fprintf (fp
, ":F%x", utp
->orig_size
);
2488 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
2491 for (a
= 0; a
< utp
->numactions
; ++a
)
2492 fprintf (fp
, "tp A%x:%s:%s\n",
2493 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2495 for (a
= 0; a
< utp
->num_step_actions
; ++a
)
2496 fprintf (fp
, "tp S%x:%s:%s\n",
2497 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2498 utp
->step_actions
[a
]);
2501 free_uploaded_tps (&uploaded_tps
);
2503 /* Mark the end of the definition section. */
2506 /* Get and write the trace data proper. We ask for big blocks, in
2507 the hopes of efficiency, but will take less if the target has
2508 packet size limitations or some such. */
2511 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
2513 error (_("Failure to get requested trace buffer data"));
2514 /* No more data is forthcoming, we're done. */
2517 written
= fwrite (buf
, gotten
, 1, fp
);
2518 if (written
< gotten
)
2519 perror_with_name (pathname
);
2523 /* Mark the end of trace data. */
2524 written
= fwrite (&gotten
, 4, 1, fp
);
2526 perror_with_name (pathname
);
2528 do_cleanups (cleanup
);
2530 printf_filtered (_("Trace data saved to file '%s'.\n"), args
);
2533 /* Tell the target what to do with an ongoing tracing run if GDB
2534 disconnects for some reason. */
2537 send_disconnected_tracing_value (int value
)
2539 target_set_disconnected_tracing (value
);
2543 set_disconnected_tracing (char *args
, int from_tty
,
2544 struct cmd_list_element
*c
)
2546 send_disconnected_tracing_value (disconnected_tracing
);
2549 /* Convert the memory pointed to by mem into hex, placing result in buf.
2550 * Return a pointer to the last char put in buf (null)
2551 * "stolen" from sparc-stub.c
2554 static const char hexchars
[] = "0123456789abcdef";
2557 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2565 *buf
++ = hexchars
[ch
>> 4];
2566 *buf
++ = hexchars
[ch
& 0xf];
2575 get_traceframe_number (void)
2577 return traceframe_number
;
2580 /* Make the traceframe NUM be the current trace frame. Does nothing
2581 if NUM is already current. */
2584 set_traceframe_number (int num
)
2588 if (traceframe_number
== num
)
2590 /* Nothing to do. */
2594 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
2597 warning (_("could not change traceframe"));
2599 traceframe_number
= newnum
;
2601 /* Changing the traceframe changes our view of registers and of the
2603 registers_changed ();
2606 /* A cleanup used when switching away and back from tfind mode. */
2608 struct current_traceframe_cleanup
2610 /* The traceframe we were inspecting. */
2611 int traceframe_number
;
2615 do_restore_current_traceframe_cleanup (void *arg
)
2617 struct current_traceframe_cleanup
*old
= arg
;
2619 set_traceframe_number (old
->traceframe_number
);
2623 restore_current_traceframe_cleanup_dtor (void *arg
)
2625 struct current_traceframe_cleanup
*old
= arg
;
2631 make_cleanup_restore_current_traceframe (void)
2633 struct current_traceframe_cleanup
*old
;
2635 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
2636 old
->traceframe_number
= traceframe_number
;
2638 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
2639 restore_current_traceframe_cleanup_dtor
);
2642 /* Given a number and address, return an uploaded tracepoint with that
2643 number, creating if necessary. */
2645 struct uploaded_tp
*
2646 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
2648 struct uploaded_tp
*utp
;
2650 for (utp
= *utpp
; utp
; utp
= utp
->next
)
2651 if (utp
->number
== num
&& utp
->addr
== addr
)
2653 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
2654 memset (utp
, 0, sizeof (struct uploaded_tp
));
2663 free_uploaded_tps (struct uploaded_tp
**utpp
)
2665 struct uploaded_tp
*next_one
;
2669 next_one
= (*utpp
)->next
;
2675 /* Given a number and address, return an uploaded tracepoint with that
2676 number, creating if necessary. */
2678 struct uploaded_tsv
*
2679 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
2681 struct uploaded_tsv
*utsv
;
2683 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
2684 if (utsv
->number
== num
)
2686 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
2687 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
2689 utsv
->next
= *utsvp
;
2695 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
2697 struct uploaded_tsv
*next_one
;
2701 next_one
= (*utsvp
)->next
;
2707 /* Look for an existing tracepoint that seems similar enough to the
2708 uploaded one. Enablement isn't compared, because the user can
2709 toggle that freely, and may have done so in anticipation of the
2713 find_matching_tracepoint (struct uploaded_tp
*utp
)
2715 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
2717 struct breakpoint
*t
;
2718 struct bp_location
*loc
;
2720 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2722 if (t
->type
== utp
->type
2723 && t
->step_count
== utp
->step
2724 && t
->pass_count
== utp
->pass
2725 /* FIXME also test conditionals and actions */
2728 /* Scan the locations for an address match. */
2729 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2731 if (loc
->address
== utp
->addr
)
2739 /* Given a list of tracepoints uploaded from a target, attempt to
2740 match them up with existing tracepoints, and create new ones if not
2744 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
2746 struct uploaded_tp
*utp
;
2747 struct breakpoint
*t
;
2749 /* Look for GDB tracepoints that match up with our uploaded versions. */
2750 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
2752 t
= find_matching_tracepoint (utp
);
2754 printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
2755 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2758 t
= create_tracepoint_from_upload (utp
);
2760 printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
2761 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2763 printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
2764 utp
->number
, paddress (get_current_arch (), utp
->addr
));
2766 /* Whether found or created, record the number used by the
2767 target, to help with mapping target tracepoints back to their
2768 counterparts here. */
2770 t
->number_on_target
= utp
->number
;
2773 free_uploaded_tps (uploaded_tps
);
2776 /* Trace state variables don't have much to identify them beyond their
2777 name, so just use that to detect matches. */
2779 struct trace_state_variable
*
2780 find_matching_tsv (struct uploaded_tsv
*utsv
)
2785 return find_trace_state_variable (utsv
->name
);
2788 struct trace_state_variable
*
2789 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
2791 const char *namebase
;
2794 struct trace_state_variable
*tsv
;
2798 namebase
= utsv
->name
;
2799 sprintf (buf
, "%s", namebase
);
2804 sprintf (buf
, "%s_%d", namebase
, try_num
++);
2807 /* Fish for a name that is not in use. */
2808 /* (should check against all internal vars?) */
2809 while (find_trace_state_variable (buf
))
2810 sprintf (buf
, "%s_%d", namebase
, try_num
++);
2812 /* We have an available name, create the variable. */
2813 tsv
= create_trace_state_variable (xstrdup (buf
));
2814 tsv
->initial_value
= utsv
->initial_value
;
2815 tsv
->builtin
= utsv
->builtin
;
2820 /* Given a list of uploaded trace state variables, try to match them
2821 up with existing variables, or create additional ones. */
2824 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
2827 struct uploaded_tsv
*utsv
;
2828 struct trace_state_variable
*tsv
;
2831 /* Most likely some numbers will have to be reassigned as part of
2832 the merge, so clear them all in anticipation. */
2833 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2836 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2838 tsv
= find_matching_tsv (utsv
);
2840 printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
2841 tsv
->name
, utsv
->number
);
2844 tsv
= create_tsv_from_upload (utsv
);
2845 printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
2846 tsv
->name
, utsv
->number
);
2848 /* Give precedence to numberings that come from the target. */
2850 tsv
->number
= utsv
->number
;
2853 /* Renumber everything that didn't get a target-assigned number. */
2855 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2856 if (tsv
->number
> highest
)
2857 highest
= tsv
->number
;
2860 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2861 if (tsv
->number
== 0)
2862 tsv
->number
= highest
++;
2864 free_uploaded_tsvs (uploaded_tsvs
);
2867 /* target tfile command */
2869 struct target_ops tfile_ops
;
2871 /* Fill in tfile_ops with its defined operations and properties. */
2873 #define TRACE_HEADER_SIZE 8
2875 char *trace_filename
;
2877 off_t trace_frames_offset
;
2880 int trace_regblock_size
;
2882 static void tfile_interp_line (char *line
,
2883 struct uploaded_tp
**utpp
,
2884 struct uploaded_tsv
**utsvp
);
2887 tfile_open (char *filename
, int from_tty
)
2890 struct cleanup
*old_chain
;
2893 char header
[TRACE_HEADER_SIZE
];
2894 char linebuf
[1000]; /* should be max remote packet size or so */
2896 int bytes
, i
, gotten
;
2897 struct trace_status
*ts
;
2898 struct uploaded_tp
*uploaded_tps
= NULL
;
2899 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
2901 target_preopen (from_tty
);
2903 error (_("No trace file specified."));
2905 filename
= tilde_expand (filename
);
2906 if (!IS_ABSOLUTE_PATH(filename
))
2908 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
2913 old_chain
= make_cleanup (xfree
, filename
);
2915 flags
= O_BINARY
| O_LARGEFILE
;
2917 scratch_chan
= open (filename
, flags
, 0);
2918 if (scratch_chan
< 0)
2919 perror_with_name (filename
);
2921 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
2923 discard_cleanups (old_chain
); /* Don't free filename any more */
2924 unpush_target (&tfile_ops
);
2926 push_target (&tfile_ops
);
2928 trace_filename
= xstrdup (filename
);
2929 trace_fd
= scratch_chan
;
2932 /* Read the file header and test for validity. */
2933 gotten
= read (trace_fd
, &header
, TRACE_HEADER_SIZE
);
2935 perror_with_name (trace_filename
);
2936 else if (gotten
< TRACE_HEADER_SIZE
)
2937 error (_("Premature end of file while reading trace file"));
2939 bytes
+= TRACE_HEADER_SIZE
;
2940 if (!(header
[0] == 0x7f
2941 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
2942 error (_("File is not a valid trace file."));
2944 trace_regblock_size
= 0;
2945 ts
= current_trace_status ();
2946 /* We know we're working with a file. */
2948 /* Set defaults in case there is no status line. */
2949 ts
->running_known
= 0;
2950 ts
->stop_reason
= trace_stop_reason_unknown
;
2951 ts
->traceframe_count
= -1;
2952 ts
->buffer_free
= 0;
2954 /* Read through a section of newline-terminated lines that
2955 define things like tracepoints. */
2959 gotten
= read (trace_fd
, &byte
, 1);
2961 perror_with_name (trace_filename
);
2962 else if (gotten
< 1)
2963 error (_("Premature end of file while reading trace file"));
2968 /* Empty line marks end of the definition section. */
2973 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
2976 linebuf
[i
++] = byte
;
2978 error (_("Excessively long lines in trace file"));
2981 /* Add the file's tracepoints and variables into the current mix. */
2983 /* Get trace state variables first, they may be checked when parsing
2984 uploaded commands. */
2985 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
2987 merge_uploaded_tracepoints (&uploaded_tps
);
2989 /* Record the starting offset of the binary trace data. */
2990 trace_frames_offset
= bytes
;
2992 /* If we don't have a blocksize, we can't interpret the
2994 if (trace_regblock_size
== 0)
2995 error (_("No register block size recorded in trace file"));
2996 if (ts
->traceframe_count
<= 0)
2998 warning ("No traceframes present in this file.");
3002 #define TFILE_PID (1)
3003 inferior_appeared (current_inferior (), TFILE_PID
);
3004 inferior_ptid
= pid_to_ptid (TFILE_PID
);
3005 add_thread_silent (inferior_ptid
);
3007 post_create_inferior (&tfile_ops
, from_tty
);
3010 /* FIXME this will get defined in MI patch submission */
3011 tfind_1 (tfind_number
, 0, 0, 0, 0);
3015 /* Interpret the given line from the definitions part of the trace
3019 tfile_interp_line (char *line
,
3020 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3024 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3027 trace_regblock_size
= strtol (p
, &p
, 16);
3029 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3031 p
+= strlen ("status ");
3032 parse_trace_status (p
, current_trace_status ());
3034 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3036 p
+= strlen ("tp ");
3037 parse_tracepoint_definition (p
, utpp
);
3039 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3041 p
+= strlen ("tsv ");
3042 parse_tsv_definition (p
, utsvp
);
3045 warning ("Ignoring trace file definition \"%s\"", line
);
3048 /* Parse the part of trace status syntax that is shared between
3049 the remote protocol and the trace file reader. */
3051 extern char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
3054 parse_trace_status (char *line
, struct trace_status
*ts
)
3056 char *p
= line
, *p1
, *p_temp
;
3059 ts
->running_known
= 1;
3060 ts
->running
= (*p
++ == '1');
3061 ts
->stop_reason
= trace_stop_reason_unknown
;
3064 p1
= strchr (p
, ':');
3066 error (_("Malformed trace status, at %s\n\
3067 Status line: '%s'\n"), p
, line
);
3068 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3070 p
= unpack_varlen_hex (++p1
, &val
);
3071 ts
->stop_reason
= trace_buffer_full
;
3073 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3075 p
= unpack_varlen_hex (++p1
, &val
);
3076 ts
->stop_reason
= trace_never_run
;
3078 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
], p1
- p
) == 0)
3080 p
= unpack_varlen_hex (++p1
, &val
);
3081 ts
->stop_reason
= tracepoint_passcount
;
3082 ts
->stopping_tracepoint
= val
;
3084 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3086 p
= unpack_varlen_hex (++p1
, &val
);
3087 ts
->stop_reason
= tstop_command
;
3089 if (strncmp (p
, "tframes", p1
- p
) == 0)
3091 p
= unpack_varlen_hex (++p1
, &val
);
3092 ts
->traceframe_count
= val
;
3094 if (strncmp (p
, "tfree", p1
- p
) == 0)
3096 p
= unpack_varlen_hex (++p1
, &val
);
3097 ts
->buffer_free
= val
;
3101 /* Silently skip unknown optional info. */
3102 p_temp
= strchr (p1
+ 1, ';');
3106 /* Must be at the end. */
3112 /* Given a line of text defining a tracepoint or tracepoint action, parse
3113 it into an "uploaded tracepoint". */
3116 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3120 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
;
3124 struct uploaded_tp
*utp
= NULL
;
3127 /* Both tracepoint and action definitions start with the same number
3128 and address sequence. */
3130 p
= unpack_varlen_hex (p
, &num
);
3131 p
++; /* skip a colon */
3132 p
= unpack_varlen_hex (p
, &addr
);
3133 p
++; /* skip a colon */
3136 enabled
= (*p
++ == 'E');
3137 p
++; /* skip a colon */
3138 p
= unpack_varlen_hex (p
, &step
);
3139 p
++; /* skip a colon */
3140 p
= unpack_varlen_hex (p
, &pass
);
3141 type
= bp_tracepoint
;
3143 /* Thumb through optional fields. */
3146 p
++; /* skip a colon */
3149 type
= bp_fast_tracepoint
;
3151 p
= unpack_varlen_hex (p
, &orig_size
);
3156 p
= unpack_varlen_hex (p
, &xlen
);
3157 p
++; /* skip a comma */
3158 cond
= (char *) xmalloc (2 * xlen
+ 1);
3159 strncpy (cond
, p
, 2 * xlen
);
3160 cond
[2 * xlen
] = '\0';
3164 warning ("Unrecognized char '%c' in tracepoint definition, skipping rest", *p
);
3166 utp
= get_uploaded_tp (num
, addr
, utpp
);
3168 utp
->enabled
= enabled
;
3173 else if (piece
== 'A')
3175 utp
= get_uploaded_tp (num
, addr
, utpp
);
3176 utp
->actions
[utp
->numactions
++] = xstrdup (p
);
3178 else if (piece
== 'S')
3180 utp
= get_uploaded_tp (num
, addr
, utpp
);
3181 utp
->step_actions
[utp
->num_step_actions
++] = xstrdup (p
);
3185 error ("Invalid tracepoint piece");
3189 /* Convert a textual description of a trace state variable into an
3193 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3196 ULONGEST num
, initval
, builtin
;
3198 struct uploaded_tsv
*utsv
= NULL
;
3200 buf
= alloca (strlen (line
));
3203 p
= unpack_varlen_hex (p
, &num
);
3204 p
++; /* skip a colon */
3205 p
= unpack_varlen_hex (p
, &initval
);
3206 p
++; /* skip a colon */
3207 p
= unpack_varlen_hex (p
, &builtin
);
3208 p
++; /* skip a colon */
3209 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3212 utsv
= get_uploaded_tsv (num
, utsvp
);
3213 utsv
->initial_value
= initval
;
3214 utsv
->builtin
= builtin
;
3215 utsv
->name
= xstrdup (buf
);
3218 /* Close the trace file and generally clean up. */
3221 tfile_close (int quitting
)
3228 pid
= ptid_get_pid (inferior_ptid
);
3229 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
3230 exit_inferior_silent (pid
);
3235 xfree (trace_filename
);
3239 tfile_files_info (struct target_ops
*t
)
3241 /* (it would be useful to mention the name of the file) */
3242 printf_filtered ("Looking at a trace file.\n");
3245 /* The trace status for a file is that tracing can never be run. */
3248 tfile_get_trace_status (struct trace_status
*ts
)
3250 /* Other bits of trace status were collected as part of opening the
3251 trace files, so nothing to do here. */
3256 /* Given the position of a traceframe in the file, figure out what
3257 address the frame was collected at. This would normally be the
3258 value of a collected PC register, but if not available, we
3262 tfile_get_traceframe_address (off_t tframe_offset
)
3266 struct breakpoint
*tp
;
3267 off_t saved_offset
= cur_offset
;
3270 /* FIXME dig pc out of collected registers */
3272 /* Fall back to using tracepoint address. */
3273 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
3274 gotten
= read (trace_fd
, &tpnum
, 2);
3276 perror_with_name (trace_filename
);
3277 else if (gotten
< 2)
3278 error (_("Premature end of file while reading trace file"));
3280 tp
= get_tracepoint_by_number_on_target (tpnum
);
3281 /* FIXME this is a poor heuristic if multiple locations */
3283 addr
= tp
->loc
->address
;
3285 /* Restore our seek position. */
3286 cur_offset
= saved_offset
;
3287 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3291 /* Given a type of search and some parameters, scan the collection of
3292 traceframes in the file looking for a match. When found, return
3293 both the traceframe and tracepoint number, otherwise -1 for
3297 tfile_trace_find (enum trace_find_type type
, int num
,
3298 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
3301 int tfnum
= 0, found
= 0, gotten
;
3303 struct breakpoint
*tp
;
3304 off_t offset
, tframe_offset
;
3307 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
3308 offset
= trace_frames_offset
;
3311 tframe_offset
= offset
;
3312 gotten
= read (trace_fd
, &tpnum
, 2);
3314 perror_with_name (trace_filename
);
3315 else if (gotten
< 2)
3316 error (_("Premature end of file while reading trace file"));
3320 gotten
= read (trace_fd
, &data_size
, 4);
3322 perror_with_name (trace_filename
);
3323 else if (gotten
< 4)
3324 error (_("Premature end of file while reading trace file"));
3333 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3334 if (tfaddr
== addr1
)
3338 tp
= get_tracepoint (num
);
3339 if (tp
&& tpnum
== tp
->number_on_target
)
3343 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3344 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
3348 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3349 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
3353 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
3357 printf_filtered ("Found traceframe %d.\n", tfnum
);
3360 cur_offset
= offset
;
3361 cur_data_size
= data_size
;
3364 /* Skip past the traceframe's data. */
3365 lseek (trace_fd
, data_size
, SEEK_CUR
);
3366 offset
+= data_size
;
3367 /* Update our own count of traceframes. */
3370 /* Did not find what we were looking for. */
3376 /* Look for a block of saved registers in the traceframe, and get the
3377 requested register from it. */
3380 tfile_fetch_registers (struct target_ops
*ops
,
3381 struct regcache
*regcache
, int regno
)
3383 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3385 int i
, pos
, offset
, regn
, regsize
, gotten
;
3386 unsigned short mlen
;
3389 /* An uninitialized reg size says we're not going to be
3390 successful at getting register blocks. */
3391 if (!trace_regblock_size
)
3394 regs
= alloca (trace_regblock_size
);
3396 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3398 while (pos
< cur_data_size
)
3400 gotten
= read (trace_fd
, &block_type
, 1);
3402 perror_with_name (trace_filename
);
3403 else if (gotten
< 1)
3404 error (_("Premature end of file while reading trace file"));
3410 gotten
= read (trace_fd
, regs
, trace_regblock_size
);
3412 perror_with_name (trace_filename
);
3413 else if (gotten
< trace_regblock_size
)
3414 error (_("Premature end of file while reading trace file"));
3416 /* Assume the block is laid out in GDB register number order,
3417 each register with the size that it has in GDB. */
3419 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3421 regsize
= register_size (gdbarch
, regn
);
3422 /* Make sure we stay within block bounds. */
3423 if (offset
+ regsize
>= trace_regblock_size
)
3425 if (!regcache_valid_p (regcache
, regn
))
3429 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
3432 else if (regno
== -1)
3434 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
3441 lseek (trace_fd
, 8, SEEK_CUR
);
3442 gotten
= read (trace_fd
, &mlen
, 2);
3444 perror_with_name (trace_filename
);
3445 else if (gotten
< 2)
3446 error (_("Premature end of file while reading trace file"));
3447 lseek (trace_fd
, mlen
, SEEK_CUR
);
3448 pos
+= (8 + 2 + mlen
);
3451 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3455 error ("Unknown block type '%c' (0x%x) in trace frame",
3456 block_type
, block_type
);
3463 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3464 const char *annex
, gdb_byte
*readbuf
,
3465 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3470 unsigned short mlen
;
3472 /* We're only doing regular memory for now. */
3473 if (object
!= TARGET_OBJECT_MEMORY
)
3476 if (readbuf
== NULL
)
3477 error ("tfile_xfer_partial: trace file is read-only");
3479 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3481 while (pos
< cur_data_size
)
3483 gotten
= read (trace_fd
, &block_type
, 1);
3485 perror_with_name (trace_filename
);
3486 else if (gotten
< 1)
3487 error (_("Premature end of file while reading trace file"));
3492 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3493 pos
+= trace_regblock_size
;
3496 gotten
= read (trace_fd
, &maddr
, 8);
3498 perror_with_name (trace_filename
);
3499 else if (gotten
< 8)
3500 error (_("Premature end of file while reading trace file"));
3502 gotten
= read (trace_fd
, &mlen
, 2);
3504 perror_with_name (trace_filename
);
3505 else if (gotten
< 2)
3506 error (_("Premature end of file while reading trace file"));
3507 if (maddr
<= offset
&& (offset
+ len
) <= (maddr
+ mlen
))
3509 gotten
= read (trace_fd
, readbuf
, mlen
);
3511 perror_with_name (trace_filename
);
3512 else if (gotten
< mlen
)
3513 error (_("Premature end of file qwhile reading trace file"));
3517 lseek (trace_fd
, mlen
, SEEK_CUR
);
3518 pos
+= (8 + 2 + mlen
);
3521 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3525 error ("Unknown block type '%c' (0x%x) in traceframe",
3526 block_type
, block_type
);
3530 /* Indicate failure to find the requested memory block. */
3534 /* Iterate through the blocks of a trace frame, looking for a 'V'
3535 block with a matching tsv number. */
3538 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
3541 int pos
, vnum
, gotten
;
3542 unsigned short mlen
;
3544 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3546 while (pos
< cur_data_size
)
3548 gotten
= read (trace_fd
, &block_type
, 1);
3550 perror_with_name (trace_filename
);
3551 else if (gotten
< 1)
3552 error (_("Premature end of file while reading trace file"));
3557 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3558 pos
+= trace_regblock_size
;
3561 lseek (trace_fd
, 8, SEEK_CUR
);
3562 gotten
= read (trace_fd
, &mlen
, 2);
3564 perror_with_name (trace_filename
);
3565 else if (gotten
< 2)
3566 error (_("Premature end of file while reading trace file"));
3567 lseek (trace_fd
, mlen
, SEEK_CUR
);
3568 pos
+= (8 + 2 + mlen
);
3571 gotten
= read (trace_fd
, &vnum
, 4);
3573 perror_with_name (trace_filename
);
3574 else if (gotten
< 4)
3575 error (_("Premature end of file while reading trace file"));
3578 gotten
= read (trace_fd
, val
, 8);
3580 perror_with_name (trace_filename
);
3581 else if (gotten
< 8)
3582 error (_("Premature end of file while reading trace file"));
3585 lseek (trace_fd
, 8, SEEK_CUR
);
3589 error ("Unknown block type '%c' (0x%x) in traceframe",
3590 block_type
, block_type
);
3594 /* Didn't find anything. */
3599 tfile_has_memory (struct target_ops
*ops
)
3605 tfile_has_stack (struct target_ops
*ops
)
3611 tfile_has_registers (struct target_ops
*ops
)
3617 init_tfile_ops (void)
3619 tfile_ops
.to_shortname
= "tfile";
3620 tfile_ops
.to_longname
= "Local trace dump file";
3622 "Use a trace file as a target. Specify the filename of the trace file.";
3623 tfile_ops
.to_open
= tfile_open
;
3624 tfile_ops
.to_close
= tfile_close
;
3625 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
3626 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
3627 tfile_ops
.to_files_info
= tfile_files_info
;
3628 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
3629 tfile_ops
.to_trace_find
= tfile_trace_find
;
3630 tfile_ops
.to_get_trace_state_variable_value
= tfile_get_trace_state_variable_value
;
3631 /* core_stratum might seem more logical, but GDB doesn't like having
3632 more than one core_stratum vector. */
3633 tfile_ops
.to_stratum
= process_stratum
;
3634 tfile_ops
.to_has_memory
= tfile_has_memory
;
3635 tfile_ops
.to_has_stack
= tfile_has_stack
;
3636 tfile_ops
.to_has_registers
= tfile_has_registers
;
3637 tfile_ops
.to_magic
= OPS_MAGIC
;
3640 /* module initialization */
3642 _initialize_tracepoint (void)
3644 struct cmd_list_element
*c
;
3646 traceframe_number
= -1;
3647 tracepoint_number
= -1;
3649 if (tracepoint_list
.list
== NULL
)
3651 tracepoint_list
.listsize
= 128;
3652 tracepoint_list
.list
= xmalloc
3653 (tracepoint_list
.listsize
* sizeof (struct memrange
));
3655 if (tracepoint_list
.aexpr_list
== NULL
)
3657 tracepoint_list
.aexpr_listsize
= 128;
3658 tracepoint_list
.aexpr_list
= xmalloc
3659 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3662 if (stepping_list
.list
== NULL
)
3664 stepping_list
.listsize
= 128;
3665 stepping_list
.list
= xmalloc
3666 (stepping_list
.listsize
* sizeof (struct memrange
));
3669 if (stepping_list
.aexpr_list
== NULL
)
3671 stepping_list
.aexpr_listsize
= 128;
3672 stepping_list
.aexpr_list
= xmalloc
3673 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3676 add_info ("scope", scope_info
,
3677 _("List the variables local to a scope"));
3679 add_cmd ("tracepoints", class_trace
, NULL
,
3680 _("Tracing of program execution without stopping the program."),
3683 add_com ("tdump", class_trace
, trace_dump_command
,
3684 _("Print everything collected at the current tracepoint."));
3686 add_com ("tsave", class_trace
, trace_save_command
, _("\
3687 Save the trace data to a file.\n\
3688 Use the '-r' option to direct the target to save directly to the file,\n\
3689 using its own filesystem."));
3691 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
3692 Define a trace state variable.\n\
3693 Argument is a $-prefixed name, optionally followed\n\
3694 by '=' and an expression that sets the initial value\n\
3695 at the start of tracing."));
3696 set_cmd_completer (c
, expression_completer
);
3698 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
3699 Delete one or more trace state variables.\n\
3700 Arguments are the names of the variables to delete.\n\
3701 If no arguments are supplied, delete all variables."), &deletelist
);
3702 /* FIXME add a trace variable completer */
3704 add_info ("tvariables", tvariables_info
, _("\
3705 Status of trace state variables and their values.\n\
3708 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
3709 Select a trace frame;\n\
3710 No argument means forward by one frame; '-' means backward by one frame."),
3711 &tfindlist
, "tfind ", 1, &cmdlist
);
3713 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
3714 Select a trace frame whose PC is outside the given range (exclusive).\n\
3715 Usage: tfind outside addr1, addr2"),
3718 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
3719 Select a trace frame whose PC is in the given range (inclusive).\n\
3720 Usage: tfind range addr1,addr2"),
3723 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
3724 Select a trace frame by source line.\n\
3725 Argument can be a line number (with optional source file), \n\
3726 a function name, or '*' followed by an address.\n\
3727 Default argument is 'the next source line that was traced'."),
3730 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
3731 Select a trace frame by tracepoint number.\n\
3732 Default is the tracepoint for the current trace frame."),
3735 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
3736 Select a trace frame by PC.\n\
3737 Default is the current PC, or the PC of the current trace frame."),
3740 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
3741 Synonym for 'none'.\n\
3742 De-select any trace frame and resume 'live' debugging."),
3745 add_cmd ("none", class_trace
, trace_find_none_command
,
3746 _("De-select any trace frame and resume 'live' debugging."),
3749 add_cmd ("start", class_trace
, trace_find_start_command
,
3750 _("Select the first trace frame in the trace buffer."),
3753 add_com ("tstatus", class_trace
, trace_status_command
,
3754 _("Display the status of the current trace data collection."));
3756 add_com ("tstop", class_trace
, trace_stop_command
,
3757 _("Stop trace data collection."));
3759 add_com ("tstart", class_trace
, trace_start_command
,
3760 _("Start trace data collection."));
3762 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
3763 Ends a list of commands or actions.\n\
3764 Several GDB commands allow you to enter a list of commands or actions.\n\
3765 Entering \"end\" on a line by itself is the normal way to terminate\n\
3767 Note: the \"end\" command cannot be used at the gdb prompt."));
3769 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
3770 Specify single-stepping behavior at a tracepoint.\n\
3771 Argument is number of instructions to trace in single-step mode\n\
3772 following the tracepoint. This command is normally followed by\n\
3773 one or more \"collect\" commands, to specify what to collect\n\
3774 while single-stepping.\n\n\
3775 Note: this command can only be used in a tracepoint \"actions\" list."));
3777 add_com_alias ("ws", "while-stepping", class_alias
, 0);
3778 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
3780 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
3781 Specify one or more data items to be collected at a tracepoint.\n\
3782 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
3783 collect all data (variables, registers) referenced by that expression.\n\
3784 Also accepts the following special arguments:\n\
3785 $regs -- all registers.\n\
3786 $args -- all function arguments.\n\
3787 $locals -- all variables local to the block/function scope.\n\
3788 Note: this command can only be used in a tracepoint \"actions\" list."));
3790 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
3791 Specify one or more expressions to be evaluated at a tracepoint.\n\
3792 Accepts a comma-separated list of (one or more) expressions.\n\
3793 The result of each evaluation will be discarded.\n\
3794 Note: this command can only be used in a tracepoint \"actions\" list."));
3796 add_com ("actions", class_trace
, trace_actions_command
, _("\
3797 Specify the actions to be taken at a tracepoint.\n\
3798 Tracepoint actions may include collecting of specified data, \n\
3799 single-stepping, or enabling/disabling other tracepoints, \n\
3800 depending on target's capabilities."));
3802 default_collect
= xstrdup ("");
3803 add_setshow_string_cmd ("default-collect", class_trace
,
3804 &default_collect
, _("\
3805 Set the list of expressions to collect by default"), _("\
3806 Show the list of expressions to collect by default"), NULL
,
3808 &setlist
, &showlist
);
3810 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
3811 &disconnected_tracing
, _("\
3812 Set whether tracing continues after GDB disconnects."), _("\
3813 Show whether tracing continues after GDB disconnects."), _("\
3814 Use this to continue a tracing run even if GDB disconnects\n\
3815 or detaches from the target. You can reconnect later and look at\n\
3816 trace data collected in the meantime."),
3817 set_disconnected_tracing
,
3824 add_target (&tfile_ops
);