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
;
630 /* if EOF is typed, *line is NULL */
634 for (p
= *line
; isspace ((int) *p
);)
637 /* Symbol lookup etc. */
638 if (*p
== '\0') /* empty line: just prompt for another line. */
641 if (*p
== '#') /* comment line */
644 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
647 warning (_("'%s' is not an action that I know, or is ambiguous."),
652 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
654 struct agent_expr
*aexpr
;
655 struct agent_reqs areqs
;
658 { /* repeat over a comma-separated list */
659 QUIT
; /* allow user to bail out with ^C */
660 while (isspace ((int) *p
))
663 if (*p
== '$') /* look for special pseudo-symbols */
665 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
666 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
667 (0 == strncasecmp ("loc", p
+ 1, 3)))
672 /* else fall thru, treat p as an expression and parse it! */
674 exp
= parse_exp_1 (&p
, block_for_pc (t
->loc
->address
), 1);
675 old_chain
= make_cleanup (free_current_contents
, &exp
);
677 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
679 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
681 warning (_("constant %s (value %ld) will not be collected."),
682 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
683 SYMBOL_VALUE (exp
->elts
[2].symbol
));
686 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
688 warning (_("%s is optimized away and cannot be collected."),
689 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
694 /* We have something to collect, make sure that the expr to
695 bytecode translator can handle it and that it's not too
697 aexpr
= gen_trace_for_expr (t
->loc
->address
, exp
);
698 make_cleanup_free_agent_expr (aexpr
);
700 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
701 error (_("expression too complicated, try simplifying"));
703 ax_reqs (aexpr
, &areqs
);
704 (void) make_cleanup (xfree
, areqs
.reg_mask
);
706 if (areqs
.flaw
!= agent_flaw_none
)
707 error (_("malformed expression"));
709 if (areqs
.min_height
< 0)
710 error (_("gdb: Internal error: expression has min height < 0"));
712 if (areqs
.max_height
> 20)
713 error (_("expression too complicated, try simplifying"));
715 do_cleanups (old_chain
);
717 while (p
&& *p
++ == ',');
720 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
722 struct agent_expr
*aexpr
;
725 { /* repeat over a comma-separated list */
726 QUIT
; /* allow user to bail out with ^C */
727 while (isspace ((int) *p
))
730 /* Only expressions are allowed for this action. */
731 exp
= parse_exp_1 (&p
, block_for_pc (t
->loc
->address
), 1);
732 old_chain
= make_cleanup (free_current_contents
, &exp
);
734 /* We have something to evaluate, make sure that the expr to
735 bytecode translator can handle it and that it's not too
737 aexpr
= gen_eval_for_expr (t
->loc
->address
, exp
);
738 make_cleanup_free_agent_expr (aexpr
);
740 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
741 error (_("expression too complicated, try simplifying"));
743 do_cleanups (old_chain
);
745 while (p
&& *p
++ == ',');
748 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
750 char *steparg
; /* in case warning is necessary */
752 while (isspace ((int) *p
))
757 (t
->step_count
= strtol (p
, &p
, 0)) == 0)
759 warning (_("'%s': bad step-count; command ignored."), *line
);
764 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
768 warning (_("'%s' is not a supported tracepoint action."), *line
);
773 /* worker function */
775 free_actions (struct breakpoint
*t
)
777 struct action_line
*line
, *next
;
779 for (line
= t
->actions
; line
; line
= next
)
783 xfree (line
->action
);
790 do_free_actions_cleanup (void *t
)
795 static struct cleanup
*
796 make_cleanup_free_actions (struct breakpoint
*t
)
798 return make_cleanup (do_free_actions_cleanup
, t
);
802 memrange_absolute
= -1
807 int type
; /* memrange_absolute for absolute memory range,
808 else basereg number */
809 bfd_signed_vma start
;
813 struct collection_list
815 unsigned char regs_mask
[32]; /* room for up to 256 regs */
818 struct memrange
*list
;
819 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
821 struct agent_expr
**aexpr_list
;
824 tracepoint_list
, stepping_list
;
826 /* MEMRANGE functions: */
828 static int memrange_cmp (const void *, const void *);
830 /* compare memranges for qsort */
832 memrange_cmp (const void *va
, const void *vb
)
834 const struct memrange
*a
= va
, *b
= vb
;
836 if (a
->type
< b
->type
)
838 if (a
->type
> b
->type
)
840 if (a
->type
== memrange_absolute
)
842 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
844 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
849 if (a
->start
< b
->start
)
851 if (a
->start
> b
->start
)
857 /* Sort the memrange list using qsort, and merge adjacent memranges. */
859 memrange_sortmerge (struct collection_list
*memranges
)
863 qsort (memranges
->list
, memranges
->next_memrange
,
864 sizeof (struct memrange
), memrange_cmp
);
865 if (memranges
->next_memrange
> 0)
867 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
869 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
870 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
873 /* memrange b starts before memrange a ends; merge them. */
874 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
875 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
876 continue; /* next b, same a */
880 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
881 sizeof (struct memrange
));
883 memranges
->next_memrange
= a
+ 1;
887 /* Add a register to a collection list. */
889 add_register (struct collection_list
*collection
, unsigned int regno
)
892 printf_filtered ("collect register %d\n", regno
);
893 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
894 error (_("Internal: register number %d too large for tracepoint"),
896 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
899 /* Add a memrange to a collection list */
901 add_memrange (struct collection_list
*memranges
,
902 int type
, bfd_signed_vma base
,
907 printf_filtered ("(%d,", type
);
909 printf_filtered (",%ld)\n", len
);
912 /* type: memrange_absolute == memory, other n == basereg */
913 memranges
->list
[memranges
->next_memrange
].type
= type
;
914 /* base: addr if memory, offset if reg relative. */
915 memranges
->list
[memranges
->next_memrange
].start
= base
;
916 /* len: we actually save end (base + len) for convenience */
917 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
918 memranges
->next_memrange
++;
919 if (memranges
->next_memrange
>= memranges
->listsize
)
921 memranges
->listsize
*= 2;
922 memranges
->list
= xrealloc (memranges
->list
,
923 memranges
->listsize
);
926 if (type
!= memrange_absolute
) /* Better collect the base register! */
927 add_register (memranges
, type
);
930 /* Add a symbol to a collection list. */
932 collect_symbol (struct collection_list
*collect
,
934 struct gdbarch
*gdbarch
,
935 long frame_regno
, long frame_offset
,
940 bfd_signed_vma offset
;
942 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
943 switch (SYMBOL_CLASS (sym
))
946 printf_filtered ("%s: don't know symbol class %d\n",
947 SYMBOL_PRINT_NAME (sym
),
951 printf_filtered ("constant %s (value %ld) will not be collected.\n",
952 SYMBOL_PRINT_NAME (sym
), SYMBOL_VALUE (sym
));
955 offset
= SYMBOL_VALUE_ADDRESS (sym
);
960 sprintf_vma (tmp
, offset
);
961 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
962 SYMBOL_PRINT_NAME (sym
), len
,
965 add_memrange (collect
, memrange_absolute
, offset
, len
);
968 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
970 printf_filtered ("LOC_REG[parm] %s: ",
971 SYMBOL_PRINT_NAME (sym
));
972 add_register (collect
, reg
);
973 /* Check for doubles stored in two registers. */
974 /* FIXME: how about larger types stored in 3 or more regs? */
975 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
976 len
> register_size (gdbarch
, reg
))
977 add_register (collect
, reg
+ 1);
980 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
981 printf_filtered (" (will not collect %s)\n",
982 SYMBOL_PRINT_NAME (sym
));
986 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
989 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
990 SYMBOL_PRINT_NAME (sym
), len
);
992 printf_filtered (" from frame ptr reg %d\n", reg
);
994 add_memrange (collect
, reg
, offset
, len
);
996 case LOC_REGPARM_ADDR
:
997 reg
= SYMBOL_VALUE (sym
);
1001 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1002 SYMBOL_PRINT_NAME (sym
), len
);
1003 printf_vma (offset
);
1004 printf_filtered (" from reg %d\n", reg
);
1006 add_memrange (collect
, reg
, offset
, len
);
1010 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1013 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1014 SYMBOL_PRINT_NAME (sym
), len
);
1015 printf_vma (offset
);
1016 printf_filtered (" from frame ptr reg %d\n", reg
);
1018 add_memrange (collect
, reg
, offset
, len
);
1020 case LOC_UNRESOLVED
:
1021 printf_filtered ("Don't know LOC_UNRESOLVED %s\n",
1022 SYMBOL_PRINT_NAME (sym
));
1024 case LOC_OPTIMIZED_OUT
:
1025 printf_filtered ("%s has been optimized out of existence.\n",
1026 SYMBOL_PRINT_NAME (sym
));
1031 struct agent_expr
*aexpr
;
1032 struct cleanup
*old_chain1
= NULL
;
1033 struct agent_reqs areqs
;
1035 aexpr
= gen_trace_for_var (scope
, sym
);
1037 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1039 ax_reqs (aexpr
, &areqs
);
1040 if (areqs
.flaw
!= agent_flaw_none
)
1041 error (_("malformed expression"));
1043 if (areqs
.min_height
< 0)
1044 error (_("gdb: Internal error: expression has min height < 0"));
1045 if (areqs
.max_height
> 20)
1046 error (_("expression too complicated, try simplifying"));
1048 discard_cleanups (old_chain1
);
1049 add_aexpr (collect
, aexpr
);
1051 /* take care of the registers */
1052 if (areqs
.reg_mask_len
> 0)
1056 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1058 QUIT
; /* allow user to bail out with ^C */
1059 if (areqs
.reg_mask
[ndx1
] != 0)
1061 /* assume chars have 8 bits */
1062 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1063 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1064 /* it's used -- record it */
1065 add_register (collect
,
1075 /* Add all locals (or args) symbols to collection list */
1077 add_local_symbols (struct collection_list
*collect
,
1078 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1079 long frame_regno
, long frame_offset
, int type
)
1082 struct block
*block
;
1083 struct dict_iterator iter
;
1086 block
= block_for_pc (pc
);
1089 QUIT
; /* allow user to bail out with ^C */
1090 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
1092 if (SYMBOL_IS_ARGUMENT (sym
)
1093 ? type
== 'A' /* collecting Arguments */
1094 : type
== 'L') /* collecting Locals */
1097 collect_symbol (collect
, sym
, gdbarch
,
1098 frame_regno
, frame_offset
, pc
);
1101 if (BLOCK_FUNCTION (block
))
1104 block
= BLOCK_SUPERBLOCK (block
);
1107 warning (_("No %s found in scope."),
1108 type
== 'L' ? "locals" : "args");
1111 /* worker function */
1113 clear_collection_list (struct collection_list
*list
)
1117 list
->next_memrange
= 0;
1118 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1120 free_agent_expr (list
->aexpr_list
[ndx
]);
1121 list
->aexpr_list
[ndx
] = NULL
;
1123 list
->next_aexpr_elt
= 0;
1124 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1127 /* reduce a collection list to string form (for gdb protocol) */
1129 stringify_collection_list (struct collection_list
*list
, char *string
)
1131 char temp_buf
[2048];
1135 char *(*str_list
)[];
1139 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1140 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1142 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1143 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1145 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1148 printf_filtered ("\nCollecting registers (mask): 0x");
1153 QUIT
; /* allow user to bail out with ^C */
1155 printf_filtered ("%02X", list
->regs_mask
[i
]);
1156 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1159 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1163 printf_filtered ("\n");
1164 if (list
->next_memrange
> 0 && info_verbose
)
1165 printf_filtered ("Collecting memranges: \n");
1166 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1168 QUIT
; /* allow user to bail out with ^C */
1169 sprintf_vma (tmp2
, list
->list
[i
].start
);
1172 printf_filtered ("(%d, %s, %ld)\n",
1175 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1177 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1179 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1186 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1188 /* The "%X" conversion specifier expects an unsigned argument,
1189 so passing -1 (memrange_absolute) to it directly gives you
1190 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1192 if (list
->list
[i
].type
== memrange_absolute
)
1193 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1195 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1198 count
+= strlen (end
);
1199 end
= temp_buf
+ count
;
1202 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1204 QUIT
; /* allow user to bail out with ^C */
1205 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1207 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1212 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1213 end
+= 10; /* 'X' + 8 hex digits + ',' */
1216 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1217 end
, list
->aexpr_list
[i
]->len
);
1218 count
+= 2 * list
->aexpr_list
[i
]->len
;
1223 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1228 (*str_list
)[ndx
] = NULL
;
1239 /* Render all actions into gdb protocol. */
1241 encode_actions (struct breakpoint
*t
, char ***tdp_actions
,
1242 char ***stepping_actions
)
1244 static char tdp_buff
[2048], step_buff
[2048];
1246 struct expression
*exp
= NULL
;
1247 struct action_line
*action
;
1249 struct value
*tempval
;
1250 struct collection_list
*collect
;
1251 struct cmd_list_element
*cmd
;
1252 struct agent_expr
*aexpr
;
1254 LONGEST frame_offset
;
1255 char *default_collect_line
= NULL
;
1256 struct action_line
*default_collect_action
= NULL
;
1258 clear_collection_list (&tracepoint_list
);
1259 clear_collection_list (&stepping_list
);
1260 collect
= &tracepoint_list
;
1262 *tdp_actions
= NULL
;
1263 *stepping_actions
= NULL
;
1265 gdbarch_virtual_frame_pointer (t
->gdbarch
,
1266 t
->loc
->address
, &frame_reg
, &frame_offset
);
1268 action
= t
->actions
;
1270 /* If there are default expressions to collect, make up a collect
1271 action and prepend to the action list to encode. Note that since
1272 validation is per-tracepoint (local var "xyz" might be valid for
1273 one tracepoint and not another, etc), we make up the action on
1274 the fly, and don't cache it. */
1275 if (*default_collect
)
1278 enum actionline_type linetype
;
1280 default_collect_line
= xmalloc (12 + strlen (default_collect
));
1281 sprintf (default_collect_line
, "collect %s", default_collect
);
1282 line
= default_collect_line
;
1283 linetype
= validate_actionline (&line
, t
);
1284 if (linetype
!= BADLINE
)
1286 default_collect_action
= xmalloc (sizeof (struct action_line
));
1287 default_collect_action
->next
= t
->actions
;
1288 default_collect_action
->action
= line
;
1289 action
= default_collect_action
;
1293 for (; action
; action
= action
->next
)
1295 QUIT
; /* allow user to bail out with ^C */
1296 action_exp
= action
->action
;
1297 while (isspace ((int) *action_exp
))
1300 if (*action_exp
== '#') /* comment line */
1303 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1305 error (_("Bad action list item: %s"), action_exp
);
1307 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1310 { /* repeat over a comma-separated list */
1311 QUIT
; /* allow user to bail out with ^C */
1312 while (isspace ((int) *action_exp
))
1315 if (0 == strncasecmp ("$reg", action_exp
, 4))
1317 for (i
= 0; i
< gdbarch_num_regs (t
->gdbarch
); i
++)
1318 add_register (collect
, i
);
1319 action_exp
= strchr (action_exp
, ','); /* more? */
1321 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1323 add_local_symbols (collect
,
1329 action_exp
= strchr (action_exp
, ','); /* more? */
1331 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1333 add_local_symbols (collect
,
1339 action_exp
= strchr (action_exp
, ','); /* more? */
1343 unsigned long addr
, len
;
1344 struct cleanup
*old_chain
= NULL
;
1345 struct cleanup
*old_chain1
= NULL
;
1346 struct agent_reqs areqs
;
1348 exp
= parse_exp_1 (&action_exp
,
1349 block_for_pc (t
->loc
->address
), 1);
1350 old_chain
= make_cleanup (free_current_contents
, &exp
);
1352 switch (exp
->elts
[0].opcode
)
1356 const char *name
= &exp
->elts
[2].string
;
1358 i
= user_reg_map_name_to_regnum (t
->gdbarch
,
1359 name
, strlen (name
));
1361 internal_error (__FILE__
, __LINE__
,
1362 _("Register $%s not available"),
1365 printf_filtered ("OP_REGISTER: ");
1366 add_register (collect
, i
);
1371 /* safe because we know it's a simple expression */
1372 tempval
= evaluate_expression (exp
);
1373 addr
= value_address (tempval
);
1374 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1375 add_memrange (collect
, memrange_absolute
, addr
, len
);
1379 collect_symbol (collect
,
1380 exp
->elts
[2].symbol
,
1387 default: /* full-fledged expression */
1388 aexpr
= gen_trace_for_expr (t
->loc
->address
, exp
);
1390 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1392 ax_reqs (aexpr
, &areqs
);
1393 if (areqs
.flaw
!= agent_flaw_none
)
1394 error (_("malformed expression"));
1396 if (areqs
.min_height
< 0)
1397 error (_("gdb: Internal error: expression has min height < 0"));
1398 if (areqs
.max_height
> 20)
1399 error (_("expression too complicated, try simplifying"));
1401 discard_cleanups (old_chain1
);
1402 add_aexpr (collect
, aexpr
);
1404 /* take care of the registers */
1405 if (areqs
.reg_mask_len
> 0)
1410 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1412 QUIT
; /* allow user to bail out with ^C */
1413 if (areqs
.reg_mask
[ndx1
] != 0)
1415 /* assume chars have 8 bits */
1416 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1417 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1418 /* it's used -- record it */
1419 add_register (collect
,
1426 do_cleanups (old_chain
);
1429 while (action_exp
&& *action_exp
++ == ',');
1431 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1434 { /* repeat over a comma-separated list */
1435 QUIT
; /* allow user to bail out with ^C */
1436 while (isspace ((int) *action_exp
))
1440 unsigned long addr
, len
;
1441 struct cleanup
*old_chain
= NULL
;
1442 struct cleanup
*old_chain1
= NULL
;
1443 struct agent_reqs areqs
;
1445 exp
= parse_exp_1 (&action_exp
,
1446 block_for_pc (t
->loc
->address
), 1);
1447 old_chain
= make_cleanup (free_current_contents
, &exp
);
1449 aexpr
= gen_eval_for_expr (t
->loc
->address
, exp
);
1450 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1452 ax_reqs (aexpr
, &areqs
);
1453 if (areqs
.flaw
!= agent_flaw_none
)
1454 error (_("malformed expression"));
1456 if (areqs
.min_height
< 0)
1457 error (_("gdb: Internal error: expression has min height < 0"));
1458 if (areqs
.max_height
> 20)
1459 error (_("expression too complicated, try simplifying"));
1461 discard_cleanups (old_chain1
);
1462 /* Even though we're not officially collecting, add
1463 to the collect list anyway. */
1464 add_aexpr (collect
, aexpr
);
1466 do_cleanups (old_chain
);
1469 while (action_exp
&& *action_exp
++ == ',');
1471 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1473 collect
= &stepping_list
;
1475 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
1477 if (collect
== &stepping_list
) /* end stepping actions */
1478 collect
= &tracepoint_list
;
1480 break; /* end tracepoint actions */
1483 memrange_sortmerge (&tracepoint_list
);
1484 memrange_sortmerge (&stepping_list
);
1486 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1488 *stepping_actions
= stringify_collection_list (&stepping_list
,
1491 xfree (default_collect_line
);
1492 xfree (default_collect_action
);
1496 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1498 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1500 collect
->aexpr_list
=
1501 xrealloc (collect
->aexpr_list
,
1502 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1503 collect
->aexpr_listsize
*= 2;
1505 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1506 collect
->next_aexpr_elt
++;
1511 Tell target to clear any previous trace experiment.
1512 Walk the list of tracepoints, and send them (and their actions)
1513 to the target. If no errors,
1514 Tell target to start a new trace experiment. */
1517 trace_start_command (char *args
, int from_tty
)
1520 VEC(breakpoint_p
) *tp_vec
= NULL
;
1522 struct breakpoint
*t
;
1523 struct trace_state_variable
*tsv
;
1524 int any_downloaded
= 0;
1526 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1528 target_trace_init ();
1530 tp_vec
= all_tracepoints ();
1531 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1533 t
->number_on_target
= 0;
1534 target_download_tracepoint (t
);
1535 t
->number_on_target
= t
->number
;
1538 VEC_free (breakpoint_p
, tp_vec
);
1540 /* No point in tracing without any tracepoints... */
1541 if (!any_downloaded
)
1542 error ("No tracepoints downloaded, not starting trace");
1544 /* Send down all the trace state variables too. */
1545 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1547 target_download_trace_state_variable (tsv
);
1550 /* Tell target to treat text-like sections as transparent. */
1551 target_trace_set_readonly_regions ();
1553 /* Now insert traps and begin collecting data. */
1554 target_trace_start ();
1556 /* Reset our local state. */
1557 set_traceframe_num (-1);
1558 set_tracepoint_num (-1);
1559 set_traceframe_context (NULL
);
1560 current_trace_status()->running
= 1;
1565 trace_stop_command (char *args
, int from_tty
)
1573 target_trace_stop ();
1574 /* should change in response to reply? */
1575 current_trace_status ()->running
= 0;
1578 /* tstatus command */
1580 trace_status_command (char *args
, int from_tty
)
1582 struct trace_status
*ts
= current_trace_status ();
1585 status
= target_get_trace_status (ts
);
1590 printf_filtered (_("Using a trace file.\n"));
1593 printf_filtered (_("Trace can not be run on this target.\n"));
1598 if (!ts
->running_known
)
1600 printf_filtered (_("Run/stop status is unknown.\n"));
1602 else if (ts
->running
)
1604 printf_filtered (_("Trace is running on the target.\n"));
1605 if (disconnected_tracing
)
1606 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1608 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1612 switch (ts
->stop_reason
)
1614 case trace_never_run
:
1615 printf_filtered (_("No trace has been run on the target.\n"));
1618 printf_filtered (_("Trace stopped by a tstop command.\n"));
1620 case trace_buffer_full
:
1621 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1623 case trace_disconnected
:
1624 printf_filtered (_("Trace stopped because of disconnection.\n"));
1626 case tracepoint_passcount
:
1627 /* FIXME account for number on target */
1628 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1629 ts
->stopping_tracepoint
);
1631 case trace_stop_reason_unknown
:
1632 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1635 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1641 if (ts
->traceframe_count
>= 0)
1643 printf_filtered (_("Collected %d trace frames.\n"),
1644 ts
->traceframe_count
);
1647 if (ts
->buffer_free
)
1649 printf_filtered (_("Trace buffer has %llu bytes free.\n"),
1653 /* Now report on what we're doing with tfind. */
1654 if (traceframe_number
>= 0)
1655 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1656 traceframe_number
, tracepoint_number
);
1658 printf_filtered (_("Not looking at any trace frame.\n"));
1662 disconnect_or_stop_tracing (int from_tty
)
1664 /* It can happen that the target that was tracing went away on its
1665 own, and we didn't notice. Get a status update, and if the
1666 current target doesn't even do tracing, then assume it's not
1668 if (target_get_trace_status (current_trace_status ()) < 0)
1669 current_trace_status ()->running
= 0;
1671 if (current_trace_status ()->running
&& from_tty
)
1673 int cont
= query (_("Trace is running. Continue tracing after detach? "));
1674 /* Note that we send the query result without affecting the
1675 user's setting of disconnected_tracing, so that the answer is
1677 send_disconnected_tracing_value (cont
);
1679 /* Also ensure that we do the equivalent of a tstop command if
1680 tracing is not to continue after the detach. */
1686 /* Worker function for the various flavors of the tfind command. */
1688 finish_tfind_command (enum trace_find_type type
, int num
,
1689 ULONGEST addr1
, ULONGEST addr2
,
1692 int target_frameno
= -1, target_tracept
= -1;
1693 struct frame_id old_frame_id
;
1695 struct breakpoint
*tp
;
1697 old_frame_id
= get_frame_id (get_current_frame ());
1699 target_frameno
= target_trace_find (type
, num
, addr1
, addr2
,
1702 if (type
== tfind_number
1704 && target_frameno
== -1)
1706 /* We told the target to get out of tfind mode, and it did. */
1708 else if (target_frameno
== -1)
1710 /* A request for a non-existant trace frame has failed.
1711 Our response will be different, depending on FROM_TTY:
1713 If FROM_TTY is true, meaning that this command was
1714 typed interactively by the user, then give an error
1715 and DO NOT change the state of traceframe_number etc.
1717 However if FROM_TTY is false, meaning that we're either
1718 in a script, a loop, or a user-defined command, then
1719 DON'T give an error, but DO change the state of
1720 traceframe_number etc. to invalid.
1722 The rationalle is that if you typed the command, you
1723 might just have committed a typo or something, and you'd
1724 like to NOT lose your current debugging state. However
1725 if you're in a user-defined command or especially in a
1726 loop, then you need a way to detect that the command
1727 failed WITHOUT aborting. This allows you to write
1728 scripts that search thru the trace buffer until the end,
1729 and then continue on to do something else. */
1732 error (_("Target failed to find requested trace frame."));
1736 printf_filtered ("End of trace buffer.\n");
1737 #if 0 /* dubious now? */
1738 /* The following will not recurse, since it's
1740 trace_find_command ("-1", from_tty
);
1745 tp
= get_tracepoint_by_number_on_target (target_tracept
);
1747 reinit_frame_cache ();
1748 registers_changed ();
1749 set_traceframe_num (target_frameno
);
1750 set_tracepoint_num (tp
? tp
->number
: target_tracept
);
1751 if (target_frameno
== -1)
1752 set_traceframe_context (NULL
);
1754 set_traceframe_context (get_current_frame ());
1756 /* If we're in nonstop mode and getting out of looking at trace
1757 frames, there won't be any current frame to go back to and
1760 && (has_stack_frames () || traceframe_number
>= 0))
1762 enum print_what print_what
;
1764 /* NOTE: in immitation of the step command, try to determine
1765 whether we have made a transition from one function to
1766 another. If so, we'll print the "stack frame" (ie. the new
1767 function and it's arguments) -- otherwise we'll just show the
1770 if (frame_id_eq (old_frame_id
,
1771 get_frame_id (get_current_frame ())))
1772 print_what
= SRC_LINE
;
1774 print_what
= SRC_AND_LOC
;
1776 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
1781 /* trace_find_command takes a trace frame number n,
1782 sends "QTFrame:<n>" to the target,
1783 and accepts a reply that may contain several optional pieces
1784 of information: a frame number, a tracepoint number, and an
1785 indication of whether this is a trap frame or a stepping frame.
1787 The minimal response is just "OK" (which indicates that the
1788 target does not give us a frame number or a tracepoint number).
1789 Instead of that, the target may send us a string containing
1791 F<hexnum> (gives the selected frame number)
1792 T<hexnum> (gives the selected tracepoint number)
1797 trace_find_command (char *args
, int from_tty
)
1798 { /* this should only be called with a numeric argument */
1801 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1802 error ("May not look at trace frames while trace is running.");
1804 if (args
== 0 || *args
== 0)
1805 { /* TFIND with no args means find NEXT trace frame. */
1806 if (traceframe_number
== -1)
1807 frameno
= 0; /* "next" is first one */
1809 frameno
= traceframe_number
+ 1;
1811 else if (0 == strcmp (args
, "-"))
1813 if (traceframe_number
== -1)
1814 error (_("not debugging trace buffer"));
1815 else if (from_tty
&& traceframe_number
== 0)
1816 error (_("already at start of trace buffer"));
1818 frameno
= traceframe_number
- 1;
1820 /* A hack to work around eval's need for fp to have been collected. */
1821 else if (0 == strcmp (args
, "-1"))
1824 frameno
= parse_and_eval_long (args
);
1827 error (_("invalid input (%d is less than zero)"), frameno
);
1829 finish_tfind_command (tfind_number
, frameno
, 0, 0, from_tty
);
1834 trace_find_end_command (char *args
, int from_tty
)
1836 trace_find_command ("-1", from_tty
);
1841 trace_find_none_command (char *args
, int from_tty
)
1843 trace_find_command ("-1", from_tty
);
1848 trace_find_start_command (char *args
, int from_tty
)
1850 trace_find_command ("0", from_tty
);
1853 /* tfind pc command */
1855 trace_find_pc_command (char *args
, int from_tty
)
1860 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1861 error ("May not look at trace frames while trace is running.");
1863 if (args
== 0 || *args
== 0)
1864 pc
= regcache_read_pc (get_current_regcache ());
1866 pc
= parse_and_eval_address (args
);
1868 finish_tfind_command (tfind_pc
, 0, pc
, 0, from_tty
);
1871 /* tfind tracepoint command */
1873 trace_find_tracepoint_command (char *args
, int from_tty
)
1876 struct breakpoint
*tp
;
1878 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1879 error ("May not look at trace frames while trace is running.");
1881 if (args
== 0 || *args
== 0)
1883 if (tracepoint_number
== -1)
1884 error (_("No current tracepoint -- please supply an argument."));
1886 tdp
= tracepoint_number
; /* default is current TDP */
1889 tdp
= parse_and_eval_long (args
);
1891 /* If we have the tracepoint on hand, use the number that the
1892 target knows about (which may be different if we disconnected
1893 and reconnected). */
1894 tp
= get_tracepoint (tdp
);
1896 tdp
= tp
->number_on_target
;
1898 finish_tfind_command (tfind_tp
, tdp
, 0, 0, from_tty
);
1901 /* TFIND LINE command:
1903 This command will take a sourceline for argument, just like BREAK
1904 or TRACE (ie. anything that "decode_line_1" can handle).
1906 With no argument, this command will find the next trace frame
1907 corresponding to a source line OTHER THAN THE CURRENT ONE. */
1910 trace_find_line_command (char *args
, int from_tty
)
1912 static CORE_ADDR start_pc
, end_pc
;
1913 struct symtabs_and_lines sals
;
1914 struct symtab_and_line sal
;
1915 struct cleanup
*old_chain
;
1916 char startpc_str
[40], endpc_str
[40];
1918 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
1919 error ("May not look at trace frames while trace is running.");
1921 if (args
== 0 || *args
== 0)
1923 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
1925 sals
.sals
= (struct symtab_and_line
*)
1926 xmalloc (sizeof (struct symtab_and_line
));
1931 sals
= decode_line_spec (args
, 1);
1935 old_chain
= make_cleanup (xfree
, sals
.sals
);
1936 if (sal
.symtab
== 0)
1938 printf_filtered ("TFIND: No line number information available");
1941 /* This is useful for "info line *0x7f34". If we can't
1942 tell the user about a source line, at least let them
1943 have the symbolic address. */
1944 printf_filtered (" for address ");
1946 print_address (get_current_arch (), sal
.pc
, gdb_stdout
);
1947 printf_filtered (";\n -- will attempt to find by PC. \n");
1951 printf_filtered (".\n");
1952 return; /* No line, no PC; what can we do? */
1955 else if (sal
.line
> 0
1956 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
1958 if (start_pc
== end_pc
)
1960 printf_filtered ("Line %d of \"%s\"",
1961 sal
.line
, sal
.symtab
->filename
);
1963 printf_filtered (" is at address ");
1964 print_address (get_current_arch (), start_pc
, gdb_stdout
);
1966 printf_filtered (" but contains no code.\n");
1967 sal
= find_pc_line (start_pc
, 0);
1969 && find_line_pc_range (sal
, &start_pc
, &end_pc
)
1970 && start_pc
!= end_pc
)
1971 printf_filtered ("Attempting to find line %d instead.\n",
1974 error (_("Cannot find a good line."));
1978 /* Is there any case in which we get here, and have an address
1979 which the user would want to see? If we have debugging
1980 symbols and no line numbers? */
1981 error (_("Line number %d is out of range for \"%s\"."),
1982 sal
.line
, sal
.symtab
->filename
);
1984 /* Find within range of stated line. */
1986 finish_tfind_command (tfind_range
, 0, start_pc
, end_pc
- 1, from_tty
);
1988 finish_tfind_command (tfind_outside
, 0, start_pc
, end_pc
- 1, from_tty
);
1989 do_cleanups (old_chain
);
1992 /* tfind range command */
1994 trace_find_range_command (char *args
, int from_tty
)
1996 static CORE_ADDR start
, stop
;
1997 char start_str
[40], stop_str
[40];
2000 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2001 error ("May not look at trace frames while trace is running.");
2003 if (args
== 0 || *args
== 0)
2004 { /* XXX FIXME: what should default behavior be? */
2005 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2009 if (0 != (tmp
= strchr (args
, ',')))
2011 *tmp
++ = '\0'; /* terminate start address */
2012 while (isspace ((int) *tmp
))
2014 start
= parse_and_eval_address (args
);
2015 stop
= parse_and_eval_address (tmp
);
2018 { /* no explicit end address? */
2019 start
= parse_and_eval_address (args
);
2020 stop
= start
+ 1; /* ??? */
2023 finish_tfind_command (tfind_range
, 0, start
, stop
, from_tty
);
2026 /* tfind outside command */
2028 trace_find_outside_command (char *args
, int from_tty
)
2030 CORE_ADDR start
, stop
;
2031 char start_str
[40], stop_str
[40];
2034 if (current_trace_status ()->running
&& !current_trace_status ()->from_file
)
2035 error ("May not look at trace frames while trace is running.");
2037 if (args
== 0 || *args
== 0)
2038 { /* XXX FIXME: what should default behavior be? */
2039 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2043 if (0 != (tmp
= strchr (args
, ',')))
2045 *tmp
++ = '\0'; /* terminate start address */
2046 while (isspace ((int) *tmp
))
2048 start
= parse_and_eval_address (args
);
2049 stop
= parse_and_eval_address (tmp
);
2052 { /* no explicit end address? */
2053 start
= parse_and_eval_address (args
);
2054 stop
= start
+ 1; /* ??? */
2057 finish_tfind_command (tfind_outside
, 0, start
, stop
, from_tty
);
2060 /* info scope command: list the locals for a scope. */
2062 scope_info (char *args
, int from_tty
)
2064 struct symtabs_and_lines sals
;
2066 struct minimal_symbol
*msym
;
2067 struct block
*block
;
2068 char **canonical
, *symname
, *save_args
= args
;
2069 struct dict_iterator iter
;
2071 struct gdbarch
*gdbarch
;
2074 if (args
== 0 || *args
== 0)
2075 error (_("requires an argument (function, line or *addr) to define a scope"));
2077 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2078 if (sals
.nelts
== 0)
2079 return; /* presumably decode_line_1 has already warned */
2081 /* Resolve line numbers to PC */
2082 resolve_sal_pc (&sals
.sals
[0]);
2083 block
= block_for_pc (sals
.sals
[0].pc
);
2087 QUIT
; /* allow user to bail out with ^C */
2088 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2090 QUIT
; /* allow user to bail out with ^C */
2092 printf_filtered ("Scope for %s:\n", save_args
);
2095 symname
= SYMBOL_PRINT_NAME (sym
);
2096 if (symname
== NULL
|| *symname
== '\0')
2097 continue; /* probably botched, certainly useless */
2099 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2101 printf_filtered ("Symbol %s is ", symname
);
2102 switch (SYMBOL_CLASS (sym
))
2105 case LOC_UNDEF
: /* messed up symbol? */
2106 printf_filtered ("a bogus symbol, class %d.\n",
2107 SYMBOL_CLASS (sym
));
2108 count
--; /* don't count this one */
2111 printf_filtered ("a constant with value %ld (0x%lx)",
2112 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2114 case LOC_CONST_BYTES
:
2115 printf_filtered ("constant bytes: ");
2116 if (SYMBOL_TYPE (sym
))
2117 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2118 fprintf_filtered (gdb_stdout
, " %02x",
2119 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2122 printf_filtered ("in static storage at address ");
2123 printf_filtered ("%s", paddress (gdbarch
,
2124 SYMBOL_VALUE_ADDRESS (sym
)));
2127 /* GDBARCH is the architecture associated with the objfile
2128 the symbol is defined in; the target architecture may be
2129 different, and may provide additional registers. However,
2130 we do not know the target architecture at this point.
2131 We assume the objfile architecture will contain all the
2132 standard registers that occur in debug info in that
2134 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2136 if (SYMBOL_IS_ARGUMENT (sym
))
2137 printf_filtered ("an argument in register $%s",
2138 gdbarch_register_name (gdbarch
, regno
));
2140 printf_filtered ("a local variable in register $%s",
2141 gdbarch_register_name (gdbarch
, regno
));
2144 printf_filtered ("an argument at stack/frame offset %ld",
2145 SYMBOL_VALUE (sym
));
2148 printf_filtered ("a local variable at frame offset %ld",
2149 SYMBOL_VALUE (sym
));
2152 printf_filtered ("a reference argument at offset %ld",
2153 SYMBOL_VALUE (sym
));
2155 case LOC_REGPARM_ADDR
:
2156 /* Note comment at LOC_REGISTER. */
2157 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2158 printf_filtered ("the address of an argument, in register $%s",
2159 gdbarch_register_name (gdbarch
, regno
));
2162 printf_filtered ("a typedef.\n");
2165 printf_filtered ("a label at address ");
2166 printf_filtered ("%s", paddress (gdbarch
,
2167 SYMBOL_VALUE_ADDRESS (sym
)));
2170 printf_filtered ("a function at address ");
2171 printf_filtered ("%s",
2172 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2174 case LOC_UNRESOLVED
:
2175 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2178 printf_filtered ("Unresolved Static");
2181 printf_filtered ("static storage at address ");
2182 printf_filtered ("%s",
2183 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2186 case LOC_OPTIMIZED_OUT
:
2187 printf_filtered ("optimized out.\n");
2190 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, gdb_stdout
);
2193 if (SYMBOL_TYPE (sym
))
2194 printf_filtered (", length %d.\n",
2195 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2197 if (BLOCK_FUNCTION (block
))
2200 block
= BLOCK_SUPERBLOCK (block
);
2203 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2207 /* worker function (cleanup) */
2209 replace_comma (void *data
)
2217 trace_dump_command (char *args
, int from_tty
)
2219 struct regcache
*regcache
;
2220 struct gdbarch
*gdbarch
;
2221 struct breakpoint
*t
;
2222 struct action_line
*action
;
2223 char *action_exp
, *next_comma
;
2224 struct cleanup
*old_cleanups
;
2225 int stepping_actions
= 0;
2226 int stepping_frame
= 0;
2228 if (tracepoint_number
== -1)
2230 warning (_("No current trace frame."));
2234 t
= get_tracepoint (tracepoint_number
);
2237 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2240 old_cleanups
= make_cleanup (null_cleanup
, NULL
);
2242 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2243 tracepoint_number
, traceframe_number
);
2245 /* The current frame is a trap frame if the frame PC is equal
2246 to the tracepoint PC. If not, then the current frame was
2247 collected during single-stepping. */
2249 regcache
= get_current_regcache ();
2250 gdbarch
= get_regcache_arch (regcache
);
2252 stepping_frame
= (t
->loc
->address
!= (regcache_read_pc (regcache
)));
2254 for (action
= t
->actions
; action
; action
= action
->next
)
2256 struct cmd_list_element
*cmd
;
2258 QUIT
; /* allow user to bail out with ^C */
2259 action_exp
= action
->action
;
2260 while (isspace ((int) *action_exp
))
2263 /* The collection actions to be done while stepping are
2264 bracketed by the commands "while-stepping" and "end". */
2266 if (*action_exp
== '#') /* comment line */
2269 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2271 error (_("Bad action list item: %s"), action_exp
);
2273 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2274 stepping_actions
= 1;
2275 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2276 stepping_actions
= 0;
2277 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2279 /* Display the collected data.
2280 For the trap frame, display only what was collected at
2281 the trap. Likewise for stepping frames, display only
2282 what was collected while stepping. This means that the
2283 two boolean variables, STEPPING_FRAME and
2284 STEPPING_ACTIONS should be equal. */
2285 if (stepping_frame
== stepping_actions
)
2288 { /* repeat over a comma-separated list */
2289 QUIT
; /* allow user to bail out with ^C */
2290 if (*action_exp
== ',')
2292 while (isspace ((int) *action_exp
))
2295 next_comma
= strchr (action_exp
, ',');
2297 if (0 == strncasecmp (action_exp
, "$reg", 4))
2298 registers_info (NULL
, from_tty
);
2299 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2300 locals_info (NULL
, from_tty
);
2301 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2302 args_info (NULL
, from_tty
);
2307 make_cleanup (replace_comma
, next_comma
);
2310 printf_filtered ("%s = ", action_exp
);
2311 output_command (action_exp
, from_tty
);
2312 printf_filtered ("\n");
2316 action_exp
= next_comma
;
2318 while (action_exp
&& *action_exp
== ',');
2322 discard_cleanups (old_cleanups
);
2325 extern int trace_regblock_size
;
2328 trace_save_command (char *args
, int from_tty
)
2331 char *filename
= NULL
, *pathname
;
2332 int target_does_save
= 0;
2333 struct cleanup
*cleanup
;
2334 struct trace_status
*ts
= current_trace_status ();
2337 struct uploaded_tp
*uploaded_tps
= NULL
, *utp
;
2338 struct uploaded_tsv
*uploaded_tsvs
= NULL
, *utsv
;
2341 ULONGEST offset
= 0;
2342 #define MAX_TRACE_UPLOAD 2000
2343 gdb_byte buf
[MAX_TRACE_UPLOAD
];
2347 error_no_arg (_("file in which to save trace data"));
2349 argv
= gdb_buildargv (args
);
2350 make_cleanup_freeargv (argv
);
2352 for (; *argv
; ++argv
)
2354 if (strcmp (*argv
, "-r") == 0)
2355 target_does_save
= 1;
2356 else if (**argv
== '-')
2357 error (_("unknown option `%s'"), *argv
);
2363 error_no_arg (_("file in which to save trace data"));
2365 /* If the target is to save the data to a file on its own, then just
2366 send the command and be done with it. */
2367 if (target_does_save
)
2369 err
= target_save_trace_data (filename
);
2371 error (_("Target failed to save trace data to '%s'."),
2376 /* Get the trace status first before opening the file, so if the
2377 target is losing, we can get out without touching files. */
2378 status
= target_get_trace_status (ts
);
2380 pathname
= tilde_expand (args
);
2381 cleanup
= make_cleanup (xfree
, pathname
);
2383 fp
= fopen (pathname
, "w");
2385 error (_("Unable to open file '%s' for saving trace data (%s)"),
2386 args
, safe_strerror (errno
));
2387 make_cleanup_fclose (fp
);
2389 /* Write a file header, with a high-bit-set char to indicate a
2390 binary file, plus a hint as what this file is, and a version
2391 number in case of future needs. */
2392 written
= fwrite ("\x7fTRACE0\n", 8, 1, fp
);
2394 perror_with_name (pathname
);
2396 /* Write descriptive info. */
2398 /* Write out the size of a register block. */
2399 fprintf (fp
, "R %x\n", trace_regblock_size
);
2401 /* Write out status of the tracing run (aka "tstatus" info). */
2402 fprintf (fp
, "status %c;%s:%x;tframes:%x;tfree:%llx\n",
2403 (ts
->running
? '1' : '0'),
2404 stop_reason_names
[ts
->stop_reason
], ts
->stopping_tracepoint
,
2405 ts
->traceframe_count
, ts
->buffer_free
);
2407 /* Note that we want to upload tracepoints and save those, rather
2408 than simply writing out the local ones, because the user may have
2409 changed tracepoints in GDB in preparation for a future tracing
2410 run, or maybe just mass-deleted all types of breakpoints as part
2411 of cleaning up. So as not to contaminate the session, leave the
2412 data in its uploaded form, don't make into real tracepoints. */
2414 /* Get trace state variables first, they may be checked when parsing
2415 uploaded commands. */
2417 target_upload_trace_state_variables (&uploaded_tsvs
);
2419 for (utsv
= uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2425 buf
= (char *) xmalloc (strlen (utsv
->name
) * 2 + 1);
2426 bin2hex ((gdb_byte
*) (utsv
->name
), buf
, 0);
2429 fprintf (fp
, "tsv %x:%s:%x:%s\n",
2430 utsv
->number
, phex_nz (utsv
->initial_value
, 8),
2431 utsv
->builtin
, buf
);
2437 free_uploaded_tsvs (&uploaded_tsvs
);
2439 target_upload_tracepoints (&uploaded_tps
);
2441 for (utp
= uploaded_tps
; utp
; utp
= utp
->next
)
2443 fprintf (fp
, "tp T%x:%s:%c:%x:%x",
2444 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2445 (utp
->enabled
? 'E' : 'D'), utp
->step
, utp
->pass
);
2446 if (utp
->type
== bp_fast_tracepoint
)
2447 fprintf (fp
, ":F%x", utp
->orig_size
);
2449 fprintf (fp
, ":X%x,%s", (unsigned int) strlen (utp
->cond
) / 2,
2452 for (a
= 0; a
< utp
->numactions
; ++a
)
2453 fprintf (fp
, "tp A%x:%s:%s\n",
2454 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2456 for (a
= 0; a
< utp
->num_step_actions
; ++a
)
2457 fprintf (fp
, "tp S%x:%s:%s\n",
2458 utp
->number
, phex_nz (utp
->addr
, sizeof (utp
->addr
)),
2459 utp
->step_actions
[a
]);
2462 free_uploaded_tps (&uploaded_tps
);
2464 /* Mark the end of the definition section. */
2467 /* Get and write the trace data proper. We ask for big blocks, in
2468 the hopes of efficiency, but will take less if the target has
2469 packet size limitations or some such. */
2472 gotten
= target_get_raw_trace_data (buf
, offset
, MAX_TRACE_UPLOAD
);
2474 error (_("Failure to get requested trace buffer data"));
2475 /* No more data is forthcoming, we're done. */
2478 written
= fwrite (buf
, gotten
, 1, fp
);
2479 if (written
< gotten
)
2480 perror_with_name (pathname
);
2484 /* Mark the end of trace data. */
2485 written
= fwrite (&gotten
, 4, 1, fp
);
2487 perror_with_name (pathname
);
2489 do_cleanups (cleanup
);
2491 printf_filtered (_("Trace data saved to file '%s'.\n"), args
);
2494 /* Tell the target what to do with an ongoing tracing run if GDB
2495 disconnects for some reason. */
2498 send_disconnected_tracing_value (int value
)
2500 target_set_disconnected_tracing (value
);
2504 set_disconnected_tracing (char *args
, int from_tty
,
2505 struct cmd_list_element
*c
)
2507 send_disconnected_tracing_value (disconnected_tracing
);
2510 /* Convert the memory pointed to by mem into hex, placing result in buf.
2511 * Return a pointer to the last char put in buf (null)
2512 * "stolen" from sparc-stub.c
2515 static const char hexchars
[] = "0123456789abcdef";
2518 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2526 *buf
++ = hexchars
[ch
>> 4];
2527 *buf
++ = hexchars
[ch
& 0xf];
2536 get_traceframe_number (void)
2538 return traceframe_number
;
2541 /* Make the traceframe NUM be the current trace frame. Does nothing
2542 if NUM is already current. */
2545 set_traceframe_number (int num
)
2549 if (traceframe_number
== num
)
2551 /* Nothing to do. */
2555 newnum
= target_trace_find (tfind_number
, num
, 0, 0, NULL
);
2558 warning (_("could not change traceframe"));
2560 traceframe_number
= newnum
;
2562 /* Changing the traceframe changes our view of registers and of the
2564 registers_changed ();
2567 /* A cleanup used when switching away and back from tfind mode. */
2569 struct current_traceframe_cleanup
2571 /* The traceframe we were inspecting. */
2572 int traceframe_number
;
2576 do_restore_current_traceframe_cleanup (void *arg
)
2578 struct current_traceframe_cleanup
*old
= arg
;
2580 set_traceframe_number (old
->traceframe_number
);
2584 restore_current_traceframe_cleanup_dtor (void *arg
)
2586 struct current_traceframe_cleanup
*old
= arg
;
2592 make_cleanup_restore_current_traceframe (void)
2594 struct current_traceframe_cleanup
*old
;
2596 old
= xmalloc (sizeof (struct current_traceframe_cleanup
));
2597 old
->traceframe_number
= traceframe_number
;
2599 return make_cleanup_dtor (do_restore_current_traceframe_cleanup
, old
,
2600 restore_current_traceframe_cleanup_dtor
);
2603 /* Given a number and address, return an uploaded tracepoint with that
2604 number, creating if necessary. */
2606 struct uploaded_tp
*
2607 get_uploaded_tp (int num
, ULONGEST addr
, struct uploaded_tp
**utpp
)
2609 struct uploaded_tp
*utp
;
2611 for (utp
= *utpp
; utp
; utp
= utp
->next
)
2612 if (utp
->number
== num
&& utp
->addr
== addr
)
2614 utp
= (struct uploaded_tp
*) xmalloc (sizeof (struct uploaded_tp
));
2615 memset (utp
, 0, sizeof (struct uploaded_tp
));
2624 free_uploaded_tps (struct uploaded_tp
**utpp
)
2626 struct uploaded_tp
*next_one
;
2630 next_one
= (*utpp
)->next
;
2636 /* Given a number and address, return an uploaded tracepoint with that
2637 number, creating if necessary. */
2639 struct uploaded_tsv
*
2640 get_uploaded_tsv (int num
, struct uploaded_tsv
**utsvp
)
2642 struct uploaded_tsv
*utsv
;
2644 for (utsv
= *utsvp
; utsv
; utsv
= utsv
->next
)
2645 if (utsv
->number
== num
)
2647 utsv
= (struct uploaded_tsv
*) xmalloc (sizeof (struct uploaded_tsv
));
2648 memset (utsv
, 0, sizeof (struct uploaded_tsv
));
2650 utsv
->next
= *utsvp
;
2656 free_uploaded_tsvs (struct uploaded_tsv
**utsvp
)
2658 struct uploaded_tsv
*next_one
;
2662 next_one
= (*utsvp
)->next
;
2668 /* Look for an existing tracepoint that seems similar enough to the
2669 uploaded one. Enablement isn't compared, because the user can
2670 toggle that freely, and may have done so in anticipation of the
2674 find_matching_tracepoint (struct uploaded_tp
*utp
)
2676 VEC(breakpoint_p
) *tp_vec
= all_tracepoints ();
2678 struct breakpoint
*t
;
2679 struct bp_location
*loc
;
2681 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
2683 if (t
->type
== utp
->type
2684 && t
->step_count
== utp
->step
2685 && t
->pass_count
== utp
->pass
2686 /* FIXME also test conditionals and actions */
2689 /* Scan the locations for an address match. */
2690 for (loc
= t
->loc
; loc
; loc
= loc
->next
)
2692 if (loc
->address
== utp
->addr
)
2700 /* Given a list of tracepoints uploaded from a target, attempt to
2701 match them up with existing tracepoints, and create new ones if not
2705 merge_uploaded_tracepoints (struct uploaded_tp
**uploaded_tps
)
2707 struct uploaded_tp
*utp
;
2708 struct breakpoint
*t
;
2710 /* Look for GDB tracepoints that match up with our uploaded versions. */
2711 for (utp
= *uploaded_tps
; utp
; utp
= utp
->next
)
2713 t
= find_matching_tracepoint (utp
);
2715 printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
2716 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2719 t
= create_tracepoint_from_upload (utp
);
2721 printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
2722 t
->number
, utp
->number
, paddress (get_current_arch (), utp
->addr
));
2724 printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
2725 utp
->number
, paddress (get_current_arch (), utp
->addr
));
2727 /* Whether found or created, record the number used by the
2728 target, to help with mapping target tracepoints back to their
2729 counterparts here. */
2731 t
->number_on_target
= utp
->number
;
2734 free_uploaded_tps (uploaded_tps
);
2737 /* Trace state variables don't have much to identify them beyond their
2738 name, so just use that to detect matches. */
2740 struct trace_state_variable
*
2741 find_matching_tsv (struct uploaded_tsv
*utsv
)
2746 return find_trace_state_variable (utsv
->name
);
2749 struct trace_state_variable
*
2750 create_tsv_from_upload (struct uploaded_tsv
*utsv
)
2752 const char *namebase
;
2755 struct trace_state_variable
*tsv
;
2759 namebase
= utsv
->name
;
2760 sprintf (buf
, "%s", namebase
);
2765 sprintf (buf
, "%s_%d", namebase
, try_num
++);
2768 /* Fish for a name that is not in use. */
2769 /* (should check against all internal vars?) */
2770 while (find_trace_state_variable (buf
))
2771 sprintf (buf
, "%s_%d", namebase
, try_num
++);
2773 /* We have an available name, create the variable. */
2774 tsv
= create_trace_state_variable (xstrdup (buf
));
2775 tsv
->initial_value
= utsv
->initial_value
;
2776 tsv
->builtin
= utsv
->builtin
;
2781 /* Given a list of uploaded trace state variables, try to match them
2782 up with existing variables, or create additional ones. */
2785 merge_uploaded_trace_state_variables (struct uploaded_tsv
**uploaded_tsvs
)
2788 struct uploaded_tsv
*utsv
;
2789 struct trace_state_variable
*tsv
;
2792 /* Most likely some numbers will have to be reassigned as part of
2793 the merge, so clear them all in anticipation. */
2794 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2797 for (utsv
= *uploaded_tsvs
; utsv
; utsv
= utsv
->next
)
2799 tsv
= find_matching_tsv (utsv
);
2801 printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
2802 tsv
->name
, utsv
->number
);
2805 tsv
= create_tsv_from_upload (utsv
);
2806 printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
2807 tsv
->name
, utsv
->number
);
2809 /* Give precedence to numberings that come from the target. */
2811 tsv
->number
= utsv
->number
;
2814 /* Renumber everything that didn't get a target-assigned number. */
2816 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2817 if (tsv
->number
> highest
)
2818 highest
= tsv
->number
;
2821 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
2822 if (tsv
->number
== 0)
2823 tsv
->number
= highest
++;
2825 free_uploaded_tsvs (uploaded_tsvs
);
2828 /* target tfile command */
2830 struct target_ops tfile_ops
;
2832 /* Fill in tfile_ops with its defined operations and properties. */
2834 #define TRACE_HEADER_SIZE 8
2836 char *trace_filename
;
2838 off_t trace_frames_offset
;
2841 int trace_regblock_size
;
2843 static void tfile_interp_line (char *line
,
2844 struct uploaded_tp
**utpp
,
2845 struct uploaded_tsv
**utsvp
);
2848 tfile_open (char *filename
, int from_tty
)
2851 struct cleanup
*old_chain
;
2854 char header
[TRACE_HEADER_SIZE
];
2855 char linebuf
[1000]; /* should be max remote packet size or so */
2857 int bytes
, i
, gotten
;
2858 struct trace_status
*ts
;
2859 struct uploaded_tp
*uploaded_tps
= NULL
;
2860 struct uploaded_tsv
*uploaded_tsvs
= NULL
;
2862 target_preopen (from_tty
);
2864 error (_("No trace file specified."));
2866 filename
= tilde_expand (filename
);
2867 if (!IS_ABSOLUTE_PATH(filename
))
2869 temp
= concat (current_directory
, "/", filename
, (char *)NULL
);
2874 old_chain
= make_cleanup (xfree
, filename
);
2876 flags
= O_BINARY
| O_LARGEFILE
;
2878 scratch_chan
= open (filename
, flags
, 0);
2879 if (scratch_chan
< 0)
2880 perror_with_name (filename
);
2882 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
2884 discard_cleanups (old_chain
); /* Don't free filename any more */
2885 unpush_target (&tfile_ops
);
2887 push_target (&tfile_ops
);
2889 trace_filename
= xstrdup (filename
);
2890 trace_fd
= scratch_chan
;
2893 /* Read the file header and test for validity. */
2894 gotten
= read (trace_fd
, &header
, TRACE_HEADER_SIZE
);
2896 perror_with_name (trace_filename
);
2897 else if (gotten
< TRACE_HEADER_SIZE
)
2898 error (_("Premature end of file while reading trace file"));
2900 bytes
+= TRACE_HEADER_SIZE
;
2901 if (!(header
[0] == 0x7f
2902 && (strncmp (header
+ 1, "TRACE0\n", 7) == 0)))
2903 error (_("File is not a valid trace file."));
2905 trace_regblock_size
= 0;
2906 ts
= current_trace_status ();
2907 /* We know we're working with a file. */
2909 /* Set defaults in case there is no status line. */
2910 ts
->running_known
= 0;
2911 ts
->stop_reason
= trace_stop_reason_unknown
;
2912 ts
->traceframe_count
= -1;
2913 ts
->buffer_free
= 0;
2915 /* Read through a section of newline-terminated lines that
2916 define things like tracepoints. */
2920 gotten
= read (trace_fd
, &byte
, 1);
2922 perror_with_name (trace_filename
);
2923 else if (gotten
< 1)
2924 error (_("Premature end of file while reading trace file"));
2929 /* Empty line marks end of the definition section. */
2934 tfile_interp_line (linebuf
, &uploaded_tps
, &uploaded_tsvs
);
2937 linebuf
[i
++] = byte
;
2939 error (_("Excessively long lines in trace file"));
2942 /* Add the file's tracepoints and variables into the current mix. */
2944 /* Get trace state variables first, they may be checked when parsing
2945 uploaded commands. */
2946 merge_uploaded_trace_state_variables (&uploaded_tsvs
);
2948 merge_uploaded_tracepoints (&uploaded_tps
);
2950 /* Record the starting offset of the binary trace data. */
2951 trace_frames_offset
= bytes
;
2953 /* If we don't have a blocksize, we can't interpret the
2955 if (trace_regblock_size
== 0)
2956 error (_("No register block size recorded in trace file"));
2957 if (ts
->traceframe_count
<= 0)
2959 warning ("No traceframes present in this file.");
2963 #define TFILE_PID (1)
2964 inferior_appeared (current_inferior (), TFILE_PID
);
2965 inferior_ptid
= pid_to_ptid (TFILE_PID
);
2966 add_thread_silent (inferior_ptid
);
2968 post_create_inferior (&tfile_ops
, from_tty
);
2971 /* FIXME this will get defined in MI patch submission */
2972 tfind_1 (tfind_number
, 0, 0, 0, 0);
2976 /* Interpret the given line from the definitions part of the trace
2980 tfile_interp_line (char *line
,
2981 struct uploaded_tp
**utpp
, struct uploaded_tsv
**utsvp
)
2985 if (strncmp (p
, "R ", strlen ("R ")) == 0)
2988 trace_regblock_size
= strtol (p
, &p
, 16);
2990 else if (strncmp (p
, "status ", strlen ("status ")) == 0)
2992 p
+= strlen ("status ");
2993 parse_trace_status (p
, current_trace_status ());
2995 else if (strncmp (p
, "tp ", strlen ("tp ")) == 0)
2997 p
+= strlen ("tp ");
2998 parse_tracepoint_definition (p
, utpp
);
3000 else if (strncmp (p
, "tsv ", strlen ("tsv ")) == 0)
3002 p
+= strlen ("tsv ");
3003 parse_tsv_definition (p
, utsvp
);
3006 warning ("Ignoring trace file definition \"%s\"", line
);
3009 /* Parse the part of trace status syntax that is shared between
3010 the remote protocol and the trace file reader. */
3012 extern char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
3015 parse_trace_status (char *line
, struct trace_status
*ts
)
3017 char *p
= line
, *p1
, *p_temp
;
3020 ts
->running_known
= 1;
3021 ts
->running
= (*p
++ == '1');
3022 ts
->stop_reason
= trace_stop_reason_unknown
;
3025 p1
= strchr (p
, ':');
3027 error (_("Malformed trace status, at %s\n\
3028 Status line: '%s'\n"), p
, line
);
3029 if (strncmp (p
, stop_reason_names
[trace_buffer_full
], p1
- p
) == 0)
3031 p
= unpack_varlen_hex (++p1
, &val
);
3032 ts
->stop_reason
= trace_buffer_full
;
3034 else if (strncmp (p
, stop_reason_names
[trace_never_run
], p1
- p
) == 0)
3036 p
= unpack_varlen_hex (++p1
, &val
);
3037 ts
->stop_reason
= trace_never_run
;
3039 else if (strncmp (p
, stop_reason_names
[tracepoint_passcount
], p1
- p
) == 0)
3041 p
= unpack_varlen_hex (++p1
, &val
);
3042 ts
->stop_reason
= tracepoint_passcount
;
3043 ts
->stopping_tracepoint
= val
;
3045 else if (strncmp (p
, stop_reason_names
[tstop_command
], p1
- p
) == 0)
3047 p
= unpack_varlen_hex (++p1
, &val
);
3048 ts
->stop_reason
= tstop_command
;
3050 if (strncmp (p
, "tframes", p1
- p
) == 0)
3052 p
= unpack_varlen_hex (++p1
, &val
);
3053 ts
->traceframe_count
= val
;
3055 if (strncmp (p
, "tfree", p1
- p
) == 0)
3057 p
= unpack_varlen_hex (++p1
, &val
);
3058 ts
->buffer_free
= val
;
3062 /* Silently skip unknown optional info. */
3063 p_temp
= strchr (p1
+ 1, ';');
3067 /* Must be at the end. */
3073 /* Given a line of text defining a tracepoint or tracepoint action, parse
3074 it into an "uploaded tracepoint". */
3077 parse_tracepoint_definition (char *line
, struct uploaded_tp
**utpp
)
3081 ULONGEST num
, addr
, step
, pass
, orig_size
, xlen
;
3085 struct uploaded_tp
*utp
= NULL
;
3088 /* Both tracepoint and action definitions start with the same number
3089 and address sequence. */
3091 p
= unpack_varlen_hex (p
, &num
);
3092 p
++; /* skip a colon */
3093 p
= unpack_varlen_hex (p
, &addr
);
3094 p
++; /* skip a colon */
3097 enabled
= (*p
++ == 'E');
3098 p
++; /* skip a colon */
3099 p
= unpack_varlen_hex (p
, &step
);
3100 p
++; /* skip a colon */
3101 p
= unpack_varlen_hex (p
, &pass
);
3102 type
= bp_tracepoint
;
3104 /* Thumb through optional fields. */
3107 p
++; /* skip a colon */
3110 type
= bp_fast_tracepoint
;
3112 p
= unpack_varlen_hex (p
, &orig_size
);
3117 p
= unpack_varlen_hex (p
, &xlen
);
3118 p
++; /* skip a comma */
3119 cond
= (char *) xmalloc (2 * xlen
+ 1);
3120 strncpy (cond
, p
, 2 * xlen
);
3121 cond
[2 * xlen
] = '\0';
3125 warning ("Unrecognized char '%c' in tracepoint definition, skipping rest", *p
);
3127 utp
= get_uploaded_tp (num
, addr
, utpp
);
3129 utp
->enabled
= enabled
;
3134 else if (piece
== 'A')
3136 utp
= get_uploaded_tp (num
, addr
, utpp
);
3137 utp
->actions
[utp
->numactions
++] = xstrdup (p
);
3139 else if (piece
== 'S')
3141 utp
= get_uploaded_tp (num
, addr
, utpp
);
3142 utp
->step_actions
[utp
->num_step_actions
++] = xstrdup (p
);
3146 error ("Invalid tracepoint piece");
3150 /* Convert a textual description of a trace state variable into an
3154 parse_tsv_definition (char *line
, struct uploaded_tsv
**utsvp
)
3157 ULONGEST num
, initval
, builtin
;
3159 struct uploaded_tsv
*utsv
= NULL
;
3161 buf
= alloca (strlen (line
));
3164 p
= unpack_varlen_hex (p
, &num
);
3165 p
++; /* skip a colon */
3166 p
= unpack_varlen_hex (p
, &initval
);
3167 p
++; /* skip a colon */
3168 p
= unpack_varlen_hex (p
, &builtin
);
3169 p
++; /* skip a colon */
3170 end
= hex2bin (p
, (gdb_byte
*) buf
, strlen (p
) / 2);
3173 utsv
= get_uploaded_tsv (num
, utsvp
);
3174 utsv
->initial_value
= initval
;
3175 utsv
->builtin
= builtin
;
3176 utsv
->name
= xstrdup (buf
);
3179 /* Close the trace file and generally clean up. */
3182 tfile_close (int quitting
)
3189 pid
= ptid_get_pid (inferior_ptid
);
3190 inferior_ptid
= null_ptid
; /* Avoid confusion from thread stuff */
3191 exit_inferior_silent (pid
);
3196 xfree (trace_filename
);
3200 tfile_files_info (struct target_ops
*t
)
3202 /* (it would be useful to mention the name of the file) */
3203 printf_filtered ("Looking at a trace file.\n");
3206 /* The trace status for a file is that tracing can never be run. */
3209 tfile_get_trace_status (struct trace_status
*ts
)
3211 /* Other bits of trace status were collected as part of opening the
3212 trace files, so nothing to do here. */
3217 /* Given the position of a traceframe in the file, figure out what
3218 address the frame was collected at. This would normally be the
3219 value of a collected PC register, but if not available, we
3223 tfile_get_traceframe_address (off_t tframe_offset
)
3227 struct breakpoint
*tp
;
3228 off_t saved_offset
= cur_offset
;
3231 /* FIXME dig pc out of collected registers */
3233 /* Fall back to using tracepoint address. */
3234 lseek (trace_fd
, tframe_offset
, SEEK_SET
);
3235 gotten
= read (trace_fd
, &tpnum
, 2);
3237 perror_with_name (trace_filename
);
3238 else if (gotten
< 2)
3239 error (_("Premature end of file while reading trace file"));
3241 tp
= get_tracepoint_by_number_on_target (tpnum
);
3243 addr
= tp
->loc
->address
;
3245 /* Restore our seek position. */
3246 cur_offset
= saved_offset
;
3247 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3251 /* Given a type of search and some parameters, scan the collection of
3252 traceframes in the file looking for a match. When found, return
3253 both the traceframe and tracepoint number, otherwise -1 for
3257 tfile_trace_find (enum trace_find_type type
, int num
,
3258 ULONGEST addr1
, ULONGEST addr2
, int *tpp
)
3261 int tfnum
= 0, found
= 0, gotten
;
3263 struct breakpoint
*tp
;
3264 off_t offset
, tframe_offset
;
3267 lseek (trace_fd
, trace_frames_offset
, SEEK_SET
);
3268 offset
= trace_frames_offset
;
3271 tframe_offset
= offset
;
3272 gotten
= read (trace_fd
, &tpnum
, 2);
3274 perror_with_name (trace_filename
);
3275 else if (gotten
< 2)
3276 error (_("Premature end of file while reading trace file"));
3280 gotten
= read (trace_fd
, &data_size
, 4);
3282 perror_with_name (trace_filename
);
3283 else if (gotten
< 4)
3284 error (_("Premature end of file while reading trace file"));
3293 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3294 if (tfaddr
== addr1
)
3298 tp
= get_tracepoint (num
);
3299 if (tp
&& tpnum
== tp
->number_on_target
)
3303 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3304 if (addr1
<= tfaddr
&& tfaddr
<= addr2
)
3308 tfaddr
= tfile_get_traceframe_address (tframe_offset
);
3309 if (!(addr1
<= tfaddr
&& tfaddr
<= addr2
))
3313 internal_error (__FILE__
, __LINE__
, _("unknown tfind type"));
3317 printf_filtered ("Found traceframe %d.\n", tfnum
);
3320 cur_offset
= offset
;
3321 cur_data_size
= data_size
;
3324 /* Skip past the traceframe's data. */
3325 lseek (trace_fd
, data_size
, SEEK_CUR
);
3326 offset
+= data_size
;
3327 /* Update our own count of traceframes. */
3330 /* Did not find what we were looking for. */
3336 /* Look for a block of saved registers in the traceframe, and get the
3337 requested register from it. */
3340 tfile_fetch_registers (struct target_ops
*ops
,
3341 struct regcache
*regcache
, int regno
)
3343 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
3345 int i
, pos
, offset
, regn
, regsize
, gotten
;
3346 unsigned short mlen
;
3349 /* An uninitialized reg size says we're not going to be
3350 successful at getting register blocks. */
3351 if (!trace_regblock_size
)
3354 regs
= alloca (trace_regblock_size
);
3356 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3358 while (pos
< cur_data_size
)
3360 gotten
= read (trace_fd
, &block_type
, 1);
3362 perror_with_name (trace_filename
);
3363 else if (gotten
< 1)
3364 error (_("Premature end of file while reading trace file"));
3370 gotten
= read (trace_fd
, regs
, trace_regblock_size
);
3372 perror_with_name (trace_filename
);
3373 else if (gotten
< trace_regblock_size
)
3374 error (_("Premature end of file while reading trace file"));
3376 /* Assume the block is laid out in GDB register number order,
3377 each register with the size that it has in GDB. */
3379 for (regn
= 0; regn
< gdbarch_num_regs (gdbarch
); regn
++)
3381 regsize
= register_size (gdbarch
, regn
);
3382 /* Make sure we stay within block bounds. */
3383 if (offset
+ regsize
>= trace_regblock_size
)
3385 if (!regcache_valid_p (regcache
, regn
))
3389 regcache_raw_supply (regcache
, regno
, regs
+ offset
);
3392 else if (regno
== -1)
3394 regcache_raw_supply (regcache
, regn
, regs
+ offset
);
3401 lseek (trace_fd
, 8, SEEK_CUR
);
3402 gotten
= read (trace_fd
, &mlen
, 2);
3404 perror_with_name (trace_filename
);
3405 else if (gotten
< 2)
3406 error (_("Premature end of file while reading trace file"));
3407 lseek (trace_fd
, mlen
, SEEK_CUR
);
3408 pos
+= (8 + 2 + mlen
);
3411 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3415 error ("Unknown block type '%c' (0x%x) in trace frame",
3416 block_type
, block_type
);
3423 tfile_xfer_partial (struct target_ops
*ops
, enum target_object object
,
3424 const char *annex
, gdb_byte
*readbuf
,
3425 const gdb_byte
*writebuf
, ULONGEST offset
, LONGEST len
)
3430 unsigned short mlen
;
3432 /* We're only doing regular memory for now. */
3433 if (object
!= TARGET_OBJECT_MEMORY
)
3436 if (readbuf
== NULL
)
3437 error ("tfile_xfer_partial: trace file is read-only");
3439 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3441 while (pos
< cur_data_size
)
3443 gotten
= read (trace_fd
, &block_type
, 1);
3445 perror_with_name (trace_filename
);
3446 else if (gotten
< 1)
3447 error (_("Premature end of file while reading trace file"));
3452 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3453 pos
+= trace_regblock_size
;
3456 gotten
= read (trace_fd
, &maddr
, 8);
3458 perror_with_name (trace_filename
);
3459 else if (gotten
< 8)
3460 error (_("Premature end of file while reading trace file"));
3462 gotten
= read (trace_fd
, &mlen
, 2);
3464 perror_with_name (trace_filename
);
3465 else if (gotten
< 2)
3466 error (_("Premature end of file while reading trace file"));
3467 if (maddr
<= offset
&& (offset
+ len
) <= (maddr
+ mlen
))
3469 gotten
= read (trace_fd
, readbuf
, mlen
);
3471 perror_with_name (trace_filename
);
3472 else if (gotten
< mlen
)
3473 error (_("Premature end of file qwhile reading trace file"));
3477 lseek (trace_fd
, mlen
, SEEK_CUR
);
3478 pos
+= (8 + 2 + mlen
);
3481 lseek (trace_fd
, 4 + 8, SEEK_CUR
);
3485 error ("Unknown block type '%c' (0x%x) in traceframe",
3486 block_type
, block_type
);
3490 /* Indicate failure to find the requested memory block. */
3494 /* Iterate through the blocks of a trace frame, looking for a 'V'
3495 block with a matching tsv number. */
3498 tfile_get_trace_state_variable_value (int tsvnum
, LONGEST
*val
)
3501 int pos
, vnum
, gotten
;
3502 unsigned short mlen
;
3504 lseek (trace_fd
, cur_offset
, SEEK_SET
);
3506 while (pos
< cur_data_size
)
3508 gotten
= read (trace_fd
, &block_type
, 1);
3510 perror_with_name (trace_filename
);
3511 else if (gotten
< 1)
3512 error (_("Premature end of file while reading trace file"));
3517 lseek (trace_fd
, trace_regblock_size
, SEEK_CUR
);
3518 pos
+= trace_regblock_size
;
3521 lseek (trace_fd
, 8, SEEK_CUR
);
3522 gotten
= read (trace_fd
, &mlen
, 2);
3524 perror_with_name (trace_filename
);
3525 else if (gotten
< 2)
3526 error (_("Premature end of file while reading trace file"));
3527 lseek (trace_fd
, mlen
, SEEK_CUR
);
3528 pos
+= (8 + 2 + mlen
);
3531 gotten
= read (trace_fd
, &vnum
, 4);
3533 perror_with_name (trace_filename
);
3534 else if (gotten
< 4)
3535 error (_("Premature end of file while reading trace file"));
3538 gotten
= read (trace_fd
, val
, 8);
3540 perror_with_name (trace_filename
);
3541 else if (gotten
< 8)
3542 error (_("Premature end of file while reading trace file"));
3545 lseek (trace_fd
, 8, SEEK_CUR
);
3549 error ("Unknown block type '%c' (0x%x) in traceframe",
3550 block_type
, block_type
);
3554 /* Didn't find anything. */
3559 tfile_has_memory (struct target_ops
*ops
)
3565 tfile_has_stack (struct target_ops
*ops
)
3571 tfile_has_registers (struct target_ops
*ops
)
3577 init_tfile_ops (void)
3579 tfile_ops
.to_shortname
= "tfile";
3580 tfile_ops
.to_longname
= "Local trace dump file";
3582 "Use a trace file as a target. Specify the filename of the trace file.";
3583 tfile_ops
.to_open
= tfile_open
;
3584 tfile_ops
.to_close
= tfile_close
;
3585 tfile_ops
.to_fetch_registers
= tfile_fetch_registers
;
3586 tfile_ops
.to_xfer_partial
= tfile_xfer_partial
;
3587 tfile_ops
.to_files_info
= tfile_files_info
;
3588 tfile_ops
.to_get_trace_status
= tfile_get_trace_status
;
3589 tfile_ops
.to_trace_find
= tfile_trace_find
;
3590 tfile_ops
.to_get_trace_state_variable_value
= tfile_get_trace_state_variable_value
;
3591 /* core_stratum might seem more logical, but GDB doesn't like having
3592 more than one core_stratum vector. */
3593 tfile_ops
.to_stratum
= process_stratum
;
3594 tfile_ops
.to_has_memory
= tfile_has_memory
;
3595 tfile_ops
.to_has_stack
= tfile_has_stack
;
3596 tfile_ops
.to_has_registers
= tfile_has_registers
;
3597 tfile_ops
.to_magic
= OPS_MAGIC
;
3600 /* module initialization */
3602 _initialize_tracepoint (void)
3604 struct cmd_list_element
*c
;
3606 traceframe_number
= -1;
3607 tracepoint_number
= -1;
3609 if (tracepoint_list
.list
== NULL
)
3611 tracepoint_list
.listsize
= 128;
3612 tracepoint_list
.list
= xmalloc
3613 (tracepoint_list
.listsize
* sizeof (struct memrange
));
3615 if (tracepoint_list
.aexpr_list
== NULL
)
3617 tracepoint_list
.aexpr_listsize
= 128;
3618 tracepoint_list
.aexpr_list
= xmalloc
3619 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3622 if (stepping_list
.list
== NULL
)
3624 stepping_list
.listsize
= 128;
3625 stepping_list
.list
= xmalloc
3626 (stepping_list
.listsize
* sizeof (struct memrange
));
3629 if (stepping_list
.aexpr_list
== NULL
)
3631 stepping_list
.aexpr_listsize
= 128;
3632 stepping_list
.aexpr_list
= xmalloc
3633 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
3636 add_info ("scope", scope_info
,
3637 _("List the variables local to a scope"));
3639 add_cmd ("tracepoints", class_trace
, NULL
,
3640 _("Tracing of program execution without stopping the program."),
3643 add_com ("tdump", class_trace
, trace_dump_command
,
3644 _("Print everything collected at the current tracepoint."));
3646 add_com ("tsave", class_trace
, trace_save_command
, _("\
3647 Save the trace data to a file.\n\
3648 Use the '-r' option to direct the target to save directly to the file,\n\
3649 using its own filesystem."));
3651 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
3652 Define a trace state variable.\n\
3653 Argument is a $-prefixed name, optionally followed\n\
3654 by '=' and an expression that sets the initial value\n\
3655 at the start of tracing."));
3656 set_cmd_completer (c
, expression_completer
);
3658 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
3659 Delete one or more trace state variables.\n\
3660 Arguments are the names of the variables to delete.\n\
3661 If no arguments are supplied, delete all variables."), &deletelist
);
3662 /* FIXME add a trace variable completer */
3664 add_info ("tvariables", tvariables_info
, _("\
3665 Status of trace state variables and their values.\n\
3668 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
3669 Select a trace frame;\n\
3670 No argument means forward by one frame; '-' means backward by one frame."),
3671 &tfindlist
, "tfind ", 1, &cmdlist
);
3673 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
3674 Select a trace frame whose PC is outside the given range (exclusive).\n\
3675 Usage: tfind outside addr1, addr2"),
3678 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
3679 Select a trace frame whose PC is in the given range (inclusive).\n\
3680 Usage: tfind range addr1,addr2"),
3683 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
3684 Select a trace frame by source line.\n\
3685 Argument can be a line number (with optional source file), \n\
3686 a function name, or '*' followed by an address.\n\
3687 Default argument is 'the next source line that was traced'."),
3690 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
3691 Select a trace frame by tracepoint number.\n\
3692 Default is the tracepoint for the current trace frame."),
3695 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
3696 Select a trace frame by PC.\n\
3697 Default is the current PC, or the PC of the current trace frame."),
3700 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
3701 Synonym for 'none'.\n\
3702 De-select any trace frame and resume 'live' debugging."),
3705 add_cmd ("none", class_trace
, trace_find_none_command
,
3706 _("De-select any trace frame and resume 'live' debugging."),
3709 add_cmd ("start", class_trace
, trace_find_start_command
,
3710 _("Select the first trace frame in the trace buffer."),
3713 add_com ("tstatus", class_trace
, trace_status_command
,
3714 _("Display the status of the current trace data collection."));
3716 add_com ("tstop", class_trace
, trace_stop_command
,
3717 _("Stop trace data collection."));
3719 add_com ("tstart", class_trace
, trace_start_command
,
3720 _("Start trace data collection."));
3722 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
3723 Ends a list of commands or actions.\n\
3724 Several GDB commands allow you to enter a list of commands or actions.\n\
3725 Entering \"end\" on a line by itself is the normal way to terminate\n\
3727 Note: the \"end\" command cannot be used at the gdb prompt."));
3729 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
3730 Specify single-stepping behavior at a tracepoint.\n\
3731 Argument is number of instructions to trace in single-step mode\n\
3732 following the tracepoint. This command is normally followed by\n\
3733 one or more \"collect\" commands, to specify what to collect\n\
3734 while single-stepping.\n\n\
3735 Note: this command can only be used in a tracepoint \"actions\" list."));
3737 add_com_alias ("ws", "while-stepping", class_alias
, 0);
3738 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
3740 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
3741 Specify one or more data items to be collected at a tracepoint.\n\
3742 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
3743 collect all data (variables, registers) referenced by that expression.\n\
3744 Also accepts the following special arguments:\n\
3745 $regs -- all registers.\n\
3746 $args -- all function arguments.\n\
3747 $locals -- all variables local to the block/function scope.\n\
3748 Note: this command can only be used in a tracepoint \"actions\" list."));
3750 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
3751 Specify one or more expressions to be evaluated at a tracepoint.\n\
3752 Accepts a comma-separated list of (one or more) expressions.\n\
3753 The result of each evaluation will be discarded.\n\
3754 Note: this command can only be used in a tracepoint \"actions\" list."));
3756 add_com ("actions", class_trace
, trace_actions_command
, _("\
3757 Specify the actions to be taken at a tracepoint.\n\
3758 Tracepoint actions may include collecting of specified data, \n\
3759 single-stepping, or enabling/disabling other tracepoints, \n\
3760 depending on target's capabilities."));
3762 default_collect
= xstrdup ("");
3763 add_setshow_string_cmd ("default-collect", class_trace
,
3764 &default_collect
, _("\
3765 Set the list of expressions to collect by default"), _("\
3766 Show the list of expressions to collect by default"), NULL
,
3768 &setlist
, &showlist
);
3770 add_setshow_boolean_cmd ("disconnected-tracing", no_class
,
3771 &disconnected_tracing
, _("\
3772 Set whether tracing continues after GDB disconnects."), _("\
3773 Show whether tracing continues after GDB disconnects."), _("\
3774 Use this to continue a tracing run even if GDB disconnects\n\
3775 or detaches from the target. You can reconnect later and look at\n\
3776 trace data collected in the meantime."),
3777 set_disconnected_tracing
,
3784 add_target (&tfile_ops
);