1 /* Tracing functionality for remote targets in custom GDB protocol
2 Copyright 1997, 1998 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,
19 Boston, MA 02111-1307, USA. */
25 #include "expression.h"
30 #include "gdb_string.h"
32 #include "tracepoint.h"
38 /* readline include files */
39 #include <readline/readline.h>
40 #include <readline/history.h>
42 /* readline defines this. */
49 /* maximum length of an agent aexpression.
50 this accounts for the fact that packets are limited to 400 bytes
51 (which includes everything -- including the checksum), and assumes
52 the worst case of maximum length for each of the pieces of a
55 NOTE: expressions get mem2hex'ed otherwise this would be twice as
56 large. (400 - 31)/2 == 184 */
57 #define MAX_AGENT_EXPR_LEN 184
60 extern int info_verbose;
61 extern void (*readline_begin_hook) PARAMS ((char *,...));
62 extern char *(*readline_hook) PARAMS ((char *));
63 extern void (*readline_end_hook) PARAMS ((void));
64 extern void x_command PARAMS ((char *, int));
65 extern int addressprint; /* Print machine addresses? */
67 /* GDB commands implemented in other modules:
70 extern void output_command PARAMS ((char *, int));
71 extern void registers_info PARAMS ((char *, int));
72 extern void args_info PARAMS ((char *, int));
73 extern void locals_info PARAMS ((char *, int));
76 /* If this definition isn't overridden by the header files, assume
77 that isatty and fileno exist on this system. */
79 #define ISATTY(FP) (isatty (fileno (FP)))
85 This module defines the following debugger commands:
86 trace : set a tracepoint on a function, line, or address.
87 info trace : list all debugger-defined tracepoints.
88 delete trace : delete one or more tracepoints.
89 enable trace : enable one or more tracepoints.
90 disable trace : disable one or more tracepoints.
91 actions : specify actions to be taken at a tracepoint.
92 passcount : specify a pass count for a tracepoint.
93 tstart : start a trace experiment.
94 tstop : stop a trace experiment.
95 tstatus : query the status of a trace experiment.
96 tfind : find a trace frame in the trace buffer.
97 tdump : print everything collected at the current tracepoint.
98 save-tracepoints : write tracepoint setup into a file.
100 This module defines the following user-visible debugger variables:
101 $trace_frame : sequence number of trace frame currently being debugged.
102 $trace_line : source line of trace frame currently being debugged.
103 $trace_file : source file of trace frame currently being debugged.
104 $tracepoint : tracepoint number of trace frame currently being debugged.
108 /* ======= Important global variables: ======= */
110 /* Chain of all tracepoints defined. */
111 struct tracepoint *tracepoint_chain;
113 /* Number of last tracepoint made. */
114 static int tracepoint_count;
116 /* Number of last traceframe collected. */
117 static int traceframe_number;
119 /* Tracepoint for last traceframe collected. */
120 static int tracepoint_number;
122 /* Symbol for function for last traceframe collected */
123 static struct symbol *traceframe_fun;
125 /* Symtab and line for last traceframe collected */
126 static struct symtab_and_line traceframe_sal;
128 /* Tracing command lists */
129 static struct cmd_list_element *tfindlist;
131 /* ======= Important command functions: ======= */
132 static void trace_command PARAMS ((char *, int));
133 static void tracepoints_info PARAMS ((char *, int));
134 static void delete_trace_command PARAMS ((char *, int));
135 static void enable_trace_command PARAMS ((char *, int));
136 static void disable_trace_command PARAMS ((char *, int));
137 static void trace_pass_command PARAMS ((char *, int));
138 static void trace_actions_command PARAMS ((char *, int));
139 static void trace_start_command PARAMS ((char *, int));
140 static void trace_stop_command PARAMS ((char *, int));
141 static void trace_status_command PARAMS ((char *, int));
142 static void trace_find_command PARAMS ((char *, int));
143 static void trace_find_pc_command PARAMS ((char *, int));
144 static void trace_find_tracepoint_command PARAMS ((char *, int));
145 static void trace_find_line_command PARAMS ((char *, int));
146 static void trace_find_range_command PARAMS ((char *, int));
147 static void trace_find_outside_command PARAMS ((char *, int));
148 static void tracepoint_save_command PARAMS ((char *, int));
149 static void trace_dump_command PARAMS ((char *, int));
151 /* support routines */
152 static void trace_mention PARAMS ((struct tracepoint *));
154 struct collection_list;
155 static void add_aexpr PARAMS ((struct collection_list *, struct agent_expr *));
156 static unsigned char *mem2hex (unsigned char *, unsigned char *, int);
157 static void add_register PARAMS ((struct collection_list * collection,
158 unsigned int regno));
159 static void free_actions_list PARAMS ((char **actions_list));
160 static void free_actions_list_cleanup_wrapper PARAMS ((void *));
162 extern void _initialize_tracepoint PARAMS ((void));
164 /* Utility: returns true if "target remote" */
168 if (current_target.to_shortname &&
169 strcmp (current_target.to_shortname, "remote") == 0)
175 /* Utility: generate error from an incoming stub packet. */
181 return; /* not an error msg */
184 case '1': /* malformed packet error */
185 if (*++buf == '0') /* general case: */
186 error ("tracepoint.c: error in outgoing packet.");
188 error ("tracepoint.c: error in outgoing packet at field #%d.",
189 strtol (buf, NULL, 16));
191 error ("trace API error 0x%s.", ++buf);
193 error ("Target returns error code '%s'.", buf);
197 /* Utility: wait for reply from stub, while accepting "O" packets */
199 remote_get_noisy_reply (char *buf,
202 do /* loop on reply from remote stub */
204 QUIT; /* allow user to bail out with ^C */
205 getpkt (buf, sizeof_buf, 0);
207 error ("Target does not support this command.");
208 else if (buf[0] == 'E')
210 else if (buf[0] == 'O' &&
212 remote_console_output (buf + 1); /* 'O' message from stub */
214 return buf; /* here's the actual reply */
219 /* Set tracepoint count to NUM. */
221 set_tracepoint_count (num)
224 tracepoint_count = num;
225 set_internalvar (lookup_internalvar ("tpnum"),
226 value_from_longest (builtin_type_int, (LONGEST) num));
229 /* Set traceframe number to NUM. */
231 set_traceframe_num (num)
234 traceframe_number = num;
235 set_internalvar (lookup_internalvar ("trace_frame"),
236 value_from_longest (builtin_type_int, (LONGEST) num));
239 /* Set tracepoint number to NUM. */
241 set_tracepoint_num (num)
244 tracepoint_number = num;
245 set_internalvar (lookup_internalvar ("tracepoint"),
246 value_from_longest (builtin_type_int, (LONGEST) num));
249 /* Set externally visible debug variables for querying/printing
250 the traceframe context (line, function, file) */
253 set_traceframe_context (trace_pc)
256 static struct type *func_string, *file_string;
257 static struct type *func_range, *file_range;
258 static value_ptr func_val, file_val;
259 static struct type *charstar;
262 if (charstar == (struct type *) NULL)
263 charstar = lookup_pointer_type (builtin_type_char);
265 if (trace_pc == -1) /* cease debugging any trace buffers */
268 traceframe_sal.pc = traceframe_sal.line = 0;
269 traceframe_sal.symtab = NULL;
270 set_internalvar (lookup_internalvar ("trace_func"),
271 value_from_longest (charstar, (LONGEST) 0));
272 set_internalvar (lookup_internalvar ("trace_file"),
273 value_from_longest (charstar, (LONGEST) 0));
274 set_internalvar (lookup_internalvar ("trace_line"),
275 value_from_longest (builtin_type_int, (LONGEST) - 1));
279 /* save as globals for internal use */
280 traceframe_sal = find_pc_line (trace_pc, 0);
281 traceframe_fun = find_pc_function (trace_pc);
283 /* save linenumber as "$trace_line", a debugger variable visible to users */
284 set_internalvar (lookup_internalvar ("trace_line"),
285 value_from_longest (builtin_type_int,
286 (LONGEST) traceframe_sal.line));
288 /* save func name as "$trace_func", a debugger variable visible to users */
289 if (traceframe_fun == NULL ||
290 SYMBOL_NAME (traceframe_fun) == NULL)
291 set_internalvar (lookup_internalvar ("trace_func"),
292 value_from_longest (charstar, (LONGEST) 0));
295 len = strlen (SYMBOL_NAME (traceframe_fun));
296 func_range = create_range_type (func_range,
297 builtin_type_int, 0, len - 1);
298 func_string = create_array_type (func_string,
299 builtin_type_char, func_range);
300 func_val = allocate_value (func_string);
301 VALUE_TYPE (func_val) = func_string;
302 memcpy (VALUE_CONTENTS_RAW (func_val),
303 SYMBOL_NAME (traceframe_fun),
305 func_val->modifiable = 0;
306 set_internalvar (lookup_internalvar ("trace_func"), func_val);
309 /* save file name as "$trace_file", a debugger variable visible to users */
310 if (traceframe_sal.symtab == NULL ||
311 traceframe_sal.symtab->filename == NULL)
312 set_internalvar (lookup_internalvar ("trace_file"),
313 value_from_longest (charstar, (LONGEST) 0));
316 len = strlen (traceframe_sal.symtab->filename);
317 file_range = create_range_type (file_range,
318 builtin_type_int, 0, len - 1);
319 file_string = create_array_type (file_string,
320 builtin_type_char, file_range);
321 file_val = allocate_value (file_string);
322 VALUE_TYPE (file_val) = file_string;
323 memcpy (VALUE_CONTENTS_RAW (file_val),
324 traceframe_sal.symtab->filename,
326 file_val->modifiable = 0;
327 set_internalvar (lookup_internalvar ("trace_file"), file_val);
331 /* Low level routine to set a tracepoint.
332 Returns the tracepoint object so caller can set other things.
333 Does not set the tracepoint number!
334 Does not print anything.
336 ==> This routine should not be called if there is a chance of later
337 error(); otherwise it leaves a bogus tracepoint on the chain. Validate
338 your arguments BEFORE calling this routine! */
340 static struct tracepoint *
341 set_raw_tracepoint (sal)
342 struct symtab_and_line sal;
344 register struct tracepoint *t, *tc;
345 struct cleanup *old_chain;
347 t = (struct tracepoint *) xmalloc (sizeof (struct tracepoint));
348 old_chain = make_cleanup (free, t);
349 memset (t, 0, sizeof (*t));
351 if (sal.symtab == NULL)
352 t->source_file = NULL;
354 t->source_file = savestring (sal.symtab->filename,
355 strlen (sal.symtab->filename));
357 t->section = sal.section;
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 %-5ld ", t->pass_count, t->step_count);
506 sym = find_pc_sect_function (t->address, t->section);
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 commands. */
552 tracepoint_operation (t, from_tty, opcode)
553 struct tracepoint *t;
555 enum tracepoint_opcode opcode;
557 struct tracepoint *t2;
559 if (t == NULL) /* no tracepoint operand */
565 t->enabled = enabled;
566 if (modify_tracepoint_hook)
567 modify_tracepoint_hook (t);
570 t->enabled = disabled;
571 if (modify_tracepoint_hook)
572 modify_tracepoint_hook (t);
575 if (tracepoint_chain == t)
576 tracepoint_chain = t->next;
585 /* Let the UI know of any deletions */
586 if (delete_tracepoint_hook)
587 delete_tracepoint_hook (t);
590 free (t->addr_string);
592 free (t->source_file);
601 /* Utility: parse a tracepoint number and look it up in the list.
602 If MULTI_P is true, there might be a range of tracepoints in ARG.
603 if OPTIONAL_P is true, then if the argument is missing, the most
604 recent tracepoint (tracepoint_count) is returned. */
606 get_tracepoint_by_number (arg, multi_p, optional_p)
608 int multi_p, optional_p;
610 struct tracepoint *t;
612 char *instring = arg == NULL ? NULL : *arg;
614 if (arg == NULL || *arg == NULL || ! **arg)
617 tpnum = tracepoint_count;
619 error_no_arg ("tracepoint number");
622 tpnum = multi_p ? get_number_or_range (arg) : get_number (arg);
626 if (instring && *instring)
627 printf_filtered ("bad tracepoint number at or near '%s'\n", instring);
629 printf_filtered ("Tracepoint argument missing and no previous tracepoint\n");
634 if (t->number == tpnum)
639 /* FIXME: if we are in the middle of a range we don't want to give
640 a message. The current interface to get_number_or_range doesn't
641 allow us to discover this. */
642 printf_unfiltered ("No tracepoint number %d.\n", tpnum);
646 /* Utility: parse a list of tracepoint numbers, and call a func for each. */
648 map_args_over_tracepoints (args, from_tty, opcode)
651 enum tracepoint_opcode opcode;
653 struct tracepoint *t, *tmp;
655 if (args == 0 || *args == 0) /* do them all */
656 ALL_TRACEPOINTS_SAFE (t, tmp)
657 tracepoint_operation (t, from_tty, opcode);
661 QUIT; /* give user option to bail out with ^C */
662 t = get_tracepoint_by_number (&args, 1, 0);
663 tracepoint_operation (t, from_tty, opcode);
664 while (*args == ' ' || *args == '\t')
669 /* The 'enable trace' command enables tracepoints. Not supported by all targets. */
671 enable_trace_command (args, from_tty)
676 map_args_over_tracepoints (args, from_tty, enable_op);
679 /* The 'disable trace' command enables tracepoints. Not supported by all targets. */
681 disable_trace_command (args, from_tty)
686 map_args_over_tracepoints (args, from_tty, disable_op);
689 /* Remove a tracepoint (or all if no argument) */
691 delete_trace_command (args, from_tty)
696 if (!args || !*args) /* No args implies all tracepoints; */
697 if (from_tty) /* confirm only if from_tty... */
698 if (tracepoint_chain) /* and if there are tracepoints to delete! */
699 if (!query ("Delete all tracepoints? "))
702 map_args_over_tracepoints (args, from_tty, delete_op);
705 /* Set passcount for tracepoint.
707 First command argument is passcount, second is tracepoint number.
708 If tracepoint number omitted, apply to most recently defined.
709 Also accepts special argument "all". */
712 trace_pass_command (args, from_tty)
716 struct tracepoint *t1 = (struct tracepoint *) -1, *t2;
720 if (args == 0 || *args == 0)
721 error ("passcount command requires an argument (count + optional TP num)");
723 count = strtoul (args, &args, 10); /* count comes first, then TP num */
725 while (*args && isspace ((int) *args))
728 if (*args && strncasecmp (args, "all", 3) == 0)
730 args += 3; /* skip special argument "all" */
733 error ("Junk at end of arguments.");
736 t1 = get_tracepoint_by_number (&args, 1, 1);
743 if (t1 == (struct tracepoint *) -1 || t1 == t2)
745 t2->pass_count = count;
746 if (modify_tracepoint_hook)
747 modify_tracepoint_hook (t2);
749 printf_filtered ("Setting tracepoint %d's passcount to %d\n",
753 t1 = get_tracepoint_by_number (&args, 1, 0);
759 /* ACTIONS functions: */
761 /* Prototypes for action-parsing utility commands */
762 static void read_actions PARAMS ((struct tracepoint *));
764 /* The three functions:
765 collect_pseudocommand,
766 while_stepping_pseudocommand, and
767 end_actions_pseudocommand
768 are placeholders for "commands" that are actually ONLY to be used
769 within a tracepoint action list. If the actual function is ever called,
770 it means that somebody issued the "command" at the top level,
771 which is always an error. */
774 end_actions_pseudocommand (args, from_tty)
778 error ("This command cannot be used at the top level.");
782 while_stepping_pseudocommand (args, from_tty)
786 error ("This command can only be used in a tracepoint actions list.");
790 collect_pseudocommand (args, from_tty)
794 error ("This command can only be used in a tracepoint actions list.");
797 /* Enter a list of actions for a tracepoint. */
799 trace_actions_command (args, from_tty)
803 struct tracepoint *t;
805 char *end_msg = "End with a line saying just \"end\".";
807 t = get_tracepoint_by_number (&args, 0, 1);
810 sprintf (tmpbuf, "Enter actions for tracepoint %d, one per line.",
815 if (readline_begin_hook)
816 (*readline_begin_hook) ("%s %s\n", tmpbuf, end_msg);
817 else if (input_from_terminal_p ())
818 printf_filtered ("%s\n%s\n", tmpbuf, end_msg);
822 t->step_count = 0; /* read_actions may set this */
825 if (readline_end_hook)
826 (*readline_end_hook) ();
827 /* tracepoints_changed () */
829 /* else just return */
832 /* worker function */
835 struct tracepoint *t;
838 char *prompt1 = "> ", *prompt2 = " > ";
839 char *prompt = prompt1;
840 enum actionline_type linetype;
841 extern FILE *instream;
842 struct action_line *next = NULL, *temp;
843 struct cleanup *old_chain;
845 /* Control-C quits instantly if typed while in this loop
846 since it should not wait until the user types a newline. */
852 signal (STOP_SIGNAL, handle_stop_sig);
854 signal (STOP_SIGNAL, stop_sig);
857 old_chain = make_cleanup ((make_cleanup_func) free_actions, (void *) t);
860 /* Make sure that all output has been output. Some machines may let
861 you get away with leaving out some of the gdb_flush, but not all. */
863 gdb_flush (gdb_stdout);
864 gdb_flush (gdb_stderr);
866 if (readline_hook && instream == NULL)
867 line = (*readline_hook) (prompt);
868 else if (instream == stdin && ISATTY (instream))
870 line = readline (prompt);
871 if (line && *line) /* add it to command history */
875 line = gdb_readline (0);
877 linetype = validate_actionline (&line, t);
878 if (linetype == BADLINE)
879 continue; /* already warned -- collect another line */
881 temp = xmalloc (sizeof (struct action_line));
885 if (next == NULL) /* first action for this tracepoint? */
886 t->actions = next = temp;
893 if (linetype == STEPPING) /* begin "while-stepping" */
895 if (prompt == prompt2)
897 warning ("Already processing 'while-stepping'");
901 prompt = prompt2; /* change prompt for stepping actions */
903 else if (linetype == END)
905 if (prompt == prompt2)
907 prompt = prompt1; /* end of single-stepping actions */
910 { /* end of actions */
911 if (t->actions->next == NULL)
913 /* an "end" all by itself with no other actions means
914 this tracepoint has no actions. Discard empty list. */
923 signal (STOP_SIGNAL, SIG_DFL);
926 discard_cleanups (old_chain);
929 /* worker function */
931 validate_actionline (line, t)
933 struct tracepoint *t;
935 struct cmd_list_element *c;
936 struct expression *exp = NULL;
937 struct cleanup *old_chain = NULL;
940 for (p = *line; isspace ((int) *p);)
943 /* symbol lookup etc. */
944 if (*p == '\0') /* empty line: just prompt for another line. */
947 if (*p == '#') /* comment line */
950 c = lookup_cmd (&p, cmdlist, "", -1, 1);
953 warning ("'%s' is not an action that I know, or is ambiguous.", p);
957 if (c->function.cfunc == collect_pseudocommand)
959 struct agent_expr *aexpr;
960 struct agent_reqs areqs;
963 { /* repeat over a comma-separated list */
964 QUIT; /* allow user to bail out with ^C */
965 while (isspace ((int) *p))
968 if (*p == '$') /* look for special pseudo-symbols */
970 if ((0 == strncasecmp ("reg", p + 1, 3)) ||
971 (0 == strncasecmp ("arg", p + 1, 3)) ||
972 (0 == strncasecmp ("loc", p + 1, 3)))
977 /* else fall thru, treat p as an expression and parse it! */
979 exp = parse_exp_1 (&p, block_for_pc (t->address), 1);
980 old_chain = make_cleanup ((make_cleanup_func) free_current_contents,
983 if (exp->elts[0].opcode == OP_VAR_VALUE)
985 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
987 warning ("constant %s (value %ld) will not be collected.",
988 SYMBOL_NAME (exp->elts[2].symbol),
989 SYMBOL_VALUE (exp->elts[2].symbol));
992 else if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_OPTIMIZED_OUT)
994 warning ("%s is optimized away and cannot be collected.",
995 SYMBOL_NAME (exp->elts[2].symbol));
1000 /* we have something to collect, make sure that the expr to
1001 bytecode translator can handle it and that it's not too long */
1002 aexpr = gen_trace_for_expr (t->address, exp);
1003 (void) make_cleanup ((make_cleanup_func) free_agent_expr, aexpr);
1005 if (aexpr->len > MAX_AGENT_EXPR_LEN)
1006 error ("expression too complicated, try simplifying");
1008 ax_reqs (aexpr, &areqs);
1009 (void) make_cleanup (free, areqs.reg_mask);
1011 if (areqs.flaw != agent_flaw_none)
1012 error ("malformed expression");
1014 if (areqs.min_height < 0)
1015 error ("gdb: Internal error: expression has min height < 0");
1017 if (areqs.max_height > 20)
1018 error ("expression too complicated, try simplifying");
1020 do_cleanups (old_chain);
1022 while (p && *p++ == ',');
1025 else if (c->function.cfunc == while_stepping_pseudocommand)
1027 char *steparg; /* in case warning is necessary */
1029 while (isspace ((int) *p))
1034 (t->step_count = strtol (p, &p, 0)) == 0)
1036 warning ("'%s': bad step-count; command ignored.", *line);
1041 else if (c->function.cfunc == end_actions_pseudocommand)
1045 warning ("'%s' is not a supported tracepoint action.", *line);
1050 /* worker function */
1053 struct tracepoint *t;
1055 struct action_line *line, *next;
1057 for (line = t->actions; line; line = next)
1061 free (line->action);
1069 int type; /* 0 for absolute memory range, else basereg number */
1070 bfd_signed_vma start;
1074 struct collection_list
1076 unsigned char regs_mask[8]; /* room for up to 256 regs */
1079 struct memrange *list;
1080 long aexpr_listsize; /* size of array pointed to by expr_list elt */
1081 long next_aexpr_elt;
1082 struct agent_expr **aexpr_list;
1085 tracepoint_list, stepping_list;
1087 /* MEMRANGE functions: */
1089 static int memrange_cmp PARAMS ((const void *, const void *));
1091 /* compare memranges for qsort */
1093 memrange_cmp (va, vb)
1097 const struct memrange *a = va, *b = vb;
1099 if (a->type < b->type)
1101 if (a->type > b->type)
1105 if ((bfd_vma) a->start < (bfd_vma) b->start)
1107 if ((bfd_vma) a->start > (bfd_vma) b->start)
1112 if (a->start < b->start)
1114 if (a->start > b->start)
1120 /* Sort the memrange list using qsort, and merge adjacent memranges */
1122 memrange_sortmerge (memranges)
1123 struct collection_list *memranges;
1127 qsort (memranges->list, memranges->next_memrange,
1128 sizeof (struct memrange), memrange_cmp);
1129 if (memranges->next_memrange > 0)
1131 for (a = 0, b = 1; b < memranges->next_memrange; b++)
1133 if (memranges->list[a].type == memranges->list[b].type &&
1134 memranges->list[b].start - memranges->list[a].end <=
1135 MAX_REGISTER_VIRTUAL_SIZE)
1137 /* memrange b starts before memrange a ends; merge them. */
1138 if (memranges->list[b].end > memranges->list[a].end)
1139 memranges->list[a].end = memranges->list[b].end;
1140 continue; /* next b, same a */
1144 memcpy (&memranges->list[a], &memranges->list[b],
1145 sizeof (struct memrange));
1147 memranges->next_memrange = a + 1;
1151 /* Add a register to a collection list */
1153 add_register (collection, regno)
1154 struct collection_list *collection;
1158 printf_filtered ("collect register %d\n", regno);
1159 if (regno > (8 * sizeof (collection->regs_mask)))
1160 error ("Internal: register number %d too large for tracepoint",
1162 collection->regs_mask[regno / 8] |= 1 << (regno % 8);
1165 /* Add a memrange to a collection list */
1167 add_memrange (memranges, type, base, len)
1168 struct collection_list *memranges;
1170 bfd_signed_vma base;
1175 printf_filtered ("(%d,", type);
1177 printf_filtered (",%ld)\n", len);
1180 /* type: 0 == memory, n == basereg */
1181 memranges->list[memranges->next_memrange].type = type;
1182 /* base: addr if memory, offset if reg relative. */
1183 memranges->list[memranges->next_memrange].start = base;
1184 /* len: we actually save end (base + len) for convenience */
1185 memranges->list[memranges->next_memrange].end = base + len;
1186 memranges->next_memrange++;
1187 if (memranges->next_memrange >= memranges->listsize)
1189 memranges->listsize *= 2;
1190 memranges->list = xrealloc (memranges->list,
1191 memranges->listsize);
1194 if (type != -1) /* better collect the base register! */
1195 add_register (memranges, type);
1198 /* Add a symbol to a collection list */
1200 collect_symbol (collect, sym, frame_regno, frame_offset)
1201 struct collection_list *collect;
1208 bfd_signed_vma offset;
1210 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
1211 switch (SYMBOL_CLASS (sym))
1214 printf_filtered ("%s: don't know symbol class %d\n",
1215 SYMBOL_NAME (sym), SYMBOL_CLASS (sym));
1218 printf_filtered ("constant %s (value %ld) will not be collected.\n",
1219 SYMBOL_NAME (sym), SYMBOL_VALUE (sym));
1222 offset = SYMBOL_VALUE_ADDRESS (sym);
1227 sprintf_vma (tmp, offset);
1228 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1229 SYMBOL_NAME (sym), len, tmp /* address */);
1231 add_memrange (collect, -1, offset, len); /* 0 == memory */
1235 reg = SYMBOL_VALUE (sym);
1237 printf_filtered ("LOC_REG[parm] %s: ", SYMBOL_NAME (sym));
1238 add_register (collect, reg);
1239 /* check for doubles stored in two registers */
1240 /* FIXME: how about larger types stored in 3 or more regs? */
1241 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
1242 len > REGISTER_RAW_SIZE (reg))
1243 add_register (collect, reg + 1);
1246 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1247 printf_filtered (" (will not collect %s)\n",
1252 offset = frame_offset + SYMBOL_VALUE (sym);
1255 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1256 SYMBOL_NAME (sym), len);
1257 printf_vma (offset);
1258 printf_filtered (" from frame ptr reg %d\n", reg);
1260 add_memrange (collect, reg, offset, len);
1262 case LOC_REGPARM_ADDR:
1263 reg = SYMBOL_VALUE (sym);
1267 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1268 SYMBOL_NAME (sym), len);
1269 printf_vma (offset);
1270 printf_filtered (" from reg %d\n", reg);
1272 add_memrange (collect, reg, offset, len);
1277 offset = frame_offset + SYMBOL_VALUE (sym);
1280 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1281 SYMBOL_NAME (sym), len);
1282 printf_vma (offset);
1283 printf_filtered (" from frame ptr reg %d\n", reg);
1285 add_memrange (collect, reg, offset, len);
1288 case LOC_BASEREG_ARG:
1289 reg = SYMBOL_BASEREG (sym);
1290 offset = SYMBOL_VALUE (sym);
1293 printf_filtered ("LOC_BASEREG %s: collect %ld bytes at offset ",
1294 SYMBOL_NAME (sym), len);
1295 printf_vma (offset);
1296 printf_filtered (" from basereg %d\n", reg);
1298 add_memrange (collect, reg, offset, len);
1300 case LOC_UNRESOLVED:
1301 printf_filtered ("Don't know LOC_UNRESOLVED %s\n", SYMBOL_NAME (sym));
1303 case LOC_OPTIMIZED_OUT:
1304 printf_filtered ("%s has been optimized out of existance.\n",
1310 /* Add all locals (or args) symbols to collection list */
1312 add_local_symbols (collect, pc, frame_regno, frame_offset, type)
1313 struct collection_list *collect;
1320 struct block *block;
1321 int i, nsyms, count = 0;
1323 block = block_for_pc (pc);
1326 QUIT; /* allow user to bail out with ^C */
1327 nsyms = BLOCK_NSYMS (block);
1328 for (i = 0; i < nsyms; i++)
1330 sym = BLOCK_SYM (block, i);
1331 switch (SYMBOL_CLASS (sym))
1334 warning ("don't know how to trace local symbol %s",
1340 if (type == 'L') /* collecting Locals */
1343 collect_symbol (collect, sym, frame_regno, frame_offset);
1350 case LOC_REGPARM_ADDR:
1351 case LOC_BASEREG_ARG:
1352 if (type == 'A') /* collecting Arguments */
1355 collect_symbol (collect, sym, frame_regno, frame_offset);
1359 if (BLOCK_FUNCTION (block))
1362 block = BLOCK_SUPERBLOCK (block);
1365 warning ("No %s found in scope.", type == 'L' ? "locals" : "args");
1368 /* worker function */
1370 clear_collection_list (list)
1371 struct collection_list *list;
1375 list->next_memrange = 0;
1376 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1378 free_agent_expr (list->aexpr_list[ndx]);
1379 list->aexpr_list[ndx] = NULL;
1381 list->next_aexpr_elt = 0;
1382 memset (list->regs_mask, 0, sizeof (list->regs_mask));
1385 /* reduce a collection list to string form (for gdb protocol) */
1387 stringify_collection_list (list, string)
1388 struct collection_list *list;
1391 char temp_buf[2048];
1395 char *(*str_list)[];
1399 count = 1 + list->next_memrange + list->next_aexpr_elt + 1;
1400 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1402 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1403 if (list->regs_mask[i] != 0) /* skip leading zeroes in regs_mask */
1405 if (list->regs_mask[i] != 0) /* prepare to send regs_mask to the stub */
1408 printf_filtered ("\nCollecting registers (mask): 0x");
1413 QUIT; /* allow user to bail out with ^C */
1415 printf_filtered ("%02X", list->regs_mask[i]);
1416 sprintf (end, "%02X", list->regs_mask[i]);
1419 (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
1423 printf_filtered ("\n");
1424 if (list->next_memrange > 0 && info_verbose)
1425 printf_filtered ("Collecting memranges: \n");
1426 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1428 QUIT; /* allow user to bail out with ^C */
1429 sprintf_vma (tmp2, list->list[i].start);
1432 printf_filtered ("(%d, %s, %ld)\n",
1435 (long) (list->list[i].end - list->list[i].start));
1437 if (count + 27 > MAX_AGENT_EXPR_LEN)
1439 (*str_list)[ndx] = savestring (temp_buf, count);
1445 sprintf (end, "M%X,%s,%lX",
1448 (long) (list->list[i].end - list->list[i].start));
1450 count += strlen (end);
1454 for (i = 0; i < list->next_aexpr_elt; i++)
1456 QUIT; /* allow user to bail out with ^C */
1457 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1459 (*str_list)[ndx] = savestring (temp_buf, count);
1464 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1465 end += 10; /* 'X' + 8 hex digits + ',' */
1468 end = mem2hex (list->aexpr_list[i]->buf, end, list->aexpr_list[i]->len);
1469 count += 2 * list->aexpr_list[i]->len;
1474 (*str_list)[ndx] = savestring (temp_buf, count);
1479 (*str_list)[ndx] = NULL;
1488 free_actions_list_cleanup_wrapper (al)
1491 free_actions_list (al);
1495 free_actions_list (actions_list)
1496 char **actions_list;
1500 if (actions_list == 0)
1503 for (ndx = 0; actions_list[ndx]; ndx++)
1504 free (actions_list[ndx]);
1506 free (actions_list);
1509 /* render all actions into gdb protocol */
1511 encode_actions (t, tdp_actions, stepping_actions)
1512 struct tracepoint *t;
1513 char ***tdp_actions;
1514 char ***stepping_actions;
1516 static char tdp_buff[2048], step_buff[2048];
1518 struct expression *exp = NULL;
1519 struct action_line *action;
1522 struct collection_list *collect;
1523 struct cmd_list_element *cmd;
1524 struct agent_expr *aexpr;
1525 long frame_reg, frame_offset;
1528 clear_collection_list (&tracepoint_list);
1529 clear_collection_list (&stepping_list);
1530 collect = &tracepoint_list;
1532 *tdp_actions = NULL;
1533 *stepping_actions = NULL;
1535 TARGET_VIRTUAL_FRAME_POINTER (t->address, &frame_reg, &frame_offset);
1537 for (action = t->actions; action; action = action->next)
1539 QUIT; /* allow user to bail out with ^C */
1540 action_exp = action->action;
1541 while (isspace ((int) *action_exp))
1544 if (*action_exp == '#') /* comment line */
1547 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1549 error ("Bad action list item: %s", action_exp);
1551 if (cmd->function.cfunc == collect_pseudocommand)
1554 { /* repeat over a comma-separated list */
1555 QUIT; /* allow user to bail out with ^C */
1556 while (isspace ((int) *action_exp))
1559 if (0 == strncasecmp ("$reg", action_exp, 4))
1561 for (i = 0; i < NUM_REGS; i++)
1562 add_register (collect, i);
1563 action_exp = strchr (action_exp, ','); /* more? */
1565 else if (0 == strncasecmp ("$arg", action_exp, 4))
1567 add_local_symbols (collect,
1572 action_exp = strchr (action_exp, ','); /* more? */
1574 else if (0 == strncasecmp ("$loc", action_exp, 4))
1576 add_local_symbols (collect,
1581 action_exp = strchr (action_exp, ','); /* more? */
1585 unsigned long addr, len;
1586 struct cleanup *old_chain = NULL;
1587 struct cleanup *old_chain1 = NULL;
1588 struct agent_reqs areqs;
1590 exp = parse_exp_1 (&action_exp, block_for_pc (t->address), 1);
1591 old_chain = make_cleanup ((make_cleanup_func)
1592 free_current_contents, &exp);
1594 switch (exp->elts[0].opcode)
1597 i = exp->elts[1].longconst;
1599 printf_filtered ("OP_REGISTER: ");
1600 add_register (collect, i);
1604 /* safe because we know it's a simple expression */
1605 tempval = evaluate_expression (exp);
1606 addr = VALUE_ADDRESS (tempval) + VALUE_OFFSET (tempval);
1607 len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
1608 add_memrange (collect, -1, addr, len);
1612 collect_symbol (collect,
1613 exp->elts[2].symbol,
1618 default: /* full-fledged expression */
1619 aexpr = gen_trace_for_expr (t->address, exp);
1621 old_chain1 = make_cleanup ((make_cleanup_func)
1622 free_agent_expr, aexpr);
1624 ax_reqs (aexpr, &areqs);
1625 if (areqs.flaw != agent_flaw_none)
1626 error ("malformed expression");
1628 if (areqs.min_height < 0)
1629 error ("gdb: Internal error: expression has min height < 0");
1630 if (areqs.max_height > 20)
1631 error ("expression too complicated, try simplifying");
1633 discard_cleanups (old_chain1);
1634 add_aexpr (collect, aexpr);
1636 /* take care of the registers */
1637 if (areqs.reg_mask_len > 0)
1642 for (ndx1 = 0; ndx1 < areqs.reg_mask_len; ndx1++)
1644 QUIT; /* allow user to bail out with ^C */
1645 if (areqs.reg_mask[ndx1] != 0)
1647 /* assume chars have 8 bits */
1648 for (ndx2 = 0; ndx2 < 8; ndx2++)
1649 if (areqs.reg_mask[ndx1] & (1 << ndx2))
1650 /* it's used -- record it */
1651 add_register (collect, ndx1 * 8 + ndx2);
1657 do_cleanups (old_chain);
1660 while (action_exp && *action_exp++ == ',');
1662 else if (cmd->function.cfunc == while_stepping_pseudocommand)
1664 collect = &stepping_list;
1666 else if (cmd->function.cfunc == end_actions_pseudocommand)
1668 if (collect == &stepping_list) /* end stepping actions */
1669 collect = &tracepoint_list;
1671 break; /* end tracepoint actions */
1674 memrange_sortmerge (&tracepoint_list);
1675 memrange_sortmerge (&stepping_list);
1677 *tdp_actions = stringify_collection_list (&tracepoint_list, &tdp_buff);
1678 *stepping_actions = stringify_collection_list (&stepping_list, &step_buff);
1682 add_aexpr (collect, aexpr)
1683 struct collection_list *collect;
1684 struct agent_expr *aexpr;
1686 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1688 collect->aexpr_list =
1689 xrealloc (collect->aexpr_list,
1690 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1691 collect->aexpr_listsize *= 2;
1693 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1694 collect->next_aexpr_elt++;
1697 static char target_buf[2048];
1699 /* Set "transparent" memory ranges
1701 Allow trace mechanism to treat text-like sections
1702 (and perhaps all read-only sections) transparently,
1703 i.e. don't reject memory requests from these address ranges
1704 just because they haven't been collected. */
1707 remote_set_transparent_ranges (void)
1709 extern bfd *exec_bfd;
1716 return; /* no information to give. */
1718 strcpy (target_buf, "QTro");
1719 for (s = exec_bfd->sections; s; s = s->next)
1721 char tmp1[40], tmp2[40];
1723 if ((s->flags & SEC_LOAD) == 0 ||
1724 /* (s->flags & SEC_CODE) == 0 || */
1725 (s->flags & SEC_READONLY) == 0)
1730 size = bfd_get_section_size_before_reloc (s);
1731 sprintf_vma (tmp1, lma);
1732 sprintf_vma (tmp2, lma + size);
1733 sprintf (target_buf + strlen (target_buf),
1734 ":%s,%s", tmp1, tmp2);
1738 putpkt (target_buf);
1739 getpkt (target_buf, sizeof (target_buf), 0);
1745 Tell target to clear any previous trace experiment.
1746 Walk the list of tracepoints, and send them (and their actions)
1747 to the target. If no errors,
1748 Tell target to start a new trace experiment. */
1751 trace_start_command (args, from_tty)
1754 { /* STUB_COMM MOSTLY_IMPLEMENTED */
1755 struct tracepoint *t;
1758 char **stepping_actions;
1760 struct cleanup *old_chain = NULL;
1762 dont_repeat (); /* like "run", dangerous to repeat accidentally */
1764 if (target_is_remote ())
1767 remote_get_noisy_reply (target_buf, sizeof (target_buf));
1768 if (strcmp (target_buf, "OK"))
1769 error ("Target does not support this command.");
1775 sprintf_vma (tmp, t->address);
1776 sprintf (buf, "QTDP:%x:%s:%c:%lx:%x", t->number, tmp, /* address */
1777 t->enabled == enabled ? 'E' : 'D',
1778 t->step_count, t->pass_count);
1783 remote_get_noisy_reply (target_buf, sizeof (target_buf));
1784 if (strcmp (target_buf, "OK"))
1785 error ("Target does not support tracepoints.");
1789 encode_actions (t, &tdp_actions, &stepping_actions);
1790 old_chain = make_cleanup (free_actions_list_cleanup_wrapper,
1792 (void) make_cleanup (free_actions_list_cleanup_wrapper,
1795 /* do_single_steps (t); */
1798 for (ndx = 0; tdp_actions[ndx]; ndx++)
1800 QUIT; /* allow user to bail out with ^C */
1801 sprintf (buf, "QTDP:-%x:%s:%s%c",
1802 t->number, tmp, /* address */
1804 ((tdp_actions[ndx + 1] || stepping_actions)
1807 remote_get_noisy_reply (target_buf, sizeof (target_buf));
1808 if (strcmp (target_buf, "OK"))
1809 error ("Error on target while setting tracepoints.");
1812 if (stepping_actions)
1814 for (ndx = 0; stepping_actions[ndx]; ndx++)
1816 QUIT; /* allow user to bail out with ^C */
1817 sprintf (buf, "QTDP:-%x:%s:%s%s%s",
1818 t->number, tmp, /* address */
1819 ((ndx == 0) ? "S" : ""),
1820 stepping_actions[ndx],
1821 (stepping_actions[ndx + 1] ? "-" : ""));
1823 remote_get_noisy_reply (target_buf, sizeof (target_buf));
1824 if (strcmp (target_buf, "OK"))
1825 error ("Error on target while setting tracepoints.");
1829 do_cleanups (old_chain);
1832 /* Tell target to treat text-like sections as transparent */
1833 remote_set_transparent_ranges ();
1834 /* Now insert traps and begin collecting data */
1836 remote_get_noisy_reply (target_buf, sizeof (target_buf));
1837 if (strcmp (target_buf, "OK"))
1838 error ("Bogus reply from target: %s", target_buf);
1839 set_traceframe_num (-1); /* all old traceframes invalidated */
1840 set_tracepoint_num (-1);
1841 set_traceframe_context (-1);
1842 trace_running_p = 1;
1843 if (trace_start_stop_hook)
1844 trace_start_stop_hook (1, from_tty);
1848 error ("Trace can only be run on remote targets.");
1853 trace_stop_command (args, from_tty)
1856 { /* STUB_COMM IS_IMPLEMENTED */
1857 if (target_is_remote ())
1860 remote_get_noisy_reply (target_buf, sizeof (target_buf));
1861 if (strcmp (target_buf, "OK"))
1862 error ("Bogus reply from target: %s", target_buf);
1863 trace_running_p = 0;
1864 if (trace_start_stop_hook)
1865 trace_start_stop_hook (0, from_tty);
1868 error ("Trace can only be run on remote targets.");
1871 unsigned long trace_running_p;
1873 /* tstatus command */
1875 trace_status_command (args, from_tty)
1878 { /* STUB_COMM IS_IMPLEMENTED */
1879 if (target_is_remote ())
1881 putpkt ("qTStatus");
1882 remote_get_noisy_reply (target_buf, sizeof (target_buf));
1884 if (target_buf[0] != 'T' ||
1885 (target_buf[1] != '0' && target_buf[1] != '1'))
1886 error ("Bogus reply from target: %s", target_buf);
1888 /* exported for use by the GUI */
1889 trace_running_p = (target_buf[1] == '1');
1892 error ("Trace can only be run on remote targets.");
1895 /* Worker function for the various flavors of the tfind command */
1897 finish_tfind_command (char *msg,
1901 int target_frameno = -1, target_tracept = -1;
1902 CORE_ADDR old_frame_addr;
1903 struct symbol *old_func;
1906 old_frame_addr = FRAME_FP (get_current_frame ());
1907 old_func = find_pc_function (read_pc ());
1910 reply = remote_get_noisy_reply (msg, sizeof_msg);
1912 while (reply && *reply)
1916 if ((target_frameno = (int) strtol (++reply, &reply, 16)) == -1)
1918 /* A request for a non-existant trace frame has failed.
1919 Our response will be different, depending on FROM_TTY:
1921 If FROM_TTY is true, meaning that this command was
1922 typed interactively by the user, then give an error
1923 and DO NOT change the state of traceframe_number etc.
1925 However if FROM_TTY is false, meaning that we're either
1926 in a script, a loop, or a user-defined command, then
1927 DON'T give an error, but DO change the state of
1928 traceframe_number etc. to invalid.
1930 The rationalle is that if you typed the command, you
1931 might just have committed a typo or something, and you'd
1932 like to NOT lose your current debugging state. However
1933 if you're in a user-defined command or especially in a
1934 loop, then you need a way to detect that the command
1935 failed WITHOUT aborting. This allows you to write
1936 scripts that search thru the trace buffer until the end,
1937 and then continue on to do something else. */
1940 error ("Target failed to find requested trace frame.");
1944 printf_filtered ("End of trace buffer.\n");
1945 /* The following will not recurse, since it's special-cased */
1946 trace_find_command ("-1", from_tty);
1947 reply = NULL; /* break out of loop,
1948 (avoid recursive nonsense) */
1953 if ((target_tracept = (int) strtol (++reply, &reply, 16)) == -1)
1954 error ("Target failed to find requested trace frame.");
1956 case 'O': /* "OK"? */
1957 if (reply[1] == 'K' && reply[2] == '\0')
1960 error ("Bogus reply from target: %s", reply);
1963 error ("Bogus reply from target: %s", reply);
1966 flush_cached_frames ();
1967 registers_changed ();
1968 select_frame (get_current_frame (), 0);
1969 set_traceframe_num (target_frameno);
1970 set_tracepoint_num (target_tracept);
1971 if (target_frameno == -1)
1972 set_traceframe_context (-1);
1974 set_traceframe_context (read_pc ());
1980 /* NOTE: in immitation of the step command, try to determine
1981 whether we have made a transition from one function to another.
1982 If so, we'll print the "stack frame" (ie. the new function and
1983 it's arguments) -- otherwise we'll just show the new source line.
1985 This determination is made by checking (1) whether the current
1986 function has changed, and (2) whether the current FP has changed.
1987 Hack: if the FP wasn't collected, either at the current or the
1988 previous frame, assume that the FP has NOT changed. */
1990 if (old_func == find_pc_function (read_pc ()) &&
1991 (old_frame_addr == 0 ||
1992 FRAME_FP (get_current_frame ()) == 0 ||
1993 old_frame_addr == FRAME_FP (get_current_frame ())))
1998 print_stack_frame (selected_frame, selected_frame_level, source_only);
2003 /* trace_find_command takes a trace frame number n,
2004 sends "QTFrame:<n>" to the target,
2005 and accepts a reply that may contain several optional pieces
2006 of information: a frame number, a tracepoint number, and an
2007 indication of whether this is a trap frame or a stepping frame.
2009 The minimal response is just "OK" (which indicates that the
2010 target does not give us a frame number or a tracepoint number).
2011 Instead of that, the target may send us a string containing
2013 F<hexnum> (gives the selected frame number)
2014 T<hexnum> (gives the selected tracepoint number)
2019 trace_find_command (args, from_tty)
2022 { /* STUB_COMM PART_IMPLEMENTED */
2023 /* this should only be called with a numeric argument */
2026 if (target_is_remote ())
2028 if (trace_find_hook)
2029 trace_find_hook (args, from_tty);
2031 if (args == 0 || *args == 0)
2032 { /* TFIND with no args means find NEXT trace frame. */
2033 if (traceframe_number == -1)
2034 frameno = 0; /* "next" is first one */
2036 frameno = traceframe_number + 1;
2038 else if (0 == strcmp (args, "-"))
2040 if (traceframe_number == -1)
2041 error ("not debugging trace buffer");
2042 else if (from_tty && traceframe_number == 0)
2043 error ("already at start of trace buffer");
2045 frameno = traceframe_number - 1;
2048 frameno = parse_and_eval_address (args);
2051 error ("invalid input (%d is less than zero)", frameno);
2053 sprintf (target_buf, "QTFrame:%x", frameno);
2054 finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
2057 error ("Trace can only be run on remote targets.");
2062 trace_find_end_command (args, from_tty)
2066 trace_find_command ("-1", from_tty);
2071 trace_find_none_command (args, from_tty)
2075 trace_find_command ("-1", from_tty);
2080 trace_find_start_command (args, from_tty)
2084 trace_find_command ("0", from_tty);
2087 /* tfind pc command */
2089 trace_find_pc_command (args, from_tty)
2092 { /* STUB_COMM PART_IMPLEMENTED */
2096 if (target_is_remote ())
2098 if (args == 0 || *args == 0)
2099 pc = read_pc (); /* default is current pc */
2101 pc = parse_and_eval_address (args);
2103 sprintf_vma (tmp, pc);
2104 sprintf (target_buf, "QTFrame:pc:%s", tmp);
2105 finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
2108 error ("Trace can only be run on remote targets.");
2111 /* tfind tracepoint command */
2113 trace_find_tracepoint_command (args, from_tty)
2116 { /* STUB_COMM PART_IMPLEMENTED */
2119 if (target_is_remote ())
2121 if (args == 0 || *args == 0)
2122 if (tracepoint_number == -1)
2123 error ("No current tracepoint -- please supply an argument.");
2125 tdp = tracepoint_number; /* default is current TDP */
2127 tdp = parse_and_eval_address (args);
2129 sprintf (target_buf, "QTFrame:tdp:%x", tdp);
2130 finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
2133 error ("Trace can only be run on remote targets.");
2136 /* TFIND LINE command:
2138 This command will take a sourceline for argument, just like BREAK
2139 or TRACE (ie. anything that "decode_line_1" can handle).
2141 With no argument, this command will find the next trace frame
2142 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2145 trace_find_line_command (args, from_tty)
2148 { /* STUB_COMM PART_IMPLEMENTED */
2149 static CORE_ADDR start_pc, end_pc;
2150 struct symtabs_and_lines sals;
2151 struct symtab_and_line sal;
2152 struct cleanup *old_chain;
2153 char startpc_str[40], endpc_str[40];
2155 if (target_is_remote ())
2157 if (args == 0 || *args == 0)
2159 sal = find_pc_line ((get_current_frame ())->pc, 0);
2161 sals.sals = (struct symtab_and_line *)
2162 xmalloc (sizeof (struct symtab_and_line));
2167 sals = decode_line_spec (args, 1);
2171 old_chain = make_cleanup (free, sals.sals);
2172 if (sal.symtab == 0)
2174 printf_filtered ("TFIND: No line number information available");
2177 /* This is useful for "info line *0x7f34". If we can't tell the
2178 user about a source line, at least let them have the symbolic
2180 printf_filtered (" for address ");
2182 print_address (sal.pc, gdb_stdout);
2183 printf_filtered (";\n -- will attempt to find by PC. \n");
2187 printf_filtered (".\n");
2188 return; /* no line, no PC; what can we do? */
2191 else if (sal.line > 0
2192 && find_line_pc_range (sal, &start_pc, &end_pc))
2194 if (start_pc == end_pc)
2196 printf_filtered ("Line %d of \"%s\"",
2197 sal.line, sal.symtab->filename);
2199 printf_filtered (" is at address ");
2200 print_address (start_pc, gdb_stdout);
2202 printf_filtered (" but contains no code.\n");
2203 sal = find_pc_line (start_pc, 0);
2205 find_line_pc_range (sal, &start_pc, &end_pc) &&
2207 printf_filtered ("Attempting to find line %d instead.\n",
2210 error ("Cannot find a good line.");
2214 /* Is there any case in which we get here, and have an address
2215 which the user would want to see? If we have debugging symbols
2216 and no line numbers? */
2217 error ("Line number %d is out of range for \"%s\".\n",
2218 sal.line, sal.symtab->filename);
2220 sprintf_vma (startpc_str, start_pc);
2221 sprintf_vma (endpc_str, end_pc - 1);
2222 if (args && *args) /* find within range of stated line */
2223 sprintf (target_buf, "QTFrame:range:%s:%s", startpc_str, endpc_str);
2224 else /* find OUTSIDE OF range of CURRENT line */
2225 sprintf (target_buf, "QTFrame:outside:%s:%s", startpc_str, endpc_str);
2226 finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
2227 do_cleanups (old_chain);
2230 error ("Trace can only be run on remote targets.");
2233 /* tfind range command */
2235 trace_find_range_command (args, from_tty)
2239 static CORE_ADDR start, stop;
2240 char start_str[40], stop_str[40];
2243 if (target_is_remote ())
2245 if (args == 0 || *args == 0)
2246 { /* XXX FIXME: what should default behavior be? */
2247 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2251 if (0 != (tmp = strchr (args, ',')))
2253 *tmp++ = '\0'; /* terminate start address */
2254 while (isspace ((int) *tmp))
2256 start = parse_and_eval_address (args);
2257 stop = parse_and_eval_address (tmp);
2260 { /* no explicit end address? */
2261 start = parse_and_eval_address (args);
2262 stop = start + 1; /* ??? */
2265 sprintf_vma (start_str, start);
2266 sprintf_vma (stop_str, stop);
2267 sprintf (target_buf, "QTFrame:range:%s:%s", start_str, stop_str);
2268 finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
2271 error ("Trace can only be run on remote targets.");
2274 /* tfind outside command */
2276 trace_find_outside_command (args, from_tty)
2280 CORE_ADDR start, stop;
2281 char start_str[40], stop_str[40];
2284 if (target_is_remote ())
2286 if (args == 0 || *args == 0)
2287 { /* XXX FIXME: what should default behavior be? */
2288 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2292 if (0 != (tmp = strchr (args, ',')))
2294 *tmp++ = '\0'; /* terminate start address */
2295 while (isspace ((int) *tmp))
2297 start = parse_and_eval_address (args);
2298 stop = parse_and_eval_address (tmp);
2301 { /* no explicit end address? */
2302 start = parse_and_eval_address (args);
2303 stop = start + 1; /* ??? */
2306 sprintf_vma (start_str, start);
2307 sprintf_vma (stop_str, stop);
2308 sprintf (target_buf, "QTFrame:outside:%s:%s", start_str, stop_str);
2309 finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
2312 error ("Trace can only be run on remote targets.");
2315 /* save-tracepoints command */
2317 tracepoint_save_command (args, from_tty)
2321 struct tracepoint *tp;
2322 struct action_line *line;
2324 char *i1 = " ", *i2 = " ";
2325 char *indent, *actionline;
2328 if (args == 0 || *args == 0)
2329 error ("Argument required (file name in which to save tracepoints");
2331 if (tracepoint_chain == 0)
2333 warning ("save-tracepoints: no tracepoints to save.\n");
2337 if (!(fp = fopen (args, "w")))
2338 error ("Unable to open file '%s' for saving tracepoints");
2340 ALL_TRACEPOINTS (tp)
2342 if (tp->addr_string)
2343 fprintf (fp, "trace %s\n", tp->addr_string);
2346 sprintf_vma (tmp, tp->address);
2347 fprintf (fp, "trace *0x%s\n", tmp);
2351 fprintf (fp, " passcount %d\n", tp->pass_count);
2355 fprintf (fp, " actions\n");
2357 for (line = tp->actions; line; line = line->next)
2359 struct cmd_list_element *cmd;
2361 QUIT; /* allow user to bail out with ^C */
2362 actionline = line->action;
2363 while (isspace ((int) *actionline))
2366 fprintf (fp, "%s%s\n", indent, actionline);
2367 if (*actionline != '#') /* skip for comment lines */
2369 cmd = lookup_cmd (&actionline, cmdlist, "", -1, 1);
2371 error ("Bad action list item: %s", actionline);
2372 if (cmd->function.cfunc == while_stepping_pseudocommand)
2374 else if (cmd->function.cfunc == end_actions_pseudocommand)
2382 printf_filtered ("Tracepoints saved to file '%s'.\n", args);
2386 /* info scope command: list the locals for a scope. */
2388 scope_info (args, from_tty)
2392 struct symtabs_and_lines sals;
2394 struct minimal_symbol *msym;
2395 struct block *block;
2396 char **canonical, *symname, *save_args = args;
2397 int i, j, nsyms, count = 0;
2399 if (args == 0 || *args == 0)
2400 error ("requires an argument (function, line or *addr) to define a scope");
2402 sals = decode_line_1 (&args, 1, NULL, 0, &canonical);
2403 if (sals.nelts == 0)
2404 return; /* presumably decode_line_1 has already warned */
2406 /* Resolve line numbers to PC */
2407 resolve_sal_pc (&sals.sals[0]);
2408 block = block_for_pc (sals.sals[0].pc);
2412 QUIT; /* allow user to bail out with ^C */
2413 nsyms = BLOCK_NSYMS (block);
2414 for (i = 0; i < nsyms; i++)
2416 QUIT; /* allow user to bail out with ^C */
2418 printf_filtered ("Scope for %s:\n", save_args);
2420 sym = BLOCK_SYM (block, i);
2421 symname = SYMBOL_NAME (sym);
2422 if (symname == NULL || *symname == '\0')
2423 continue; /* probably botched, certainly useless */
2425 printf_filtered ("Symbol %s is ", symname);
2426 switch (SYMBOL_CLASS (sym))
2429 case LOC_UNDEF: /* messed up symbol? */
2430 printf_filtered ("a bogus symbol, class %d.\n",
2431 SYMBOL_CLASS (sym));
2432 count--; /* don't count this one */
2435 printf_filtered ("a constant with value %ld (0x%lx)",
2436 SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
2438 case LOC_CONST_BYTES:
2439 printf_filtered ("constant bytes: ");
2440 if (SYMBOL_TYPE (sym))
2441 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2442 fprintf_filtered (gdb_stdout, " %02x",
2443 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2446 printf_filtered ("in static storage at address ");
2447 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
2450 printf_filtered ("a local variable in register $%s",
2451 REGISTER_NAME (SYMBOL_VALUE (sym)));
2455 printf_filtered ("an argument at stack/frame offset %ld",
2456 SYMBOL_VALUE (sym));
2459 printf_filtered ("a local variable at frame offset %ld",
2460 SYMBOL_VALUE (sym));
2463 printf_filtered ("a reference argument at offset %ld",
2464 SYMBOL_VALUE (sym));
2467 printf_filtered ("an argument in register $%s",
2468 REGISTER_NAME (SYMBOL_VALUE (sym)));
2470 case LOC_REGPARM_ADDR:
2471 printf_filtered ("the address of an argument, in register $%s",
2472 REGISTER_NAME (SYMBOL_VALUE (sym)));
2475 printf_filtered ("a typedef.\n");
2478 printf_filtered ("a label at address ");
2479 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
2482 printf_filtered ("a function at address ");
2483 print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)), 1,
2487 printf_filtered ("a variable at offset %ld from register $%s",
2489 REGISTER_NAME (SYMBOL_BASEREG (sym)));
2491 case LOC_BASEREG_ARG:
2492 printf_filtered ("an argument at offset %ld from register $%s",
2494 REGISTER_NAME (SYMBOL_BASEREG (sym)));
2496 case LOC_UNRESOLVED:
2497 msym = lookup_minimal_symbol (SYMBOL_NAME (sym), NULL, NULL);
2499 printf_filtered ("Unresolved Static");
2502 printf_filtered ("static storage at address ");
2503 print_address_numeric (SYMBOL_VALUE_ADDRESS (msym), 1,
2507 case LOC_OPTIMIZED_OUT:
2508 printf_filtered ("optimized out.\n");
2511 if (SYMBOL_TYPE (sym))
2512 printf_filtered (", length %d.\n",
2513 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2515 if (BLOCK_FUNCTION (block))
2518 block = BLOCK_SUPERBLOCK (block);
2521 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2525 /* worker function (cleanup) */
2527 replace_comma (comma)
2535 trace_dump_command (args, from_tty)
2539 struct tracepoint *t;
2540 struct action_line *action;
2541 char *action_exp, *next_comma;
2542 struct cleanup *old_cleanups;
2543 int stepping_actions = 0;
2544 int stepping_frame = 0;
2546 if (!target_is_remote ())
2548 error ("Trace can only be run on remote targets.");
2552 if (tracepoint_number == -1)
2554 warning ("No current trace frame.");
2559 if (t->number == tracepoint_number)
2563 error ("No known tracepoint matches 'current' tracepoint #%d.",
2566 old_cleanups = make_cleanup (null_cleanup, NULL);
2568 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2569 tracepoint_number, traceframe_number);
2571 /* The current frame is a trap frame if the frame PC is equal
2572 to the tracepoint PC. If not, then the current frame was
2573 collected during single-stepping. */
2575 stepping_frame = (t->address != read_pc ());
2577 for (action = t->actions; action; action = action->next)
2579 struct cmd_list_element *cmd;
2581 QUIT; /* allow user to bail out with ^C */
2582 action_exp = action->action;
2583 while (isspace ((int) *action_exp))
2586 /* The collection actions to be done while stepping are
2587 bracketed by the commands "while-stepping" and "end". */
2589 if (*action_exp == '#') /* comment line */
2592 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2594 error ("Bad action list item: %s", action_exp);
2596 if (cmd->function.cfunc == while_stepping_pseudocommand)
2597 stepping_actions = 1;
2598 else if (cmd->function.cfunc == end_actions_pseudocommand)
2599 stepping_actions = 0;
2600 else if (cmd->function.cfunc == collect_pseudocommand)
2602 /* Display the collected data.
2603 For the trap frame, display only what was collected at the trap.
2604 Likewise for stepping frames, display only what was collected
2605 while stepping. This means that the two boolean variables,
2606 STEPPING_FRAME and STEPPING_ACTIONS should be equal. */
2607 if (stepping_frame == stepping_actions)
2610 { /* repeat over a comma-separated list */
2611 QUIT; /* allow user to bail out with ^C */
2612 if (*action_exp == ',')
2614 while (isspace ((int) *action_exp))
2617 next_comma = strchr (action_exp, ',');
2619 if (0 == strncasecmp (action_exp, "$reg", 4))
2620 registers_info (NULL, from_tty);
2621 else if (0 == strncasecmp (action_exp, "$loc", 4))
2622 locals_info (NULL, from_tty);
2623 else if (0 == strncasecmp (action_exp, "$arg", 4))
2624 args_info (NULL, from_tty);
2629 make_cleanup (replace_comma, next_comma);
2632 printf_filtered ("%s = ", action_exp);
2633 output_command (action_exp, from_tty);
2634 printf_filtered ("\n");
2638 action_exp = next_comma;
2640 while (action_exp && *action_exp == ',');
2644 discard_cleanups (old_cleanups);
2647 /* Convert the memory pointed to by mem into hex, placing result in buf.
2648 * Return a pointer to the last char put in buf (null)
2649 * "stolen" from sparc-stub.c
2652 static const char hexchars[] = "0123456789abcdef";
2654 static unsigned char *
2655 mem2hex (mem, buf, count)
2666 *buf++ = hexchars[ch >> 4];
2667 *buf++ = hexchars[ch & 0xf];
2676 get_traceframe_number ()
2678 return traceframe_number;
2682 /* module initialization */
2684 _initialize_tracepoint ()
2686 tracepoint_chain = 0;
2687 tracepoint_count = 0;
2688 traceframe_number = -1;
2689 tracepoint_number = -1;
2691 set_internalvar (lookup_internalvar ("tpnum"),
2692 value_from_longest (builtin_type_int, (LONGEST) 0));
2693 set_internalvar (lookup_internalvar ("trace_frame"),
2694 value_from_longest (builtin_type_int, (LONGEST) - 1));
2696 if (tracepoint_list.list == NULL)
2698 tracepoint_list.listsize = 128;
2699 tracepoint_list.list = xmalloc
2700 (tracepoint_list.listsize * sizeof (struct memrange));
2702 if (tracepoint_list.aexpr_list == NULL)
2704 tracepoint_list.aexpr_listsize = 128;
2705 tracepoint_list.aexpr_list = xmalloc
2706 (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
2709 if (stepping_list.list == NULL)
2711 stepping_list.listsize = 128;
2712 stepping_list.list = xmalloc
2713 (stepping_list.listsize * sizeof (struct memrange));
2716 if (stepping_list.aexpr_list == NULL)
2718 stepping_list.aexpr_listsize = 128;
2719 stepping_list.aexpr_list = xmalloc
2720 (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
2723 add_info ("scope", scope_info,
2724 "List the variables local to a scope");
2726 add_cmd ("tracepoints", class_trace, NO_FUNCTION,
2727 "Tracing of program execution without stopping the program.",
2730 add_info ("tracepoints", tracepoints_info,
2731 "Status of tracepoints, or tracepoint number NUMBER.\n\
2732 Convenience variable \"$tpnum\" contains the number of the\n\
2733 last tracepoint set.");
2735 add_info_alias ("tp", "tracepoints", 1);
2737 add_com ("save-tracepoints", class_trace, tracepoint_save_command,
2738 "Save current tracepoint definitions as a script.\n\
2739 Use the 'source' command in another debug session to restore them.");
2741 add_com ("tdump", class_trace, trace_dump_command,
2742 "Print everything collected at the current tracepoint.");
2744 add_prefix_cmd ("tfind", class_trace, trace_find_command,
2745 "Select a trace frame;\n\
2746 No argument means forward by one frame; '-' meand backward by one frame.",
2747 &tfindlist, "tfind ", 1, &cmdlist);
2749 add_cmd ("outside", class_trace, trace_find_outside_command,
2750 "Select a trace frame whose PC is outside the given \
2751 range.\nUsage: tfind outside addr1, addr2",
2754 add_cmd ("range", class_trace, trace_find_range_command,
2755 "Select a trace frame whose PC is in the given range.\n\
2756 Usage: tfind range addr1,addr2",
2759 add_cmd ("line", class_trace, trace_find_line_command,
2760 "Select a trace frame by source line.\n\
2761 Argument can be a line number (with optional source file), \n\
2762 a function name, or '*' followed by an address.\n\
2763 Default argument is 'the next source line that was traced'.",
2766 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command,
2767 "Select a trace frame by tracepoint number.\n\
2768 Default is the tracepoint for the current trace frame.",
2771 add_cmd ("pc", class_trace, trace_find_pc_command,
2772 "Select a trace frame by PC.\n\
2773 Default is the current PC, or the PC of the current trace frame.",
2776 add_cmd ("end", class_trace, trace_find_end_command,
2777 "Synonym for 'none'.\n\
2778 De-select any trace frame and resume 'live' debugging.",
2781 add_cmd ("none", class_trace, trace_find_none_command,
2782 "De-select any trace frame and resume 'live' debugging.",
2785 add_cmd ("start", class_trace, trace_find_start_command,
2786 "Select the first trace frame in the trace buffer.",
2789 add_com ("tstatus", class_trace, trace_status_command,
2790 "Display the status of the current trace data collection.");
2792 add_com ("tstop", class_trace, trace_stop_command,
2793 "Stop trace data collection.");
2795 add_com ("tstart", class_trace, trace_start_command,
2796 "Start trace data collection.");
2798 add_com ("passcount", class_trace, trace_pass_command,
2799 "Set the passcount for a tracepoint.\n\
2800 The trace will end when the tracepoint has been passed 'count' times.\n\
2801 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
2802 if TPNUM is omitted, passcount refers to the last tracepoint defined.");
2804 add_com ("end", class_trace, end_actions_pseudocommand,
2805 "Ends a list of commands or actions.\n\
2806 Several GDB commands allow you to enter a list of commands or actions.\n\
2807 Entering \"end\" on a line by itself is the normal way to terminate\n\
2809 Note: the \"end\" command cannot be used at the gdb prompt.");
2811 add_com ("while-stepping", class_trace, while_stepping_pseudocommand,
2812 "Specify single-stepping behavior at a tracepoint.\n\
2813 Argument is number of instructions to trace in single-step mode\n\
2814 following the tracepoint. This command is normally followed by\n\
2815 one or more \"collect\" commands, to specify what to collect\n\
2816 while single-stepping.\n\n\
2817 Note: this command can only be used in a tracepoint \"actions\" list.");
2819 add_com_alias ("ws", "while-stepping", class_alias, 0);
2820 add_com_alias ("stepping", "while-stepping", class_alias, 0);
2822 add_com ("collect", class_trace, collect_pseudocommand,
2823 "Specify one or more data items to be collected at a tracepoint.\n\
2824 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
2825 collect all data (variables, registers) referenced by that expression.\n\
2826 Also accepts the following special arguments:\n\
2827 $regs -- all registers.\n\
2828 $args -- all function arguments.\n\
2829 $locals -- all variables local to the block/function scope.\n\
2830 Note: this command can only be used in a tracepoint \"actions\" list.");
2832 add_com ("actions", class_trace, trace_actions_command,
2833 "Specify the actions to be taken at a tracepoint.\n\
2834 Tracepoint actions may include collecting of specified data, \n\
2835 single-stepping, or enabling/disabling other tracepoints, \n\
2836 depending on target's capabilities.");
2838 add_cmd ("tracepoints", class_trace, delete_trace_command,
2839 "Delete specified tracepoints.\n\
2840 Arguments are tracepoint numbers, separated by spaces.\n\
2841 No argument means delete all tracepoints.",
2844 add_cmd ("tracepoints", class_trace, disable_trace_command,
2845 "Disable specified tracepoints.\n\
2846 Arguments are tracepoint numbers, separated by spaces.\n\
2847 No argument means disable all tracepoints.",
2850 add_cmd ("tracepoints", class_trace, enable_trace_command,
2851 "Enable specified tracepoints.\n\
2852 Arguments are tracepoint numbers, separated by spaces.\n\
2853 No argument means enable all tracepoints.",
2856 add_com ("trace", class_trace, trace_command,
2857 "Set a tracepoint at a specified line or function or address.\n\
2858 Argument may be a line number, function name, or '*' plus an address.\n\
2859 For a line number or function, trace at the start of its code.\n\
2860 If an address is specified, trace at that exact address.\n\n\
2861 Do \"help tracepoints\" for info on other tracepoint commands.");
2863 add_com_alias ("tp", "trace", class_alias, 0);
2864 add_com_alias ("tr", "trace", class_alias, 1);
2865 add_com_alias ("tra", "trace", class_alias, 1);
2866 add_com_alias ("trac", "trace", class_alias, 1);