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 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"
36 extern int remote_supports_cond_tracepoints (void);
37 extern char *unpack_varlen_hex (char *buff
, ULONGEST
*result
);
40 #include "completer.h"
42 #include "dictionary.h"
44 #include "user-regs.h"
52 /* readline include files */
53 #include "readline/readline.h"
54 #include "readline/history.h"
56 /* readline defines this. */
63 /* Maximum length of an agent aexpression.
64 This accounts for the fact that packets are limited to 400 bytes
65 (which includes everything -- including the checksum), and assumes
66 the worst case of maximum length for each of the pieces of a
69 NOTE: expressions get mem2hex'ed otherwise this would be twice as
70 large. (400 - 31)/2 == 184 */
71 #define MAX_AGENT_EXPR_LEN 184
73 /* A hook used to notify the UI of tracepoint operations. */
75 void (*deprecated_trace_find_hook
) (char *arg
, int from_tty
);
76 void (*deprecated_trace_start_stop_hook
) (int start
, int from_tty
);
78 extern void (*deprecated_readline_begin_hook
) (char *, ...);
79 extern char *(*deprecated_readline_hook
) (char *);
80 extern void (*deprecated_readline_end_hook
) (void);
82 /* GDB commands implemented in other modules:
85 extern void output_command (char *, int);
90 This module defines the following debugger commands:
91 trace : set a tracepoint on a function, line, or address.
92 info trace : list all debugger-defined tracepoints.
93 delete trace : delete one or more tracepoints.
94 enable trace : enable one or more tracepoints.
95 disable trace : disable one or more tracepoints.
96 actions : specify actions to be taken at a tracepoint.
97 passcount : specify a pass count for a tracepoint.
98 tstart : start a trace experiment.
99 tstop : stop a trace experiment.
100 tstatus : query the status of a trace experiment.
101 tfind : find a trace frame in the trace buffer.
102 tdump : print everything collected at the current tracepoint.
103 save-tracepoints : write tracepoint setup into a file.
105 This module defines the following user-visible debugger variables:
106 $trace_frame : sequence number of trace frame currently being debugged.
107 $trace_line : source line of trace frame currently being debugged.
108 $trace_file : source file of trace frame currently being debugged.
109 $tracepoint : tracepoint number of trace frame currently being debugged.
113 /* ======= Important global variables: ======= */
115 /* The list of all trace state variables. We don't retain pointers to
116 any of these for any reason - API is by name or number only - so it
117 works to have a vector of objects. */
119 typedef struct trace_state_variable tsv_s
;
122 static VEC(tsv_s
) *tvariables
;
124 /* The next integer to assign to a variable. */
126 static int next_tsv_number
= 1;
128 /* Number of last traceframe collected. */
129 static int traceframe_number
;
131 /* Tracepoint for last traceframe collected. */
132 static int tracepoint_number
;
134 /* Symbol for function for last traceframe collected */
135 static struct symbol
*traceframe_fun
;
137 /* Symtab and line for last traceframe collected */
138 static struct symtab_and_line traceframe_sal
;
140 /* Tracing command lists */
141 static struct cmd_list_element
*tfindlist
;
143 /* List of expressions to collect by default at each tracepoint hit. */
144 static char *default_collect
= "";
146 static char *target_buf
;
147 static long target_buf_size
;
149 /* ======= Important command functions: ======= */
150 static void trace_actions_command (char *, int);
151 static void trace_start_command (char *, int);
152 static void trace_stop_command (char *, int);
153 static void trace_status_command (char *, int);
154 static void trace_find_command (char *, int);
155 static void trace_find_pc_command (char *, int);
156 static void trace_find_tracepoint_command (char *, int);
157 static void trace_find_line_command (char *, int);
158 static void trace_find_range_command (char *, int);
159 static void trace_find_outside_command (char *, int);
160 static void tracepoint_save_command (char *, int);
161 static void trace_dump_command (char *, int);
163 /* support routines */
165 struct collection_list
;
166 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
167 static char *mem2hex (gdb_byte
*, char *, int);
168 static void add_register (struct collection_list
*collection
,
170 static struct cleanup
*make_cleanup_free_actions (struct breakpoint
*t
);
171 static void free_actions_list (char **actions_list
);
172 static void free_actions_list_cleanup_wrapper (void *);
174 extern void _initialize_tracepoint (void);
176 /* Utility: returns true if "target remote" */
178 target_is_remote (void)
180 if (current_target
.to_shortname
&&
181 (strcmp (current_target
.to_shortname
, "remote") == 0
182 || strcmp (current_target
.to_shortname
, "extended-remote") == 0))
188 /* Utility: generate error from an incoming stub packet. */
190 trace_error (char *buf
)
193 return; /* not an error msg */
196 case '1': /* malformed packet error */
197 if (*++buf
== '0') /* general case: */
198 error (_("tracepoint.c: error in outgoing packet."));
200 error (_("tracepoint.c: error in outgoing packet at field #%ld."),
201 strtol (buf
, NULL
, 16));
203 error (_("trace API error 0x%s."), ++buf
);
205 error (_("Target returns error code '%s'."), buf
);
209 /* Utility: wait for reply from stub, while accepting "O" packets. */
211 remote_get_noisy_reply (char **buf_p
,
214 do /* Loop on reply from remote stub. */
217 QUIT
; /* allow user to bail out with ^C */
218 getpkt (buf_p
, sizeof_buf
, 0);
221 error (_("Target does not support this command."));
222 else if (buf
[0] == 'E')
224 else if (buf
[0] == 'O' &&
226 remote_console_output (buf
+ 1); /* 'O' message from stub */
228 return buf
; /* here's the actual reply */
233 /* Set traceframe number to NUM. */
235 set_traceframe_num (int num
)
237 traceframe_number
= num
;
238 set_internalvar_integer (lookup_internalvar ("trace_frame"), num
);
241 /* Set tracepoint number to NUM. */
243 set_tracepoint_num (int num
)
245 tracepoint_number
= num
;
246 set_internalvar_integer (lookup_internalvar ("tracepoint"), num
);
249 /* Set externally visible debug variables for querying/printing
250 the traceframe context (line, function, file) */
253 set_traceframe_context (struct frame_info
*trace_frame
)
257 if (trace_frame
== NULL
) /* Cease debugging any trace buffers. */
260 traceframe_sal
.pc
= traceframe_sal
.line
= 0;
261 traceframe_sal
.symtab
= NULL
;
262 clear_internalvar (lookup_internalvar ("trace_func"));
263 clear_internalvar (lookup_internalvar ("trace_file"));
264 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
268 /* Save as globals for internal use. */
269 trace_pc
= get_frame_pc (trace_frame
);
270 traceframe_sal
= find_pc_line (trace_pc
, 0);
271 traceframe_fun
= find_pc_function (trace_pc
);
273 /* Save linenumber as "$trace_line", a debugger variable visible to
275 set_internalvar_integer (lookup_internalvar ("trace_line"),
276 traceframe_sal
.line
);
278 /* Save func name as "$trace_func", a debugger variable visible to
280 if (traceframe_fun
== NULL
281 || SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
282 clear_internalvar (lookup_internalvar ("trace_func"));
284 set_internalvar_string (lookup_internalvar ("trace_func"),
285 SYMBOL_LINKAGE_NAME (traceframe_fun
));
287 /* Save file name as "$trace_file", a debugger variable visible to
289 if (traceframe_sal
.symtab
== NULL
290 || traceframe_sal
.symtab
->filename
== NULL
)
291 clear_internalvar (lookup_internalvar ("trace_file"));
293 set_internalvar_string (lookup_internalvar ("trace_file"),
294 traceframe_sal
.symtab
->filename
);
297 /* Create a new trace state variable with the given name. */
299 struct trace_state_variable
*
300 create_trace_state_variable (const char *name
)
302 struct trace_state_variable tsv
;
304 memset (&tsv
, 0, sizeof (tsv
));
306 tsv
.number
= next_tsv_number
++;
307 return VEC_safe_push (tsv_s
, tvariables
, &tsv
);
310 /* Look for a trace state variable of the given name. */
312 struct trace_state_variable
*
313 find_trace_state_variable (const char *name
)
315 struct trace_state_variable
*tsv
;
318 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
319 if (strcmp (name
, tsv
->name
) == 0)
326 delete_trace_state_variable (const char *name
)
328 struct trace_state_variable
*tsv
;
331 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
332 if (strcmp (name
, tsv
->name
) == 0)
334 VEC_unordered_remove (tsv_s
, tvariables
, ix
);
338 warning (_("No trace variable named \"$%s\", not deleting"), name
);
341 /* The 'tvariable' command collects a name and optional expression to
342 evaluate into an initial value. */
345 trace_variable_command (char *args
, int from_tty
)
347 struct expression
*expr
;
348 struct cleanup
*old_chain
;
349 struct internalvar
*intvar
= NULL
;
351 struct trace_state_variable
*tsv
;
354 error_no_arg (_("trace state variable name"));
356 /* All the possible valid arguments are expressions. */
357 expr
= parse_expression (args
);
358 old_chain
= make_cleanup (free_current_contents
, &expr
);
360 if (expr
->nelts
== 0)
361 error (_("No expression?"));
363 /* Only allow two syntaxes; "$name" and "$name=value". */
364 if (expr
->elts
[0].opcode
== OP_INTERNALVAR
)
366 intvar
= expr
->elts
[1].internalvar
;
368 else if (expr
->elts
[0].opcode
== BINOP_ASSIGN
369 && expr
->elts
[1].opcode
== OP_INTERNALVAR
)
371 intvar
= expr
->elts
[2].internalvar
;
372 initval
= value_as_long (evaluate_subexpression_type (expr
, 4));
375 error (_("Syntax must be $NAME [ = EXPR ]"));
378 error (_("No name given"));
380 if (strlen (internalvar_name (intvar
)) <= 0)
381 error (_("Must supply a non-empty variable name"));
383 /* If the variable already exists, just change its initial value. */
384 tsv
= find_trace_state_variable (internalvar_name (intvar
));
387 tsv
->initial_value
= initval
;
388 printf_filtered (_("Trace state variable $%s now has initial value %s.\n"),
389 tsv
->name
, plongest (tsv
->initial_value
));
393 /* Create a new variable. */
394 tsv
= create_trace_state_variable (internalvar_name (intvar
));
395 tsv
->initial_value
= initval
;
397 printf_filtered (_("Trace state variable $%s created, with initial value %s.\n"),
398 tsv
->name
, plongest (tsv
->initial_value
));
400 do_cleanups (old_chain
);
404 delete_trace_variable_command (char *args
, int from_tty
)
408 struct cleanup
*back_to
;
409 struct trace_state_variable
*tsv
;
413 if (query (_("Delete all trace state variables? ")))
414 VEC_free (tsv_s
, tvariables
);
419 argv
= gdb_buildargv (args
);
420 back_to
= make_cleanup_freeargv (argv
);
422 for (i
= 0; argv
[i
] != NULL
; i
++)
425 delete_trace_state_variable (argv
[i
] + 1);
427 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv
[i
]);
430 do_cleanups (back_to
);
435 /* List all the trace state variables. */
438 tvariables_info (char *args
, int from_tty
)
440 struct trace_state_variable
*tsv
;
445 if (target_is_remote ())
449 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
451 /* We don't know anything about the value until we get a
453 tsv
->value_known
= 0;
454 sprintf (buf
, "qTV:%x", tsv
->number
);
456 reply
= remote_get_noisy_reply (&target_buf
, &target_buf_size
);
461 unpack_varlen_hex (reply
+ 1, &tval
);
462 tsv
->value
= (LONGEST
) tval
;
463 tsv
->value_known
= 1;
465 /* FIXME say anything about oddball replies? */
470 if (VEC_length (tsv_s
, tvariables
) == 0)
472 printf_filtered (_("No trace state variables.\n"));
476 printf_filtered (_("Name\t\t Initial\tCurrent\n"));
478 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
480 printf_filtered ("$%s", tsv
->name
);
481 print_spaces_filtered (17 - strlen (tsv
->name
), gdb_stdout
);
482 printf_filtered ("%s ", plongest (tsv
->initial_value
));
483 print_spaces_filtered (11 - strlen (plongest (tsv
->initial_value
)), gdb_stdout
);
484 if (tsv
->value_known
)
485 printf_filtered (" %s", plongest (tsv
->value
));
486 else if (trace_running_p
|| traceframe_number
>= 0)
487 /* The value is/was defined, but we don't have it. */
488 printf_filtered (_(" <unknown>"));
490 /* It is not meaningful to ask about the value. */
491 printf_filtered (_(" <undefined>"));
492 printf_filtered ("\n");
496 /* ACTIONS functions: */
498 /* Prototypes for action-parsing utility commands */
499 static void read_actions (struct breakpoint
*);
501 /* The three functions:
502 collect_pseudocommand,
503 while_stepping_pseudocommand, and
504 end_actions_pseudocommand
505 are placeholders for "commands" that are actually ONLY to be used
506 within a tracepoint action list. If the actual function is ever called,
507 it means that somebody issued the "command" at the top level,
508 which is always an error. */
511 end_actions_pseudocommand (char *args
, int from_tty
)
513 error (_("This command cannot be used at the top level."));
517 while_stepping_pseudocommand (char *args
, int from_tty
)
519 error (_("This command can only be used in a tracepoint actions list."));
523 collect_pseudocommand (char *args
, int from_tty
)
525 error (_("This command can only be used in a tracepoint actions list."));
529 teval_pseudocommand (char *args
, int from_tty
)
531 error (_("This command can only be used in a tracepoint actions list."));
534 /* Enter a list of actions for a tracepoint. */
536 trace_actions_command (char *args
, int from_tty
)
538 struct breakpoint
*t
;
540 char *end_msg
= "End with a line saying just \"end\".";
542 t
= get_tracepoint_by_number (&args
, 0, 1);
545 sprintf (tmpbuf
, "Enter actions for tracepoint %d, one per line.",
550 if (deprecated_readline_begin_hook
)
551 (*deprecated_readline_begin_hook
) ("%s %s\n", tmpbuf
, end_msg
);
552 else if (input_from_terminal_p ())
553 printf_filtered ("%s\n%s\n", tmpbuf
, end_msg
);
557 t
->step_count
= 0; /* read_actions may set this */
560 if (deprecated_readline_end_hook
)
561 (*deprecated_readline_end_hook
) ();
562 /* tracepoints_changed () */
564 /* else just return */
567 /* worker function */
569 read_actions (struct breakpoint
*t
)
572 char *prompt1
= "> ", *prompt2
= " > ";
573 char *prompt
= prompt1
;
574 enum actionline_type linetype
;
575 extern FILE *instream
;
576 struct action_line
*next
= NULL
, *temp
;
577 struct cleanup
*old_chain
;
579 /* Control-C quits instantly if typed while in this loop
580 since it should not wait until the user types a newline. */
582 /* FIXME: kettenis/20010823: Something is wrong here. In this file
583 STOP_SIGNAL is never defined. So this code has been left out, at
584 least for quite a while now. Replacing STOP_SIGNAL with SIGTSTP
585 leads to compilation failures since the variable job_control
586 isn't declared. Leave this alone for now. */
589 signal (STOP_SIGNAL
, handle_stop_sig
);
591 old_chain
= make_cleanup_free_actions (t
);
594 /* Make sure that all output has been output. Some machines may
595 let you get away with leaving out some of the gdb_flush, but
598 gdb_flush (gdb_stdout
);
599 gdb_flush (gdb_stderr
);
601 if (deprecated_readline_hook
&& instream
== NULL
)
602 line
= (*deprecated_readline_hook
) (prompt
);
603 else if (instream
== stdin
&& ISATTY (instream
))
605 line
= gdb_readline_wrapper (prompt
);
606 if (line
&& *line
) /* add it to command history */
610 line
= gdb_readline (0);
614 line
= xstrdup ("end");
615 printf_filtered ("end\n");
618 linetype
= validate_actionline (&line
, t
);
619 if (linetype
== BADLINE
)
620 continue; /* already warned -- collect another line */
622 temp
= xmalloc (sizeof (struct action_line
));
626 if (next
== NULL
) /* first action for this tracepoint? */
627 t
->actions
= next
= temp
;
634 if (linetype
== STEPPING
) /* begin "while-stepping" */
636 if (prompt
== prompt2
)
638 warning (_("Already processing 'while-stepping'"));
642 prompt
= prompt2
; /* change prompt for stepping actions */
644 else if (linetype
== END
)
646 if (prompt
== prompt2
)
648 prompt
= prompt1
; /* end of single-stepping actions */
651 { /* end of actions */
652 if (t
->actions
->next
== NULL
)
654 /* An "end" all by itself with no other actions
655 means this tracepoint has no actions.
656 Discard empty list. */
665 signal (STOP_SIGNAL
, SIG_DFL
);
668 discard_cleanups (old_chain
);
671 /* worker function */
673 validate_actionline (char **line
, struct breakpoint
*t
)
675 struct cmd_list_element
*c
;
676 struct expression
*exp
= NULL
;
677 struct cleanup
*old_chain
= NULL
;
680 /* if EOF is typed, *line is NULL */
684 for (p
= *line
; isspace ((int) *p
);)
687 /* Symbol lookup etc. */
688 if (*p
== '\0') /* empty line: just prompt for another line. */
691 if (*p
== '#') /* comment line */
694 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
697 warning (_("'%s' is not an action that I know, or is ambiguous."),
702 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
704 struct agent_expr
*aexpr
;
705 struct agent_reqs areqs
;
708 { /* repeat over a comma-separated list */
709 QUIT
; /* allow user to bail out with ^C */
710 while (isspace ((int) *p
))
713 if (*p
== '$') /* look for special pseudo-symbols */
715 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
716 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
717 (0 == strncasecmp ("loc", p
+ 1, 3)))
722 /* else fall thru, treat p as an expression and parse it! */
724 exp
= parse_exp_1 (&p
, block_for_pc (t
->loc
->address
), 1);
725 old_chain
= make_cleanup (free_current_contents
, &exp
);
727 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
729 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
731 warning (_("constant %s (value %ld) will not be collected."),
732 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
733 SYMBOL_VALUE (exp
->elts
[2].symbol
));
736 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
738 warning (_("%s is optimized away and cannot be collected."),
739 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
744 /* We have something to collect, make sure that the expr to
745 bytecode translator can handle it and that it's not too
747 aexpr
= gen_trace_for_expr (t
->loc
->address
, exp
);
748 make_cleanup_free_agent_expr (aexpr
);
750 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
751 error (_("expression too complicated, try simplifying"));
753 ax_reqs (aexpr
, &areqs
);
754 (void) make_cleanup (xfree
, areqs
.reg_mask
);
756 if (areqs
.flaw
!= agent_flaw_none
)
757 error (_("malformed expression"));
759 if (areqs
.min_height
< 0)
760 error (_("gdb: Internal error: expression has min height < 0"));
762 if (areqs
.max_height
> 20)
763 error (_("expression too complicated, try simplifying"));
765 do_cleanups (old_chain
);
767 while (p
&& *p
++ == ',');
770 else if (cmd_cfunc_eq (c
, teval_pseudocommand
))
772 struct agent_expr
*aexpr
;
775 { /* repeat over a comma-separated list */
776 QUIT
; /* allow user to bail out with ^C */
777 while (isspace ((int) *p
))
780 /* Only expressions are allowed for this action. */
781 exp
= parse_exp_1 (&p
, block_for_pc (t
->loc
->address
), 1);
782 old_chain
= make_cleanup (free_current_contents
, &exp
);
784 /* We have something to evaluate, make sure that the expr to
785 bytecode translator can handle it and that it's not too
787 aexpr
= gen_eval_for_expr (t
->loc
->address
, exp
);
788 make_cleanup_free_agent_expr (aexpr
);
790 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
791 error (_("expression too complicated, try simplifying"));
793 do_cleanups (old_chain
);
795 while (p
&& *p
++ == ',');
798 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
800 char *steparg
; /* in case warning is necessary */
802 while (isspace ((int) *p
))
807 (t
->step_count
= strtol (p
, &p
, 0)) == 0)
809 warning (_("'%s': bad step-count; command ignored."), *line
);
814 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
818 warning (_("'%s' is not a supported tracepoint action."), *line
);
823 /* worker function */
825 free_actions (struct breakpoint
*t
)
827 struct action_line
*line
, *next
;
829 for (line
= t
->actions
; line
; line
= next
)
833 xfree (line
->action
);
840 do_free_actions_cleanup (void *t
)
845 static struct cleanup
*
846 make_cleanup_free_actions (struct breakpoint
*t
)
848 return make_cleanup (do_free_actions_cleanup
, t
);
852 memrange_absolute
= -1
857 int type
; /* memrange_absolute for absolute memory range,
858 else basereg number */
859 bfd_signed_vma start
;
863 struct collection_list
865 unsigned char regs_mask
[32]; /* room for up to 256 regs */
868 struct memrange
*list
;
869 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
871 struct agent_expr
**aexpr_list
;
874 tracepoint_list
, stepping_list
;
876 /* MEMRANGE functions: */
878 static int memrange_cmp (const void *, const void *);
880 /* compare memranges for qsort */
882 memrange_cmp (const void *va
, const void *vb
)
884 const struct memrange
*a
= va
, *b
= vb
;
886 if (a
->type
< b
->type
)
888 if (a
->type
> b
->type
)
890 if (a
->type
== memrange_absolute
)
892 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
894 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
899 if (a
->start
< b
->start
)
901 if (a
->start
> b
->start
)
907 /* Sort the memrange list using qsort, and merge adjacent memranges. */
909 memrange_sortmerge (struct collection_list
*memranges
)
913 qsort (memranges
->list
, memranges
->next_memrange
,
914 sizeof (struct memrange
), memrange_cmp
);
915 if (memranges
->next_memrange
> 0)
917 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
919 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
920 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
923 /* memrange b starts before memrange a ends; merge them. */
924 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
925 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
926 continue; /* next b, same a */
930 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
931 sizeof (struct memrange
));
933 memranges
->next_memrange
= a
+ 1;
937 /* Add a register to a collection list. */
939 add_register (struct collection_list
*collection
, unsigned int regno
)
942 printf_filtered ("collect register %d\n", regno
);
943 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
944 error (_("Internal: register number %d too large for tracepoint"),
946 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
949 /* Add a memrange to a collection list */
951 add_memrange (struct collection_list
*memranges
,
952 int type
, bfd_signed_vma base
,
957 printf_filtered ("(%d,", type
);
959 printf_filtered (",%ld)\n", len
);
962 /* type: memrange_absolute == memory, other n == basereg */
963 memranges
->list
[memranges
->next_memrange
].type
= type
;
964 /* base: addr if memory, offset if reg relative. */
965 memranges
->list
[memranges
->next_memrange
].start
= base
;
966 /* len: we actually save end (base + len) for convenience */
967 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
968 memranges
->next_memrange
++;
969 if (memranges
->next_memrange
>= memranges
->listsize
)
971 memranges
->listsize
*= 2;
972 memranges
->list
= xrealloc (memranges
->list
,
973 memranges
->listsize
);
976 if (type
!= memrange_absolute
) /* Better collect the base register! */
977 add_register (memranges
, type
);
980 /* Add a symbol to a collection list. */
982 collect_symbol (struct collection_list
*collect
,
984 struct gdbarch
*gdbarch
,
985 long frame_regno
, long frame_offset
,
990 bfd_signed_vma offset
;
992 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
993 switch (SYMBOL_CLASS (sym
))
996 printf_filtered ("%s: don't know symbol class %d\n",
997 SYMBOL_PRINT_NAME (sym
),
1001 printf_filtered ("constant %s (value %ld) will not be collected.\n",
1002 SYMBOL_PRINT_NAME (sym
), SYMBOL_VALUE (sym
));
1005 offset
= SYMBOL_VALUE_ADDRESS (sym
);
1010 sprintf_vma (tmp
, offset
);
1011 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1012 SYMBOL_PRINT_NAME (sym
), len
,
1015 add_memrange (collect
, memrange_absolute
, offset
, len
);
1018 reg
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
1020 printf_filtered ("LOC_REG[parm] %s: ",
1021 SYMBOL_PRINT_NAME (sym
));
1022 add_register (collect
, reg
);
1023 /* Check for doubles stored in two registers. */
1024 /* FIXME: how about larger types stored in 3 or more regs? */
1025 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1026 len
> register_size (gdbarch
, reg
))
1027 add_register (collect
, reg
+ 1);
1030 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1031 printf_filtered (" (will not collect %s)\n",
1032 SYMBOL_PRINT_NAME (sym
));
1036 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1039 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1040 SYMBOL_PRINT_NAME (sym
), len
);
1041 printf_vma (offset
);
1042 printf_filtered (" from frame ptr reg %d\n", reg
);
1044 add_memrange (collect
, reg
, offset
, len
);
1046 case LOC_REGPARM_ADDR
:
1047 reg
= SYMBOL_VALUE (sym
);
1051 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1052 SYMBOL_PRINT_NAME (sym
), len
);
1053 printf_vma (offset
);
1054 printf_filtered (" from reg %d\n", reg
);
1056 add_memrange (collect
, reg
, offset
, len
);
1060 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1063 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1064 SYMBOL_PRINT_NAME (sym
), len
);
1065 printf_vma (offset
);
1066 printf_filtered (" from frame ptr reg %d\n", reg
);
1068 add_memrange (collect
, reg
, offset
, len
);
1070 case LOC_UNRESOLVED
:
1071 printf_filtered ("Don't know LOC_UNRESOLVED %s\n",
1072 SYMBOL_PRINT_NAME (sym
));
1074 case LOC_OPTIMIZED_OUT
:
1075 printf_filtered ("%s has been optimized out of existence.\n",
1076 SYMBOL_PRINT_NAME (sym
));
1081 struct agent_expr
*aexpr
;
1082 struct cleanup
*old_chain1
= NULL
;
1083 struct agent_reqs areqs
;
1085 aexpr
= gen_trace_for_var (scope
, sym
);
1087 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1089 ax_reqs (aexpr
, &areqs
);
1090 if (areqs
.flaw
!= agent_flaw_none
)
1091 error (_("malformed expression"));
1093 if (areqs
.min_height
< 0)
1094 error (_("gdb: Internal error: expression has min height < 0"));
1095 if (areqs
.max_height
> 20)
1096 error (_("expression too complicated, try simplifying"));
1098 discard_cleanups (old_chain1
);
1099 add_aexpr (collect
, aexpr
);
1101 /* take care of the registers */
1102 if (areqs
.reg_mask_len
> 0)
1106 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1108 QUIT
; /* allow user to bail out with ^C */
1109 if (areqs
.reg_mask
[ndx1
] != 0)
1111 /* assume chars have 8 bits */
1112 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1113 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1114 /* it's used -- record it */
1115 add_register (collect
,
1125 /* Add all locals (or args) symbols to collection list */
1127 add_local_symbols (struct collection_list
*collect
,
1128 struct gdbarch
*gdbarch
, CORE_ADDR pc
,
1129 long frame_regno
, long frame_offset
, int type
)
1132 struct block
*block
;
1133 struct dict_iterator iter
;
1136 block
= block_for_pc (pc
);
1139 QUIT
; /* allow user to bail out with ^C */
1140 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
1142 if (SYMBOL_IS_ARGUMENT (sym
)
1143 ? type
== 'A' /* collecting Arguments */
1144 : type
== 'L') /* collecting Locals */
1147 collect_symbol (collect
, sym
, gdbarch
,
1148 frame_regno
, frame_offset
, pc
);
1151 if (BLOCK_FUNCTION (block
))
1154 block
= BLOCK_SUPERBLOCK (block
);
1157 warning (_("No %s found in scope."),
1158 type
== 'L' ? "locals" : "args");
1161 /* worker function */
1163 clear_collection_list (struct collection_list
*list
)
1167 list
->next_memrange
= 0;
1168 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1170 free_agent_expr (list
->aexpr_list
[ndx
]);
1171 list
->aexpr_list
[ndx
] = NULL
;
1173 list
->next_aexpr_elt
= 0;
1174 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1177 /* reduce a collection list to string form (for gdb protocol) */
1179 stringify_collection_list (struct collection_list
*list
, char *string
)
1181 char temp_buf
[2048];
1185 char *(*str_list
)[];
1189 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1190 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1192 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1193 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1195 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1198 printf_filtered ("\nCollecting registers (mask): 0x");
1203 QUIT
; /* allow user to bail out with ^C */
1205 printf_filtered ("%02X", list
->regs_mask
[i
]);
1206 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1209 (*str_list
)[ndx
] = xstrdup (temp_buf
);
1213 printf_filtered ("\n");
1214 if (list
->next_memrange
> 0 && info_verbose
)
1215 printf_filtered ("Collecting memranges: \n");
1216 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1218 QUIT
; /* allow user to bail out with ^C */
1219 sprintf_vma (tmp2
, list
->list
[i
].start
);
1222 printf_filtered ("(%d, %s, %ld)\n",
1225 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1227 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1229 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1236 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1238 /* The "%X" conversion specifier expects an unsigned argument,
1239 so passing -1 (memrange_absolute) to it directly gives you
1240 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1242 if (list
->list
[i
].type
== memrange_absolute
)
1243 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1245 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1248 count
+= strlen (end
);
1249 end
= temp_buf
+ count
;
1252 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1254 QUIT
; /* allow user to bail out with ^C */
1255 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1257 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1262 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1263 end
+= 10; /* 'X' + 8 hex digits + ',' */
1266 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1267 end
, list
->aexpr_list
[i
]->len
);
1268 count
+= 2 * list
->aexpr_list
[i
]->len
;
1273 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1278 (*str_list
)[ndx
] = NULL
;
1290 free_actions_list_cleanup_wrapper (void *al
)
1292 free_actions_list (al
);
1296 free_actions_list (char **actions_list
)
1300 if (actions_list
== 0)
1303 for (ndx
= 0; actions_list
[ndx
]; ndx
++)
1304 xfree (actions_list
[ndx
]);
1306 xfree (actions_list
);
1309 /* Render all actions into gdb protocol. */
1311 encode_actions (struct breakpoint
*t
, char ***tdp_actions
,
1312 char ***stepping_actions
)
1314 static char tdp_buff
[2048], step_buff
[2048];
1316 struct expression
*exp
= NULL
;
1317 struct action_line
*action
;
1319 struct value
*tempval
;
1320 struct collection_list
*collect
;
1321 struct cmd_list_element
*cmd
;
1322 struct agent_expr
*aexpr
;
1324 LONGEST frame_offset
;
1325 char *default_collect_line
= NULL
;
1326 struct action_line
*default_collect_action
= NULL
;
1328 clear_collection_list (&tracepoint_list
);
1329 clear_collection_list (&stepping_list
);
1330 collect
= &tracepoint_list
;
1332 *tdp_actions
= NULL
;
1333 *stepping_actions
= NULL
;
1335 gdbarch_virtual_frame_pointer (t
->gdbarch
,
1336 t
->loc
->address
, &frame_reg
, &frame_offset
);
1338 action
= t
->actions
;
1340 /* If there are default expressions to collect, make up a collect
1341 action and prepend to the action list to encode. Note that since
1342 validation is per-tracepoint (local var "xyz" might be valid for
1343 one tracepoint and not another, etc), we make up the action on
1344 the fly, and don't cache it. */
1345 if (*default_collect
)
1348 enum actionline_type linetype
;
1350 default_collect_line
= xmalloc (12 + strlen (default_collect
));
1351 sprintf (default_collect_line
, "collect %s", default_collect
);
1352 line
= default_collect_line
;
1353 linetype
= validate_actionline (&line
, t
);
1354 if (linetype
!= BADLINE
)
1356 default_collect_action
= xmalloc (sizeof (struct action_line
));
1357 default_collect_action
->next
= t
->actions
;
1358 default_collect_action
->action
= line
;
1359 action
= default_collect_action
;
1363 for (; action
; action
= action
->next
)
1365 QUIT
; /* allow user to bail out with ^C */
1366 action_exp
= action
->action
;
1367 while (isspace ((int) *action_exp
))
1370 if (*action_exp
== '#') /* comment line */
1373 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1375 error (_("Bad action list item: %s"), action_exp
);
1377 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1380 { /* repeat over a comma-separated list */
1381 QUIT
; /* allow user to bail out with ^C */
1382 while (isspace ((int) *action_exp
))
1385 if (0 == strncasecmp ("$reg", action_exp
, 4))
1387 for (i
= 0; i
< gdbarch_num_regs (t
->gdbarch
); i
++)
1388 add_register (collect
, i
);
1389 action_exp
= strchr (action_exp
, ','); /* more? */
1391 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1393 add_local_symbols (collect
,
1399 action_exp
= strchr (action_exp
, ','); /* more? */
1401 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1403 add_local_symbols (collect
,
1409 action_exp
= strchr (action_exp
, ','); /* more? */
1413 unsigned long addr
, len
;
1414 struct cleanup
*old_chain
= NULL
;
1415 struct cleanup
*old_chain1
= NULL
;
1416 struct agent_reqs areqs
;
1418 exp
= parse_exp_1 (&action_exp
,
1419 block_for_pc (t
->loc
->address
), 1);
1420 old_chain
= make_cleanup (free_current_contents
, &exp
);
1422 switch (exp
->elts
[0].opcode
)
1426 const char *name
= &exp
->elts
[2].string
;
1428 i
= user_reg_map_name_to_regnum (t
->gdbarch
,
1429 name
, strlen (name
));
1431 internal_error (__FILE__
, __LINE__
,
1432 _("Register $%s not available"),
1435 printf_filtered ("OP_REGISTER: ");
1436 add_register (collect
, i
);
1441 /* safe because we know it's a simple expression */
1442 tempval
= evaluate_expression (exp
);
1443 addr
= value_address (tempval
);
1444 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1445 add_memrange (collect
, memrange_absolute
, addr
, len
);
1449 collect_symbol (collect
,
1450 exp
->elts
[2].symbol
,
1457 default: /* full-fledged expression */
1458 aexpr
= gen_trace_for_expr (t
->loc
->address
, exp
);
1460 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1462 ax_reqs (aexpr
, &areqs
);
1463 if (areqs
.flaw
!= agent_flaw_none
)
1464 error (_("malformed expression"));
1466 if (areqs
.min_height
< 0)
1467 error (_("gdb: Internal error: expression has min height < 0"));
1468 if (areqs
.max_height
> 20)
1469 error (_("expression too complicated, try simplifying"));
1471 discard_cleanups (old_chain1
);
1472 add_aexpr (collect
, aexpr
);
1474 /* take care of the registers */
1475 if (areqs
.reg_mask_len
> 0)
1480 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1482 QUIT
; /* allow user to bail out with ^C */
1483 if (areqs
.reg_mask
[ndx1
] != 0)
1485 /* assume chars have 8 bits */
1486 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1487 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1488 /* it's used -- record it */
1489 add_register (collect
,
1496 do_cleanups (old_chain
);
1499 while (action_exp
&& *action_exp
++ == ',');
1501 else if (cmd_cfunc_eq (cmd
, teval_pseudocommand
))
1504 { /* repeat over a comma-separated list */
1505 QUIT
; /* allow user to bail out with ^C */
1506 while (isspace ((int) *action_exp
))
1510 unsigned long addr
, len
;
1511 struct cleanup
*old_chain
= NULL
;
1512 struct cleanup
*old_chain1
= NULL
;
1513 struct agent_reqs areqs
;
1515 exp
= parse_exp_1 (&action_exp
,
1516 block_for_pc (t
->loc
->address
), 1);
1517 old_chain
= make_cleanup (free_current_contents
, &exp
);
1519 aexpr
= gen_eval_for_expr (t
->loc
->address
, exp
);
1520 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1522 ax_reqs (aexpr
, &areqs
);
1523 if (areqs
.flaw
!= agent_flaw_none
)
1524 error (_("malformed expression"));
1526 if (areqs
.min_height
< 0)
1527 error (_("gdb: Internal error: expression has min height < 0"));
1528 if (areqs
.max_height
> 20)
1529 error (_("expression too complicated, try simplifying"));
1531 discard_cleanups (old_chain1
);
1532 /* Even though we're not officially collecting, add
1533 to the collect list anyway. */
1534 add_aexpr (collect
, aexpr
);
1536 do_cleanups (old_chain
);
1539 while (action_exp
&& *action_exp
++ == ',');
1541 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1543 collect
= &stepping_list
;
1545 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
1547 if (collect
== &stepping_list
) /* end stepping actions */
1548 collect
= &tracepoint_list
;
1550 break; /* end tracepoint actions */
1553 memrange_sortmerge (&tracepoint_list
);
1554 memrange_sortmerge (&stepping_list
);
1556 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1558 *stepping_actions
= stringify_collection_list (&stepping_list
,
1561 xfree (default_collect_line
);
1562 xfree (default_collect_action
);
1566 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1568 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1570 collect
->aexpr_list
=
1571 xrealloc (collect
->aexpr_list
,
1572 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1573 collect
->aexpr_listsize
*= 2;
1575 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1576 collect
->next_aexpr_elt
++;
1579 /* Set "transparent" memory ranges
1581 Allow trace mechanism to treat text-like sections
1582 (and perhaps all read-only sections) transparently,
1583 i.e. don't reject memory requests from these address ranges
1584 just because they haven't been collected. */
1587 remote_set_transparent_ranges (void)
1595 return; /* No information to give. */
1597 strcpy (target_buf
, "QTro");
1598 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
1600 char tmp1
[40], tmp2
[40];
1602 if ((s
->flags
& SEC_LOAD
) == 0 ||
1603 /* (s->flags & SEC_CODE) == 0 || */
1604 (s
->flags
& SEC_READONLY
) == 0)
1609 size
= bfd_get_section_size (s
);
1610 sprintf_vma (tmp1
, lma
);
1611 sprintf_vma (tmp2
, lma
+ size
);
1612 sprintf (target_buf
+ strlen (target_buf
),
1613 ":%s,%s", tmp1
, tmp2
);
1617 putpkt (target_buf
);
1618 getpkt (&target_buf
, &target_buf_size
, 0);
1624 Tell target to clear any previous trace experiment.
1625 Walk the list of tracepoints, and send them (and their actions)
1626 to the target. If no errors,
1627 Tell target to start a new trace experiment. */
1629 void download_tracepoint (struct breakpoint
*t
);
1632 trace_start_command (char *args
, int from_tty
)
1635 VEC(breakpoint_p
) *tp_vec
= NULL
;
1637 struct breakpoint
*t
;
1638 struct trace_state_variable
*tsv
;
1640 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1642 if (target_is_remote ())
1645 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1646 if (strcmp (target_buf
, "OK"))
1647 error (_("Target does not support this command."));
1649 tp_vec
= all_tracepoints ();
1650 for (ix
= 0; VEC_iterate (breakpoint_p
, tp_vec
, ix
, t
); ix
++)
1652 download_tracepoint (t
);
1654 VEC_free (breakpoint_p
, tp_vec
);
1656 /* Init any trace state variables that start with nonzero values. */
1658 for (ix
= 0; VEC_iterate (tsv_s
, tvariables
, ix
, tsv
); ++ix
)
1660 if (tsv
->initial_value
!= 0)
1662 sprintf (buf
, "QTDV:%x:%s",
1663 tsv
->number
, phex ((ULONGEST
) tsv
->initial_value
, 8));
1665 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1669 /* Tell target to treat text-like sections as transparent. */
1670 remote_set_transparent_ranges ();
1671 /* Now insert traps and begin collecting data. */
1673 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1674 if (strcmp (target_buf
, "OK"))
1675 error (_("Bogus reply from target: %s"), target_buf
);
1676 set_traceframe_num (-1); /* All old traceframes invalidated. */
1677 set_tracepoint_num (-1);
1678 set_traceframe_context (NULL
);
1679 trace_running_p
= 1;
1680 if (deprecated_trace_start_stop_hook
)
1681 deprecated_trace_start_stop_hook (1, from_tty
);
1685 error (_("Trace can only be run on remote targets."));
1688 /* Send the definition of a single tracepoint to the target. */
1691 download_tracepoint (struct breakpoint
*t
)
1696 char **stepping_actions
;
1698 struct cleanup
*old_chain
= NULL
;
1699 struct agent_expr
*aexpr
;
1700 struct cleanup
*aexpr_chain
= NULL
;
1702 sprintf_vma (tmp
, (t
->loc
? t
->loc
->address
: 0));
1703 sprintf (buf
, "QTDP:%x:%s:%c:%lx:%x", t
->number
,
1705 (t
->enable_state
== bp_enabled
? 'E' : 'D'),
1706 t
->step_count
, t
->pass_count
);
1707 /* If the tracepoint has a conditional, make it into an agent
1708 expression and append to the definition. */
1711 /* Only test support at download time, we may not know target
1712 capabilities at definition time. */
1713 if (remote_supports_cond_tracepoints ())
1715 aexpr
= gen_eval_for_expr (t
->loc
->address
, t
->loc
->cond
);
1716 aexpr_chain
= make_cleanup_free_agent_expr (aexpr
);
1717 sprintf (buf
+ strlen (buf
), ":X%x,", aexpr
->len
);
1718 mem2hex (aexpr
->buf
, buf
+ strlen (buf
), aexpr
->len
);
1719 do_cleanups (aexpr_chain
);
1722 warning (_("Target does not support conditional tracepoints, ignoring tp %d cond"), t
->number
);
1725 if (t
->actions
|| *default_collect
)
1728 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1729 if (strcmp (target_buf
, "OK"))
1730 error (_("Target does not support tracepoints."));
1732 if (!t
->actions
&& !*default_collect
)
1735 encode_actions (t
, &tdp_actions
, &stepping_actions
);
1736 old_chain
= make_cleanup (free_actions_list_cleanup_wrapper
,
1738 (void) make_cleanup (free_actions_list_cleanup_wrapper
, stepping_actions
);
1740 /* do_single_steps (t); */
1743 for (ndx
= 0; tdp_actions
[ndx
]; ndx
++)
1745 QUIT
; /* allow user to bail out with ^C */
1746 sprintf (buf
, "QTDP:-%x:%s:%s%c",
1747 t
->number
, tmp
, /* address */
1749 ((tdp_actions
[ndx
+ 1] || stepping_actions
)
1752 remote_get_noisy_reply (&target_buf
,
1754 if (strcmp (target_buf
, "OK"))
1755 error (_("Error on target while setting tracepoints."));
1758 if (stepping_actions
)
1760 for (ndx
= 0; stepping_actions
[ndx
]; ndx
++)
1762 QUIT
; /* allow user to bail out with ^C */
1763 sprintf (buf
, "QTDP:-%x:%s:%s%s%s",
1764 t
->number
, tmp
, /* address */
1765 ((ndx
== 0) ? "S" : ""),
1766 stepping_actions
[ndx
],
1767 (stepping_actions
[ndx
+ 1] ? "-" : ""));
1769 remote_get_noisy_reply (&target_buf
,
1771 if (strcmp (target_buf
, "OK"))
1772 error (_("Error on target while setting tracepoints."));
1775 do_cleanups (old_chain
);
1780 trace_stop_command (char *args
, int from_tty
)
1782 if (target_is_remote ())
1785 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1786 if (strcmp (target_buf
, "OK"))
1787 error (_("Bogus reply from target: %s"), target_buf
);
1788 trace_running_p
= 0;
1789 if (deprecated_trace_start_stop_hook
)
1790 deprecated_trace_start_stop_hook (0, from_tty
);
1793 error (_("Trace can only be run on remote targets."));
1796 unsigned long trace_running_p
;
1798 /* tstatus command */
1800 trace_status_command (char *args
, int from_tty
)
1802 if (target_is_remote ())
1804 putpkt ("qTStatus");
1805 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1807 if (target_buf
[0] != 'T' ||
1808 (target_buf
[1] != '0' && target_buf
[1] != '1'))
1809 error (_("Bogus reply from target: %s"), target_buf
);
1811 /* exported for use by the GUI */
1812 trace_running_p
= (target_buf
[1] == '1');
1814 if (trace_running_p
)
1815 printf_filtered (_("Trace is running on the target.\n"));
1817 printf_filtered (_("Trace is not running on the target.\n"));
1819 if (traceframe_number
>= 0)
1820 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1821 traceframe_number
, tracepoint_number
);
1823 printf_filtered (_("Not looking at any trace frame.\n"));
1827 error (_("Trace can only be run on remote targets."));
1830 /* Worker function for the various flavors of the tfind command. */
1832 finish_tfind_command (char **msg
,
1836 int target_frameno
= -1, target_tracept
= -1;
1837 struct frame_id old_frame_id
;
1840 old_frame_id
= get_frame_id (get_current_frame ());
1843 reply
= remote_get_noisy_reply (msg
, sizeof_msg
);
1845 while (reply
&& *reply
)
1849 if ((target_frameno
= (int) strtol (++reply
, &reply
, 16)) == -1)
1851 /* A request for a non-existant trace frame has failed.
1852 Our response will be different, depending on FROM_TTY:
1854 If FROM_TTY is true, meaning that this command was
1855 typed interactively by the user, then give an error
1856 and DO NOT change the state of traceframe_number etc.
1858 However if FROM_TTY is false, meaning that we're either
1859 in a script, a loop, or a user-defined command, then
1860 DON'T give an error, but DO change the state of
1861 traceframe_number etc. to invalid.
1863 The rationalle is that if you typed the command, you
1864 might just have committed a typo or something, and you'd
1865 like to NOT lose your current debugging state. However
1866 if you're in a user-defined command or especially in a
1867 loop, then you need a way to detect that the command
1868 failed WITHOUT aborting. This allows you to write
1869 scripts that search thru the trace buffer until the end,
1870 and then continue on to do something else. */
1873 error (_("Target failed to find requested trace frame."));
1877 printf_filtered ("End of trace buffer.\n");
1878 /* The following will not recurse, since it's
1880 trace_find_command ("-1", from_tty
);
1881 reply
= NULL
; /* Break out of loop
1882 (avoid recursive nonsense). */
1887 if ((target_tracept
= (int) strtol (++reply
, &reply
, 16)) == -1)
1888 error (_("Target failed to find requested trace frame."));
1890 case 'O': /* "OK"? */
1891 if (reply
[1] == 'K' && reply
[2] == '\0')
1894 error (_("Bogus reply from target: %s"), reply
);
1897 error (_("Bogus reply from target: %s"), reply
);
1900 reinit_frame_cache ();
1901 registers_changed ();
1902 set_traceframe_num (target_frameno
);
1903 set_tracepoint_num (target_tracept
);
1904 if (target_frameno
== -1)
1905 set_traceframe_context (NULL
);
1907 set_traceframe_context (get_current_frame ());
1911 enum print_what print_what
;
1913 /* NOTE: in immitation of the step command, try to determine
1914 whether we have made a transition from one function to
1915 another. If so, we'll print the "stack frame" (ie. the new
1916 function and it's arguments) -- otherwise we'll just show the
1919 if (frame_id_eq (old_frame_id
,
1920 get_frame_id (get_current_frame ())))
1921 print_what
= SRC_LINE
;
1923 print_what
= SRC_AND_LOC
;
1925 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
1930 /* trace_find_command takes a trace frame number n,
1931 sends "QTFrame:<n>" to the target,
1932 and accepts a reply that may contain several optional pieces
1933 of information: a frame number, a tracepoint number, and an
1934 indication of whether this is a trap frame or a stepping frame.
1936 The minimal response is just "OK" (which indicates that the
1937 target does not give us a frame number or a tracepoint number).
1938 Instead of that, the target may send us a string containing
1940 F<hexnum> (gives the selected frame number)
1941 T<hexnum> (gives the selected tracepoint number)
1946 trace_find_command (char *args
, int from_tty
)
1947 { /* this should only be called with a numeric argument */
1950 if (target_is_remote ())
1952 if (trace_running_p
)
1953 error ("May not look at trace frames while trace is running.");
1955 if (deprecated_trace_find_hook
)
1956 deprecated_trace_find_hook (args
, from_tty
);
1958 if (args
== 0 || *args
== 0)
1959 { /* TFIND with no args means find NEXT trace frame. */
1960 if (traceframe_number
== -1)
1961 frameno
= 0; /* "next" is first one */
1963 frameno
= traceframe_number
+ 1;
1965 else if (0 == strcmp (args
, "-"))
1967 if (traceframe_number
== -1)
1968 error (_("not debugging trace buffer"));
1969 else if (from_tty
&& traceframe_number
== 0)
1970 error (_("already at start of trace buffer"));
1972 frameno
= traceframe_number
- 1;
1975 frameno
= parse_and_eval_long (args
);
1978 error (_("invalid input (%d is less than zero)"), frameno
);
1980 sprintf (target_buf
, "QTFrame:%x", frameno
);
1981 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
1984 error (_("Trace can only be run on remote targets."));
1989 trace_find_end_command (char *args
, int from_tty
)
1991 trace_find_command ("-1", from_tty
);
1996 trace_find_none_command (char *args
, int from_tty
)
1998 trace_find_command ("-1", from_tty
);
2003 trace_find_start_command (char *args
, int from_tty
)
2005 trace_find_command ("0", from_tty
);
2008 /* tfind pc command */
2010 trace_find_pc_command (char *args
, int from_tty
)
2015 if (target_is_remote ())
2017 if (trace_running_p
)
2018 error ("May not look at trace frames while trace is running.");
2020 if (args
== 0 || *args
== 0)
2021 pc
= regcache_read_pc (get_current_regcache ());
2023 pc
= parse_and_eval_address (args
);
2025 sprintf_vma (tmp
, pc
);
2026 sprintf (target_buf
, "QTFrame:pc:%s", tmp
);
2027 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2030 error (_("Trace can only be run on remote targets."));
2033 /* tfind tracepoint command */
2035 trace_find_tracepoint_command (char *args
, int from_tty
)
2039 if (target_is_remote ())
2041 if (trace_running_p
)
2042 error ("May not look at trace frames while trace is running.");
2044 if (args
== 0 || *args
== 0)
2046 if (tracepoint_number
== -1)
2047 error (_("No current tracepoint -- please supply an argument."));
2049 tdp
= tracepoint_number
; /* default is current TDP */
2052 tdp
= parse_and_eval_long (args
);
2054 sprintf (target_buf
, "QTFrame:tdp:%x", tdp
);
2055 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2058 error (_("Trace can only be run on remote targets."));
2061 /* TFIND LINE command:
2063 This command will take a sourceline for argument, just like BREAK
2064 or TRACE (ie. anything that "decode_line_1" can handle).
2066 With no argument, this command will find the next trace frame
2067 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2070 trace_find_line_command (char *args
, int from_tty
)
2072 static CORE_ADDR start_pc
, end_pc
;
2073 struct symtabs_and_lines sals
;
2074 struct symtab_and_line sal
;
2075 struct cleanup
*old_chain
;
2076 char startpc_str
[40], endpc_str
[40];
2078 if (target_is_remote ())
2080 if (trace_running_p
)
2081 error ("May not look at trace frames while trace is running.");
2083 if (args
== 0 || *args
== 0)
2085 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2087 sals
.sals
= (struct symtab_and_line
*)
2088 xmalloc (sizeof (struct symtab_and_line
));
2093 sals
= decode_line_spec (args
, 1);
2097 old_chain
= make_cleanup (xfree
, sals
.sals
);
2098 if (sal
.symtab
== 0)
2100 struct gdbarch
*gdbarch
= get_current_arch ();
2102 printf_filtered ("TFIND: No line number information available");
2105 /* This is useful for "info line *0x7f34". If we can't
2106 tell the user about a source line, at least let them
2107 have the symbolic address. */
2108 printf_filtered (" for address ");
2110 print_address (gdbarch
, sal
.pc
, gdb_stdout
);
2111 printf_filtered (";\n -- will attempt to find by PC. \n");
2115 printf_filtered (".\n");
2116 return; /* No line, no PC; what can we do? */
2119 else if (sal
.line
> 0
2120 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2122 struct gdbarch
*gdbarch
= get_objfile_arch (sal
.symtab
->objfile
);
2124 if (start_pc
== end_pc
)
2126 printf_filtered ("Line %d of \"%s\"",
2127 sal
.line
, sal
.symtab
->filename
);
2129 printf_filtered (" is at address ");
2130 print_address (gdbarch
, start_pc
, gdb_stdout
);
2132 printf_filtered (" but contains no code.\n");
2133 sal
= find_pc_line (start_pc
, 0);
2135 find_line_pc_range (sal
, &start_pc
, &end_pc
) &&
2137 printf_filtered ("Attempting to find line %d instead.\n",
2140 error (_("Cannot find a good line."));
2144 /* Is there any case in which we get here, and have an address
2145 which the user would want to see? If we have debugging
2146 symbols and no line numbers? */
2147 error (_("Line number %d is out of range for \"%s\"."),
2148 sal
.line
, sal
.symtab
->filename
);
2150 sprintf_vma (startpc_str
, start_pc
);
2151 sprintf_vma (endpc_str
, end_pc
- 1);
2152 /* Find within range of stated line. */
2154 sprintf (target_buf
, "QTFrame:range:%s:%s",
2155 startpc_str
, endpc_str
);
2156 /* Find OUTSIDE OF range of CURRENT line. */
2158 sprintf (target_buf
, "QTFrame:outside:%s:%s",
2159 startpc_str
, endpc_str
);
2160 finish_tfind_command (&target_buf
, &target_buf_size
,
2162 do_cleanups (old_chain
);
2165 error (_("Trace can only be run on remote targets."));
2168 /* tfind range command */
2170 trace_find_range_command (char *args
, int from_tty
)
2172 static CORE_ADDR start
, stop
;
2173 char start_str
[40], stop_str
[40];
2176 if (target_is_remote ())
2178 if (trace_running_p
)
2179 error ("May not look at trace frames while trace is running.");
2181 if (args
== 0 || *args
== 0)
2182 { /* XXX FIXME: what should default behavior be? */
2183 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2187 if (0 != (tmp
= strchr (args
, ',')))
2189 *tmp
++ = '\0'; /* terminate start address */
2190 while (isspace ((int) *tmp
))
2192 start
= parse_and_eval_address (args
);
2193 stop
= parse_and_eval_address (tmp
);
2196 { /* no explicit end address? */
2197 start
= parse_and_eval_address (args
);
2198 stop
= start
+ 1; /* ??? */
2201 sprintf_vma (start_str
, start
);
2202 sprintf_vma (stop_str
, stop
);
2203 sprintf (target_buf
, "QTFrame:range:%s:%s", start_str
, stop_str
);
2204 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2207 error (_("Trace can only be run on remote targets."));
2210 /* tfind outside command */
2212 trace_find_outside_command (char *args
, int from_tty
)
2214 CORE_ADDR start
, stop
;
2215 char start_str
[40], stop_str
[40];
2218 if (target_is_remote ())
2220 if (trace_running_p
)
2221 error ("May not look at trace frames while trace is running.");
2223 if (args
== 0 || *args
== 0)
2224 { /* XXX FIXME: what should default behavior be? */
2225 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2229 if (0 != (tmp
= strchr (args
, ',')))
2231 *tmp
++ = '\0'; /* terminate start address */
2232 while (isspace ((int) *tmp
))
2234 start
= parse_and_eval_address (args
);
2235 stop
= parse_and_eval_address (tmp
);
2238 { /* no explicit end address? */
2239 start
= parse_and_eval_address (args
);
2240 stop
= start
+ 1; /* ??? */
2243 sprintf_vma (start_str
, start
);
2244 sprintf_vma (stop_str
, stop
);
2245 sprintf (target_buf
, "QTFrame:outside:%s:%s", start_str
, stop_str
);
2246 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2249 error (_("Trace can only be run on remote targets."));
2252 /* info scope command: list the locals for a scope. */
2254 scope_info (char *args
, int from_tty
)
2256 struct symtabs_and_lines sals
;
2258 struct minimal_symbol
*msym
;
2259 struct block
*block
;
2260 char **canonical
, *symname
, *save_args
= args
;
2261 struct dict_iterator iter
;
2263 struct gdbarch
*gdbarch
;
2266 if (args
== 0 || *args
== 0)
2267 error (_("requires an argument (function, line or *addr) to define a scope"));
2269 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2270 if (sals
.nelts
== 0)
2271 return; /* presumably decode_line_1 has already warned */
2273 /* Resolve line numbers to PC */
2274 resolve_sal_pc (&sals
.sals
[0]);
2275 block
= block_for_pc (sals
.sals
[0].pc
);
2279 QUIT
; /* allow user to bail out with ^C */
2280 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2282 QUIT
; /* allow user to bail out with ^C */
2284 printf_filtered ("Scope for %s:\n", save_args
);
2287 symname
= SYMBOL_PRINT_NAME (sym
);
2288 if (symname
== NULL
|| *symname
== '\0')
2289 continue; /* probably botched, certainly useless */
2291 gdbarch
= get_objfile_arch (SYMBOL_SYMTAB (sym
)->objfile
);
2293 printf_filtered ("Symbol %s is ", symname
);
2294 switch (SYMBOL_CLASS (sym
))
2297 case LOC_UNDEF
: /* messed up symbol? */
2298 printf_filtered ("a bogus symbol, class %d.\n",
2299 SYMBOL_CLASS (sym
));
2300 count
--; /* don't count this one */
2303 printf_filtered ("a constant with value %ld (0x%lx)",
2304 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2306 case LOC_CONST_BYTES
:
2307 printf_filtered ("constant bytes: ");
2308 if (SYMBOL_TYPE (sym
))
2309 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2310 fprintf_filtered (gdb_stdout
, " %02x",
2311 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2314 printf_filtered ("in static storage at address ");
2315 printf_filtered ("%s", paddress (gdbarch
,
2316 SYMBOL_VALUE_ADDRESS (sym
)));
2319 /* GDBARCH is the architecture associated with the objfile
2320 the symbol is defined in; the target architecture may be
2321 different, and may provide additional registers. However,
2322 we do not know the target architecture at this point.
2323 We assume the objfile architecture will contain all the
2324 standard registers that occur in debug info in that
2326 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2328 if (SYMBOL_IS_ARGUMENT (sym
))
2329 printf_filtered ("an argument in register $%s",
2330 gdbarch_register_name (gdbarch
, regno
));
2332 printf_filtered ("a local variable in register $%s",
2333 gdbarch_register_name (gdbarch
, regno
));
2336 printf_filtered ("an argument at stack/frame offset %ld",
2337 SYMBOL_VALUE (sym
));
2340 printf_filtered ("a local variable at frame offset %ld",
2341 SYMBOL_VALUE (sym
));
2344 printf_filtered ("a reference argument at offset %ld",
2345 SYMBOL_VALUE (sym
));
2347 case LOC_REGPARM_ADDR
:
2348 /* Note comment at LOC_REGISTER. */
2349 regno
= SYMBOL_REGISTER_OPS (sym
)->register_number (sym
, gdbarch
);
2350 printf_filtered ("the address of an argument, in register $%s",
2351 gdbarch_register_name (gdbarch
, regno
));
2354 printf_filtered ("a typedef.\n");
2357 printf_filtered ("a label at address ");
2358 printf_filtered ("%s", paddress (gdbarch
,
2359 SYMBOL_VALUE_ADDRESS (sym
)));
2362 printf_filtered ("a function at address ");
2363 printf_filtered ("%s",
2364 paddress (gdbarch
, BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2366 case LOC_UNRESOLVED
:
2367 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2370 printf_filtered ("Unresolved Static");
2373 printf_filtered ("static storage at address ");
2374 printf_filtered ("%s",
2375 paddress (gdbarch
, SYMBOL_VALUE_ADDRESS (msym
)));
2378 case LOC_OPTIMIZED_OUT
:
2379 printf_filtered ("optimized out.\n");
2382 SYMBOL_COMPUTED_OPS (sym
)->describe_location (sym
, gdb_stdout
);
2385 if (SYMBOL_TYPE (sym
))
2386 printf_filtered (", length %d.\n",
2387 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2389 if (BLOCK_FUNCTION (block
))
2392 block
= BLOCK_SUPERBLOCK (block
);
2395 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2399 /* worker function (cleanup) */
2401 replace_comma (void *data
)
2409 trace_dump_command (char *args
, int from_tty
)
2411 struct regcache
*regcache
;
2412 struct gdbarch
*gdbarch
;
2413 struct breakpoint
*t
;
2414 struct action_line
*action
;
2415 char *action_exp
, *next_comma
;
2416 struct cleanup
*old_cleanups
;
2417 int stepping_actions
= 0;
2418 int stepping_frame
= 0;
2420 if (!target_is_remote ())
2422 error (_("Trace can only be run on remote targets."));
2426 if (tracepoint_number
== -1)
2428 warning (_("No current trace frame."));
2432 t
= get_tracepoint (tracepoint_number
);
2435 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2438 old_cleanups
= make_cleanup (null_cleanup
, NULL
);
2440 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2441 tracepoint_number
, traceframe_number
);
2443 /* The current frame is a trap frame if the frame PC is equal
2444 to the tracepoint PC. If not, then the current frame was
2445 collected during single-stepping. */
2447 regcache
= get_current_regcache ();
2448 gdbarch
= get_regcache_arch (regcache
);
2450 stepping_frame
= (t
->loc
->address
!= (regcache_read_pc (regcache
)
2451 - gdbarch_decr_pc_after_break (gdbarch
)));
2453 for (action
= t
->actions
; action
; action
= action
->next
)
2455 struct cmd_list_element
*cmd
;
2457 QUIT
; /* allow user to bail out with ^C */
2458 action_exp
= action
->action
;
2459 while (isspace ((int) *action_exp
))
2462 /* The collection actions to be done while stepping are
2463 bracketed by the commands "while-stepping" and "end". */
2465 if (*action_exp
== '#') /* comment line */
2468 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2470 error (_("Bad action list item: %s"), action_exp
);
2472 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2473 stepping_actions
= 1;
2474 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2475 stepping_actions
= 0;
2476 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2478 /* Display the collected data.
2479 For the trap frame, display only what was collected at
2480 the trap. Likewise for stepping frames, display only
2481 what was collected while stepping. This means that the
2482 two boolean variables, STEPPING_FRAME and
2483 STEPPING_ACTIONS should be equal. */
2484 if (stepping_frame
== stepping_actions
)
2487 { /* repeat over a comma-separated list */
2488 QUIT
; /* allow user to bail out with ^C */
2489 if (*action_exp
== ',')
2491 while (isspace ((int) *action_exp
))
2494 next_comma
= strchr (action_exp
, ',');
2496 if (0 == strncasecmp (action_exp
, "$reg", 4))
2497 registers_info (NULL
, from_tty
);
2498 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2499 locals_info (NULL
, from_tty
);
2500 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2501 args_info (NULL
, from_tty
);
2506 make_cleanup (replace_comma
, next_comma
);
2509 printf_filtered ("%s = ", action_exp
);
2510 output_command (action_exp
, from_tty
);
2511 printf_filtered ("\n");
2515 action_exp
= next_comma
;
2517 while (action_exp
&& *action_exp
== ',');
2521 discard_cleanups (old_cleanups
);
2524 /* Convert the memory pointed to by mem into hex, placing result in buf.
2525 * Return a pointer to the last char put in buf (null)
2526 * "stolen" from sparc-stub.c
2529 static const char hexchars
[] = "0123456789abcdef";
2532 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2540 *buf
++ = hexchars
[ch
>> 4];
2541 *buf
++ = hexchars
[ch
& 0xf];
2550 get_traceframe_number (void)
2552 return traceframe_number
;
2556 /* module initialization */
2558 _initialize_tracepoint (void)
2560 struct cmd_list_element
*c
;
2562 traceframe_number
= -1;
2563 tracepoint_number
= -1;
2565 if (tracepoint_list
.list
== NULL
)
2567 tracepoint_list
.listsize
= 128;
2568 tracepoint_list
.list
= xmalloc
2569 (tracepoint_list
.listsize
* sizeof (struct memrange
));
2571 if (tracepoint_list
.aexpr_list
== NULL
)
2573 tracepoint_list
.aexpr_listsize
= 128;
2574 tracepoint_list
.aexpr_list
= xmalloc
2575 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
2578 if (stepping_list
.list
== NULL
)
2580 stepping_list
.listsize
= 128;
2581 stepping_list
.list
= xmalloc
2582 (stepping_list
.listsize
* sizeof (struct memrange
));
2585 if (stepping_list
.aexpr_list
== NULL
)
2587 stepping_list
.aexpr_listsize
= 128;
2588 stepping_list
.aexpr_list
= xmalloc
2589 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
2592 add_info ("scope", scope_info
,
2593 _("List the variables local to a scope"));
2595 add_cmd ("tracepoints", class_trace
, NULL
,
2596 _("Tracing of program execution without stopping the program."),
2599 add_com ("tdump", class_trace
, trace_dump_command
,
2600 _("Print everything collected at the current tracepoint."));
2602 c
= add_com ("tvariable", class_trace
, trace_variable_command
,_("\
2603 Define a trace state variable.\n\
2604 Argument is a $-prefixed name, optionally followed\n\
2605 by '=' and an expression that sets the initial value\n\
2606 at the start of tracing."));
2607 set_cmd_completer (c
, expression_completer
);
2609 add_cmd ("tvariable", class_trace
, delete_trace_variable_command
, _("\
2610 Delete one or more trace state variables.\n\
2611 Arguments are the names of the variables to delete.\n\
2612 If no arguments are supplied, delete all variables."), &deletelist
);
2613 /* FIXME add a trace variable completer */
2615 add_info ("tvariables", tvariables_info
, _("\
2616 Status of trace state variables and their values.\n\
2619 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
2620 Select a trace frame;\n\
2621 No argument means forward by one frame; '-' means backward by one frame."),
2622 &tfindlist
, "tfind ", 1, &cmdlist
);
2624 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
2625 Select a trace frame whose PC is outside the given range.\n\
2626 Usage: tfind outside addr1, addr2"),
2629 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
2630 Select a trace frame whose PC is in the given range.\n\
2631 Usage: tfind range addr1,addr2"),
2634 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
2635 Select a trace frame by source line.\n\
2636 Argument can be a line number (with optional source file), \n\
2637 a function name, or '*' followed by an address.\n\
2638 Default argument is 'the next source line that was traced'."),
2641 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
2642 Select a trace frame by tracepoint number.\n\
2643 Default is the tracepoint for the current trace frame."),
2646 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
2647 Select a trace frame by PC.\n\
2648 Default is the current PC, or the PC of the current trace frame."),
2651 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
2652 Synonym for 'none'.\n\
2653 De-select any trace frame and resume 'live' debugging."),
2656 add_cmd ("none", class_trace
, trace_find_none_command
,
2657 _("De-select any trace frame and resume 'live' debugging."),
2660 add_cmd ("start", class_trace
, trace_find_start_command
,
2661 _("Select the first trace frame in the trace buffer."),
2664 add_com ("tstatus", class_trace
, trace_status_command
,
2665 _("Display the status of the current trace data collection."));
2667 add_com ("tstop", class_trace
, trace_stop_command
,
2668 _("Stop trace data collection."));
2670 add_com ("tstart", class_trace
, trace_start_command
,
2671 _("Start trace data collection."));
2673 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
2674 Ends a list of commands or actions.\n\
2675 Several GDB commands allow you to enter a list of commands or actions.\n\
2676 Entering \"end\" on a line by itself is the normal way to terminate\n\
2678 Note: the \"end\" command cannot be used at the gdb prompt."));
2680 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
2681 Specify single-stepping behavior at a tracepoint.\n\
2682 Argument is number of instructions to trace in single-step mode\n\
2683 following the tracepoint. This command is normally followed by\n\
2684 one or more \"collect\" commands, to specify what to collect\n\
2685 while single-stepping.\n\n\
2686 Note: this command can only be used in a tracepoint \"actions\" list."));
2688 add_com_alias ("ws", "while-stepping", class_alias
, 0);
2689 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
2691 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
2692 Specify one or more data items to be collected at a tracepoint.\n\
2693 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
2694 collect all data (variables, registers) referenced by that expression.\n\
2695 Also accepts the following special arguments:\n\
2696 $regs -- all registers.\n\
2697 $args -- all function arguments.\n\
2698 $locals -- all variables local to the block/function scope.\n\
2699 Note: this command can only be used in a tracepoint \"actions\" list."));
2701 add_com ("teval", class_trace
, teval_pseudocommand
, _("\
2702 Specify one or more expressions to be evaluated at a tracepoint.\n\
2703 Accepts a comma-separated list of (one or more) expressions.\n\
2704 The result of each evaluation will be discarded.\n\
2705 Note: this command can only be used in a tracepoint \"actions\" list."));
2707 add_com ("actions", class_trace
, trace_actions_command
, _("\
2708 Specify the actions to be taken at a tracepoint.\n\
2709 Tracepoint actions may include collecting of specified data, \n\
2710 single-stepping, or enabling/disabling other tracepoints, \n\
2711 depending on target's capabilities."));
2713 default_collect
= xstrdup ("");
2714 add_setshow_string_cmd ("default-collect", class_trace
,
2715 &default_collect
, _("\
2716 Set the list of expressions to collect by default"), _("\
2717 Show the list of expressions to collect by default"), NULL
,
2719 &setlist
, &showlist
);
2721 target_buf_size
= 2048;
2722 target_buf
= xmalloc (target_buf_size
);