1 /* Tracing functionality for remote targets in custom GDB protocol
2 Copyright 1997 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 #include "tracepoint.h"
25 #include "expression.h"
30 #include "gdb_string.h"
35 /* readline include files */
39 /* readline defines this. */
46 /* maximum length of an agent aexpression.
47 this accounts for the fact that packets are limited to 400 bytes
48 (which includes everything -- including the checksum), and assumes
49 the worst case of maximum length for each of the pieces of a
52 NOTE: expressions get mem2hex'ed otherwise this would be twice as
53 large. (400 - 31)/2 == 184 */
54 #define MAX_AGENT_EXPR_LEN 184
57 extern int info_verbose
;
58 extern void (*readline_begin_hook
) PARAMS ((char *, ...));
59 extern char * (*readline_hook
) PARAMS ((char *));
60 extern void (*readline_end_hook
) PARAMS ((void));
61 extern void x_command
PARAMS ((char *, int));
62 extern int addressprint
; /* Print machine addresses? */
64 /* If this definition isn't overridden by the header files, assume
65 that isatty and fileno exist on this system. */
67 #define ISATTY(FP) (isatty (fileno (FP)))
73 This module defines the following debugger commands:
74 trace : set a tracepoint on a function, line, or address.
75 info trace : list all debugger-defined tracepoints.
76 delete trace : delete one or more tracepoints.
77 enable trace : enable one or more tracepoints.
78 disable trace : disable one or more tracepoints.
79 actions : specify actions to be taken at a tracepoint.
80 passcount : specify a pass count for a tracepoint.
81 tstart : start a trace experiment.
82 tstop : stop a trace experiment.
83 tstatus : query the status of a trace experiment.
84 tfind : find a trace frame in the trace buffer.
85 tdump : print everything collected at the current tracepoint.
86 save-tracepoints : write tracepoint setup into a file.
88 This module defines the following user-visible debugger variables:
89 $trace_frame : sequence number of trace frame currently being debugged.
90 $trace_line : source line of trace frame currently being debugged.
91 $trace_file : source file of trace frame currently being debugged.
92 $tracepoint : tracepoint number of trace frame currently being debugged.
96 /* ======= Important global variables: ======= */
98 /* Chain of all tracepoints defined. */
99 struct tracepoint
*tracepoint_chain
;
101 /* Number of last tracepoint made. */
102 static int tracepoint_count
;
104 /* Number of last traceframe collected. */
105 static int traceframe_number
;
107 /* Tracepoint for last traceframe collected. */
108 static int tracepoint_number
;
110 /* Symbol for function for last traceframe collected */
111 static struct symbol
*traceframe_fun
;
113 /* Symtab and line for last traceframe collected */
114 static struct symtab_and_line traceframe_sal
;
116 /* Tracing command lists */
117 static struct cmd_list_element
*tfindlist
;
119 /* ======= Important command functions: ======= */
120 static void trace_command
PARAMS ((char *, int));
121 static void tracepoints_info
PARAMS ((char *, int));
122 static void delete_trace_command
PARAMS ((char *, int));
123 static void enable_trace_command
PARAMS ((char *, int));
124 static void disable_trace_command
PARAMS ((char *, int));
125 static void trace_pass_command
PARAMS ((char *, int));
126 static void trace_actions_command
PARAMS ((char *, int));
127 static void trace_start_command
PARAMS ((char *, int));
128 static void trace_stop_command
PARAMS ((char *, int));
129 static void trace_status_command
PARAMS ((char *, int));
130 static void trace_find_command
PARAMS ((char *, int));
131 static void trace_find_pc_command
PARAMS ((char *, int));
132 static void trace_find_tracepoint_command
PARAMS ((char *, int));
133 static void trace_find_line_command
PARAMS ((char *, int));
134 static void trace_find_range_command
PARAMS ((char *, int));
135 static void trace_find_outside_command
PARAMS ((char *, int));
136 static void tracepoint_save_command
PARAMS ((char *, int));
137 static void trace_dump_command
PARAMS ((char *, int));
139 /* support routines */
140 static void trace_mention
PARAMS ((struct tracepoint
*));
142 struct collection_list
;
143 static void add_aexpr
PARAMS ((struct collection_list
*, struct agent_expr
*));
144 static unsigned char *mem2hex(unsigned char *, unsigned char *, int);
146 /* Utility: returns true if "target remote" */
150 if (current_target
.to_shortname
&&
151 strcmp (current_target
.to_shortname
, "remote") == 0)
157 /* Utility: generate error from an incoming stub packet. */
163 return; /* not an error msg */
166 case '1': /* malformed packet error */
167 if (*++buf
== '0') /* general case: */
168 error ("tracepoint.c: error in outgoing packet.");
170 error ("tracepoint.c: error in outgoing packet at field #%d.",
171 strtol (buf
, NULL
, 16));
173 error ("trace API error 0x%s.", ++buf
);
175 error ("Target returns error code '%s'.", buf
);
179 /* Utility: wait for reply from stub, while accepting "O" packets */
181 remote_get_noisy_reply (buf
)
184 do /* loop on reply from remote stub */
186 QUIT
; /* allow user to bail out with ^C */
189 error ("Target does not support this command.");
190 else if (buf
[0] == 'E')
192 else if (buf
[0] == 'O' &&
194 remote_console_output (buf
+ 1); /* 'O' message from stub */
196 return buf
; /* here's the actual reply */
200 /* Set tracepoint count to NUM. */
202 set_tracepoint_count (num
)
205 tracepoint_count
= num
;
206 set_internalvar (lookup_internalvar ("tpnum"),
207 value_from_longest (builtin_type_int
, (LONGEST
) num
));
210 /* Set traceframe number to NUM. */
212 set_traceframe_num (num
)
215 traceframe_number
= num
;
216 set_internalvar (lookup_internalvar ("trace_frame"),
217 value_from_longest (builtin_type_int
, (LONGEST
) num
));
220 /* Set tracepoint number to NUM. */
222 set_tracepoint_num (num
)
225 tracepoint_number
= num
;
226 set_internalvar (lookup_internalvar ("tracepoint"),
227 value_from_longest (builtin_type_int
, (LONGEST
) num
));
230 /* Set externally visible debug variables for querying/printing
231 the traceframe context (line, function, file) */
234 set_traceframe_context (trace_pc
)
237 static struct type
*func_string
, *file_string
;
238 static struct type
*func_range
, *file_range
;
239 static value_ptr func_val
, file_val
;
240 static struct type
*charstar
;
243 if (charstar
== (struct type
*) NULL
)
244 charstar
= lookup_pointer_type (builtin_type_char
);
246 if (trace_pc
== -1) /* cease debugging any trace buffers */
249 traceframe_sal
.pc
= traceframe_sal
.line
= 0;
250 traceframe_sal
.symtab
= NULL
;
251 set_internalvar (lookup_internalvar ("trace_func"),
252 value_from_longest (charstar
, (LONGEST
) 0));
253 set_internalvar (lookup_internalvar ("trace_file"),
254 value_from_longest (charstar
, (LONGEST
) 0));
255 set_internalvar (lookup_internalvar ("trace_line"),
256 value_from_longest (builtin_type_int
, (LONGEST
) -1));
260 /* save as globals for internal use */
261 traceframe_sal
= find_pc_line (trace_pc
, 0);
262 traceframe_fun
= find_pc_function (trace_pc
);
264 /* save linenumber as "$trace_line", a debugger variable visible to users */
265 set_internalvar (lookup_internalvar ("trace_line"),
266 value_from_longest (builtin_type_int
,
267 (LONGEST
) traceframe_sal
.line
));
269 /* save func name as "$trace_func", a debugger variable visible to users */
270 if (traceframe_fun
== NULL
||
271 SYMBOL_NAME (traceframe_fun
) == NULL
)
272 set_internalvar (lookup_internalvar ("trace_func"),
273 value_from_longest (charstar
, (LONGEST
) 0));
276 len
= strlen (SYMBOL_NAME (traceframe_fun
));
277 func_range
= create_range_type (func_range
,
278 builtin_type_int
, 0, len
- 1);
279 func_string
= create_array_type (func_string
,
280 builtin_type_char
, func_range
);
281 func_val
= allocate_value (func_string
);
282 VALUE_TYPE (func_val
) = func_string
;
283 memcpy (VALUE_CONTENTS_RAW (func_val
),
284 SYMBOL_NAME (traceframe_fun
),
286 func_val
->modifiable
= 0;
287 set_internalvar (lookup_internalvar ("trace_func"), func_val
);
290 /* save file name as "$trace_file", a debugger variable visible to users */
291 if (traceframe_sal
.symtab
== NULL
||
292 traceframe_sal
.symtab
->filename
== NULL
)
293 set_internalvar (lookup_internalvar ("trace_file"),
294 value_from_longest (charstar
, (LONGEST
) 0));
297 len
= strlen (traceframe_sal
.symtab
->filename
);
298 file_range
= create_range_type (file_range
,
299 builtin_type_int
, 0, len
- 1);
300 file_string
= create_array_type (file_string
,
301 builtin_type_char
, file_range
);
302 file_val
= allocate_value (file_string
);
303 VALUE_TYPE (file_val
) = file_string
;
304 memcpy (VALUE_CONTENTS_RAW (file_val
),
305 traceframe_sal
.symtab
->filename
,
307 file_val
->modifiable
= 0;
308 set_internalvar (lookup_internalvar ("trace_file"), file_val
);
312 /* Low level routine to set a tracepoint.
313 Returns the tracepoint object so caller can set other things.
314 Does not set the tracepoint number!
315 Does not print anything.
317 ==> This routine should not be called if there is a chance of later
318 error(); otherwise it leaves a bogus tracepoint on the chain. Validate
319 your arguments BEFORE calling this routine! */
321 static struct tracepoint
*
322 set_raw_tracepoint (sal
)
323 struct symtab_and_line sal
;
325 register struct tracepoint
*t
, *tc
;
326 struct cleanup
*old_chain
;
328 t
= (struct tracepoint
*) xmalloc (sizeof (struct tracepoint
));
329 old_chain
= make_cleanup (free
, t
);
330 memset (t
, 0, sizeof (*t
));
332 if (sal
.symtab
== NULL
)
333 t
->source_file
= NULL
;
336 if (sal
.symtab
->dirname
== NULL
)
338 t
->source_file
= (char *) xmalloc (strlen (sal
.symtab
->filename
) + 1);
339 strcpy (t
->source_file
, sal
.symtab
->filename
);
345 t
->source_file
= (char *) xmalloc (strlen (sal
.symtab
->filename
) +
346 strlen (sal
.symtab
->dirname
) + 2);
348 strcpy (t
->source_file
, sal
.symtab
->dirname
);
352 if (*(--p
) != '/') /* Will this work on Windows? */
353 strcat (t
->source_file
, "/");
354 strcat (t
->source_file
, sal
.symtab
->filename
);
358 t
->language
= current_language
->la_language
;
359 t
->input_radix
= input_radix
;
360 t
->line_number
= sal
.line
;
361 t
->enabled
= enabled
;
365 t
->addr_string
= NULL
;
367 /* Add this tracepoint to the end of the chain
368 so that a list of tracepoints will come out in order
369 of increasing numbers. */
371 tc
= tracepoint_chain
;
373 tracepoint_chain
= t
;
380 discard_cleanups (old_chain
);
384 /* Set a tracepoint according to ARG (function, linenum or *address) */
386 trace_command (arg
, from_tty
)
390 char **canonical
= (char **)NULL
;
391 struct symtabs_and_lines sals
;
392 struct symtab_and_line sal
;
393 struct tracepoint
*t
;
394 char *addr_start
= 0, *addr_end
= 0;
398 error ("trace command requires an argument");
400 if (from_tty
&& info_verbose
)
401 printf_filtered ("TRACE %s\n", arg
);
404 sals
= decode_line_1 (&arg
, 1, (struct symtab
*)NULL
, 0, &canonical
);
407 return; /* ??? Presumably decode_line_1 has already warned? */
409 /* Resolve all line numbers to PC's */
410 for (i
= 0; i
< sals
.nelts
; i
++)
411 resolve_sal_pc (&sals
.sals
[i
]);
413 /* Now set all the tracepoints. */
414 for (i
= 0; i
< sals
.nelts
; i
++)
418 t
= set_raw_tracepoint (sal
);
419 set_tracepoint_count (tracepoint_count
+ 1);
420 t
->number
= tracepoint_count
;
422 /* If a canonical line spec is needed use that instead of the
424 if (canonical
!= (char **)NULL
&& canonical
[i
] != NULL
)
425 t
->addr_string
= canonical
[i
];
427 t
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
431 /* Let the UI know of any additions */
432 if (create_tracepoint_hook
)
433 create_tracepoint_hook (t
);
438 printf_filtered ("Multiple tracepoints were set.\n");
439 printf_filtered ("Use 'delete trace' to delete unwanted tracepoints.\n");
443 /* Tell the user we have just set a tracepoint TP. */
447 struct tracepoint
*tp
;
449 printf_filtered ("Tracepoint %d", tp
->number
);
451 if (addressprint
|| (tp
->source_file
== NULL
))
453 printf_filtered (" at ");
454 print_address_numeric (tp
->address
, 1, gdb_stdout
);
457 printf_filtered (": file %s, line %d.",
458 tp
->source_file
, tp
->line_number
);
460 printf_filtered ("\n");
463 /* Print information on tracepoint number TPNUM_EXP, or all if omitted. */
466 tracepoints_info (tpnum_exp
, from_tty
)
470 struct tracepoint
*t
;
471 struct action_line
*action
;
472 int found_a_tracepoint
= 0;
473 char wrap_indent
[80];
478 tpnum
= parse_and_eval_address (tpnum_exp
);
481 if (tpnum
== -1 || tpnum
== t
->number
)
483 extern int addressprint
; /* print machine addresses? */
485 if (!found_a_tracepoint
++)
487 printf_filtered ("Num Enb ");
489 printf_filtered ("Address ");
490 printf_filtered ("PassC StepC What\n");
492 strcpy (wrap_indent
, " ");
494 strcat (wrap_indent
, " ");
496 printf_filtered ("%-3d %-3s ", t
->number
,
497 t
->enabled
== enabled
? "y" : "n");
499 printf_filtered ("%s ",
500 local_hex_string_custom ((unsigned long) t
->address
,
502 printf_filtered ("%-5d %-5d ", t
->pass_count
, t
->step_count
);
506 sym
= find_pc_function (t
->address
);
509 fputs_filtered ("in ", gdb_stdout
);
510 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), gdb_stdout
);
511 wrap_here (wrap_indent
);
512 fputs_filtered (" at ", gdb_stdout
);
514 fputs_filtered (t
->source_file
, gdb_stdout
);
515 printf_filtered (":%d", t
->line_number
);
518 print_address_symbolic (t
->address
, gdb_stdout
, demangle
, " ");
520 printf_filtered ("\n");
523 printf_filtered (" Actions for tracepoint %d: \n", t
->number
);
524 for (action
= t
->actions
; action
; action
= action
->next
)
526 printf_filtered ("\t%s\n", action
->action
);
530 if (!found_a_tracepoint
)
533 printf_filtered ("No tracepoints.\n");
535 printf_filtered ("No tracepoint number %d.\n", tpnum
);
539 /* Optimization: the code to parse an enable, disable, or delete TP command
540 is virtually identical except for whether it performs an enable, disable,
541 or delete. Therefore I've combined them into one function with an opcode.
543 enum tracepoint_opcode
550 /* This function implements enable, disable and delete. */
552 tracepoint_operation (t
, from_tty
, opcode
)
553 struct tracepoint
*t
;
555 enum tracepoint_opcode opcode
;
557 struct tracepoint
*t2
;
561 t
->enabled
= enabled
;
562 if (modify_tracepoint_hook
)
563 modify_tracepoint_hook (t
);
566 t
->enabled
= disabled
;
567 if (modify_tracepoint_hook
)
568 modify_tracepoint_hook (t
);
571 if (tracepoint_chain
== t
)
572 tracepoint_chain
= t
->next
;
581 /* Let the UI know of any deletions */
582 if (delete_tracepoint_hook
)
583 delete_tracepoint_hook (t
);
586 free (t
->addr_string
);
588 free (t
->source_file
);
597 /* Utility: parse a tracepoint number and look it up in the list. */
599 get_tracepoint_by_number (arg
)
602 struct tracepoint
*t
;
608 error ("Bad tracepoint argument");
610 if (*arg
== 0 || **arg
== 0) /* empty arg means refer to last tp */
611 tpnum
= tracepoint_count
;
612 else if (**arg
== '$') /* handle convenience variable */
614 /* Make a copy of the name, so we can null-terminate it
615 to pass to lookup_internalvar(). */
617 while (isalnum(*end
) || *end
== '_')
619 copy
= (char *) alloca (end
- *arg
);
620 strncpy (copy
, *arg
+ 1, (end
- *arg
- 1));
621 copy
[end
- *arg
- 1] = '\0';
624 val
= value_of_internalvar (lookup_internalvar (copy
));
625 if (TYPE_CODE( VALUE_TYPE (val
)) != TYPE_CODE_INT
)
626 error ("Convenience variable must have integral type.");
627 tpnum
= (int) value_as_long (val
);
629 else /* handle tracepoint number */
631 tpnum
= strtol (*arg
, arg
, 0);
632 if (tpnum
== 0) /* possible strtol failure */
633 while (**arg
&& !isspace (**arg
))
634 (*arg
)++; /* advance to next white space, if any */
637 if (t
->number
== tpnum
)
641 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
645 /* Utility: parse a list of tracepoint numbers, and call a func for each. */
647 map_args_over_tracepoints (args
, from_tty
, opcode
)
650 enum tracepoint_opcode opcode
;
652 struct tracepoint
*t
, *tmp
;
656 if (args
== 0 || *args
== 0) /* do them all */
657 ALL_TRACEPOINTS_SAFE (t
, tmp
)
658 tracepoint_operation (t
, from_tty
, opcode
);
662 QUIT
; /* give user option to bail out with ^C */
663 if (t
= get_tracepoint_by_number (&args
))
664 tracepoint_operation (t
, from_tty
, opcode
);
665 while (*args
== ' ' || *args
== '\t')
670 /* The 'enable trace' command enables tracepoints. Not supported by all targets. */
672 enable_trace_command (args
, from_tty
)
677 map_args_over_tracepoints (args
, from_tty
, enable
);
680 /* The 'disable trace' command enables tracepoints. Not supported by all targets. */
682 disable_trace_command (args
, from_tty
)
687 map_args_over_tracepoints (args
, from_tty
, disable
);
690 /* Remove a tracepoint (or all if no argument) */
692 delete_trace_command (args
, from_tty
)
697 if (!args
|| !*args
) /* No args implies all tracepoints; */
698 if (from_tty
) /* confirm only if from_tty... */
699 if (tracepoint_chain
) /* and if there are tracepoints to delete! */
700 if (!query ("Delete all tracepoints? "))
703 map_args_over_tracepoints (args
, from_tty
, delete);
706 /* Set passcount for tracepoint.
708 First command argument is passcount, second is tracepoint number.
709 If tracepoint number omitted, apply to most recently defined.
710 Also accepts special argument "all". */
713 trace_pass_command (args
, from_tty
)
717 struct tracepoint
*t1
= (struct tracepoint
*) -1, *t2
;
720 if (args
== 0 || *args
== 0)
721 error ("PASS command requires an argument (count + optional TP num)");
723 count
= strtoul (args
, &args
, 10); /* count comes first, then TP num */
725 while (*args
&& isspace (*args
))
728 if (*args
&& strncasecmp (args
, "all", 3) == 0)
729 args
+= 3; /* skip special argument "all" */
731 t1
= get_tracepoint_by_number (&args
);
734 error ("Junk at end of arguments.");
737 return; /* error, bad tracepoint number */
740 if (t1
== (struct tracepoint
*) -1 || t1
== t2
)
742 t2
->pass_count
= count
;
743 if (modify_tracepoint_hook
)
744 modify_tracepoint_hook (t2
);
746 printf_filtered ("Setting tracepoint %d's passcount to %d\n",
751 /* ACTIONS functions: */
753 /* Prototypes for action-parsing utility commands */
754 static void read_actions
PARAMS((struct tracepoint
*));
755 static char *parse_and_eval_memrange
PARAMS ((char *,
761 /* The three functions:
762 collect_pseudocommand,
763 while_stepping_pseudocommand, and
764 end_actions_pseudocommand
765 are placeholders for "commands" that are actually ONLY to be used
766 within a tracepoint action list. If the actual function is ever called,
767 it means that somebody issued the "command" at the top level,
768 which is always an error. */
771 end_actions_pseudocommand (args
, from_tty
)
775 error ("This command cannot be used at the top level.");
779 while_stepping_pseudocommand (args
, from_tty
)
783 error ("This command can only be used in a tracepoint actions list.");
787 collect_pseudocommand (args
, from_tty
)
791 error ("This command can only be used in a tracepoint actions list.");
794 /* Enter a list of actions for a tracepoint. */
796 trace_actions_command (args
, from_tty
)
800 struct tracepoint
*t
;
803 char *end_msg
= "End with a line saying just \"end\".";
805 if (t
= get_tracepoint_by_number (&args
))
807 sprintf (tmpbuf
, "Enter actions for tracepoint %d, one per line.",
812 if (readline_begin_hook
)
813 (*readline_begin_hook
) ("%s %s\n", tmpbuf
, end_msg
);
814 else if (input_from_terminal_p ())
815 printf_filtered ("%s\n%s\n", tmpbuf
, end_msg
);
819 t
->step_count
= 0; /* read_actions may set this */
822 if (readline_end_hook
)
823 (*readline_end_hook
) ();
825 /* tracepoints_changed () */
827 /* else error, just return; */
830 /* worker function */
833 struct tracepoint
*t
;
836 char *prompt1
= "> ", *prompt2
= " > ";
837 char *prompt
= prompt1
;
838 enum actionline_type linetype
;
839 extern FILE *instream
;
840 struct action_line
*next
= NULL
, *temp
;
841 struct cleanup
*old_chain
;
843 /* Control-C quits instantly if typed while in this loop
844 since it should not wait until the user types a newline. */
848 signal (STOP_SIGNAL
, stop_sig
);
850 old_chain
= make_cleanup (free_actions
, (void *) t
);
853 /* Make sure that all output has been output. Some machines may let
854 you get away with leaving out some of the gdb_flush, but not all. */
856 gdb_flush (gdb_stdout
);
857 gdb_flush (gdb_stderr
);
859 if (readline_hook
&& instream
== NULL
)
860 line
= (*readline_hook
) (prompt
);
861 else if (instream
== stdin
&& ISATTY (instream
))
863 line
= readline (prompt
);
864 if (line
&& *line
) /* add it to command history */
868 line
= gdb_readline (0);
870 linetype
= validate_actionline (&line
, t
);
871 if (linetype
== BADLINE
)
872 continue; /* already warned -- collect another line */
874 temp
= xmalloc (sizeof (struct action_line
));
878 if (next
== NULL
) /* first action for this tracepoint? */
879 t
->actions
= next
= temp
;
886 if (linetype
== STEPPING
) /* begin "while-stepping" */
887 if (prompt
== prompt2
)
889 warning ("Already processing 'while-stepping'");
893 prompt
= prompt2
; /* change prompt for stepping actions */
894 else if (linetype
== END
)
895 if (prompt
== prompt2
)
897 prompt
= prompt1
; /* end of single-stepping actions */
900 { /* end of actions */
901 if (t
->actions
->next
== NULL
)
903 /* an "end" all by itself with no other actions means
904 this tracepoint has no actions. Discard empty list. */
912 signal (STOP_SIGNAL
, SIG_DFL
);
915 discard_cleanups (old_chain
);
918 /* worker function */
920 validate_actionline (line
, t
)
922 struct tracepoint
*t
;
924 struct cmd_list_element
*c
;
925 struct expression
*exp
= NULL
;
926 value_ptr temp
, temp2
;
927 struct cleanup
*old_chain
= NULL
;
930 for (p
= *line
; isspace (*p
); )
933 /* symbol lookup etc. */
934 if (*p
== '\0') /* empty line: just prompt for another line. */
937 if (*p
== '#') /* comment line */
940 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
943 warning ("'%s' is not an action that I know, or is ambiguous.", p
);
947 if (c
->function
.cfunc
== collect_pseudocommand
)
949 struct agent_expr
*aexpr
;
950 struct agent_reqs areqs
;
952 do { /* repeat over a comma-separated list */
953 QUIT
; /* allow user to bail out with ^C */
957 if (*p
== '$') /* look for special pseudo-symbols */
960 bfd_signed_vma offset
;
962 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
963 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
964 (0 == strncasecmp ("loc", p
+ 1, 3)))
969 /* else fall thru, treat p as an expression and parse it! */
971 exp
= parse_exp_1 (&p
, block_for_pc (t
->address
), 1);
972 old_chain
= make_cleanup (free_current_contents
, &exp
);
974 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
975 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
977 warning ("%s is constant (value %d): will not be collected.",
978 SYMBOL_NAME (exp
->elts
[2].symbol
),
979 SYMBOL_VALUE (exp
->elts
[2].symbol
));
982 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
984 warning ("%s is optimized away and cannot be collected.",
985 SYMBOL_NAME (exp
->elts
[2].symbol
));
989 /* we have something to collect, make sure that the expr to
990 bytecode translator can handle it and that it's not too long */
991 aexpr
= gen_trace_for_expr(exp
);
992 (void) make_cleanup (free_agent_expr
, aexpr
);
994 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
995 error ("expression too complicated, try simplifying");
997 ax_reqs(aexpr
, &areqs
);
998 (void) make_cleanup (free
, areqs
.reg_mask
);
1000 if (areqs
.flaw
!= agent_flaw_none
)
1001 error ("malformed expression");
1003 if (areqs
.min_height
< 0)
1004 error ("gdb: Internal error: expression has min height < 0");
1006 if (areqs
.max_height
> 20)
1007 error ("expression too complicated, try simplifying");
1009 do_cleanups (old_chain
);
1010 } while (p
&& *p
++ == ',');
1013 else if (c
->function
.cfunc
== while_stepping_pseudocommand
)
1015 char *steparg
; /* in case warning is necessary */
1017 while (isspace (*p
))
1022 (t
->step_count
= strtol (p
, &p
, 0)) == 0)
1024 warning ("bad step-count: command ignored.", *line
);
1029 else if (c
->function
.cfunc
== end_actions_pseudocommand
)
1033 warning ("'%s' is not a supported tracepoint action.", *line
);
1038 /* worker function */
1041 struct tracepoint
*t
;
1043 struct action_line
*line
, *next
;
1045 for (line
= t
->actions
; line
; line
= next
)
1049 free (line
->action
);
1056 int type
; /* 0 for absolute memory range, else basereg number */
1057 bfd_signed_vma start
;
1061 struct collection_list
{
1062 unsigned char regs_mask
[8]; /* room for up to 256 regs */
1065 struct memrange
*list
;
1066 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
1067 long next_aexpr_elt
;
1068 struct agent_expr
**aexpr_list
;
1070 } tracepoint_list
, stepping_list
;
1072 /* MEMRANGE functions: */
1074 static int memrange_cmp
PARAMS ((const void *, const void *));
1076 /* compare memranges for qsort */
1078 memrange_cmp (va
, vb
)
1082 const struct memrange
*a
= va
, *b
= vb
;
1084 if (a
->type
< b
->type
)
1086 if (a
->type
> b
->type
)
1090 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
) return -1;
1091 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
) return 1;
1095 if (a
->start
< b
->start
)
1097 if (a
->start
> b
->start
)
1103 /* Sort the memrange list using qsort, and merge adjacent memranges */
1105 memrange_sortmerge (memranges
)
1106 struct collection_list
*memranges
;
1110 qsort (memranges
->list
, memranges
->next_memrange
,
1111 sizeof (struct memrange
), memrange_cmp
);
1112 if (memranges
->next_memrange
> 0)
1114 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
1116 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
1117 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
1118 MAX_REGISTER_VIRTUAL_SIZE
)
1120 /* memrange b starts before memrange a ends; merge them. */
1121 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
1122 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
1123 continue; /* next b, same a */
1127 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
1128 sizeof (struct memrange
));
1130 memranges
->next_memrange
= a
+ 1;
1134 /* Add a register to a collection list */
1136 add_register (collection
, regno
)
1137 struct collection_list
*collection
;
1138 unsigned long regno
;
1141 printf_filtered ("collect register %d\n", regno
);
1142 if (regno
> (8 * sizeof (collection
->regs_mask
)))
1143 error ("Internal: register number %d too large for tracepoint",
1145 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
1148 /* Add a memrange to a collection list */
1150 add_memrange (memranges
, type
, base
, len
)
1151 struct collection_list
*memranges
;
1153 bfd_signed_vma base
;
1157 printf_filtered ("(%d,0x%x,%d)\n", type
, base
, len
);
1158 /* type: 0 == memory, n == basereg */
1159 memranges
->list
[memranges
->next_memrange
].type
= type
;
1160 /* base: addr if memory, offset if reg relative. */
1161 memranges
->list
[memranges
->next_memrange
].start
= base
;
1162 /* len: we actually save end (base + len) for convenience */
1163 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
1164 memranges
->next_memrange
++;
1165 if (memranges
->next_memrange
>= memranges
->listsize
)
1167 memranges
->listsize
*= 2;
1168 memranges
->list
= xrealloc (memranges
->list
,
1169 memranges
->listsize
);
1172 if (type
!= -1) /* better collect the base register! */
1173 add_register (memranges
, type
);
1176 /* Add a symbol to a collection list */
1178 collect_symbol (collect
, sym
)
1179 struct collection_list
*collect
;
1184 bfd_signed_vma offset
;
1186 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
1187 switch (SYMBOL_CLASS (sym
)) {
1189 printf_filtered ("%s: don't know symbol class %d\n",
1190 SYMBOL_NAME (sym
), SYMBOL_CLASS (sym
));
1193 printf_filtered ("%s is constant, value is %d: will not be collected.\n",
1194 SYMBOL_NAME (sym
), SYMBOL_VALUE (sym
));
1197 offset
= SYMBOL_VALUE_ADDRESS (sym
);
1199 printf_filtered ("LOC_STATIC %s: collect %d bytes at 0x%08x\n",
1200 SYMBOL_NAME (sym
), len
, offset
);
1201 add_memrange (collect
, -1, offset
, len
); /* 0 == memory */
1205 reg
= SYMBOL_VALUE (sym
);
1207 printf_filtered ("LOC_REG[parm] %s: ", SYMBOL_NAME (sym
));
1208 add_register (collect
, reg
);
1212 printf_filtered ("Sorry, don't know how to do LOC_ARGs yet.\n");
1213 printf_filtered (" (will not collect %s)\n",
1216 case LOC_REGPARM_ADDR
:
1217 reg
= SYMBOL_VALUE (sym
);
1221 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %d bytes at offset %d from reg %d\n",
1222 SYMBOL_NAME (sym
), len
, offset
, reg
);
1224 add_memrange (collect
, reg
, offset
, len
);
1228 offset
= SYMBOL_VALUE (sym
);
1232 printf_filtered ("LOC_LOCAL %s: Collect %d bytes at offset %d from frame ptr reg %d\n",
1233 SYMBOL_NAME (sym
), len
, offset
, reg
);
1235 add_memrange (collect
, reg
, offset
, len
);
1238 case LOC_BASEREG_ARG
:
1239 reg
= SYMBOL_BASEREG (sym
);
1240 offset
= SYMBOL_VALUE (sym
);
1243 printf_filtered ("LOC_BASEREG %s: collect %d bytes at offset %d from basereg %d\n",
1244 SYMBOL_NAME (sym
), len
, offset
, reg
);
1246 add_memrange (collect
, reg
, offset
, len
);
1248 case LOC_UNRESOLVED
:
1249 printf_filtered ("Don't know LOC_UNRESOLVED %s\n", SYMBOL_NAME (sym
));
1251 case LOC_OPTIMIZED_OUT
:
1252 printf_filtered ("%s has been optimized out of existance.\n",
1258 /* Add all locals (or args) symbols to collection list */
1260 add_local_symbols (collect
, pc
, type
)
1261 struct collection_list
*collect
;
1266 struct block
*block
;
1267 int i
, nsyms
, count
= 0;
1269 block
= block_for_pc (pc
);
1272 QUIT
; /* allow user to bail out with ^C */
1273 nsyms
= BLOCK_NSYMS (block
);
1274 for (i
= 0; i
< nsyms
; i
++)
1276 sym
= BLOCK_SYM (block
, i
);
1277 switch (SYMBOL_CLASS (sym
)) {
1282 if (type
== 'L') /* collecting Locals */
1285 collect_symbol (collect
, sym
);
1292 case LOC_REGPARM_ADDR
:
1293 case LOC_BASEREG_ARG
:
1294 if (type
== 'A') /* collecting Arguments */
1297 collect_symbol (collect
, sym
);
1301 if (BLOCK_FUNCTION (block
))
1304 block
= BLOCK_SUPERBLOCK (block
);
1307 warning ("No %s found in scope.", type
== 'L' ? "locals" : "args");
1310 /* worker function */
1312 clear_collection_list (list
)
1313 struct collection_list
*list
;
1317 list
->next_memrange
= 0;
1318 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1320 free_agent_expr(list
->aexpr_list
[ndx
]);
1321 list
->aexpr_list
[ndx
] = NULL
;
1323 list
->next_aexpr_elt
= 0;
1324 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1327 /* reduce a collection list to string form (for gdb protocol) */
1329 stringify_collection_list (list
, string
)
1330 struct collection_list
*list
;
1333 char temp_buf
[2048];
1336 char *(*str_list
)[];
1340 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1341 str_list
= (char *(*)[])xmalloc(count
* sizeof (char *));
1343 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1344 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1346 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1349 printf_filtered ("\nCollecting registers (mask): 0x");
1354 QUIT
; /* allow user to bail out with ^C */
1356 printf_filtered ("%02X", list
->regs_mask
[i
]);
1357 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1360 (*str_list
)[ndx
] = savestring(temp_buf
, end
- temp_buf
);
1364 printf_filtered ("\n");
1365 if (list
->next_memrange
> 0 && info_verbose
)
1366 printf_filtered ("Collecting memranges: \n");
1367 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1369 QUIT
; /* allow user to bail out with ^C */
1371 printf_filtered ("(%d, 0x%x, %d)\n",
1373 list
->list
[i
].start
,
1374 list
->list
[i
].end
- list
->list
[i
].start
);
1375 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1377 (*str_list
)[ndx
] = savestring(temp_buf
, count
);
1382 sprintf (end
, "M%X,%X,%X",
1384 list
->list
[i
].start
,
1385 list
->list
[i
].end
- list
->list
[i
].start
);
1386 count
+= strlen (end
);
1387 end
+= strlen (end
);
1390 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1392 QUIT
; /* allow user to bail out with ^C */
1393 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1395 (*str_list
)[ndx
] = savestring(temp_buf
, count
);
1400 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1401 end
+= 10; /* 'X' + 8 hex digits + ',' */
1404 end
= mem2hex(list
->aexpr_list
[i
]->buf
, end
, list
->aexpr_list
[i
]->len
);
1405 count
+= 2 * list
->aexpr_list
[i
]->len
;
1410 (*str_list
)[ndx
] = savestring(temp_buf
, count
);
1415 (*str_list
)[ndx
] = NULL
;
1424 free_actions_list(actions_list
)
1425 char **actions_list
;
1429 if (actions_list
== 0)
1432 for (ndx
= 0; actions_list
[ndx
]; ndx
++)
1433 free(actions_list
[ndx
]);
1438 /* render all actions into gdb protocol */
1440 encode_actions (t
, tdp_actions
, stepping_actions
)
1441 struct tracepoint
*t
;
1442 char ***tdp_actions
;
1443 char ***stepping_actions
;
1445 static char tdp_buff
[2048], step_buff
[2048];
1447 struct expression
*exp
= NULL
;
1448 struct action_line
*action
;
1449 bfd_signed_vma offset
;
1452 struct collection_list
*collect
;
1453 struct cmd_list_element
*cmd
;
1454 struct agent_expr
*aexpr
;
1456 clear_collection_list (&tracepoint_list
);
1457 clear_collection_list (&stepping_list
);
1458 collect
= &tracepoint_list
;
1460 *tdp_actions
= NULL
;
1461 *stepping_actions
= NULL
;
1463 for (action
= t
->actions
; action
; action
= action
->next
)
1465 QUIT
; /* allow user to bail out with ^C */
1466 action_exp
= action
->action
;
1467 while (isspace (*action_exp
))
1470 if (*action_exp
== '#') /* comment line */
1473 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1475 error ("Bad action list item: %s", action_exp
);
1477 if (cmd
->function
.cfunc
== collect_pseudocommand
)
1479 do { /* repeat over a comma-separated list */
1480 QUIT
; /* allow user to bail out with ^C */
1481 while (isspace (*action_exp
))
1484 if (0 == strncasecmp ("$reg", action_exp
, 4))
1486 for (i
= 0; i
< NUM_REGS
; i
++)
1487 add_register (collect
, i
);
1488 action_exp
= strchr (action_exp
, ','); /* more? */
1490 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1492 add_local_symbols (collect
, t
->address
, 'A');
1493 action_exp
= strchr (action_exp
, ','); /* more? */
1495 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1497 add_local_symbols (collect
, t
->address
, 'L');
1498 action_exp
= strchr (action_exp
, ','); /* more? */
1502 unsigned long addr
, len
;
1503 struct cleanup
*old_chain
= NULL
;
1504 struct cleanup
*old_chain1
= NULL
;
1505 struct agent_reqs areqs
;
1507 exp
= parse_exp_1 (&action_exp
, block_for_pc (t
->address
), 1);
1509 old_chain
= make_cleanup (free_current_contents
, &exp
);
1511 aexpr
= gen_trace_for_expr (exp
);
1513 old_chain1
= make_cleanup (free_agent_expr
, aexpr
);
1515 ax_reqs (aexpr
, &areqs
);
1516 if (areqs
.flaw
!= agent_flaw_none
)
1517 error ("malformed expression");
1519 if (areqs
.min_height
< 0)
1520 error ("gdb: Internal error: expression has min height < 0");
1521 if (areqs
.max_height
> 20)
1522 error ("expression too complicated, try simplifying");
1524 discard_cleanups (old_chain1
);
1525 add_aexpr (collect
, aexpr
);
1527 /* take care of the registers */
1528 if (areqs
.reg_mask_len
> 0)
1533 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1535 QUIT
; /* allow user to bail out with ^C */
1536 if (areqs
.reg_mask
[ndx1
] != 0)
1538 /* assume chars have 8 bits */
1539 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1540 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1541 /* it's used -- record it */
1542 add_register (collect
, ndx1
* 8 + ndx2
);
1546 do_cleanups (old_chain
);
1548 } while (action_exp
&& *action_exp
++ == ',');
1550 else if (cmd
->function
.cfunc
== while_stepping_pseudocommand
)
1552 collect
= &stepping_list
;
1554 else if (cmd
->function
.cfunc
== end_actions_pseudocommand
)
1556 if (collect
== &stepping_list
) /* end stepping actions */
1557 collect
= &tracepoint_list
;
1559 break; /* end tracepoint actions */
1562 memrange_sortmerge (&tracepoint_list
);
1563 memrange_sortmerge (&stepping_list
);
1565 *tdp_actions
= stringify_collection_list (&tracepoint_list
, &tdp_buff
);
1566 *stepping_actions
= stringify_collection_list (&stepping_list
, &step_buff
);
1570 add_aexpr(collect
, aexpr
)
1571 struct collection_list
*collect
;
1572 struct agent_expr
*aexpr
;
1574 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1576 collect
->aexpr_list
=
1577 xrealloc (collect
->aexpr_list
,
1578 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1579 collect
->aexpr_listsize
*= 2;
1581 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1582 collect
->next_aexpr_elt
++;
1586 static char target_buf
[2048];
1590 Tell target to clear any previous trace experiment.
1591 Walk the list of tracepoints, and send them (and their actions)
1592 to the target. If no errors,
1593 Tell target to start a new trace experiment. */
1596 trace_start_command (args
, from_tty
)
1599 { /* STUB_COMM MOSTLY_IMPLEMENTED */
1600 struct tracepoint
*t
;
1603 char **stepping_actions
;
1605 struct cleanup
*old_chain
= NULL
;
1607 dont_repeat (); /* like "run", dangerous to repeat accidentally */
1609 if (target_is_remote ())
1612 remote_get_noisy_reply (target_buf
);
1613 if (strcmp (target_buf
, "OK"))
1614 error ("Target does not support this command.");
1618 int ss_count
; /* if actions include singlestepping */
1619 int disable_mask
; /* ??? */
1620 int enable_mask
; /* ??? */
1622 sprintf (buf
, "QTDP:%x:%x:%c:%x:%x", t
->number
, t
->address
,
1623 t
->enabled
== enabled
? 'E' : 'D',
1624 t
->step_count
, t
->pass_count
);
1629 remote_get_noisy_reply (target_buf
);
1630 if (strcmp (target_buf
, "OK"))
1631 error ("Target does not support tracepoints.");
1635 encode_actions (t
, &tdp_actions
, &stepping_actions
);
1636 old_chain
= make_cleanup (free_actions_list
, tdp_actions
);
1637 (void) make_cleanup (free_actions_list
, stepping_actions
);
1639 /* do_single_steps (t); */
1642 for (ndx
= 0; tdp_actions
[ndx
]; ndx
++)
1644 QUIT
; /* allow user to bail out with ^C */
1645 sprintf (buf
, "QTDP:-%x:%x:%s%c",
1646 t
->number
, t
->address
,
1648 ((tdp_actions
[ndx
+1] || stepping_actions
)
1651 remote_get_noisy_reply (target_buf
);
1652 if (strcmp (target_buf
, "OK"))
1653 error ("Error on target while setting tracepoints.");
1656 if (stepping_actions
)
1658 for (ndx
= 0; stepping_actions
[ndx
]; ndx
++)
1660 QUIT
; /* allow user to bail out with ^C */
1661 sprintf (buf
, "QTDP:-%x:%x:%s%s%s",
1662 t
->number
, t
->address
,
1663 ((ndx
== 0) ? "S" : ""),
1664 stepping_actions
[ndx
],
1665 (stepping_actions
[ndx
+1] ? "-" : ""));
1667 remote_get_noisy_reply (target_buf
);
1668 if (strcmp (target_buf
, "OK"))
1669 error ("Error on target while setting tracepoints.");
1673 do_cleanups (old_chain
);
1677 remote_get_noisy_reply (target_buf
);
1678 if (strcmp (target_buf
, "OK"))
1679 error ("Bogus reply from target: %s", target_buf
);
1680 set_traceframe_num (-1); /* all old traceframes invalidated */
1681 set_tracepoint_num (-1);
1682 set_traceframe_context(-1);
1683 trace_running_p
= 1;
1686 error ("Trace can only be run on remote targets.");
1691 trace_stop_command (args
, from_tty
)
1694 { /* STUB_COMM IS_IMPLEMENTED */
1695 if (target_is_remote ())
1698 remote_get_noisy_reply (target_buf
);
1699 if (strcmp (target_buf
, "OK"))
1700 error ("Bogus reply from target: %s", target_buf
);
1701 trace_running_p
= 0;
1704 error ("Trace can only be run on remote targets.");
1707 unsigned long trace_running_p
;
1709 /* tstatus command */
1711 trace_status_command (args
, from_tty
)
1714 { /* STUB_COMM IS_IMPLEMENTED */
1715 if (target_is_remote ())
1717 putpkt ("qTStatus");
1718 remote_get_noisy_reply (target_buf
);
1720 if (target_buf
[0] != 'T' ||
1721 (target_buf
[1] != '0' && target_buf
[1] != '1'))
1722 error ("Bogus reply from target: %s", target_buf
);
1724 /* exported for use by the GUI */
1725 trace_running_p
= (target_buf
[1] == '1');
1728 error ("Trace can only be run on remote targets.");
1731 /* Worker function for the various flavors of the tfind command */
1733 finish_tfind_command (msg
, from_tty
)
1737 int target_frameno
= -1, target_tracept
= -1;
1738 CORE_ADDR old_frame_addr
;
1739 struct symbol
*old_func
;
1742 old_frame_addr
= FRAME_FP (get_current_frame ());
1743 old_func
= find_pc_function (read_pc ());
1746 reply
= remote_get_noisy_reply (msg
);
1748 while (reply
&& *reply
)
1751 if ((target_frameno
= strtol (++reply
, &reply
, 16)) == -1)
1753 /* A request for a non-existant trace frame has failed.
1754 Our response will be different, depending on FROM_TTY:
1756 If FROM_TTY is true, meaning that this command was
1757 typed interactively by the user, then give an error
1758 and DO NOT change the state of traceframe_number etc.
1760 However if FROM_TTY is false, meaning that we're either
1761 in a script, a loop, or a user-defined command, then
1762 DON'T give an error, but DO change the state of
1763 traceframe_number etc. to invalid.
1765 The rationalle is that if you typed the command, you
1766 might just have committed a typo or something, and you'd
1767 like to NOT lose your current debugging state. However
1768 if you're in a user-defined command or especially in a
1769 loop, then you need a way to detect that the command
1770 failed WITHOUT aborting. This allows you to write
1771 scripts that search thru the trace buffer until the end,
1772 and then continue on to do something else. */
1775 error ("Target failed to find requested trace frame.");
1779 printf_filtered ("End of trace buffer.\n");
1780 /* The following will not recurse, since it's special-cased */
1781 trace_find_command ("-1", from_tty
);
1782 reply
= NULL
; /* break out of loop,
1783 (avoid recursive nonsense) */
1788 if ((target_tracept
= strtol (++reply
, &reply
, 16)) == -1)
1789 error ("Target failed to find requested trace frame.");
1791 case 'O': /* "OK"? */
1792 if (reply
[1] == 'K' && reply
[2] == '\0')
1795 error ("Bogus reply from target: %s", reply
);
1798 error ("Bogus reply from target: %s", reply
);
1801 flush_cached_frames ();
1802 registers_changed ();
1803 select_frame (get_current_frame (), 0);
1804 set_traceframe_num (target_frameno
);
1805 set_tracepoint_num (target_tracept
);
1806 if (target_frameno
== -1)
1807 set_traceframe_context (-1);
1809 set_traceframe_context (read_pc ());
1815 /* NOTE: in immitation of the step command, try to determine
1816 whether we have made a transition from one function to another.
1817 If so, we'll print the "stack frame" (ie. the new function and
1818 it's arguments) -- otherwise we'll just show the new source line.
1820 This determination is made by checking (1) whether the current
1821 function has changed, and (2) whether the current FP has changed.
1822 Hack: if the FP wasn't collected, either at the current or the
1823 previous frame, assume that the FP has NOT changed. */
1825 if (old_func
== find_pc_function (read_pc ()) &&
1826 (old_frame_addr
== 0 ||
1827 FRAME_FP (get_current_frame ()) == 0 ||
1828 old_frame_addr
== FRAME_FP (get_current_frame ())))
1833 print_stack_frame (selected_frame
, selected_frame_level
, source_only
);
1838 /* trace_find_command takes a trace frame number n,
1839 sends "QTFrame:<n>" to the target,
1840 and accepts a reply that may contain several optional pieces
1841 of information: a frame number, a tracepoint number, and an
1842 indication of whether this is a trap frame or a stepping frame.
1844 The minimal response is just "OK" (which indicates that the
1845 target does not give us a frame number or a tracepoint number).
1846 Instead of that, the target may send us a string containing
1848 F<hexnum> (gives the selected frame number)
1849 T<hexnum> (gives the selected tracepoint number)
1854 trace_find_command (args
, from_tty
)
1857 { /* STUB_COMM PART_IMPLEMENTED */
1858 /* this should only be called with a numeric argument */
1860 int target_frameno
= -1, target_tracept
= -1, target_stepfrm
= 0;
1863 if (target_is_remote ())
1865 if (args
== 0 || *args
== 0)
1866 { /* TFIND with no args means find NEXT trace frame. */
1867 if (traceframe_number
== -1)
1868 frameno
= 0; /* "next" is first one */
1870 frameno
= traceframe_number
+ 1;
1872 else if (0 == strcmp (args
, "-"))
1874 if (traceframe_number
== -1)
1875 error ("not debugging trace buffer");
1876 else if (from_tty
&& traceframe_number
== 0)
1877 error ("already at start of trace buffer");
1879 frameno
= traceframe_number
- 1;
1882 frameno
= parse_and_eval_address (args
);
1885 error ("invalid input (%d is less than zero)", frameno
);
1887 sprintf (target_buf
, "QTFrame:%x", frameno
);
1888 finish_tfind_command (target_buf
, from_tty
);
1891 error ("Trace can only be run on remote targets.");
1896 trace_find_end_command (args
, from_tty
)
1900 trace_find_command ("-1", from_tty
);
1905 trace_find_none_command (args
, from_tty
)
1909 trace_find_command ("-1", from_tty
);
1914 trace_find_start_command (args
, from_tty
)
1918 trace_find_command ("0", from_tty
);
1921 /* tfind pc command */
1923 trace_find_pc_command (args
, from_tty
)
1926 { /* STUB_COMM PART_IMPLEMENTED */
1931 if (target_is_remote ())
1933 if (args
== 0 || *args
== 0)
1934 pc
= read_pc (); /* default is current pc */
1936 pc
= parse_and_eval_address (args
);
1938 sprintf (target_buf
, "QTFrame:pc:%x", pc
);
1939 finish_tfind_command (target_buf
, from_tty
);
1942 error ("Trace can only be run on remote targets.");
1945 /* tfind tracepoint command */
1947 trace_find_tracepoint_command (args
, from_tty
)
1950 { /* STUB_COMM PART_IMPLEMENTED */
1951 int target_frameno
, tdp
;
1954 if (target_is_remote ())
1956 if (args
== 0 || *args
== 0)
1957 if (tracepoint_number
== -1)
1958 error ("No current tracepoint -- please supply an argument.");
1960 tdp
= tracepoint_number
; /* default is current TDP */
1962 tdp
= parse_and_eval_address (args
);
1964 sprintf (target_buf
, "QTFrame:tdp:%x", tdp
);
1965 finish_tfind_command (target_buf
, from_tty
);
1968 error ("Trace can only be run on remote targets.");
1971 /* TFIND LINE command:
1973 This command will take a sourceline for argument, just like BREAK
1974 or TRACE (ie. anything that "decode_line_1" can handle).
1976 With no argument, this command will find the next trace frame
1977 corresponding to a source line OTHER THAN THE CURRENT ONE. */
1980 trace_find_line_command (args
, from_tty
)
1983 { /* STUB_COMM PART_IMPLEMENTED */
1984 static CORE_ADDR start_pc
, end_pc
;
1985 struct symtabs_and_lines sals
;
1986 struct symtab_and_line sal
;
1989 struct cleanup
*old_chain
;
1991 if (target_is_remote ())
1993 if (args
== 0 || *args
== 0)
1995 sal
= find_pc_line ((get_current_frame ())->pc
, 0);
1997 sals
.sals
= (struct symtab_and_line
*)
1998 xmalloc (sizeof (struct symtab_and_line
));
2003 sals
= decode_line_spec (args
, 1);
2007 old_chain
= make_cleanup (free
, sals
.sals
);
2008 if (sal
.symtab
== 0)
2010 printf_filtered ("TFIND: No line number information available");
2013 /* This is useful for "info line *0x7f34". If we can't tell the
2014 user about a source line, at least let them have the symbolic
2016 printf_filtered (" for address ");
2018 print_address (sal
.pc
, gdb_stdout
);
2019 printf_filtered (";\n -- will attempt to find by PC. \n");
2023 printf_filtered (".\n");
2024 return; /* no line, no PC; what can we do? */
2027 else if (sal
.line
> 0
2028 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2030 if (start_pc
== end_pc
)
2032 printf_filtered ("Line %d of \"%s\"",
2033 sal
.line
, sal
.symtab
->filename
);
2035 printf_filtered (" is at address ");
2036 print_address (start_pc
, gdb_stdout
);
2038 printf_filtered (" but contains no code.\n");
2039 sal
= find_pc_line (start_pc
, 0);
2041 find_line_pc_range (sal
, &start_pc
, &end_pc
) &&
2043 printf_filtered ("Attempting to find line %d instead.\n",
2046 error ("Cannot find a good line.");
2050 /* Is there any case in which we get here, and have an address
2051 which the user would want to see? If we have debugging symbols
2052 and no line numbers? */
2053 error ("Line number %d is out of range for \"%s\".\n",
2054 sal
.line
, sal
.symtab
->filename
);
2056 if (args
&& *args
) /* find within range of stated line */
2057 sprintf (target_buf
, "QTFrame:range:%x:%x", start_pc
, end_pc
- 1);
2058 else /* find OUTSIDE OF range of CURRENT line */
2059 sprintf (target_buf
, "QTFrame:outside:%x:%x", start_pc
, end_pc
- 1);
2060 finish_tfind_command (target_buf
, from_tty
);
2061 do_cleanups (old_chain
);
2064 error ("Trace can only be run on remote targets.");
2067 /* tfind range command */
2069 trace_find_range_command (args
, from_tty
)
2072 { /* STUB_COMM PART_IMPLEMENTED */
2073 static CORE_ADDR start
, stop
;
2077 if (target_is_remote ())
2079 if (args
== 0 || *args
== 0)
2080 { /* XXX FIXME: what should default behavior be? */
2081 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2085 if (0 != (tmp
= strchr (args
, ',' )))
2087 *tmp
++ = '\0'; /* terminate start address */
2088 while (isspace (*tmp
))
2090 start
= parse_and_eval_address (args
);
2091 stop
= parse_and_eval_address (tmp
);
2094 { /* no explicit end address? */
2095 start
= parse_and_eval_address (args
);
2096 stop
= start
+ 1; /* ??? */
2099 sprintf (target_buf
, "QTFrame:range:%x:%x", start
, stop
);
2100 finish_tfind_command (target_buf
, from_tty
);
2103 error ("Trace can only be run on remote targets.");
2106 /* tfind outside command */
2108 trace_find_outside_command (args
, from_tty
)
2111 { /* STUB_COMM PART_IMPLEMENTED */
2112 CORE_ADDR start
, stop
;
2116 if (target_is_remote ())
2118 if (args
== 0 || *args
== 0)
2119 { /* XXX FIXME: what should default behavior be? */
2120 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2124 if (0 != (tmp
= strchr (args
, ',' )))
2126 *tmp
++ = '\0'; /* terminate start address */
2127 while (isspace (*tmp
))
2129 start
= parse_and_eval_address (args
);
2130 stop
= parse_and_eval_address (tmp
);
2133 { /* no explicit end address? */
2134 start
= parse_and_eval_address (args
);
2135 stop
= start
+ 1; /* ??? */
2138 sprintf (target_buf
, "QTFrame:outside:%x:%x", start
, stop
);
2139 finish_tfind_command (target_buf
, from_tty
);
2142 error ("Trace can only be run on remote targets.");
2145 /* save-tracepoints command */
2147 tracepoint_save_command (args
, from_tty
)
2151 struct tracepoint
*tp
;
2152 struct action_line
*line
;
2154 char *i1
= " ", *i2
= " ";
2155 char *indent
, *actionline
;
2157 if (args
== 0 || *args
== 0)
2158 error ("Argument required (file name in which to save tracepoints");
2160 if (tracepoint_chain
== 0)
2162 warning ("save-tracepoints: no tracepoints to save.\n");
2166 if (!(fp
= fopen (args
, "w")))
2167 error ("Unable to open file '%s' for saving tracepoints");
2169 ALL_TRACEPOINTS (tp
)
2171 if (tp
->addr_string
)
2172 fprintf (fp
, "trace %s\n", tp
->addr_string
);
2174 fprintf (fp
, "trace *0x%x\n", tp
->address
);
2177 fprintf (fp
, " passcount %d\n", tp
->pass_count
);
2181 fprintf (fp
, " actions\n");
2183 for (line
= tp
->actions
; line
; line
= line
->next
)
2185 struct cmd_list_element
*cmd
;
2187 QUIT
; /* allow user to bail out with ^C */
2188 actionline
= line
->action
;
2189 while (isspace(*actionline
))
2192 fprintf (fp
, "%s%s\n", indent
, actionline
);
2193 if (*actionline
!= '#') /* skip for comment lines */
2195 cmd
= lookup_cmd (&actionline
, cmdlist
, "", -1, 1);
2197 error ("Bad action list item: %s", actionline
);
2198 if (cmd
->function
.cfunc
== while_stepping_pseudocommand
)
2200 else if (cmd
->function
.cfunc
== end_actions_pseudocommand
)
2208 printf_filtered ("Tracepoints saved to file '%s'.\n", args
);
2212 /* info scope command: list the locals for a scope. */
2214 scope_info (args
, from_tty
)
2218 struct symtab_and_line sal
;
2219 struct symtabs_and_lines sals
;
2221 struct minimal_symbol
*msym
;
2222 struct block
*block
;
2223 char **canonical
, *symname
, *save_args
= args
;
2224 int i
, nsyms
, count
= 0;
2226 if (args
== 0 || *args
== 0)
2227 error ("requires an argument (function, line or *addr) to define a scope");
2229 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
);
2230 if (sals
.nelts
== 0)
2231 return; /* presumably decode_line_1 has already warned */
2233 /* Resolve line numbers to PC */
2234 resolve_sal_pc (&sals
.sals
[0]);
2235 block
= block_for_pc (sals
.sals
[0].pc
);
2239 QUIT
; /* allow user to bail out with ^C */
2240 nsyms
= BLOCK_NSYMS (block
);
2241 for (i
= 0; i
< nsyms
; i
++)
2243 QUIT
; /* allow user to bail out with ^C */
2245 printf_filtered ("Scope for %s:\n", save_args
);
2247 sym
= BLOCK_SYM (block
, i
);
2248 symname
= SYMBOL_NAME (sym
);
2249 if (symname
== NULL
|| *symname
== '\0')
2250 continue; /* probably botched, certainly useless */
2252 printf_filtered ("Symbol %s is ", symname
);
2253 switch (SYMBOL_CLASS (sym
)) {
2255 case LOC_UNDEF
: /* messed up symbol? */
2256 printf_filtered ("a bogus symbol, class %d.\n",
2257 SYMBOL_CLASS (sym
));
2258 count
--; /* don't count this one */
2261 printf_filtered ("a constant with value %d (0x%x)",
2262 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2264 case LOC_CONST_BYTES
:
2265 printf_filtered ("constant bytes: ");
2266 if (SYMBOL_TYPE (sym
))
2267 for (i
= 0; i
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); i
++)
2268 fprintf_filtered (gdb_stdout
, " %02x",
2269 (unsigned) SYMBOL_VALUE_BYTES (sym
) [i
]);
2272 printf_filtered ("in static storage at address ");
2273 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
), 1, gdb_stdout
);
2276 printf_filtered ("a local variable in register $%s",
2277 reg_names
[SYMBOL_VALUE (sym
)]);
2281 printf_filtered ("an argument at stack/frame offset %ld",
2282 SYMBOL_VALUE (sym
));
2285 printf_filtered ("a local variable at frame offset %ld",
2286 SYMBOL_VALUE (sym
));
2289 printf_filtered ("a reference argument at offset %ld",
2290 SYMBOL_VALUE (sym
));
2293 printf_filtered ("an argument in register $%s",
2294 reg_names
[SYMBOL_VALUE (sym
)]);
2296 case LOC_REGPARM_ADDR
:
2297 printf_filtered ("the address of an argument, in register $%s",
2298 reg_names
[SYMBOL_VALUE (sym
)]);
2301 printf_filtered ("a typedef.\n");
2304 printf_filtered ("a label at address ");
2305 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
), 1, gdb_stdout
);
2308 printf_filtered ("a function at address ");
2309 print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)), 1,
2313 printf_filtered ("a variable at offset %d from register $%s",
2315 reg_names
[SYMBOL_BASEREG (sym
)]);
2317 case LOC_BASEREG_ARG
:
2318 printf_filtered ("an argument at offset %d from register $%s",
2320 reg_names
[SYMBOL_BASEREG (sym
)]);
2322 case LOC_UNRESOLVED
:
2323 msym
= lookup_minimal_symbol (SYMBOL_NAME (sym
), NULL
, NULL
);
2325 printf_filtered ("Unresolved Static");
2328 printf_filtered ("static storage at address ");
2329 print_address_numeric (SYMBOL_VALUE_ADDRESS (msym
), 1,
2333 case LOC_OPTIMIZED_OUT
:
2334 printf_filtered ("optimized out.\n");
2337 if (SYMBOL_TYPE (sym
))
2338 printf_filtered (", length %d.\n",
2339 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2341 if (BLOCK_FUNCTION (block
))
2344 block
= BLOCK_SUPERBLOCK (block
);
2347 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2351 /* worker function (cleanup) */
2353 replace_comma (comma
)
2361 trace_dump_command (args
, from_tty
)
2365 struct tracepoint
*t
;
2366 struct action_line
*action
;
2367 char *action_exp
, *next_comma
;
2368 struct cleanup
*old_cleanups
;
2369 int stepping_actions
= 0;
2370 int stepping_frame
= 0;
2372 if (!target_is_remote ())
2374 error ("Trace can only be run on remote targets.");
2378 if (tracepoint_number
== -1)
2380 warning ("No current trace frame.");
2385 if (t
->number
== tracepoint_number
)
2389 error ("No known tracepoint matches 'current' tracepoint #%d.",
2392 old_cleanups
= make_cleanup (null_cleanup
, NULL
);
2394 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2395 tracepoint_number
, traceframe_number
);
2397 /* The current frame is a trap frame if the frame PC is equal
2398 to the tracepoint PC. If not, then the current frame was
2399 collected during single-stepping. */
2401 stepping_frame
= (t
->address
!= read_pc());
2403 for (action
= t
->actions
; action
; action
= action
->next
)
2405 struct cmd_list_element
*cmd
;
2407 QUIT
; /* allow user to bail out with ^C */
2408 action_exp
= action
->action
;
2409 while (isspace (*action_exp
))
2412 /* The collection actions to be done while stepping are
2413 bracketed by the commands "while-stepping" and "end". */
2415 if (*action_exp
== '#') /* comment line */
2418 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2420 error ("Bad action list item: %s", action_exp
);
2422 if (cmd
->function
.cfunc
== while_stepping_pseudocommand
)
2423 stepping_actions
= 1;
2424 else if (cmd
->function
.cfunc
== end_actions_pseudocommand
)
2425 stepping_actions
= 0;
2426 else if (cmd
->function
.cfunc
== collect_pseudocommand
)
2428 /* Display the collected data.
2429 For the trap frame, display only what was collected at the trap.
2430 Likewise for stepping frames, display only what was collected
2431 while stepping. This means that the two boolean variables,
2432 STEPPING_FRAME and STEPPING_ACTIONS should be equal. */
2433 if (stepping_frame
== stepping_actions
)
2435 do { /* repeat over a comma-separated list */
2436 QUIT
; /* allow user to bail out with ^C */
2437 if (*action_exp
== ',')
2439 while (isspace (*action_exp
))
2442 next_comma
= strchr (action_exp
, ',');
2444 if (0 == strncasecmp (action_exp
, "$reg", 4))
2445 registers_info (NULL
, from_tty
);
2446 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2447 locals_info (NULL
, from_tty
);
2448 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2449 args_info (NULL
, from_tty
);
2454 make_cleanup (replace_comma
, next_comma
);
2457 printf_filtered ("%s = ", action_exp
);
2458 output_command (action_exp
, from_tty
);
2459 printf_filtered ("\n");
2463 action_exp
= next_comma
;
2464 } while (action_exp
&& *action_exp
== ',');
2468 discard_cleanups (old_cleanups
);
2471 /* Convert the memory pointed to by mem into hex, placing result in buf.
2472 * Return a pointer to the last char put in buf (null)
2473 * "stolen" from sparc-stub.c
2476 static const char hexchars
[]="0123456789abcdef";
2478 static unsigned char *
2479 mem2hex(mem
, buf
, count
)
2490 *buf
++ = hexchars
[ch
>> 4];
2491 *buf
++ = hexchars
[ch
& 0xf];
2499 int get_traceframe_number()
2501 return traceframe_number
;
2505 /* module initialization */
2507 _initialize_tracepoint ()
2509 tracepoint_chain
= 0;
2510 tracepoint_count
= 0;
2511 traceframe_number
= -1;
2512 tracepoint_number
= -1;
2514 set_internalvar (lookup_internalvar ("tpnum"),
2515 value_from_longest (builtin_type_int
, (LONGEST
) 0));
2516 set_internalvar (lookup_internalvar ("trace_frame"),
2517 value_from_longest (builtin_type_int
, (LONGEST
) -1));
2519 if (tracepoint_list
.list
== NULL
)
2521 tracepoint_list
.listsize
= 128;
2522 tracepoint_list
.list
= xmalloc
2523 (tracepoint_list
.listsize
* sizeof (struct memrange
));
2525 if (tracepoint_list
.aexpr_list
== NULL
)
2527 tracepoint_list
.aexpr_listsize
= 128;
2528 tracepoint_list
.aexpr_list
= xmalloc
2529 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
2532 if (stepping_list
.list
== NULL
)
2534 stepping_list
.listsize
= 128;
2535 stepping_list
.list
= xmalloc
2536 (stepping_list
.listsize
* sizeof (struct memrange
));
2539 if (stepping_list
.aexpr_list
== NULL
)
2541 stepping_list
.aexpr_listsize
= 128;
2542 stepping_list
.aexpr_list
= xmalloc
2543 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
2546 add_info ("scope", scope_info
,
2547 "List the variables local to a scope");
2549 add_cmd ("tracepoints", class_trace
, NO_FUNCTION
,
2550 "Tracing of program execution without stopping the program.",
2553 add_info ("tracepoints", tracepoints_info
,
2554 "Status of tracepoints, or tracepoint number NUMBER.\n\
2555 Convenience variable \"$tpnum\" contains the number of the\n\
2556 last tracepoint set.");
2558 add_info_alias ("tp", "tracepoints", 1);
2560 add_com ("save-tracepoints", class_trace
, tracepoint_save_command
,
2561 "Save current tracepoint definitions as a script.\n\
2562 Use the 'source' command in another debug session to restore them.");
2564 add_com ("tdump", class_trace
, trace_dump_command
,
2565 "Print everything collected at the current tracepoint.");
2567 add_prefix_cmd ("tfind", class_trace
, trace_find_command
,
2568 "Select a trace frame;\n\
2569 No argument means forward by one frame; '-' meand backward by one frame.",
2570 &tfindlist
, "tfind ", 1, &cmdlist
);
2572 add_cmd ("outside", class_trace
, trace_find_outside_command
,
2573 "Select a trace frame whose PC is outside the given \
2574 range.\nUsage: tfind outside addr1, addr2",
2577 add_cmd ("range", class_trace
, trace_find_range_command
,
2578 "Select a trace frame whose PC is in the given range.\n\
2579 Usage: tfind range addr1,addr2",
2582 add_cmd ("line", class_trace
, trace_find_line_command
,
2583 "Select a trace frame by source line.\n\
2584 Argument can be a line number (with optional source file), \n\
2585 a function name, or '*' followed by an address.\n\
2586 Default argument is 'the next source line that was traced'.",
2589 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
,
2590 "Select a trace frame by tracepoint number.\n\
2591 Default is the tracepoint for the current trace frame.",
2594 add_cmd ("pc", class_trace
, trace_find_pc_command
,
2595 "Select a trace frame by PC.\n\
2596 Default is the current PC, or the PC of the current trace frame.",
2599 add_cmd ("end", class_trace
, trace_find_end_command
,
2600 "Synonym for 'none'.\n\
2601 De-select any trace frame and resume 'live' debugging.",
2604 add_cmd ("none", class_trace
, trace_find_none_command
,
2605 "De-select any trace frame and resume 'live' debugging.",
2608 add_cmd ("start", class_trace
, trace_find_start_command
,
2609 "Select the first trace frame in the trace buffer.",
2612 add_com ("tstatus", class_trace
, trace_status_command
,
2613 "Display the status of the current trace data collection.");
2615 add_com ("tstop", class_trace
, trace_stop_command
,
2616 "Stop trace data collection.");
2618 add_com ("tstart", class_trace
, trace_start_command
,
2619 "Start trace data collection.");
2621 add_com ("passcount", class_trace
, trace_pass_command
,
2622 "Set the passcount for a tracepoint.\n\
2623 The trace will end when the tracepoint has been passed 'count' times.\n\
2624 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
2625 if TPNUM is omitted, passcount refers to the last tracepoint defined.");
2627 add_com ("end", class_trace
, end_actions_pseudocommand
,
2628 "Ends a list of commands or actions.\n\
2629 Several GDB commands allow you to enter a list of commands or actions.\n\
2630 Entering \"end\" on a line by itself is the normal way to terminate\n\
2632 Note: the \"end\" command cannot be used at the gdb prompt.");
2634 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
,
2635 "Specify single-stepping behavior at a tracepoint.\n\
2636 Argument is number of instructions to trace in single-step mode\n\
2637 following the tracepoint. This command is normally followed by\n\
2638 one or more \"collect\" commands, to specify what to collect\n\
2639 while single-stepping.\n\n\
2640 Note: this command can only be used in a tracepoint \"actions\" list.");
2642 add_com_alias ("ws", "while-stepping", class_alias
, 0);
2643 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
2645 add_com ("collect", class_trace
, collect_pseudocommand
,
2646 "Specify one or more data items to be collected at a tracepoint.\n\
2647 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
2648 collect all data (variables, registers) referenced by that expression.\n\
2649 Also accepts the following special arguments:\n\
2650 $regs -- all registers.\n\
2651 $args -- all function arguments.\n\
2652 $locals -- all variables local to the block/function scope.\n\
2653 Note: this command can only be used in a tracepoint \"actions\" list.");
2655 add_com ("actions", class_trace
, trace_actions_command
,
2656 "Specify the actions to be taken at a tracepoint.\n\
2657 Tracepoint actions may include collecting of specified data, \n\
2658 single-stepping, or enabling/disabling other tracepoints, \n\
2659 depending on target's capabilities.");
2661 add_cmd ("tracepoints", class_trace
, delete_trace_command
,
2662 "Delete specified tracepoints.\n\
2663 Arguments are tracepoint numbers, separated by spaces.\n\
2664 No argument means delete all tracepoints.",
2667 add_cmd ("tracepoints", class_trace
, disable_trace_command
,
2668 "Disable specified tracepoints.\n\
2669 Arguments are tracepoint numbers, separated by spaces.\n\
2670 No argument means disable all tracepoints.",
2673 add_cmd ("tracepoints", class_trace
, enable_trace_command
,
2674 "Enable specified tracepoints.\n\
2675 Arguments are tracepoint numbers, separated by spaces.\n\
2676 No argument means enable all tracepoints.",
2679 add_com ("trace", class_trace
, trace_command
,
2680 "Set a tracepoint at a specified line or function or address.\n\
2681 Argument may be a line number, function name, or '*' plus an address.\n\
2682 For a line number or function, trace at the start of its code.\n\
2683 If an address is specified, trace at that exact address.\n\n\
2684 Do \"help tracepoints\" for info on other tracepoint commands.");
2686 add_com_alias ("tp", "trace", class_alias
, 0);
2687 add_com_alias ("tr", "trace", class_alias
, 1);
2688 add_com_alias ("tra", "trace", class_alias
, 1);
2689 add_com_alias ("trac", "trace", class_alias
, 1);