1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
4 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "arch-utils.h"
26 #include "expression.h"
31 #include "gdb_string.h"
33 #include "breakpoint.h"
34 #include "tracepoint.h"
37 #include "completer.h"
39 #include "dictionary.h"
41 #include "user-regs.h"
45 #include "filenames.h"
46 #include "gdbthread.h"
51 /* readline include files */
52 #include "readline/readline.h"
53 #include "readline/history.h"
55 /* readline defines this. */
66 extern int hex2bin (const char *hex
, gdb_byte
*bin
, int count
);
67 extern int bin2hex (const gdb_byte
*bin
, char *hex
, int count
);
69 extern void stop_tracing ();
71 /* Maximum length of an agent aexpression.
72 This accounts for the fact that packets are limited to 400 bytes
73 (which includes everything -- including the checksum), and assumes
74 the worst case of maximum length for each of the pieces of a
77 NOTE: expressions get mem2hex'ed otherwise this would be twice as
78 large. (400 - 31)/2 == 184 */
79 #define MAX_AGENT_EXPR_LEN 184
81 /* A hook used to notify the UI of tracepoint operations. */
83 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
84 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
86 extern void (*deprecated_readline_begin_hook
) (char *, ...);
87 extern char *(*deprecated_readline_hook
) (char *);
88 extern void (*deprecated_readline_end_hook
) (void);
90 /* GDB commands implemented in other modules:
93 extern void output_command (char *, int);
98 This module defines the following debugger commands:
99 trace : set a tracepoint on a function, line, or address.
100 info trace : list all debugger-defined tracepoints.
101 delete trace : delete one or more tracepoints.
102 enable trace : enable one or more tracepoints.
103 disable trace : disable one or more tracepoints.
104 actions : specify actions to be taken at a tracepoint.
105 passcount : specify a pass count for a tracepoint.
106 tstart : start a trace experiment.
107 tstop : stop a trace experiment.
108 tstatus : query the status of a trace experiment.
109 tfind : find a trace frame in the trace buffer.
110 tdump : print everything collected at the current tracepoint.
111 save-tracepoints : write tracepoint setup into a file.
113 This module defines the following user-visible debugger variables:
114 $trace_frame : sequence number of trace frame currently being debugged.
115 $trace_line : source line of trace frame currently being debugged.
116 $trace_file : source file of trace frame currently being debugged.
117 $tracepoint : tracepoint number of trace frame currently being debugged.
121 /* ======= Important global variables: ======= */
123 /* The list of all trace state variables. We don't retain pointers to
124 any of these for any reason - API is by name or number only - so it
125 works to have a vector of objects. */
127 typedef struct trace_state_variable tsv_s
;
130 static VEC(tsv_s
) *tvariables
;
132 /* The next integer to assign to a variable. */
134 static int next_tsv_number
= 1;
136 /* Number of last traceframe collected. */
137 static int traceframe_number
;
139 /* Tracepoint for last traceframe collected. */
140 static int tracepoint_number
;
142 /* Symbol for function for last traceframe collected */
143 static struct symbol
*traceframe_fun
;
145 /* Symtab and line for last traceframe collected */
146 static struct symtab_and_line traceframe_sal
;
148 /* Tracing command lists */
149 static struct cmd_list_element
*tfindlist
;
151 /* List of expressions to collect by default at each tracepoint hit. */
152 char *default_collect
= "";
154 static int disconnected_tracing
;
156 /* ======= Important command functions: ======= */
157 static void trace_actions_command (char *, int);
158 static void trace_start_command (char *, int);
159 static void trace_stop_command (char *, int);
160 static void trace_status_command (char *, int);
161 static void trace_find_command (char *, int);
162 static void trace_find_pc_command (char *, int);
163 static void trace_find_tracepoint_command (char *, int);
164 static void trace_find_line_command (char *, int);
165 static void trace_find_range_command (char *, int);
166 static void trace_find_outside_command (char *, int);
167 static void trace_dump_command (char *, int);
169 /* support routines */
171 struct collection_list
;
172 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
173 static char *mem2hex (gdb_byte
*, char *, int);
174 static void add_register (struct collection_list
*collection
,
176 static struct cleanup
*make_cleanup_free_actions (struct breakpoint
*t
);
178 extern void send_disconnected_tracing_value (int value
);
180 static void free_uploaded_tps (struct uploaded_tp
**utpp
);
181 static void free_uploaded_tsvs (struct uploaded_tsv
**utsvp
);
184 extern void _initialize_tracepoint (void);
186 static struct trace_status trace_status
;
188 char *stop_reason_names
[] = {
197 struct trace_status
*
198 current_trace_status ()
200 return &trace_status
;
203 /* Set traceframe number to NUM. */
205 set_traceframe_num (int num
)
207 traceframe_number
= num
;
208 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
211 /* Set tracepoint number to NUM. */
213 set_tracepoint_num (int num
)
215 tracepoint_number
= num
;
216 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
219 /* Set externally visible debug variables for querying/printing
220 the traceframe context (line, function, file) */
223 set_traceframe_context (struct frame_info
*trace_frame
)
227 if (trace_frame
== NULL
) /* Cease debugging any trace buffers. */
230 traceframe_sal
.pc
= traceframe_sal
.line
= 0;
231 traceframe_sal
.symtab
= NULL
;
232 clear_internalvar (lookup_internalvar ("trace_func"));
233 clear_internalvar (lookup_internalvar ("trace_file"));
234 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
238 /* Save as globals for internal use. */
239 trace_pc
= get_frame_pc (trace_frame
);
240 traceframe_sal
= find_pc_line (trace_pc
, 0);
241 traceframe_fun
= find_pc_function (trace_pc
);
243 /* Save linenumber as "$trace_line", a debugger variable visible to
245 set_internalvar_integer (lookup_internalvar ("trace_line"),
246 traceframe_sal
.line
);
248 /* Save func name as "$trace_func", a debugger variable visible to
250 if (traceframe_fun
== NULL
251 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
252 clear_internalvar (lookup_internalvar ("trace_func"));
254 set_internalvar_string (lookup_internalvar ("trace_func"),
255 SYMBOL_LINKAGE_NAME (traceframe_fun
));
257 /* Save file name as "$trace_file", a debugger variable visible to
259 if (traceframe_sal
.symtab
== NULL
260 || traceframe_sal
.symtab
->filename
== NULL
)
261 clear_internalvar (lookup_internalvar ("trace_file"));
263 set_internalvar_string (lookup_internalvar ("trace_file"),
264 traceframe_sal
.symtab
->filename
);
267 /* Create a new trace state variable with the given name. */
269 struct trace_state_variable
*
270 create_trace_state_variable (const char *name
)
272 struct trace_state_variable tsv
;
274 memset (&tsv
, 0, sizeof (tsv
));
276 tsv
.number
= next_tsv_number
++;
277 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
280 /* Look for a trace state variable of the given name. */
282 struct trace_state_variable
*
283 find_trace_state_variable (const char *name
)
285 struct trace_state_variable
*tsv
;
288 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
289 if (strcmp (name
, tsv
->name
) == 0)
296 delete_trace_state_variable (const char *name
)
298 struct trace_state_variable
*tsv
;
301 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
302 if (strcmp (name
, tsv
->name
) == 0)
304 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
308 warning (_("No trace variable named \"$%s\", not deleting"), name
);
311 /* The 'tvariable' command collects a name and optional expression to
312 evaluate into an initial value. */
315 trace_variable_command (char *args
, int from_tty
)
317 struct expression
*expr
;
318 struct cleanup
*old_chain
;
319 struct internalvar
*intvar
= NULL
;
321 struct trace_state_variable
*tsv
;
324 error_no_arg (_("trace state variable name"));
326 /* All the possible valid arguments are expressions. */
327 expr
= parse_expression (args
);
328 old_chain
= make_cleanup (free_current_contents
, &expr
);
330 if (expr
->nelts
== 0)
331 error (_("No expression?"));
333 /* Only allow two syntaxes; "$name" and "$name=value". */
334 if (expr
->elts
[0].opcode
== OP_INTERNALVAR
)
336 intvar
= expr
->elts
[1].internalvar
;
338 else if (expr
->elts
[0].opcode
== BINOP_ASSIGN
339 && expr
->elts
[1].opcode
== OP_INTERNALVAR
)
341 intvar
= expr
->elts
[2].internalvar
;
342 initval
= value_as_long (evaluate_subexpression_type (expr
, 4));
345 error (_("Syntax must be $NAME [ = EXPR ]"));
348 error (_("No name given"));
350 if (strlen (internalvar_name (intvar
)) <= 0)
351 error (_("Must supply a non-empty variable name"));
353 /* If the variable already exists, just change its initial value. */
354 tsv
= find_trace_state_variable (internalvar_name (intvar
));
357 tsv
->initial_value
= initval
;
358 printf_filtered (_("Trace state variable $%s now has initial value %s.\n"),
359 tsv
->name
, plongest (tsv
->initial_value
));
363 /* Create a new variable. */
364 tsv
= create_trace_state_variable (internalvar_name (intvar
));
365 tsv
->initial_value
= initval
;
367 printf_filtered (_("Trace state variable $%s created, with initial value %s.\n"),
368 tsv
->name
, plongest (tsv
->initial_value
));
370 do_cleanups (old_chain
);
374 delete_trace_variable_command (char *args
, int from_tty
)
378 struct cleanup
*back_to
;
379 struct trace_state_variable
*tsv
;
383 if (query (_("Delete all trace state variables? ")))
384 VEC_free (tsv_s
, tvariables
);
389 argv
= gdb_buildargv (args
);
390 back_to
= make_cleanup_freeargv (argv
);
392 for (i
= 0; argv
[i
] != NULL
; i
++)
395 delete_trace_state_variable (argv
[i
] + 1);
397 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[i
]);
400 do_cleanups (back_to
);
405 /* List all the trace state variables. */
408 tvariables_info (char *args
, int from_tty
)
410 struct trace_state_variable
*tsv
;
415 if (VEC_length (tsv_s
, tvariables
) == 0)
417 printf_filtered (_("No trace state variables.\n"));
421 /* Try to acquire values from the target. */
422 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
423 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
426 printf_filtered (_("Name\t\t Initial\tCurrent\n"));
428 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
430 printf_filtered ("$%s", tsv
->name
);
431 print_spaces_filtered (17 - strlen (tsv
->name
), gdb_stdout
);
432 printf_filtered ("%s ", plongest (tsv
->initial_value
));
433 print_spaces_filtered (11 - strlen (plongest (tsv
->initial_value
)), gdb_stdout
);
434 if (tsv
->value_known
)
435 printf_filtered (" %s", plongest (tsv
->value
));
436 else if (current_trace_status ()->running
|| traceframe_number
>= 0)
437 /* The value is/was defined, but we don't have it. */
438 printf_filtered (_(" <unknown>"));
440 /* It is not meaningful to ask about the value. */
441 printf_filtered (_(" <undefined>"));
442 printf_filtered ("\n");
446 /* ACTIONS functions: */
448 /* Prototypes for action-parsing utility commands */
449 static void read_actions (struct breakpoint
*);
451 /* The three functions:
452 collect_pseudocommand,
453 while_stepping_pseudocommand, and
454 end_actions_pseudocommand
455 are placeholders for "commands" that are actually ONLY to be used
456 within a tracepoint action list. If the actual function is ever called,
457 it means that somebody issued the "command" at the top level,
458 which is always an error. */
461 end_actions_pseudocommand (char *args
, int from_tty
)
463 error (_("This command cannot be used at the top level."));
467 while_stepping_pseudocommand (char *args
, int from_tty
)
469 error (_("This command can only be used in a tracepoint actions list."));
473 collect_pseudocommand (char *args
, int from_tty
)
475 error (_("This command can only be used in a tracepoint actions list."));
479 teval_pseudocommand (char *args
, int from_tty
)
481 error (_("This command can only be used in a tracepoint actions list."));
484 /* Enter a list of actions for a tracepoint. */
486 trace_actions_command (char *args
, int from_tty
)
488 struct breakpoint
*t
;
490 char *end_msg
= "End with a line saying just \"end\".";
492 t
= get_tracepoint_by_number (&args
, 0, 1);
495 sprintf (tmpbuf
, "Enter actions for tracepoint %d, one per line.",
500 if (deprecated_readline_begin_hook
)
501 (*deprecated_readline_begin_hook
) ("%s %s\n", tmpbuf
, end_msg
);
502 else if (input_from_terminal_p ())
503 printf_filtered ("%s\n%s\n", tmpbuf
, end_msg
);
507 t
->step_count
= 0; /* read_actions may set this */
510 if (deprecated_readline_end_hook
)
511 (*deprecated_readline_end_hook
) ();
512 /* tracepoints_changed () */
514 /* else just return */
517 /* worker function */
519 read_actions (struct breakpoint
*t
)
522 char *prompt1
= "> ", *prompt2
= " > ";
523 char *prompt
= prompt1
;
524 enum actionline_type linetype
;
525 extern FILE *instream
;
526 struct action_line
*next
= NULL
, *temp
;
527 struct cleanup
*old_chain
;
529 /* Control-C quits instantly if typed while in this loop
530 since it should not wait until the user types a newline. */
532 /* FIXME: kettenis/20010823: Something is wrong here. In this file
533 STOP_SIGNAL is never defined. So this code has been left out, at
534 least for quite a while now. Replacing STOP_SIGNAL with SIGTSTP
535 leads to compilation failures since the variable job_control
536 isn't declared. Leave this alone for now. */
539 signal (STOP_SIGNAL
, handle_stop_sig
);
541 old_chain
= make_cleanup_free_actions (t
);
544 /* Make sure that all output has been output. Some machines may
545 let you get away with leaving out some of the gdb_flush, but
548 gdb_flush (gdb_stdout
);
549 gdb_flush (gdb_stderr
);
551 if (deprecated_readline_hook
&& instream
== NULL
)
552 line
= (*deprecated_readline_hook
) (prompt
);
553 else if (instream
== stdin
&& ISATTY (instream
))
555 line
= gdb_readline_wrapper (prompt
);
556 if (line
&& *line
) /* add it to command history */
560 line
= gdb_readline (0);
564 line
= xstrdup ("end");
565 printf_filtered ("end\n");
568 linetype
= validate_actionline (&line
, t
);
569 if (linetype
== BADLINE
)
570 continue; /* already warned -- collect another line */
572 temp
= xmalloc (sizeof (struct action_line
));
576 if (next
== NULL
) /* first action for this tracepoint? */
577 t
->actions
= next
= temp
;
584 if (linetype
== STEPPING
) /* begin "while-stepping" */
586 if (prompt
== prompt2
)
588 warning (_("Already processing 'while-stepping'"));
592 prompt
= prompt2
; /* change prompt for stepping actions */
594 else if (linetype
== END
)
596 if (prompt
== prompt2
)
598 prompt
= prompt1
; /* end of single-stepping actions */
601 { /* end of actions */
602 if (t
->actions
->next
== NULL
)
604 /* An "end" all by itself with no other actions
605 means this tracepoint has no actions.
606 Discard empty list. */
615 signal (STOP_SIGNAL
, SIG_DFL
);
618 discard_cleanups (old_chain
);
621 /* worker function */
623 validate_actionline (char **line
, struct breakpoint
*t
)
625 struct cmd_list_element
*c
;
626 struct expression
*exp
= NULL
;
627 struct cleanup
*old_chain
= NULL
;
629 struct bp_location
*loc
;
631 /* if EOF is typed, *line is NULL */
635 for (p
= *line
; isspace ((int) *p
);)
638 /* Symbol lookup etc. */
639 if (*p
== '\0') /* empty line: just prompt for another line. */
642 if (*p
== '#') /* comment line */
645 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
648 warning (_("'%s' is not an action that I know, or is ambiguous."),
653 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
655 struct agent_expr
*aexpr
;
656 struct agent_reqs areqs
;
659 { /* repeat over a comma-separated list */
660 QUIT
; /* allow user to bail out with ^C */
661 while (isspace ((int) *p
))
664 if (*p
== '$') /* look for special pseudo-symbols */
666 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
667 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
668 (0 == strncasecmp ("loc", p
+ 1, 3)))
673 /* else fall thru, treat p as an expression and parse it! */
676 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
679 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
680 old_chain
= make_cleanup (free_current_contents
, &exp
);
682 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
684 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
686 warning (_("constant %s (value %ld) will not be collected."),
687 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
688 SYMBOL_VALUE (exp
->elts
[2].symbol
));
691 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
693 warning (_("%s is optimized away and cannot be collected."),
694 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
699 /* We have something to collect, make sure that the expr to
700 bytecode translator can handle it and that it's not too
702 aexpr
= gen_trace_for_expr (loc
->address
, exp
);
703 make_cleanup_free_agent_expr (aexpr
);
705 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
706 error (_("expression too complicated, try simplifying"));
708 ax_reqs (aexpr
, &areqs
);
709 (void) make_cleanup (xfree
, areqs
.reg_mask
);
711 if (areqs
.flaw
!= agent_flaw_none
)
712 error (_("malformed expression"));
714 if (areqs
.min_height
< 0)
715 error (_("gdb: Internal error: expression has min height < 0"));
717 if (areqs
.max_height
> 20)
718 error (_("expression too complicated, try simplifying"));
720 do_cleanups (old_chain
);
723 while (p
&& *p
++ == ',');
726 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
728 struct agent_expr
*aexpr
;
731 { /* repeat over a comma-separated list */
732 QUIT
; /* allow user to bail out with ^C */
733 while (isspace ((int) *p
))
737 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
740 /* Only expressions are allowed for this action. */
741 exp
= parse_exp_1 (&p
, block_for_pc (loc
->address
), 1);
742 old_chain
= make_cleanup (free_current_contents
, &exp
);
744 /* We have something to evaluate, make sure that the expr to
745 bytecode translator can handle it and that it's not too
747 aexpr
= gen_eval_for_expr (loc
->address
, exp
);
748 make_cleanup_free_agent_expr (aexpr
);
750 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
751 error (_("expression too complicated, try simplifying"));
753 do_cleanups (old_chain
);
756 while (p
&& *p
++ == ',');
759 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
761 char *steparg
; /* in case warning is necessary */
763 while (isspace ((int) *p
))
768 (t
->step_count
= strtol (p
, &p
, 0)) == 0)
770 warning (_("'%s': bad step-count; command ignored."), *line
);
775 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
779 warning (_("'%s' is not a supported tracepoint action."), *line
);
784 /* worker function */
786 free_actions (struct breakpoint
*t
)
788 struct action_line
*line
, *next
;
790 for (line
= t
->actions
; line
; line
= next
)
794 xfree (line
->action
);
801 do_free_actions_cleanup (void *t
)
806 static struct cleanup
*
807 make_cleanup_free_actions (struct breakpoint
*t
)
809 return make_cleanup (do_free_actions_cleanup
, t
);
813 memrange_absolute
= -1
818 int type
; /* memrange_absolute for absolute memory range,
819 else basereg number */
820 bfd_signed_vma start
;
824 struct collection_list
826 unsigned char regs_mask
[32]; /* room for up to 256 regs */
829 struct memrange
*list
;
830 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
832 struct agent_expr
**aexpr_list
;
835 tracepoint_list
, stepping_list
;
837 /* MEMRANGE functions: */
839 static int memrange_cmp (const void *, const void *);
841 /* compare memranges for qsort */
843 memrange_cmp (const void *va
, const void *vb
)
845 const struct memrange
*a
= va
, *b
= vb
;
847 if (a
->type
< b
->type
)
849 if (a
->type
> b
->type
)
851 if (a
->type
== memrange_absolute
)
853 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
855 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
860 if (a
->start
< b
->start
)
862 if (a
->start
> b
->start
)
868 /* Sort the memrange list using qsort, and merge adjacent memranges. */
870 memrange_sortmerge (struct collection_list
*memranges
)
874 qsort (memranges
->list
, memranges
->next_memrange
,
875 sizeof (struct memrange
), memrange_cmp
);
876 if (memranges
->next_memrange
> 0)
878 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
880 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
881 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
884 /* memrange b starts before memrange a ends; merge them. */
885 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
886 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
887 continue; /* next b, same a */
891 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
892 sizeof (struct memrange
));
894 memranges
->next_memrange
= a
+ 1;
898 /* Add a register to a collection list. */
900 add_register (struct collection_list
*collection
, unsigned int regno
)
903 printf_filtered ("collect register %d\n", regno
);
904 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
905 error (_("Internal: register number %d too large for tracepoint"),
907 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
910 /* Add a memrange to a collection list */
912 add_memrange (struct collection_list
*memranges
,
913 int type
, bfd_signed_vma base
,
918 printf_filtered ("(%d,", type
);
920 printf_filtered (",%ld)\n", len
);
923 /* type: memrange_absolute == memory, other n == basereg */
924 memranges
->list
[memranges
->next_memrange
].type
= type
;
925 /* base: addr if memory, offset if reg relative. */
926 memranges
->list
[memranges
->next_memrange
].start
= base
;
927 /* len: we actually save end (base + len) for convenience */
928 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
929 memranges
->next_memrange
++;
930 if (memranges
->next_memrange
>= memranges
->listsize
)
932 memranges
->listsize
*= 2;
933 memranges
->list
= xrealloc (memranges
->list
,
934 memranges
->listsize
);
937 if (type
!= memrange_absolute
) /* Better collect the base register! */
938 add_register (memranges
, type
);
941 /* Add a symbol to a collection list. */
943 collect_symbol (struct collection_list
*collect
,
945 struct gdbarch
*gdbarch
,
946 long frame_regno
, long frame_offset
,
951 bfd_signed_vma offset
;
953 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
954 switch (SYMBOL_CLASS (sym
))
957 printf_filtered ("%s: don't know symbol class %d\n",
958 SYMBOL_PRINT_NAME (sym
),
962 printf_filtered ("constant %s (value %ld) will not be collected.\n",
963 SYMBOL_PRINT_NAME (sym
), SYMBOL_VALUE (sym
));
966 offset
= SYMBOL_VALUE_ADDRESS (sym
);
971 sprintf_vma (tmp
, offset
);
972 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
973 SYMBOL_PRINT_NAME (sym
), len
,
976 add_memrange (collect
, memrange_absolute
, offset
, len
);
979 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
981 printf_filtered ("LOC_REG[parm] %s: ",
982 SYMBOL_PRINT_NAME (sym
));
983 add_register (collect
, reg
);
984 /* Check for doubles stored in two registers. */
985 /* FIXME: how about larger types stored in 3 or more regs? */
986 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
987 len
> register_size (gdbarch
, reg
))
988 add_register (collect
, reg
+ 1);
991 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
992 printf_filtered (" (will not collect %s)\n",
993 SYMBOL_PRINT_NAME (sym
));
997 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1000 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1001 SYMBOL_PRINT_NAME (sym
), len
);
1002 printf_vma (offset
);
1003 printf_filtered (" from frame ptr reg %d\n", reg
);
1005 add_memrange (collect
, reg
, offset
, len
);
1007 case LOC_REGPARM_ADDR
:
1008 reg
= SYMBOL_VALUE (sym
);
1012 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1013 SYMBOL_PRINT_NAME (sym
), len
);
1014 printf_vma (offset
);
1015 printf_filtered (" from reg %d\n", reg
);
1017 add_memrange (collect
, reg
, offset
, len
);
1021 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1024 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1025 SYMBOL_PRINT_NAME (sym
), len
);
1026 printf_vma (offset
);
1027 printf_filtered (" from frame ptr reg %d\n", reg
);
1029 add_memrange (collect
, reg
, offset
, len
);
1031 case LOC_UNRESOLVED
:
1032 printf_filtered ("Don't know LOC_UNRESOLVED %s\n",
1033 SYMBOL_PRINT_NAME (sym
));
1035 case LOC_OPTIMIZED_OUT
:
1036 printf_filtered ("%s has been optimized out of existence.\n",
1037 SYMBOL_PRINT_NAME (sym
));
1042 struct agent_expr
*aexpr
;
1043 struct cleanup
*old_chain1
= NULL
;
1044 struct agent_reqs areqs
;
1046 aexpr
= gen_trace_for_var (scope
, sym
);
1048 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1050 ax_reqs (aexpr
, &areqs
);
1051 if (areqs
.flaw
!= agent_flaw_none
)
1052 error (_("malformed expression"));
1054 if (areqs
.min_height
< 0)
1055 error (_("gdb: Internal error: expression has min height < 0"));
1056 if (areqs
.max_height
> 20)
1057 error (_("expression too complicated, try simplifying"));
1059 discard_cleanups (old_chain1
);
1060 add_aexpr (collect
, aexpr
);
1062 /* take care of the registers */
1063 if (areqs
.reg_mask_len
> 0)
1067 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1069 QUIT
; /* allow user to bail out with ^C */
1070 if (areqs
.reg_mask
[ndx1
] != 0)
1072 /* assume chars have 8 bits */
1073 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1074 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1075 /* it's used -- record it */
1076 add_register (collect
,
1086 /* Add all locals (or args) symbols to collection list */
1088 add_local_symbols (struct collection_list
*collect
,
1089 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1090 long frame_regno
, long frame_offset
, int type
)
1093 struct block
*block
;
1094 struct dict_iterator iter
;
1097 block
= block_for_pc (pc
);
1100 QUIT
; /* allow user to bail out with ^C */
1101 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
1103 if (SYMBOL_IS_ARGUMENT (sym
)
1104 ? type
== 'A' /* collecting Arguments */
1105 : type
== 'L') /* collecting Locals */
1108 collect_symbol (collect
, sym
, gdbarch
,
1109 frame_regno
, frame_offset
, pc
);
1112 if (BLOCK_FUNCTION (block
))
1115 block
= BLOCK_SUPERBLOCK (block
);
1118 warning (_("No %s found in scope."),
1119 type
== 'L' ? "locals" : "args");
1122 /* worker function */
1124 clear_collection_list (struct collection_list
*list
)
1128 list
->next_memrange
= 0;
1129 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1131 free_agent_expr (list
->aexpr_list
[ndx
]);
1132 list
->aexpr_list
[ndx
] = NULL
;
1134 list
->next_aexpr_elt
= 0;
1135 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1138 /* reduce a collection list to string form (for gdb protocol) */
1140 stringify_collection_list (struct collection_list
*list
, char *string
)
1142 char temp_buf
[2048];
1146 char *(*str_list
)[];
1150 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1151 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1153 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1154 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1156 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1159 printf_filtered ("\nCollecting registers (mask): 0x");
1164 QUIT
; /* allow user to bail out with ^C */
1166 printf_filtered ("%02X", list
->regs_mask
[i
]);
1167 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1170 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1174 printf_filtered ("\n");
1175 if (list
->next_memrange
> 0 && info_verbose
)
1176 printf_filtered ("Collecting memranges: \n");
1177 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1179 QUIT
; /* allow user to bail out with ^C */
1180 sprintf_vma (tmp2
, list
->list
[i
].start
);
1183 printf_filtered ("(%d, %s, %ld)\n",
1186 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1188 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1190 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1197 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1199 /* The "%X" conversion specifier expects an unsigned argument,
1200 so passing -1 (memrange_absolute) to it directly gives you
1201 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1203 if (list
->list
[i
].type
== memrange_absolute
)
1204 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1206 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1209 count
+= strlen (end
);
1210 end
= temp_buf
+ count
;
1213 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1215 QUIT
; /* allow user to bail out with ^C */
1216 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1218 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1223 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1224 end
+= 10; /* 'X' + 8 hex digits + ',' */
1227 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1228 end
, list
->aexpr_list
[i
]->len
);
1229 count
+= 2 * list
->aexpr_list
[i
]->len
;
1234 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1239 (*str_list
)[ndx
] = NULL
;
1250 /* Render all actions into gdb protocol. */
1252 encode_actions (struct breakpoint
*t
, struct bp_location
*tloc
,
1253 char ***tdp_actions
, char ***stepping_actions
)
1255 static char tdp_buff
[2048], step_buff
[2048];
1257 struct expression
*exp
= NULL
;
1258 struct action_line
*action
;
1260 struct value
*tempval
;
1261 struct collection_list
*collect
;
1262 struct cmd_list_element
*cmd
;
1263 struct agent_expr
*aexpr
;
1265 LONGEST frame_offset
;
1266 char *default_collect_line
= NULL
;
1267 struct action_line
*default_collect_action
= NULL
;
1269 clear_collection_list (&tracepoint_list
);
1270 clear_collection_list (&stepping_list
);
1271 collect
= &tracepoint_list
;
1273 *tdp_actions
= NULL
;
1274 *stepping_actions
= NULL
;
1276 gdbarch_virtual_frame_pointer (t
->gdbarch
,
1277 tloc
->address
, &frame_reg
, &frame_offset
);
1279 action
= t
->actions
;
1281 /* If there are default expressions to collect, make up a collect
1282 action and prepend to the action list to encode. Note that since
1283 validation is per-tracepoint (local var "xyz" might be valid for
1284 one tracepoint and not another, etc), we make up the action on
1285 the fly, and don't cache it. */
1286 if (*default_collect
)
1289 enum actionline_type linetype
;
1291 default_collect_line
= xmalloc (12 + strlen (default_collect
));
1292 sprintf (default_collect_line
, "collect %s", default_collect
);
1293 line
= default_collect_line
;
1294 linetype
= validate_actionline (&line
, t
);
1295 if (linetype
!= BADLINE
)
1297 default_collect_action
= xmalloc (sizeof (struct action_line
));
1298 default_collect_action
->next
= t
->actions
;
1299 default_collect_action
->action
= line
;
1300 action
= default_collect_action
;
1304 for (; action
; action
= action
->next
)
1306 QUIT
; /* allow user to bail out with ^C */
1307 action_exp
= action
->action
;
1308 while (isspace ((int) *action_exp
))
1311 if (*action_exp
== '#') /* comment line */
1314 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1316 error (_("Bad action list item: %s"), action_exp
);
1318 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1321 { /* repeat over a comma-separated list */
1322 QUIT
; /* allow user to bail out with ^C */
1323 while (isspace ((int) *action_exp
))
1326 if (0 == strncasecmp ("$reg", action_exp
, 4))
1328 for (i
= 0; i
< gdbarch_num_regs (t
->gdbarch
); i
++)
1329 add_register (collect
, i
);
1330 action_exp
= strchr (action_exp
, ','); /* more? */
1332 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1334 add_local_symbols (collect
,
1340 action_exp
= strchr (action_exp
, ','); /* more? */
1342 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1344 add_local_symbols (collect
,
1350 action_exp
= strchr (action_exp
, ','); /* more? */
1354 unsigned long addr
, len
;
1355 struct cleanup
*old_chain
= NULL
;
1356 struct cleanup
*old_chain1
= NULL
;
1357 struct agent_reqs areqs
;
1359 exp
= parse_exp_1 (&action_exp
,
1360 block_for_pc (tloc
->address
), 1);
1361 old_chain
= make_cleanup (free_current_contents
, &exp
);
1363 switch (exp
->elts
[0].opcode
)
1367 const char *name
= &exp
->elts
[2].string
;
1369 i
= user_reg_map_name_to_regnum (t
->gdbarch
,
1370 name
, strlen (name
));
1372 internal_error (__FILE__
, __LINE__
,
1373 _("Register $%s not available"),
1376 printf_filtered ("OP_REGISTER: ");
1377 add_register (collect
, i
);
1382 /* safe because we know it's a simple expression */
1383 tempval
= evaluate_expression (exp
);
1384 addr
= value_address (tempval
);
1385 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1386 add_memrange (collect
, memrange_absolute
, addr
, len
);
1390 collect_symbol (collect
,
1391 exp
->elts
[2].symbol
,
1398 default: /* full-fledged expression */
1399 aexpr
= gen_trace_for_expr (tloc
->address
, exp
);
1401 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1403 ax_reqs (aexpr
, &areqs
);
1404 if (areqs
.flaw
!= agent_flaw_none
)
1405 error (_("malformed expression"));
1407 if (areqs
.min_height
< 0)
1408 error (_("gdb: Internal error: expression has min height < 0"));
1409 if (areqs
.max_height
> 20)
1410 error (_("expression too complicated, try simplifying"));
1412 discard_cleanups (old_chain1
);
1413 add_aexpr (collect
, aexpr
);
1415 /* take care of the registers */
1416 if (areqs
.reg_mask_len
> 0)
1421 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1423 QUIT
; /* allow user to bail out with ^C */
1424 if (areqs
.reg_mask
[ndx1
] != 0)
1426 /* assume chars have 8 bits */
1427 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1428 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1429 /* it's used -- record it */
1430 add_register (collect
,
1437 do_cleanups (old_chain
);
1440 while (action_exp
&& *action_exp
++ == ',');
1442 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1445 { /* repeat over a comma-separated list */
1446 QUIT
; /* allow user to bail out with ^C */
1447 while (isspace ((int) *action_exp
))
1451 unsigned long addr
, len
;
1452 struct cleanup
*old_chain
= NULL
;
1453 struct cleanup
*old_chain1
= NULL
;
1454 struct agent_reqs areqs
;
1456 exp
= parse_exp_1 (&action_exp
,
1457 block_for_pc (tloc
->address
), 1);
1458 old_chain
= make_cleanup (free_current_contents
, &exp
);
1460 aexpr
= gen_eval_for_expr (tloc
->address
, exp
);
1461 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1463 ax_reqs (aexpr
, &areqs
);
1464 if (areqs
.flaw
!= agent_flaw_none
)
1465 error (_("malformed expression"));
1467 if (areqs
.min_height
< 0)
1468 error (_("gdb: Internal error: expression has min height < 0"));
1469 if (areqs
.max_height
> 20)
1470 error (_("expression too complicated, try simplifying"));
1472 discard_cleanups (old_chain1
);
1473 /* Even though we're not officially collecting, add
1474 to the collect list anyway. */
1475 add_aexpr (collect
, aexpr
);
1477 do_cleanups (old_chain
);
1480 while (action_exp
&& *action_exp
++ == ',');
1482 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1484 collect
= &stepping_list
;
1486 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
1488 if (collect
== &stepping_list
) /* end stepping actions */
1489 collect
= &tracepoint_list
;
1491 break; /* end tracepoint actions */
1494 memrange_sortmerge (&tracepoint_list
);
1495 memrange_sortmerge (&stepping_list
);
1497 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1499 *stepping_actions
= stringify_collection_list (&stepping_list
,
1502 xfree (default_collect_line
);
1503 xfree (default_collect_action
);
1507 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1509 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1511 collect
->aexpr_list
=
1512 xrealloc (collect
->aexpr_list
,
1513 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1514 collect
->aexpr_listsize
*= 2;
1516 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1517 collect
->next_aexpr_elt
++;
1522 Tell target to clear any previous trace experiment.
1523 Walk the list of tracepoints, and send them (and their actions)
1524 to the target. If no errors,
1525 Tell target to start a new trace experiment. */
1528 trace_start_command (char *args
, int from_tty
)
1531 VEC(breakpoint_p
) *tp_vec
= NULL
;
1533 struct breakpoint
*t
;
1534 struct trace_state_variable
*tsv
;
1535 int any_downloaded
= 0;
1537 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1539 target_trace_init ();
1541 tp_vec
= all_tracepoints ();
1542 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1544 t
->number_on_target
= 0;
1545 target_download_tracepoint (t
);
1546 t
->number_on_target
= t
->number
;
1549 VEC_free (breakpoint_p
, tp_vec
);
1551 /* No point in tracing without any tracepoints... */
1552 if (!any_downloaded
)
1553 error ("No tracepoints downloaded, not starting trace");
1555 /* Send down all the trace state variables too. */
1556 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1558 target_download_trace_state_variable (tsv
);
1561 /* Tell target to treat text-like sections as transparent. */
1562 target_trace_set_readonly_regions ();
1564 /* Now insert traps and begin collecting data. */
1565 target_trace_start ();
1567 /* Reset our local state. */
1568 set_traceframe_num (-1);
1569 set_tracepoint_num (-1);
1570 set_traceframe_context (NULL
);
1571 current_trace_status()->running
= 1;
1576 trace_stop_command (char *args
, int from_tty
)
1584 target_trace_stop ();
1585 /* should change in response to reply? */
1586 current_trace_status ()->running
= 0;
1589 /* tstatus command */
1591 trace_status_command (char *args
, int from_tty
)
1593 struct trace_status
*ts
= current_trace_status ();
1596 status
= target_get_trace_status (ts
);
1601 printf_filtered (_("Using a trace file.\n"));
1604 printf_filtered (_("Trace can not be run on this target.\n"));
1609 if (!ts
->running_known
)
1611 printf_filtered (_("Run/stop status is unknown.\n"));
1613 else if (ts
->running
)
1615 printf_filtered (_("Trace is running on the target.\n"));
1616 if (disconnected_tracing
)
1617 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1619 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1623 switch (ts
->stop_reason
)
1625 case trace_never_run
:
1626 printf_filtered (_("No trace has been run on the target.\n"));
1629 printf_filtered (_("Trace stopped by a tstop command.\n"));
1631 case trace_buffer_full
:
1632 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1634 case trace_disconnected
:
1635 printf_filtered (_("Trace stopped because of disconnection.\n"));
1637 case tracepoint_passcount
:
1638 /* FIXME account for number on target */
1639 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1640 ts
->stopping_tracepoint
);
1642 case trace_stop_reason_unknown
:
1643 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1646 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1652 if (ts
->traceframe_count
>= 0)
1654 printf_filtered (_("Collected %d trace frames.\n"),
1655 ts
->traceframe_count
);
1658 if (ts
->buffer_free
)
1660 printf_filtered (_("Trace buffer has %llu bytes free.\n"),
1664 /* Now report on what we're doing with tfind. */
1665 if (traceframe_number
>= 0)
1666 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1667 traceframe_number
, tracepoint_number
);
1669 printf_filtered (_("Not looking at any trace frame.\n"));
1673 disconnect_or_stop_tracing (int from_tty
)
1675 /* It can happen that the target that was tracing went away on its
1676 own, and we didn't notice. Get a status update, and if the
1677 current target doesn't even do tracing, then assume it's not
1679 if (target_get_trace_status (current_trace_status ()) < 0)
1680 current_trace_status ()->running
= 0;
1682 if (current_trace_status ()->running
&& from_tty
)
1684 int cont
= query (_("Trace is running. Continue tracing after detach? "));
1685 /* Note that we send the query result without affecting the
1686 user's setting of disconnected_tracing, so that the answer is
1688 send_disconnected_tracing_value (cont
);
1690 /* Also ensure that we do the equivalent of a tstop command if
1691 tracing is not to continue after the detach. */
1697 /* Worker function for the various flavors of the tfind command. */
1699 finish_tfind_command (enum trace_find_type type
, int num
,
1700 ULONGEST addr1
, ULONGEST addr2
,
1703 int target_frameno
= -1, target_tracept
= -1;
1704 struct frame_id old_frame_id
;
1706 struct breakpoint
*tp
;
1708 old_frame_id
= get_frame_id (get_current_frame ());
1710 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
1713 if (type
== tfind_number
1715 && target_frameno
== -1)
1717 /* We told the target to get out of tfind mode, and it did. */
1719 else if (target_frameno
== -1)
1721 /* A request for a non-existant trace frame has failed.
1722 Our response will be different, depending on FROM_TTY:
1724 If FROM_TTY is true, meaning that this command was
1725 typed interactively by the user, then give an error
1726 and DO NOT change the state of traceframe_number etc.
1728 However if FROM_TTY is false, meaning that we're either
1729 in a script, a loop, or a user-defined command, then
1730 DON'T give an error, but DO change the state of
1731 traceframe_number etc. to invalid.
1733 The rationalle is that if you typed the command, you
1734 might just have committed a typo or something, and you'd
1735 like to NOT lose your current debugging state. However
1736 if you're in a user-defined command or especially in a
1737 loop, then you need a way to detect that the command
1738 failed WITHOUT aborting. This allows you to write
1739 scripts that search thru the trace buffer until the end,
1740 and then continue on to do something else. */
1743 error (_("Target failed to find requested trace frame."));
1747 printf_filtered ("End of trace buffer.\n");
1748 #if 0 /* dubious now? */
1749 /* The following will not recurse, since it's
1751 trace_find_command ("-1", from_tty
);
1756 tp
= get_tracepoint_by_number_on_target (target_tracept
);
1758 reinit_frame_cache ();
1759 registers_changed ();
1760 target_dcache_invalidate ();
1761 set_traceframe_num (target_frameno
);
1762 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
1763 if (target_frameno
== -1)
1764 set_traceframe_context (NULL
);
1766 set_traceframe_context (get_current_frame ());
1768 /* If we're in nonstop mode and getting out of looking at trace
1769 frames, there won't be any current frame to go back to and
1772 && (has_stack_frames () || traceframe_number
>= 0))
1774 enum print_what print_what
;
1776 /* NOTE: in immitation of the step command, try to determine
1777 whether we have made a transition from one function to
1778 another. If so, we'll print the "stack frame" (ie. the new
1779 function and it's arguments) -- otherwise we'll just show the
1782 if (frame_id_eq (old_frame_id
,
1783 get_frame_id (get_current_frame ())))
1784 print_what
= SRC_LINE
;
1786 print_what
= SRC_AND_LOC
;
1788 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
1793 /* trace_find_command takes a trace frame number n,
1794 sends "QTFrame:<n>" to the target,
1795 and accepts a reply that may contain several optional pieces
1796 of information: a frame number, a tracepoint number, and an
1797 indication of whether this is a trap frame or a stepping frame.
1799 The minimal response is just "OK" (which indicates that the
1800 target does not give us a frame number or a tracepoint number).
1801 Instead of that, the target may send us a string containing
1803 F<hexnum> (gives the selected frame number)
1804 T<hexnum> (gives the selected tracepoint number)
1809 trace_find_command (char *args
, int from_tty
)
1810 { /* this should only be called with a numeric argument */
1813 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1814 error ("May not look at trace frames while trace is running.");
1816 if (args
== 0 || *args
== 0)
1817 { /* TFIND with no args means find NEXT trace frame. */
1818 if (traceframe_number
== -1)
1819 frameno
= 0; /* "next" is first one */
1821 frameno
= traceframe_number
+ 1;
1823 else if (0 == strcmp (args
, "-"))
1825 if (traceframe_number
== -1)
1826 error (_("not debugging trace buffer"));
1827 else if (from_tty
&& traceframe_number
== 0)
1828 error (_("already at start of trace buffer"));
1830 frameno
= traceframe_number
- 1;
1832 /* A hack to work around eval's need for fp to have been collected. */
1833 else if (0 == strcmp (args
, "-1"))
1836 frameno
= parse_and_eval_long (args
);
1839 error (_("invalid input (%d is less than zero)"), frameno
);
1841 finish_tfind_command (tfind_number
, frameno
, 0, 0, from_tty
);
1846 trace_find_end_command (char *args
, int from_tty
)
1848 trace_find_command ("-1", from_tty
);
1853 trace_find_none_command (char *args
, int from_tty
)
1855 trace_find_command ("-1", from_tty
);
1860 trace_find_start_command (char *args
, int from_tty
)
1862 trace_find_command ("0", from_tty
);
1865 /* tfind pc command */
1867 trace_find_pc_command (char *args
, int from_tty
)
1872 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1873 error ("May not look at trace frames while trace is running.");
1875 if (args
== 0 || *args
== 0)
1876 pc
= regcache_read_pc (get_current_regcache ());
1878 pc
= parse_and_eval_address (args
);
1880 finish_tfind_command (tfind_pc
, 0, pc
, 0, from_tty
);
1883 /* tfind tracepoint command */
1885 trace_find_tracepoint_command (char *args
, int from_tty
)
1888 struct breakpoint
*tp
;
1890 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1891 error ("May not look at trace frames while trace is running.");
1893 if (args
== 0 || *args
== 0)
1895 if (tracepoint_number
== -1)
1896 error (_("No current tracepoint -- please supply an argument."));
1898 tdp
= tracepoint_number
; /* default is current TDP */
1901 tdp
= parse_and_eval_long (args
);
1903 /* If we have the tracepoint on hand, use the number that the
1904 target knows about (which may be different if we disconnected
1905 and reconnected). */
1906 tp
= get_tracepoint (tdp
);
1908 tdp
= tp
->number_on_target
;
1910 finish_tfind_command (tfind_tp
, tdp
, 0, 0, from_tty
);
1913 /* TFIND LINE command:
1915 This command will take a sourceline for argument, just like BREAK
1916 or TRACE (ie. anything that "decode_line_1" can handle).
1918 With no argument, this command will find the next trace frame
1919 corresponding to a source line OTHER THAN THE CURRENT ONE. */
1922 trace_find_line_command (char *args
, int from_tty
)
1924 static CORE_ADDR start_pc
, end_pc
;
1925 struct symtabs_and_lines sals
;
1926 struct symtab_and_line sal
;
1927 struct cleanup
*old_chain
;
1928 char startpc_str
[40], endpc_str
[40];
1930 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1931 error ("May not look at trace frames while trace is running.");
1933 if (args
== 0 || *args
== 0)
1935 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
1937 sals
.sals
= (struct symtab_and_line
*)
1938 xmalloc (sizeof (struct symtab_and_line
));
1943 sals
= decode_line_spec (args
, 1);
1947 old_chain
= make_cleanup (xfree
, sals
.sals
);
1948 if (sal
.symtab
== 0)
1950 printf_filtered ("TFIND: No line number information available");
1953 /* This is useful for "info line *0x7f34". If we can't
1954 tell the user about a source line, at least let them
1955 have the symbolic address. */
1956 printf_filtered (" for address ");
1958 print_address (get_current_arch (), sal
.pc
, gdb_stdout
);
1959 printf_filtered (";\n -- will attempt to find by PC. \n");
1963 printf_filtered (".\n");
1964 return; /* No line, no PC; what can we do? */
1967 else if (sal
.line
> 0
1968 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
1970 if (start_pc
== end_pc
)
1972 printf_filtered ("Line %d of \"%s\"",
1973 sal
.line
, sal
.symtab
->filename
);
1975 printf_filtered (" is at address ");
1976 print_address (get_current_arch (), start_pc
, gdb_stdout
);
1978 printf_filtered (" but contains no code.\n");
1979 sal
= find_pc_line (start_pc
, 0);
1981 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
1982 && start_pc
!= end_pc
)
1983 printf_filtered ("Attempting to find line %d instead.\n",
1986 error (_("Cannot find a good line."));
1990 /* Is there any case in which we get here, and have an address
1991 which the user would want to see? If we have debugging
1992 symbols and no line numbers? */
1993 error (_("Line number %d is out of range for \"%s\"."),
1994 sal
.line
, sal
.symtab
->filename
);
1996 /* Find within range of stated line. */
1998 finish_tfind_command (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
2000 finish_tfind_command (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
2001 do_cleanups (old_chain
);
2004 /* tfind range command */
2006 trace_find_range_command (char *args
, int from_tty
)
2008 static CORE_ADDR start
, stop
;
2009 char start_str
[40], stop_str
[40];
2012 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2013 error ("May not look at trace frames while trace is running.");
2015 if (args
== 0 || *args
== 0)
2016 { /* XXX FIXME: what should default behavior be? */
2017 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2021 if (0 != (tmp
= strchr (args
, ',')))
2023 *tmp
++ = '\0'; /* terminate start address */
2024 while (isspace ((int) *tmp
))
2026 start
= parse_and_eval_address (args
);
2027 stop
= parse_and_eval_address (tmp
);
2030 { /* no explicit end address? */
2031 start
= parse_and_eval_address (args
);
2032 stop
= start
+ 1; /* ??? */
2035 finish_tfind_command (tfind_range
, 0, start
, stop
, from_tty
);
2038 /* tfind outside command */
2040 trace_find_outside_command (char *args
, int from_tty
)
2042 CORE_ADDR start
, stop
;
2043 char start_str
[40], stop_str
[40];
2046 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2047 error ("May not look at trace frames while trace is running.");
2049 if (args
== 0 || *args
== 0)
2050 { /* XXX FIXME: what should default behavior be? */
2051 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2055 if (0 != (tmp
= strchr (args
, ',')))
2057 *tmp
++ = '\0'; /* terminate start address */
2058 while (isspace ((int) *tmp
))
2060 start
= parse_and_eval_address (args
);
2061 stop
= parse_and_eval_address (tmp
);
2064 { /* no explicit end address? */
2065 start
= parse_and_eval_address (args
);
2066 stop
= start
+ 1; /* ??? */
2069 finish_tfind_command (tfind_outside
, 0, start
, stop
, from_tty
);
2072 /* info scope command: list the locals for a scope. */
2074 scope_info (char *args
, int from_tty
)
2076 struct symtabs_and_lines sals
;
2078 struct minimal_symbol
*msym
;
2079 struct block
*block
;
2080 char **canonical
, *symname
, *save_args
= args
;
2081 struct dict_iterator iter
;
2083 struct gdbarch
*gdbarch
;
2086 if (args
== 0 || *args
== 0)
2087 error (_("requires an argument (function, line or *addr) to define a scope"));
2089 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2090 if (sals
.nelts
== 0)
2091 return; /* presumably decode_line_1 has already warned */
2093 /* Resolve line numbers to PC */
2094 resolve_sal_pc (&sals
.sals
[0]);
2095 block
= block_for_pc (sals
.sals
[0].pc
);
2099 QUIT
; /* allow user to bail out with ^C */
2100 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2102 QUIT
; /* allow user to bail out with ^C */
2104 printf_filtered ("Scope for %s:\n", save_args
);
2107 symname
= SYMBOL_PRINT_NAME (sym
);
2108 if (symname
== NULL
|| *symname
== '\0')
2109 continue; /* probably botched, certainly useless */
2111 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2113 printf_filtered ("Symbol %s is ", symname
);
2114 switch (SYMBOL_CLASS (sym
))
2117 case LOC_UNDEF
: /* messed up symbol? */
2118 printf_filtered ("a bogus symbol, class %d.\n",
2119 SYMBOL_CLASS (sym
));
2120 count
--; /* don't count this one */
2123 printf_filtered ("a constant with value %ld (0x%lx)",
2124 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2126 case LOC_CONST_BYTES
:
2127 printf_filtered ("constant bytes: ");
2128 if (SYMBOL_TYPE (sym
))
2129 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2130 fprintf_filtered (gdb_stdout
, " %02x",
2131 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2134 printf_filtered ("in static storage at address ");
2135 printf_filtered ("%s", paddress (gdbarch
,
2136 SYMBOL_VALUE_ADDRESS (sym
)));
2139 /* GDBARCH is the architecture associated with the objfile
2140 the symbol is defined in; the target architecture may be
2141 different, and may provide additional registers. However,
2142 we do not know the target architecture at this point.
2143 We assume the objfile architecture will contain all the
2144 standard registers that occur in debug info in that
2146 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2148 if (SYMBOL_IS_ARGUMENT (sym
))
2149 printf_filtered ("an argument in register $%s",
2150 gdbarch_register_name (gdbarch
, regno
));
2152 printf_filtered ("a local variable in register $%s",
2153 gdbarch_register_name (gdbarch
, regno
));
2156 printf_filtered ("an argument at stack/frame offset %ld",
2157 SYMBOL_VALUE (sym
));
2160 printf_filtered ("a local variable at frame offset %ld",
2161 SYMBOL_VALUE (sym
));
2164 printf_filtered ("a reference argument at offset %ld",
2165 SYMBOL_VALUE (sym
));
2167 case LOC_REGPARM_ADDR
:
2168 /* Note comment at LOC_REGISTER. */
2169 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2170 printf_filtered ("the address of an argument, in register $%s",
2171 gdbarch_register_name (gdbarch
, regno
));
2174 printf_filtered ("a typedef.\n");
2177 printf_filtered ("a label at address ");
2178 printf_filtered ("%s", paddress (gdbarch
,
2179 SYMBOL_VALUE_ADDRESS (sym
)));
2182 printf_filtered ("a function at address ");
2183 printf_filtered ("%s",
2184 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2186 case LOC_UNRESOLVED
:
2187 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2190 printf_filtered ("Unresolved Static");
2193 printf_filtered ("static storage at address ");
2194 printf_filtered ("%s",
2195 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2198 case LOC_OPTIMIZED_OUT
:
2199 printf_filtered ("optimized out.\n");
2202 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, gdb_stdout
);
2205 if (SYMBOL_TYPE (sym
))
2206 printf_filtered (", length %d.\n",
2207 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2209 if (BLOCK_FUNCTION (block
))
2212 block
= BLOCK_SUPERBLOCK (block
);
2215 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2219 /* worker function (cleanup) */
2221 replace_comma (void *data
)
2229 trace_dump_command (char *args
, int from_tty
)
2231 struct regcache
*regcache
;
2232 struct gdbarch
*gdbarch
;
2233 struct breakpoint
*t
;
2234 struct action_line
*action
;
2235 char *action_exp
, *next_comma
;
2236 struct cleanup
*old_cleanups
;
2237 int stepping_actions
= 0;
2238 int stepping_frame
= 0;
2239 struct bp_location
*loc
;
2241 if (tracepoint_number
== -1)
2243 warning (_("No current trace frame."));
2247 t
= get_tracepoint (tracepoint_number
);
2250 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2253 old_cleanups
= make_cleanup (null_cleanup
, NULL
);
2255 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2256 tracepoint_number
, traceframe_number
);
2258 /* The current frame is a trap frame if the frame PC is equal
2259 to the tracepoint PC. If not, then the current frame was
2260 collected during single-stepping. */
2262 regcache
= get_current_regcache ();
2263 gdbarch
= get_regcache_arch (regcache
);
2265 /* If the traceframe's address matches any of the tracepoint's
2266 locations, assume it is a direct hit rather than a while-stepping
2267 frame. (FIXME this is not reliable, should record each frame's
2270 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2271 if (loc
->address
== regcache_read_pc (regcache
))
2274 for (action
= t
->actions
; action
; action
= action
->next
)
2276 struct cmd_list_element
*cmd
;
2278 QUIT
; /* allow user to bail out with ^C */
2279 action_exp
= action
->action
;
2280 while (isspace ((int) *action_exp
))
2283 /* The collection actions to be done while stepping are
2284 bracketed by the commands "while-stepping" and "end". */
2286 if (*action_exp
== '#') /* comment line */
2289 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2291 error (_("Bad action list item: %s"), action_exp
);
2293 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2294 stepping_actions
= 1;
2295 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2296 stepping_actions
= 0;
2297 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2299 /* Display the collected data.
2300 For the trap frame, display only what was collected at
2301 the trap. Likewise for stepping frames, display only
2302 what was collected while stepping. This means that the
2303 two boolean variables, STEPPING_FRAME and
2304 STEPPING_ACTIONS should be equal. */
2305 if (stepping_frame
== stepping_actions
)
2308 { /* repeat over a comma-separated list */
2309 QUIT
; /* allow user to bail out with ^C */
2310 if (*action_exp
== ',')
2312 while (isspace ((int) *action_exp
))
2315 next_comma
= strchr (action_exp
, ',');
2317 if (0 == strncasecmp (action_exp
, "$reg", 4))
2318 registers_info (NULL
, from_tty
);
2319 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2320 locals_info (NULL
, from_tty
);
2321 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2322 args_info (NULL
, from_tty
);
2327 make_cleanup (replace_comma
, next_comma
);
2330 printf_filtered ("%s = ", action_exp
);
2331 output_command (action_exp
, from_tty
);
2332 printf_filtered ("\n");
2336 action_exp
= next_comma
;
2338 while (action_exp
&& *action_exp
== ',');
2342 discard_cleanups (old_cleanups
);
2345 extern int trace_regblock_size
;
2348 trace_save_command (char *args
, int from_tty
)
2351 char *filename
= NULL
, *pathname
;
2352 int target_does_save
= 0;
2353 struct cleanup
*cleanup
;
2354 struct trace_status
*ts
= current_trace_status ();
2357 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2358 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2361 ULONGEST offset
= 0;
2362 #define MAX_TRACE_UPLOAD 2000
2363 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2367 error_no_arg (_("file in which to save trace data"));
2369 argv
= gdb_buildargv (args
);
2370 make_cleanup_freeargv (argv
);
2372 for (; *argv
; ++argv
)
2374 if (strcmp (*argv
, "-r") == 0)
2375 target_does_save
= 1;
2376 else if (**argv
== '-')
2377 error (_("unknown option `%s'"), *argv
);
2383 error_no_arg (_("file in which to save trace data"));
2385 /* If the target is to save the data to a file on its own, then just
2386 send the command and be done with it. */
2387 if (target_does_save
)
2389 err
= target_save_trace_data (filename
);
2391 error (_("Target failed to save trace data to '%s'."),
2396 /* Get the trace status first before opening the file, so if the
2397 target is losing, we can get out without touching files. */
2398 status
= target_get_trace_status (ts
);
2400 pathname
= tilde_expand (args
);
2401 cleanup
= make_cleanup (xfree
, pathname
);
2403 fp
= fopen (pathname
, "w");
2405 error (_("Unable to open file '%s' for saving trace data (%s)"),
2406 args
, safe_strerror (errno
));
2407 make_cleanup_fclose (fp
);
2409 /* Write a file header, with a high-bit-set char to indicate a
2410 binary file, plus a hint as what this file is, and a version
2411 number in case of future needs. */
2412 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2414 perror_with_name (pathname
);
2416 /* Write descriptive info. */
2418 /* Write out the size of a register block. */
2419 fprintf (fp
, "R %x\n", trace_regblock_size
);
2421 /* Write out status of the tracing run (aka "tstatus" info). */
2422 fprintf (fp
, "status %c;%s:%x;tframes:%x;tfree:%llx\n",
2423 (ts
->running
? '1' : '0'),
2424 stop_reason_names
[ts
->stop_reason
], ts
->stopping_tracepoint
,
2425 ts
->traceframe_count
, ts
->buffer_free
);
2427 /* Note that we want to upload tracepoints and save those, rather
2428 than simply writing out the local ones, because the user may have
2429 changed tracepoints in GDB in preparation for a future tracing
2430 run, or maybe just mass-deleted all types of breakpoints as part
2431 of cleaning up. So as not to contaminate the session, leave the
2432 data in its uploaded form, don't make into real tracepoints. */
2434 /* Get trace state variables first, they may be checked when parsing
2435 uploaded commands. */
2437 target_upload_trace_state_variables (&uploaded_tsvs
);
2439 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2445 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
2446 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
2449 fprintf (fp
, "tsv %x:%s:%x:%s\n",
2450 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
2451 utsv
->builtin
, buf
);
2457 free_uploaded_tsvs (&uploaded_tsvs
);
2459 target_upload_tracepoints (&uploaded_tps
);
2461 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
2463 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
2464 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2465 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
2466 if (utp
->type
== bp_fast_tracepoint
)
2467 fprintf (fp
, ":F%x", utp
->orig_size
);
2469 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
2472 for (a
= 0; a
< utp
->numactions
; ++a
)
2473 fprintf (fp
, "tp A%x:%s:%s\n",
2474 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2476 for (a
= 0; a
< utp
->num_step_actions
; ++a
)
2477 fprintf (fp
, "tp S%x:%s:%s\n",
2478 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2479 utp
->step_actions
[a
]);
2482 free_uploaded_tps (&uploaded_tps
);
2484 /* Mark the end of the definition section. */
2487 /* Get and write the trace data proper. We ask for big blocks, in
2488 the hopes of efficiency, but will take less if the target has
2489 packet size limitations or some such. */
2492 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
2494 error (_("Failure to get requested trace buffer data"));
2495 /* No more data is forthcoming, we're done. */
2498 written
= fwrite (buf
, gotten
, 1, fp
);
2499 if (written
< gotten
)
2500 perror_with_name (pathname
);
2504 /* Mark the end of trace data. */
2505 written
= fwrite (&gotten
, 4, 1, fp
);
2507 perror_with_name (pathname
);
2509 do_cleanups (cleanup
);
2511 printf_filtered (_("Trace data saved to file '%s'.\n"), args
);
2514 /* Tell the target what to do with an ongoing tracing run if GDB
2515 disconnects for some reason. */
2518 send_disconnected_tracing_value (int value
)
2520 target_set_disconnected_tracing (value
);
2524 set_disconnected_tracing (char *args
, int from_tty
,
2525 struct cmd_list_element
*c
)
2527 send_disconnected_tracing_value (disconnected_tracing
);
2530 /* Convert the memory pointed to by mem into hex, placing result in buf.
2531 * Return a pointer to the last char put in buf (null)
2532 * "stolen" from sparc-stub.c
2535 static const char hexchars
[] = "0123456789abcdef";
2538 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2546 *buf
++ = hexchars
[ch
>> 4];
2547 *buf
++ = hexchars
[ch
& 0xf];
2556 get_traceframe_number (void)
2558 return traceframe_number
;
2561 /* Make the traceframe NUM be the current trace frame. Does nothing
2562 if NUM is already current. */
2565 set_traceframe_number (int num
)
2569 if (traceframe_number
== num
)
2571 /* Nothing to do. */
2575 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
2578 warning (_("could not change traceframe"));
2580 traceframe_number
= newnum
;
2582 /* Changing the traceframe changes our view of registers and of the
2584 registers_changed ();
2587 /* A cleanup used when switching away and back from tfind mode. */
2589 struct current_traceframe_cleanup
2591 /* The traceframe we were inspecting. */
2592 int traceframe_number
;
2596 do_restore_current_traceframe_cleanup (void *arg
)
2598 struct current_traceframe_cleanup
*old
= arg
;
2600 set_traceframe_number (old
->traceframe_number
);
2604 restore_current_traceframe_cleanup_dtor (void *arg
)
2606 struct current_traceframe_cleanup
*old
= arg
;
2612 make_cleanup_restore_current_traceframe (void)
2614 struct current_traceframe_cleanup
*old
;
2616 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
2617 old
->traceframe_number
= traceframe_number
;
2619 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
2620 restore_current_traceframe_cleanup_dtor
);
2623 /* Given a number and address, return an uploaded tracepoint with that
2624 number, creating if necessary. */
2626 struct uploaded_tp
*
2627 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
2629 struct uploaded_tp
*utp
;
2631 for (utp
= *utpp
; utp
; utp
= utp
->next
)
2632 if (utp
->number
== num
&& utp
->addr
== addr
)
2634 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
2635 memset (utp
, 0, sizeof (struct uploaded_tp
));
2644 free_uploaded_tps (struct uploaded_tp
**utpp
)
2646 struct uploaded_tp
*next_one
;
2650 next_one
= (*utpp
)->next
;
2656 /* Given a number and address, return an uploaded tracepoint with that
2657 number, creating if necessary. */
2659 struct uploaded_tsv
*
2660 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
2662 struct uploaded_tsv
*utsv
;
2664 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
2665 if (utsv
->number
== num
)
2667 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
2668 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
2670 utsv
->next
= *utsvp
;
2676 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
2678 struct uploaded_tsv
*next_one
;
2682 next_one
= (*utsvp
)->next
;
2688 /* Look for an existing tracepoint that seems similar enough to the
2689 uploaded one. Enablement isn't compared, because the user can
2690 toggle that freely, and may have done so in anticipation of the
2694 find_matching_tracepoint (struct uploaded_tp
*utp
)
2696 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
2698 struct breakpoint
*t
;
2699 struct bp_location
*loc
;
2701 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2703 if (t
->type
== utp
->type
2704 && t
->step_count
== utp
->step
2705 && t
->pass_count
== utp
->pass
2706 /* FIXME also test conditionals and actions */
2709 /* Scan the locations for an address match. */
2710 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2712 if (loc
->address
== utp
->addr
)
2720 /* Given a list of tracepoints uploaded from a target, attempt to
2721 match them up with existing tracepoints, and create new ones if not
2725 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
2727 struct uploaded_tp
*utp
;
2728 struct breakpoint
*t
;
2730 /* Look for GDB tracepoints that match up with our uploaded versions. */
2731 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
2733 t
= find_matching_tracepoint (utp
);
2735 printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
2736 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2739 t
= create_tracepoint_from_upload (utp
);
2741 printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
2742 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2744 printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
2745 utp
->number
, paddress (get_current_arch (), utp
->addr
));
2747 /* Whether found or created, record the number used by the
2748 target, to help with mapping target tracepoints back to their
2749 counterparts here. */
2751 t
->number_on_target
= utp
->number
;
2754 free_uploaded_tps (uploaded_tps
);
2757 /* Trace state variables don't have much to identify them beyond their
2758 name, so just use that to detect matches. */
2760 struct trace_state_variable
*
2761 find_matching_tsv (struct uploaded_tsv
*utsv
)
2766 return find_trace_state_variable (utsv
->name
);
2769 struct trace_state_variable
*
2770 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
2772 const char *namebase
;
2775 struct trace_state_variable
*tsv
;
2779 namebase
= utsv
->name
;
2780 sprintf (buf
, "%s", namebase
);
2785 sprintf (buf
, "%s_%d", namebase
, try_num
++);
2788 /* Fish for a name that is not in use. */
2789 /* (should check against all internal vars?) */
2790 while (find_trace_state_variable (buf
))
2791 sprintf (buf
, "%s_%d", namebase
, try_num
++);
2793 /* We have an available name, create the variable. */
2794 tsv
= create_trace_state_variable (xstrdup (buf
));
2795 tsv
->initial_value
= utsv
->initial_value
;
2796 tsv
->builtin
= utsv
->builtin
;
2801 /* Given a list of uploaded trace state variables, try to match them
2802 up with existing variables, or create additional ones. */
2805 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
2808 struct uploaded_tsv
*utsv
;
2809 struct trace_state_variable
*tsv
;
2812 /* Most likely some numbers will have to be reassigned as part of
2813 the merge, so clear them all in anticipation. */
2814 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2817 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2819 tsv
= find_matching_tsv (utsv
);
2821 printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
2822 tsv
->name
, utsv
->number
);
2825 tsv
= create_tsv_from_upload (utsv
);
2826 printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
2827 tsv
->name
, utsv
->number
);
2829 /* Give precedence to numberings that come from the target. */
2831 tsv
->number
= utsv
->number
;
2834 /* Renumber everything that didn't get a target-assigned number. */
2836 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2837 if (tsv
->number
> highest
)
2838 highest
= tsv
->number
;
2841 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2842 if (tsv
->number
== 0)
2843 tsv
->number
= highest
++;
2845 free_uploaded_tsvs (uploaded_tsvs
);
2848 /* target tfile command */
2850 struct target_ops tfile_ops
;
2852 /* Fill in tfile_ops with its defined operations and properties. */
2854 #define TRACE_HEADER_SIZE 8
2856 char *trace_filename
;
2858 off_t trace_frames_offset
;
2861 int trace_regblock_size
;
2863 static void tfile_interp_line (char *line
,
2864 struct uploaded_tp
**utpp
,
2865 struct uploaded_tsv
**utsvp
);
2868 tfile_open (char *filename
, int from_tty
)
2871 struct cleanup
*old_chain
;
2874 char header
[TRACE_HEADER_SIZE
];
2875 char linebuf
[1000]; /* should be max remote packet size or so */
2877 int bytes
, i
, gotten
;
2878 struct trace_status
*ts
;
2879 struct uploaded_tp
*uploaded_tps
= NULL
;
2880 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
2882 target_preopen (from_tty
);
2884 error (_("No trace file specified."));
2886 filename
= tilde_expand (filename
);
2887 if (!IS_ABSOLUTE_PATH(filename
))
2889 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
2894 old_chain
= make_cleanup (xfree
, filename
);
2896 flags
= O_BINARY
| O_LARGEFILE
;
2898 scratch_chan
= open (filename
, flags
, 0);
2899 if (scratch_chan
< 0)
2900 perror_with_name (filename
);
2902 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
2904 discard_cleanups (old_chain
); /* Don't free filename any more */
2905 unpush_target (&tfile_ops
);
2907 push_target (&tfile_ops
);
2909 trace_filename
= xstrdup (filename
);
2910 trace_fd
= scratch_chan
;
2913 /* Read the file header and test for validity. */
2914 gotten
= read (trace_fd
, &header
, TRACE_HEADER_SIZE
);
2916 perror_with_name (trace_filename
);
2917 else if (gotten
< TRACE_HEADER_SIZE
)
2918 error (_("Premature end of file while reading trace file"));
2920 bytes
+= TRACE_HEADER_SIZE
;
2921 if (!(header
[0] == 0x7f
2922 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
2923 error (_("File is not a valid trace file."));
2925 trace_regblock_size
= 0;
2926 ts
= current_trace_status ();
2927 /* We know we're working with a file. */
2929 /* Set defaults in case there is no status line. */
2930 ts
->running_known
= 0;
2931 ts
->stop_reason
= trace_stop_reason_unknown
;
2932 ts
->traceframe_count
= -1;
2933 ts
->buffer_free
= 0;
2935 /* Read through a section of newline-terminated lines that
2936 define things like tracepoints. */
2940 gotten
= read (trace_fd
, &byte
, 1);
2942 perror_with_name (trace_filename
);
2943 else if (gotten
< 1)
2944 error (_("Premature end of file while reading trace file"));
2949 /* Empty line marks end of the definition section. */
2954 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
2957 linebuf
[i
++] = byte
;
2959 error (_("Excessively long lines in trace file"));
2962 /* Add the file's tracepoints and variables into the current mix. */
2964 /* Get trace state variables first, they may be checked when parsing
2965 uploaded commands. */
2966 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
2968 merge_uploaded_tracepoints (&uploaded_tps
);
2970 /* Record the starting offset of the binary trace data. */
2971 trace_frames_offset
= bytes
;
2973 /* If we don't have a blocksize, we can't interpret the
2975 if (trace_regblock_size
== 0)
2976 error (_("No register block size recorded in trace file"));
2977 if (ts
->traceframe_count
<= 0)
2979 warning ("No traceframes present in this file.");
2983 #define TFILE_PID (1)
2984 inferior_appeared (current_inferior (), TFILE_PID
);
2985 inferior_ptid
= pid_to_ptid (TFILE_PID
);
2986 add_thread_silent (inferior_ptid
);
2988 post_create_inferior (&tfile_ops
, from_tty
);
2991 /* FIXME this will get defined in MI patch submission */
2992 tfind_1 (tfind_number
, 0, 0, 0, 0);
2996 /* Interpret the given line from the definitions part of the trace
3000 tfile_interp_line (char *line
,
3001 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
3005 if (strncmp (p
, "R ", strlen ("R ")) == 0)
3008 trace_regblock_size
= strtol (p
, &p
, 16);
3010 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
3012 p
+= strlen ("status ");
3013 parse_trace_status (p
, current_trace_status ());
3015 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
3017 p
+= strlen ("tp ");
3018 parse_tracepoint_definition (p
, utpp
);
3020 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3022 p
+= strlen ("tsv ");
3023 parse_tsv_definition (p
, utsvp
);
3026 warning ("Ignoring trace file definition \"%s\"", line
);
3029 /* Parse the part of trace status syntax that is shared between
3030 the remote protocol and the trace file reader. */
3032 extern char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
3035 parse_trace_status (char *line
, struct trace_status
*ts
)
3037 char *p
= line
, *p1
, *p_temp
;
3040 ts
->running_known
= 1;
3041 ts
->running
= (*p
++ == '1');
3042 ts
->stop_reason
= trace_stop_reason_unknown
;
3045 p1
= strchr (p
, ':');
3047 error (_("Malformed trace status, at %s\n\
3048 Status line: '%s'\n"), p
, line
);
3049 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3051 p
= unpack_varlen_hex (++p1
, &val
);
3052 ts
->stop_reason
= trace_buffer_full
;
3054 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3056 p
= unpack_varlen_hex (++p1
, &val
);
3057 ts
->stop_reason
= trace_never_run
;
3059 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
], p1
- p
) == 0)
3061 p
= unpack_varlen_hex (++p1
, &val
);
3062 ts
->stop_reason
= tracepoint_passcount
;
3063 ts
->stopping_tracepoint
= val
;
3065 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3067 p
= unpack_varlen_hex (++p1
, &val
);
3068 ts
->stop_reason
= tstop_command
;
3070 if (strncmp (p
, "tframes", p1
- p
) == 0)
3072 p
= unpack_varlen_hex (++p1
, &val
);
3073 ts
->traceframe_count
= val
;
3075 if (strncmp (p
, "tfree", p1
- p
) == 0)
3077 p
= unpack_varlen_hex (++p1
, &val
);
3078 ts
->buffer_free
= val
;
3082 /* Silently skip unknown optional info. */
3083 p_temp
= strchr (p1
+ 1, ';');
3087 /* Must be at the end. */
3093 /* Given a line of text defining a tracepoint or tracepoint action, parse
3094 it into an "uploaded tracepoint". */
3097 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3101 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
;
3105 struct uploaded_tp
*utp
= NULL
;
3108 /* Both tracepoint and action definitions start with the same number
3109 and address sequence. */
3111 p
= unpack_varlen_hex (p
, &num
);
3112 p
++; /* skip a colon */
3113 p
= unpack_varlen_hex (p
, &addr
);
3114 p
++; /* skip a colon */
3117 enabled
= (*p
++ == 'E');
3118 p
++; /* skip a colon */
3119 p
= unpack_varlen_hex (p
, &step
);
3120 p
++; /* skip a colon */
3121 p
= unpack_varlen_hex (p
, &pass
);
3122 type
= bp_tracepoint
;
3124 /* Thumb through optional fields. */
3127 p
++; /* skip a colon */
3130 type
= bp_fast_tracepoint
;
3132 p
= unpack_varlen_hex (p
, &orig_size
);
3137 p
= unpack_varlen_hex (p
, &xlen
);
3138 p
++; /* skip a comma */
3139 cond
= (char *) xmalloc (2 * xlen
+ 1);
3140 strncpy (cond
, p
, 2 * xlen
);
3141 cond
[2 * xlen
] = '\0';
3145 warning ("Unrecognized char '%c' in tracepoint definition, skipping rest", *p
);
3147 utp
= get_uploaded_tp (num
, addr
, utpp
);
3149 utp
->enabled
= enabled
;
3154 else if (piece
== 'A')
3156 utp
= get_uploaded_tp (num
, addr
, utpp
);
3157 utp
->actions
[utp
->numactions
++] = xstrdup (p
);
3159 else if (piece
== 'S')
3161 utp
= get_uploaded_tp (num
, addr
, utpp
);
3162 utp
->step_actions
[utp
->num_step_actions
++] = xstrdup (p
);
3166 error ("Invalid tracepoint piece");
3170 /* Convert a textual description of a trace state variable into an
3174 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3177 ULONGEST num
, initval
, builtin
;
3179 struct uploaded_tsv
*utsv
= NULL
;
3181 buf
= alloca (strlen (line
));
3184 p
= unpack_varlen_hex (p
, &num
);
3185 p
++; /* skip a colon */
3186 p
= unpack_varlen_hex (p
, &initval
);
3187 p
++; /* skip a colon */
3188 p
= unpack_varlen_hex (p
, &builtin
);
3189 p
++; /* skip a colon */
3190 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3193 utsv
= get_uploaded_tsv (num
, utsvp
);
3194 utsv
->initial_value
= initval
;
3195 utsv
->builtin
= builtin
;
3196 utsv
->name
= xstrdup (buf
);
3199 /* Close the trace file and generally clean up. */
3202 tfile_close (int quitting
)
3209 pid
= ptid_get_pid (inferior_ptid
);
3210 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
3211 exit_inferior_silent (pid
);
3216 xfree (trace_filename
);
3220 tfile_files_info (struct target_ops
*t
)
3222 /* (it would be useful to mention the name of the file) */
3223 printf_filtered ("Looking at a trace file.\n");
3226 /* The trace status for a file is that tracing can never be run. */
3229 tfile_get_trace_status (struct trace_status
*ts
)
3231 /* Other bits of trace status were collected as part of opening the
3232 trace files, so nothing to do here. */
3237 /* Given the position of a traceframe in the file, figure out what
3238 address the frame was collected at. This would normally be the
3239 value of a collected PC register, but if not available, we
3243 tfile_get_traceframe_address (off_t tframe_offset
)
3247 struct breakpoint
*tp
;
3248 off_t saved_offset
= cur_offset
;
3251 /* FIXME dig pc out of collected registers */
3253 /* Fall back to using tracepoint address. */
3254 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
3255 gotten
= read (trace_fd
, &tpnum
, 2);
3257 perror_with_name (trace_filename
);
3258 else if (gotten
< 2)
3259 error (_("Premature end of file while reading trace file"));
3261 tp
= get_tracepoint_by_number_on_target (tpnum
);
3262 /* FIXME this is a poor heuristic if multiple locations */
3264 addr
= tp
->loc
->address
;
3266 /* Restore our seek position. */
3267 cur_offset
= saved_offset
;
3268 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3272 /* Given a type of search and some parameters, scan the collection of
3273 traceframes in the file looking for a match. When found, return
3274 both the traceframe and tracepoint number, otherwise -1 for
3278 tfile_trace_find (enum trace_find_type type
, int num
,
3279 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
3282 int tfnum
= 0, found
= 0, gotten
;
3284 struct breakpoint
*tp
;
3285 off_t offset
, tframe_offset
;
3288 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
3289 offset
= trace_frames_offset
;
3292 tframe_offset
= offset
;
3293 gotten
= read (trace_fd
, &tpnum
, 2);
3295 perror_with_name (trace_filename
);
3296 else if (gotten
< 2)
3297 error (_("Premature end of file while reading trace file"));
3301 gotten
= read (trace_fd
, &data_size
, 4);
3303 perror_with_name (trace_filename
);
3304 else if (gotten
< 4)
3305 error (_("Premature end of file while reading trace file"));
3314 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3315 if (tfaddr
== addr1
)
3319 tp
= get_tracepoint (num
);
3320 if (tp
&& tpnum
== tp
->number_on_target
)
3324 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3325 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
3329 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3330 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
3334 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
3338 printf_filtered ("Found traceframe %d.\n", tfnum
);
3341 cur_offset
= offset
;
3342 cur_data_size
= data_size
;
3345 /* Skip past the traceframe's data. */
3346 lseek (trace_fd
, data_size
, SEEK_CUR
);
3347 offset
+= data_size
;
3348 /* Update our own count of traceframes. */
3351 /* Did not find what we were looking for. */
3357 /* Look for a block of saved registers in the traceframe, and get the
3358 requested register from it. */
3361 tfile_fetch_registers (struct target_ops
*ops
,
3362 struct regcache
*regcache
, int regno
)
3364 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3366 int i
, pos
, offset
, regn
, regsize
, gotten
;
3367 unsigned short mlen
;
3370 /* An uninitialized reg size says we're not going to be
3371 successful at getting register blocks. */
3372 if (!trace_regblock_size
)
3375 regs
= alloca (trace_regblock_size
);
3377 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3379 while (pos
< cur_data_size
)
3381 gotten
= read (trace_fd
, &block_type
, 1);
3383 perror_with_name (trace_filename
);
3384 else if (gotten
< 1)
3385 error (_("Premature end of file while reading trace file"));
3391 gotten
= read (trace_fd
, regs
, trace_regblock_size
);
3393 perror_with_name (trace_filename
);
3394 else if (gotten
< trace_regblock_size
)
3395 error (_("Premature end of file while reading trace file"));
3397 /* Assume the block is laid out in GDB register number order,
3398 each register with the size that it has in GDB. */
3400 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3402 regsize
= register_size (gdbarch
, regn
);
3403 /* Make sure we stay within block bounds. */
3404 if (offset
+ regsize
>= trace_regblock_size
)
3406 if (!regcache_valid_p (regcache
, regn
))
3410 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
3413 else if (regno
== -1)
3415 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
3422 lseek (trace_fd
, 8, SEEK_CUR
);
3423 gotten
= read (trace_fd
, &mlen
, 2);
3425 perror_with_name (trace_filename
);
3426 else if (gotten
< 2)
3427 error (_("Premature end of file while reading trace file"));
3428 lseek (trace_fd
, mlen
, SEEK_CUR
);
3429 pos
+= (8 + 2 + mlen
);
3432 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3436 error ("Unknown block type '%c' (0x%x) in trace frame",
3437 block_type
, block_type
);
3444 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3445 const char *annex
, gdb_byte
*readbuf
,
3446 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3451 unsigned short mlen
;
3453 /* We're only doing regular memory for now. */
3454 if (object
!= TARGET_OBJECT_MEMORY
)
3457 if (readbuf
== NULL
)
3458 error ("tfile_xfer_partial: trace file is read-only");
3460 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3462 while (pos
< cur_data_size
)
3464 gotten
= read (trace_fd
, &block_type
, 1);
3466 perror_with_name (trace_filename
);
3467 else if (gotten
< 1)
3468 error (_("Premature end of file while reading trace file"));
3473 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3474 pos
+= trace_regblock_size
;
3477 gotten
= read (trace_fd
, &maddr
, 8);
3479 perror_with_name (trace_filename
);
3480 else if (gotten
< 8)
3481 error (_("Premature end of file while reading trace file"));
3483 gotten
= read (trace_fd
, &mlen
, 2);
3485 perror_with_name (trace_filename
);
3486 else if (gotten
< 2)
3487 error (_("Premature end of file while reading trace file"));
3488 if (maddr
<= offset
&& (offset
+ len
) <= (maddr
+ mlen
))
3490 gotten
= read (trace_fd
, readbuf
, mlen
);
3492 perror_with_name (trace_filename
);
3493 else if (gotten
< mlen
)
3494 error (_("Premature end of file qwhile reading trace file"));
3498 lseek (trace_fd
, mlen
, SEEK_CUR
);
3499 pos
+= (8 + 2 + mlen
);
3502 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3506 error ("Unknown block type '%c' (0x%x) in traceframe",
3507 block_type
, block_type
);
3511 /* Indicate failure to find the requested memory block. */
3515 /* Iterate through the blocks of a trace frame, looking for a 'V'
3516 block with a matching tsv number. */
3519 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
3522 int pos
, vnum
, gotten
;
3523 unsigned short mlen
;
3525 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3527 while (pos
< cur_data_size
)
3529 gotten
= read (trace_fd
, &block_type
, 1);
3531 perror_with_name (trace_filename
);
3532 else if (gotten
< 1)
3533 error (_("Premature end of file while reading trace file"));
3538 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3539 pos
+= trace_regblock_size
;
3542 lseek (trace_fd
, 8, SEEK_CUR
);
3543 gotten
= read (trace_fd
, &mlen
, 2);
3545 perror_with_name (trace_filename
);
3546 else if (gotten
< 2)
3547 error (_("Premature end of file while reading trace file"));
3548 lseek (trace_fd
, mlen
, SEEK_CUR
);
3549 pos
+= (8 + 2 + mlen
);
3552 gotten
= read (trace_fd
, &vnum
, 4);
3554 perror_with_name (trace_filename
);
3555 else if (gotten
< 4)
3556 error (_("Premature end of file while reading trace file"));
3559 gotten
= read (trace_fd
, val
, 8);
3561 perror_with_name (trace_filename
);
3562 else if (gotten
< 8)
3563 error (_("Premature end of file while reading trace file"));
3566 lseek (trace_fd
, 8, SEEK_CUR
);
3570 error ("Unknown block type '%c' (0x%x) in traceframe",
3571 block_type
, block_type
);
3575 /* Didn't find anything. */
3580 tfile_has_memory (struct target_ops
*ops
)
3586 tfile_has_stack (struct target_ops
*ops
)
3592 tfile_has_registers (struct target_ops
*ops
)
3598 init_tfile_ops (void)
3600 tfile_ops
.to_shortname
= "tfile";
3601 tfile_ops
.to_longname
= "Local trace dump file";
3603 "Use a trace file as a target. Specify the filename of the trace file.";
3604 tfile_ops
.to_open
= tfile_open
;
3605 tfile_ops
.to_close
= tfile_close
;
3606 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
3607 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
3608 tfile_ops
.to_files_info
= tfile_files_info
;
3609 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
3610 tfile_ops
.to_trace_find
= tfile_trace_find
;
3611 tfile_ops
.to_get_trace_state_variable_value
= tfile_get_trace_state_variable_value
;
3612 /* core_stratum might seem more logical, but GDB doesn't like having
3613 more than one core_stratum vector. */
3614 tfile_ops
.to_stratum
= process_stratum
;
3615 tfile_ops
.to_has_memory
= tfile_has_memory
;
3616 tfile_ops
.to_has_stack
= tfile_has_stack
;
3617 tfile_ops
.to_has_registers
= tfile_has_registers
;
3618 tfile_ops
.to_magic
= OPS_MAGIC
;
3621 /* module initialization */
3623 _initialize_tracepoint (void)
3625 struct cmd_list_element
*c
;
3627 traceframe_number
= -1;
3628 tracepoint_number
= -1;
3630 if (tracepoint_list
.list
== NULL
)
3632 tracepoint_list
.listsize
= 128;
3633 tracepoint_list
.list
= xmalloc
3634 (tracepoint_list
.listsize
* sizeof (struct memrange
));
3636 if (tracepoint_list
.aexpr_list
== NULL
)
3638 tracepoint_list
.aexpr_listsize
= 128;
3639 tracepoint_list
.aexpr_list
= xmalloc
3640 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3643 if (stepping_list
.list
== NULL
)
3645 stepping_list
.listsize
= 128;
3646 stepping_list
.list
= xmalloc
3647 (stepping_list
.listsize
* sizeof (struct memrange
));
3650 if (stepping_list
.aexpr_list
== NULL
)
3652 stepping_list
.aexpr_listsize
= 128;
3653 stepping_list
.aexpr_list
= xmalloc
3654 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3657 add_info ("scope", scope_info
,
3658 _("List the variables local to a scope"));
3660 add_cmd ("tracepoints", class_trace
, NULL
,
3661 _("Tracing of program execution without stopping the program."),
3664 add_com ("tdump", class_trace
, trace_dump_command
,
3665 _("Print everything collected at the current tracepoint."));
3667 add_com ("tsave", class_trace
, trace_save_command
, _("\
3668 Save the trace data to a file.\n\
3669 Use the '-r' option to direct the target to save directly to the file,\n\
3670 using its own filesystem."));
3672 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
3673 Define a trace state variable.\n\
3674 Argument is a $-prefixed name, optionally followed\n\
3675 by '=' and an expression that sets the initial value\n\
3676 at the start of tracing."));
3677 set_cmd_completer (c
, expression_completer
);
3679 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
3680 Delete one or more trace state variables.\n\
3681 Arguments are the names of the variables to delete.\n\
3682 If no arguments are supplied, delete all variables."), &deletelist
);
3683 /* FIXME add a trace variable completer */
3685 add_info ("tvariables", tvariables_info
, _("\
3686 Status of trace state variables and their values.\n\
3689 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
3690 Select a trace frame;\n\
3691 No argument means forward by one frame; '-' means backward by one frame."),
3692 &tfindlist
, "tfind ", 1, &cmdlist
);
3694 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
3695 Select a trace frame whose PC is outside the given range (exclusive).\n\
3696 Usage: tfind outside addr1, addr2"),
3699 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
3700 Select a trace frame whose PC is in the given range (inclusive).\n\
3701 Usage: tfind range addr1,addr2"),
3704 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
3705 Select a trace frame by source line.\n\
3706 Argument can be a line number (with optional source file), \n\
3707 a function name, or '*' followed by an address.\n\
3708 Default argument is 'the next source line that was traced'."),
3711 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
3712 Select a trace frame by tracepoint number.\n\
3713 Default is the tracepoint for the current trace frame."),
3716 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
3717 Select a trace frame by PC.\n\
3718 Default is the current PC, or the PC of the current trace frame."),
3721 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
3722 Synonym for 'none'.\n\
3723 De-select any trace frame and resume 'live' debugging."),
3726 add_cmd ("none", class_trace
, trace_find_none_command
,
3727 _("De-select any trace frame and resume 'live' debugging."),
3730 add_cmd ("start", class_trace
, trace_find_start_command
,
3731 _("Select the first trace frame in the trace buffer."),
3734 add_com ("tstatus", class_trace
, trace_status_command
,
3735 _("Display the status of the current trace data collection."));
3737 add_com ("tstop", class_trace
, trace_stop_command
,
3738 _("Stop trace data collection."));
3740 add_com ("tstart", class_trace
, trace_start_command
,
3741 _("Start trace data collection."));
3743 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
3744 Ends a list of commands or actions.\n\
3745 Several GDB commands allow you to enter a list of commands or actions.\n\
3746 Entering \"end\" on a line by itself is the normal way to terminate\n\
3748 Note: the \"end\" command cannot be used at the gdb prompt."));
3750 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
3751 Specify single-stepping behavior at a tracepoint.\n\
3752 Argument is number of instructions to trace in single-step mode\n\
3753 following the tracepoint. This command is normally followed by\n\
3754 one or more \"collect\" commands, to specify what to collect\n\
3755 while single-stepping.\n\n\
3756 Note: this command can only be used in a tracepoint \"actions\" list."));
3758 add_com_alias ("ws", "while-stepping", class_alias
, 0);
3759 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
3761 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
3762 Specify one or more data items to be collected at a tracepoint.\n\
3763 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
3764 collect all data (variables, registers) referenced by that expression.\n\
3765 Also accepts the following special arguments:\n\
3766 $regs -- all registers.\n\
3767 $args -- all function arguments.\n\
3768 $locals -- all variables local to the block/function scope.\n\
3769 Note: this command can only be used in a tracepoint \"actions\" list."));
3771 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
3772 Specify one or more expressions to be evaluated at a tracepoint.\n\
3773 Accepts a comma-separated list of (one or more) expressions.\n\
3774 The result of each evaluation will be discarded.\n\
3775 Note: this command can only be used in a tracepoint \"actions\" list."));
3777 add_com ("actions", class_trace
, trace_actions_command
, _("\
3778 Specify the actions to be taken at a tracepoint.\n\
3779 Tracepoint actions may include collecting of specified data, \n\
3780 single-stepping, or enabling/disabling other tracepoints, \n\
3781 depending on target's capabilities."));
3783 default_collect
= xstrdup ("");
3784 add_setshow_string_cmd ("default-collect", class_trace
,
3785 &default_collect
, _("\
3786 Set the list of expressions to collect by default"), _("\
3787 Show the list of expressions to collect by default"), NULL
,
3789 &setlist
, &showlist
);
3791 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
3792 &disconnected_tracing
, _("\
3793 Set whether tracing continues after GDB disconnects."), _("\
3794 Show whether tracing continues after GDB disconnects."), _("\
3795 Use this to continue a tracing run even if GDB disconnects\n\
3796 or detaches from the target. You can reconnect later and look at\n\
3797 trace data collected in the meantime."),
3798 set_disconnected_tracing
,
3805 add_target (&tfile_ops
);