1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright 1997, 1998, 1999, 2000, 2001, 2002 Free Software
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
27 #include "expression.h"
32 #include "gdb_string.h"
34 #include "tracepoint.h"
38 #include "completer.h"
39 #include "gdb-events.h"
44 /* readline include files */
45 #include <readline/readline.h>
46 #include <readline/history.h>
48 /* readline defines this. */
55 /* maximum length of an agent aexpression.
56 this accounts for the fact that packets are limited to 400 bytes
57 (which includes everything -- including the checksum), and assumes
58 the worst case of maximum length for each of the pieces of a
61 NOTE: expressions get mem2hex'ed otherwise this would be twice as
62 large. (400 - 31)/2 == 184 */
63 #define MAX_AGENT_EXPR_LEN 184
66 extern void (*readline_begin_hook) (char *, ...);
67 extern char *(*readline_hook) (char *);
68 extern void (*readline_end_hook) (void);
69 extern void x_command (char *, int);
70 extern int addressprint; /* Print machine addresses? */
72 /* GDB commands implemented in other modules:
75 extern void output_command (char *, int);
77 /* If this definition isn't overridden by the header files, assume
78 that isatty and fileno exist on this system. */
80 #define ISATTY(FP) (isatty (fileno (FP)))
86 This module defines the following debugger commands:
87 trace : set a tracepoint on a function, line, or address.
88 info trace : list all debugger-defined tracepoints.
89 delete trace : delete one or more tracepoints.
90 enable trace : enable one or more tracepoints.
91 disable trace : disable one or more tracepoints.
92 actions : specify actions to be taken at a tracepoint.
93 passcount : specify a pass count for a tracepoint.
94 tstart : start a trace experiment.
95 tstop : stop a trace experiment.
96 tstatus : query the status of a trace experiment.
97 tfind : find a trace frame in the trace buffer.
98 tdump : print everything collected at the current tracepoint.
99 save-tracepoints : write tracepoint setup into a file.
101 This module defines the following user-visible debugger variables:
102 $trace_frame : sequence number of trace frame currently being debugged.
103 $trace_line : source line of trace frame currently being debugged.
104 $trace_file : source file of trace frame currently being debugged.
105 $tracepoint : tracepoint number of trace frame currently being debugged.
109 /* ======= Important global variables: ======= */
111 /* Chain of all tracepoints defined. */
112 struct tracepoint *tracepoint_chain;
114 /* Number of last tracepoint made. */
115 static int tracepoint_count;
117 /* Number of last traceframe collected. */
118 static int traceframe_number;
120 /* Tracepoint for last traceframe collected. */
121 static int tracepoint_number;
123 /* Symbol for function for last traceframe collected */
124 static struct symbol *traceframe_fun;
126 /* Symtab and line for last traceframe collected */
127 static struct symtab_and_line traceframe_sal;
129 /* Tracing command lists */
130 static struct cmd_list_element *tfindlist;
132 /* ======= Important command functions: ======= */
133 static void trace_command (char *, int);
134 static void tracepoints_info (char *, int);
135 static void delete_trace_command (char *, int);
136 static void enable_trace_command (char *, int);
137 static void disable_trace_command (char *, int);
138 static void trace_pass_command (char *, int);
139 static void trace_actions_command (char *, int);
140 static void trace_start_command (char *, int);
141 static void trace_stop_command (char *, int);
142 static void trace_status_command (char *, int);
143 static void trace_find_command (char *, int);
144 static void trace_find_pc_command (char *, int);
145 static void trace_find_tracepoint_command (char *, int);
146 static void trace_find_line_command (char *, int);
147 static void trace_find_range_command (char *, int);
148 static void trace_find_outside_command (char *, int);
149 static void tracepoint_save_command (char *, int);
150 static void trace_dump_command (char *, int);
152 /* support routines */
153 static void trace_mention (struct tracepoint *);
155 struct collection_list;
156 static void add_aexpr (struct collection_list *, struct agent_expr *);
157 static unsigned char *mem2hex (unsigned char *, unsigned char *, int);
158 static void add_register (struct collection_list *collection,
160 static struct cleanup *make_cleanup_free_actions (struct tracepoint *t);
161 static void free_actions_list (char **actions_list);
162 static void free_actions_list_cleanup_wrapper (void *);
164 extern void _initialize_tracepoint (void);
166 /* Utility: returns true if "target remote" */
168 target_is_remote (void)
170 if (current_target.to_shortname &&
171 strcmp (current_target.to_shortname, "remote") == 0)
177 /* Utility: generate error from an incoming stub packet. */
179 trace_error (char *buf)
182 return; /* not an error msg */
185 case '1': /* malformed packet error */
186 if (*++buf == '0') /* general case: */
187 error ("tracepoint.c: error in outgoing packet.");
189 error ("tracepoint.c: error in outgoing packet at field #%ld.",
190 strtol (buf, NULL, 16));
192 error ("trace API error 0x%s.", ++buf);
194 error ("Target returns error code '%s'.", buf);
198 /* Utility: wait for reply from stub, while accepting "O" packets */
200 remote_get_noisy_reply (char *buf,
203 do /* loop on reply from remote stub */
205 QUIT; /* allow user to bail out with ^C */
206 getpkt (buf, sizeof_buf, 0);
208 error ("Target does not support this command.");
209 else if (buf[0] == 'E')
211 else if (buf[0] == 'O' &&
213 remote_console_output (buf + 1); /* 'O' message from stub */
215 return buf; /* here's the actual reply */
220 /* Set tracepoint count to NUM. */
222 set_tracepoint_count (int 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 (int num)
233 traceframe_number = num;
234 set_internalvar (lookup_internalvar ("trace_frame"),
235 value_from_longest (builtin_type_int, (LONGEST) num));
238 /* Set tracepoint number to NUM. */
240 set_tracepoint_num (int num)
242 tracepoint_number = num;
243 set_internalvar (lookup_internalvar ("tracepoint"),
244 value_from_longest (builtin_type_int, (LONGEST) num));
247 /* Set externally visible debug variables for querying/printing
248 the traceframe context (line, function, file) */
251 set_traceframe_context (CORE_ADDR trace_pc)
253 static struct type *func_string, *file_string;
254 static struct type *func_range, *file_range;
255 struct value *func_val;
256 struct value *file_val;
257 static struct type *charstar;
260 if (charstar == (struct type *) NULL)
261 charstar = lookup_pointer_type (builtin_type_char);
263 if (trace_pc == -1) /* cease debugging any trace buffers */
266 traceframe_sal.pc = traceframe_sal.line = 0;
267 traceframe_sal.symtab = NULL;
268 set_internalvar (lookup_internalvar ("trace_func"),
269 value_from_pointer (charstar, (LONGEST) 0));
270 set_internalvar (lookup_internalvar ("trace_file"),
271 value_from_pointer (charstar, (LONGEST) 0));
272 set_internalvar (lookup_internalvar ("trace_line"),
273 value_from_pointer (builtin_type_int, (LONGEST) - 1));
277 /* save as globals for internal use */
278 traceframe_sal = find_pc_line (trace_pc, 0);
279 traceframe_fun = find_pc_function (trace_pc);
281 /* save linenumber as "$trace_line", a debugger variable visible to users */
282 set_internalvar (lookup_internalvar ("trace_line"),
283 value_from_longest (builtin_type_int,
284 (LONGEST) traceframe_sal.line));
286 /* save func name as "$trace_func", a debugger variable visible to users */
287 if (traceframe_fun == NULL ||
288 SYMBOL_NAME (traceframe_fun) == NULL)
289 set_internalvar (lookup_internalvar ("trace_func"),
290 value_from_pointer (charstar, (LONGEST) 0));
293 len = strlen (SYMBOL_NAME (traceframe_fun));
294 func_range = create_range_type (func_range,
295 builtin_type_int, 0, len - 1);
296 func_string = create_array_type (func_string,
297 builtin_type_char, func_range);
298 func_val = allocate_value (func_string);
299 VALUE_TYPE (func_val) = func_string;
300 memcpy (VALUE_CONTENTS_RAW (func_val),
301 SYMBOL_NAME (traceframe_fun),
303 func_val->modifiable = 0;
304 set_internalvar (lookup_internalvar ("trace_func"), func_val);
307 /* save file name as "$trace_file", a debugger variable visible to users */
308 if (traceframe_sal.symtab == NULL ||
309 traceframe_sal.symtab->filename == NULL)
310 set_internalvar (lookup_internalvar ("trace_file"),
311 value_from_pointer (charstar, (LONGEST) 0));
314 len = strlen (traceframe_sal.symtab->filename);
315 file_range = create_range_type (file_range,
316 builtin_type_int, 0, len - 1);
317 file_string = create_array_type (file_string,
318 builtin_type_char, file_range);
319 file_val = allocate_value (file_string);
320 VALUE_TYPE (file_val) = file_string;
321 memcpy (VALUE_CONTENTS_RAW (file_val),
322 traceframe_sal.symtab->filename,
324 file_val->modifiable = 0;
325 set_internalvar (lookup_internalvar ("trace_file"), file_val);
329 /* Low level routine to set a tracepoint.
330 Returns the tracepoint object so caller can set other things.
331 Does not set the tracepoint number!
332 Does not print anything.
334 ==> This routine should not be called if there is a chance of later
335 error(); otherwise it leaves a bogus tracepoint on the chain. Validate
336 your arguments BEFORE calling this routine! */
338 static struct tracepoint *
339 set_raw_tracepoint (struct symtab_and_line sal)
341 register struct tracepoint *t, *tc;
342 struct cleanup *old_chain;
344 t = (struct tracepoint *) xmalloc (sizeof (struct tracepoint));
345 old_chain = make_cleanup (xfree, t);
346 memset (t, 0, sizeof (*t));
348 if (sal.symtab == NULL)
349 t->source_file = NULL;
351 t->source_file = savestring (sal.symtab->filename,
352 strlen (sal.symtab->filename));
354 t->section = sal.section;
355 t->language = current_language->la_language;
356 t->input_radix = input_radix;
357 t->line_number = sal.line;
362 t->addr_string = NULL;
364 /* Add this tracepoint to the end of the chain
365 so that a list of tracepoints will come out in order
366 of increasing numbers. */
368 tc = tracepoint_chain;
370 tracepoint_chain = t;
377 discard_cleanups (old_chain);
381 /* Set a tracepoint according to ARG (function, linenum or *address) */
383 trace_command (char *arg, int from_tty)
385 char **canonical = (char **) NULL;
386 struct symtabs_and_lines sals;
387 struct symtab_and_line sal;
388 struct tracepoint *t;
389 char *addr_start = 0, *addr_end = 0;
393 error ("trace command requires an argument");
395 if (from_tty && info_verbose)
396 printf_filtered ("TRACE %s\n", arg);
399 sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, 0, &canonical);
402 return; /* ??? Presumably decode_line_1 has already warned? */
404 /* Resolve all line numbers to PC's */
405 for (i = 0; i < sals.nelts; i++)
406 resolve_sal_pc (&sals.sals[i]);
408 /* Now set all the tracepoints. */
409 for (i = 0; i < sals.nelts; i++)
413 t = set_raw_tracepoint (sal);
414 set_tracepoint_count (tracepoint_count + 1);
415 t->number = tracepoint_count;
417 /* If a canonical line spec is needed use that instead of the
419 if (canonical != (char **) NULL && canonical[i] != NULL)
420 t->addr_string = canonical[i];
422 t->addr_string = savestring (addr_start, addr_end - addr_start);
429 printf_filtered ("Multiple tracepoints were set.\n");
430 printf_filtered ("Use 'delete trace' to delete unwanted tracepoints.\n");
434 /* Tell the user we have just set a tracepoint TP. */
437 trace_mention (struct tracepoint *tp)
439 printf_filtered ("Tracepoint %d", tp->number);
441 if (addressprint || (tp->source_file == NULL))
443 printf_filtered (" at ");
444 print_address_numeric (tp->address, 1, gdb_stdout);
447 printf_filtered (": file %s, line %d.",
448 tp->source_file, tp->line_number);
450 printf_filtered ("\n");
453 /* Print information on tracepoint number TPNUM_EXP, or all if omitted. */
456 tracepoints_info (char *tpnum_exp, int from_tty)
458 struct tracepoint *t;
459 struct action_line *action;
460 int found_a_tracepoint = 0;
461 char wrap_indent[80];
466 tpnum = parse_and_eval_long (tpnum_exp);
469 if (tpnum == -1 || tpnum == t->number)
471 extern int addressprint; /* print machine addresses? */
473 if (!found_a_tracepoint++)
475 printf_filtered ("Num Enb ");
478 if (TARGET_ADDR_BIT <= 32)
479 printf_filtered ("Address ");
481 printf_filtered ("Address ");
483 printf_filtered ("PassC StepC What\n");
485 strcpy (wrap_indent, " ");
488 if (TARGET_ADDR_BIT <= 32)
489 strcat (wrap_indent, " ");
491 strcat (wrap_indent, " ");
494 printf_filtered ("%-3d %-3s ", t->number,
495 t->enabled_p ? "y" : "n");
500 if (TARGET_ADDR_BIT <= 32)
501 tmp = local_hex_string_custom (t->address
502 & (CORE_ADDR) 0xffffffff,
505 tmp = local_hex_string_custom (t->address, "016l");
507 printf_filtered ("%s ", tmp);
509 printf_filtered ("%-5d %-5ld ", t->pass_count, t->step_count);
513 sym = find_pc_sect_function (t->address, t->section);
516 fputs_filtered ("in ", gdb_stdout);
517 fputs_filtered (SYMBOL_SOURCE_NAME (sym), gdb_stdout);
518 wrap_here (wrap_indent);
519 fputs_filtered (" at ", gdb_stdout);
521 fputs_filtered (t->source_file, gdb_stdout);
522 printf_filtered (":%d", t->line_number);
525 print_address_symbolic (t->address, gdb_stdout, demangle, " ");
527 printf_filtered ("\n");
530 printf_filtered (" Actions for tracepoint %d: \n", t->number);
531 for (action = t->actions; action; action = action->next)
533 printf_filtered ("\t%s\n", action->action);
537 if (!found_a_tracepoint)
540 printf_filtered ("No tracepoints.\n");
542 printf_filtered ("No tracepoint number %d.\n", tpnum);
546 /* Optimization: the code to parse an enable, disable, or delete TP command
547 is virtually identical except for whether it performs an enable, disable,
548 or delete. Therefore I've combined them into one function with an opcode.
550 enum tracepoint_opcode
557 /* This function implements enable, disable and delete commands. */
559 tracepoint_operation (struct tracepoint *t, int from_tty,
560 enum tracepoint_opcode opcode)
562 struct tracepoint *t2;
564 if (t == NULL) /* no tracepoint operand */
571 tracepoint_modify_event (t->number);
575 tracepoint_modify_event (t->number);
578 if (tracepoint_chain == t)
579 tracepoint_chain = t->next;
584 tracepoint_delete_event (t2->number);
590 xfree (t->addr_string);
592 xfree (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 (char **arg, int multi_p, int optional_p)
608 struct tracepoint *t;
610 char *instring = arg == NULL ? NULL : *arg;
612 if (arg == NULL || *arg == NULL || ! **arg)
615 tpnum = tracepoint_count;
617 error_no_arg ("tracepoint number");
620 tpnum = multi_p ? get_number_or_range (arg) : get_number (arg);
624 if (instring && *instring)
625 printf_filtered ("bad tracepoint number at or near '%s'\n", instring);
627 printf_filtered ("Tracepoint argument missing and no previous tracepoint\n");
632 if (t->number == tpnum)
637 /* FIXME: if we are in the middle of a range we don't want to give
638 a message. The current interface to get_number_or_range doesn't
639 allow us to discover this. */
640 printf_unfiltered ("No tracepoint number %d.\n", tpnum);
644 /* Utility: parse a list of tracepoint numbers, and call a func for each. */
646 map_args_over_tracepoints (char *args, int from_tty,
647 enum tracepoint_opcode opcode)
649 struct tracepoint *t, *tmp;
651 if (args == 0 || *args == 0) /* do them all */
652 ALL_TRACEPOINTS_SAFE (t, tmp)
653 tracepoint_operation (t, from_tty, opcode);
657 QUIT; /* give user option to bail out with ^C */
658 t = get_tracepoint_by_number (&args, 1, 0);
659 tracepoint_operation (t, from_tty, opcode);
660 while (*args == ' ' || *args == '\t')
665 /* The 'enable trace' command enables tracepoints. Not supported by all targets. */
667 enable_trace_command (char *args, int from_tty)
670 map_args_over_tracepoints (args, from_tty, enable_op);
673 /* The 'disable trace' command enables tracepoints. Not supported by all targets. */
675 disable_trace_command (char *args, int from_tty)
678 map_args_over_tracepoints (args, from_tty, disable_op);
681 /* Remove a tracepoint (or all if no argument) */
683 delete_trace_command (char *args, int from_tty)
686 if (!args || !*args) /* No args implies all tracepoints; */
687 if (from_tty) /* confirm only if from_tty... */
688 if (tracepoint_chain) /* and if there are tracepoints to delete! */
689 if (!query ("Delete all tracepoints? "))
692 map_args_over_tracepoints (args, from_tty, delete_op);
695 /* Set passcount for tracepoint.
697 First command argument is passcount, second is tracepoint number.
698 If tracepoint number omitted, apply to most recently defined.
699 Also accepts special argument "all". */
702 trace_pass_command (char *args, int from_tty)
704 struct tracepoint *t1 = (struct tracepoint *) -1, *t2;
708 if (args == 0 || *args == 0)
709 error ("passcount command requires an argument (count + optional TP num)");
711 count = strtoul (args, &args, 10); /* count comes first, then TP num */
713 while (*args && isspace ((int) *args))
716 if (*args && strncasecmp (args, "all", 3) == 0)
718 args += 3; /* skip special argument "all" */
721 error ("Junk at end of arguments.");
724 t1 = get_tracepoint_by_number (&args, 1, 1);
731 if (t1 == (struct tracepoint *) -1 || t1 == t2)
733 t2->pass_count = count;
734 tracepoint_modify_event (t2->number);
736 printf_filtered ("Setting tracepoint %d's passcount to %d\n",
740 t1 = get_tracepoint_by_number (&args, 1, 0);
746 /* ACTIONS functions: */
748 /* Prototypes for action-parsing utility commands */
749 static void read_actions (struct tracepoint *);
751 /* The three functions:
752 collect_pseudocommand,
753 while_stepping_pseudocommand, and
754 end_actions_pseudocommand
755 are placeholders for "commands" that are actually ONLY to be used
756 within a tracepoint action list. If the actual function is ever called,
757 it means that somebody issued the "command" at the top level,
758 which is always an error. */
761 end_actions_pseudocommand (char *args, int from_tty)
763 error ("This command cannot be used at the top level.");
767 while_stepping_pseudocommand (char *args, int from_tty)
769 error ("This command can only be used in a tracepoint actions list.");
773 collect_pseudocommand (char *args, int from_tty)
775 error ("This command can only be used in a tracepoint actions list.");
778 /* Enter a list of actions for a tracepoint. */
780 trace_actions_command (char *args, int from_tty)
782 struct tracepoint *t;
784 char *end_msg = "End with a line saying just \"end\".";
786 t = get_tracepoint_by_number (&args, 0, 1);
789 sprintf (tmpbuf, "Enter actions for tracepoint %d, one per line.",
794 if (readline_begin_hook)
795 (*readline_begin_hook) ("%s %s\n", tmpbuf, end_msg);
796 else if (input_from_terminal_p ())
797 printf_filtered ("%s\n%s\n", tmpbuf, end_msg);
801 t->step_count = 0; /* read_actions may set this */
804 if (readline_end_hook)
805 (*readline_end_hook) ();
806 /* tracepoints_changed () */
808 /* else just return */
811 /* worker function */
813 read_actions (struct tracepoint *t)
816 char *prompt1 = "> ", *prompt2 = " > ";
817 char *prompt = prompt1;
818 enum actionline_type linetype;
819 extern FILE *instream;
820 struct action_line *next = NULL, *temp;
821 struct cleanup *old_chain;
823 /* Control-C quits instantly if typed while in this loop
824 since it should not wait until the user types a newline. */
826 /* FIXME: kettenis/20010823: Something is wrong here. In this file
827 STOP_SIGNAL is never defined. So this code has been left out, at
828 least for quite a while now. Replacing STOP_SIGNAL with SIGTSTP
829 leads to compilation failures since the variable job_control
830 isn't declared. Leave this alone for now. */
835 signal (STOP_SIGNAL, handle_stop_sig);
837 signal (STOP_SIGNAL, stop_sig);
840 old_chain = make_cleanup_free_actions (t);
843 /* Make sure that all output has been output. Some machines may let
844 you get away with leaving out some of the gdb_flush, but not all. */
846 gdb_flush (gdb_stdout);
847 gdb_flush (gdb_stderr);
849 if (readline_hook && instream == NULL)
850 line = (*readline_hook) (prompt);
851 else if (instream == stdin && ISATTY (instream))
853 line = gdb_readline_wrapper (prompt);
854 if (line && *line) /* add it to command history */
858 line = gdb_readline (0);
860 linetype = validate_actionline (&line, t);
861 if (linetype == BADLINE)
862 continue; /* already warned -- collect another line */
864 temp = xmalloc (sizeof (struct action_line));
868 if (next == NULL) /* first action for this tracepoint? */
869 t->actions = next = temp;
876 if (linetype == STEPPING) /* begin "while-stepping" */
878 if (prompt == prompt2)
880 warning ("Already processing 'while-stepping'");
884 prompt = prompt2; /* change prompt for stepping actions */
886 else if (linetype == END)
888 if (prompt == prompt2)
890 prompt = prompt1; /* end of single-stepping actions */
893 { /* end of actions */
894 if (t->actions->next == NULL)
896 /* an "end" all by itself with no other actions means
897 this tracepoint has no actions. Discard empty list. */
906 signal (STOP_SIGNAL, SIG_DFL);
909 discard_cleanups (old_chain);
912 /* worker function */
914 validate_actionline (char **line, struct tracepoint *t)
916 struct cmd_list_element *c;
917 struct expression *exp = NULL;
918 struct cleanup *old_chain = NULL;
921 for (p = *line; isspace ((int) *p);)
924 /* symbol lookup etc. */
925 if (*p == '\0') /* empty line: just prompt for another line. */
928 if (*p == '#') /* comment line */
931 c = lookup_cmd (&p, cmdlist, "", -1, 1);
934 warning ("'%s' is not an action that I know, or is ambiguous.", p);
938 if (cmd_cfunc_eq (c, collect_pseudocommand))
940 struct agent_expr *aexpr;
941 struct agent_reqs areqs;
944 { /* repeat over a comma-separated list */
945 QUIT; /* allow user to bail out with ^C */
946 while (isspace ((int) *p))
949 if (*p == '$') /* look for special pseudo-symbols */
951 if ((0 == strncasecmp ("reg", p + 1, 3)) ||
952 (0 == strncasecmp ("arg", p + 1, 3)) ||
953 (0 == strncasecmp ("loc", p + 1, 3)))
958 /* else fall thru, treat p as an expression and parse it! */
960 exp = parse_exp_1 (&p, block_for_pc (t->address), 1);
961 old_chain = make_cleanup (free_current_contents, &exp);
963 if (exp->elts[0].opcode == OP_VAR_VALUE)
965 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
967 warning ("constant %s (value %ld) will not be collected.",
968 SYMBOL_NAME (exp->elts[2].symbol),
969 SYMBOL_VALUE (exp->elts[2].symbol));
972 else if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_OPTIMIZED_OUT)
974 warning ("%s is optimized away and cannot be collected.",
975 SYMBOL_NAME (exp->elts[2].symbol));
980 /* we have something to collect, make sure that the expr to
981 bytecode translator can handle it and that it's not too long */
982 aexpr = gen_trace_for_expr (t->address, exp);
983 make_cleanup_free_agent_expr (aexpr);
985 if (aexpr->len > MAX_AGENT_EXPR_LEN)
986 error ("expression too complicated, try simplifying");
988 ax_reqs (aexpr, &areqs);
989 (void) make_cleanup (xfree, areqs.reg_mask);
991 if (areqs.flaw != agent_flaw_none)
992 error ("malformed expression");
994 if (areqs.min_height < 0)
995 error ("gdb: Internal error: expression has min height < 0");
997 if (areqs.max_height > 20)
998 error ("expression too complicated, try simplifying");
1000 do_cleanups (old_chain);
1002 while (p && *p++ == ',');
1005 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
1007 char *steparg; /* in case warning is necessary */
1009 while (isspace ((int) *p))
1014 (t->step_count = strtol (p, &p, 0)) == 0)
1016 warning ("'%s': bad step-count; command ignored.", *line);
1021 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
1025 warning ("'%s' is not a supported tracepoint action.", *line);
1030 /* worker function */
1032 free_actions (struct tracepoint *t)
1034 struct action_line *line, *next;
1036 for (line = t->actions; line; line = next)
1040 xfree (line->action);
1047 do_free_actions_cleanup (void *t)
1052 static struct cleanup *
1053 make_cleanup_free_actions (struct tracepoint *t)
1055 return make_cleanup (do_free_actions_cleanup, t);
1060 int type; /* 0 for absolute memory range, else basereg number */
1061 bfd_signed_vma start;
1065 struct collection_list
1067 unsigned char regs_mask[8]; /* room for up to 256 regs */
1070 struct memrange *list;
1071 long aexpr_listsize; /* size of array pointed to by expr_list elt */
1072 long next_aexpr_elt;
1073 struct agent_expr **aexpr_list;
1076 tracepoint_list, stepping_list;
1078 /* MEMRANGE functions: */
1080 static int memrange_cmp (const void *, const void *);
1082 /* compare memranges for qsort */
1084 memrange_cmp (const void *va, const void *vb)
1086 const struct memrange *a = va, *b = vb;
1088 if (a->type < b->type)
1090 if (a->type > b->type)
1094 if ((bfd_vma) a->start < (bfd_vma) b->start)
1096 if ((bfd_vma) a->start > (bfd_vma) b->start)
1101 if (a->start < b->start)
1103 if (a->start > b->start)
1109 /* Sort the memrange list using qsort, and merge adjacent memranges */
1111 memrange_sortmerge (struct collection_list *memranges)
1115 qsort (memranges->list, memranges->next_memrange,
1116 sizeof (struct memrange), memrange_cmp);
1117 if (memranges->next_memrange > 0)
1119 for (a = 0, b = 1; b < memranges->next_memrange; b++)
1121 if (memranges->list[a].type == memranges->list[b].type &&
1122 memranges->list[b].start - memranges->list[a].end <=
1123 MAX_REGISTER_VIRTUAL_SIZE)
1125 /* memrange b starts before memrange a ends; merge them. */
1126 if (memranges->list[b].end > memranges->list[a].end)
1127 memranges->list[a].end = memranges->list[b].end;
1128 continue; /* next b, same a */
1132 memcpy (&memranges->list[a], &memranges->list[b],
1133 sizeof (struct memrange));
1135 memranges->next_memrange = a + 1;
1139 /* Add a register to a collection list */
1141 add_register (struct collection_list *collection, unsigned int regno)
1144 printf_filtered ("collect register %d\n", regno);
1145 if (regno > (8 * sizeof (collection->regs_mask)))
1146 error ("Internal: register number %d too large for tracepoint",
1148 collection->regs_mask[regno / 8] |= 1 << (regno % 8);
1151 /* Add a memrange to a collection list */
1153 add_memrange (struct collection_list *memranges, int type, bfd_signed_vma base,
1158 printf_filtered ("(%d,", type);
1160 printf_filtered (",%ld)\n", len);
1163 /* type: 0 == memory, n == basereg */
1164 memranges->list[memranges->next_memrange].type = type;
1165 /* base: addr if memory, offset if reg relative. */
1166 memranges->list[memranges->next_memrange].start = base;
1167 /* len: we actually save end (base + len) for convenience */
1168 memranges->list[memranges->next_memrange].end = base + len;
1169 memranges->next_memrange++;
1170 if (memranges->next_memrange >= memranges->listsize)
1172 memranges->listsize *= 2;
1173 memranges->list = xrealloc (memranges->list,
1174 memranges->listsize);
1177 if (type != -1) /* better collect the base register! */
1178 add_register (memranges, type);
1181 /* Add a symbol to a collection list */
1183 collect_symbol (struct collection_list *collect, struct symbol *sym,
1184 long frame_regno, long frame_offset)
1188 bfd_signed_vma offset;
1190 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
1191 switch (SYMBOL_CLASS (sym))
1194 printf_filtered ("%s: don't know symbol class %d\n",
1195 SYMBOL_NAME (sym), SYMBOL_CLASS (sym));
1198 printf_filtered ("constant %s (value %ld) will not be collected.\n",
1199 SYMBOL_NAME (sym), SYMBOL_VALUE (sym));
1202 offset = SYMBOL_VALUE_ADDRESS (sym);
1207 sprintf_vma (tmp, offset);
1208 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1209 SYMBOL_NAME (sym), len, tmp /* address */);
1211 add_memrange (collect, -1, offset, len); /* 0 == memory */
1215 reg = SYMBOL_VALUE (sym);
1217 printf_filtered ("LOC_REG[parm] %s: ", SYMBOL_NAME (sym));
1218 add_register (collect, reg);
1219 /* check for doubles stored in two registers */
1220 /* FIXME: how about larger types stored in 3 or more regs? */
1221 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
1222 len > REGISTER_RAW_SIZE (reg))
1223 add_register (collect, reg + 1);
1226 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1227 printf_filtered (" (will not collect %s)\n",
1232 offset = frame_offset + SYMBOL_VALUE (sym);
1235 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1236 SYMBOL_NAME (sym), len);
1237 printf_vma (offset);
1238 printf_filtered (" from frame ptr reg %d\n", reg);
1240 add_memrange (collect, reg, offset, len);
1242 case LOC_REGPARM_ADDR:
1243 reg = SYMBOL_VALUE (sym);
1247 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1248 SYMBOL_NAME (sym), len);
1249 printf_vma (offset);
1250 printf_filtered (" from reg %d\n", reg);
1252 add_memrange (collect, reg, offset, len);
1257 offset = frame_offset + SYMBOL_VALUE (sym);
1260 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1261 SYMBOL_NAME (sym), len);
1262 printf_vma (offset);
1263 printf_filtered (" from frame ptr reg %d\n", reg);
1265 add_memrange (collect, reg, offset, len);
1268 case LOC_BASEREG_ARG:
1269 reg = SYMBOL_BASEREG (sym);
1270 offset = SYMBOL_VALUE (sym);
1273 printf_filtered ("LOC_BASEREG %s: collect %ld bytes at offset ",
1274 SYMBOL_NAME (sym), len);
1275 printf_vma (offset);
1276 printf_filtered (" from basereg %d\n", reg);
1278 add_memrange (collect, reg, offset, len);
1280 case LOC_UNRESOLVED:
1281 printf_filtered ("Don't know LOC_UNRESOLVED %s\n", SYMBOL_NAME (sym));
1283 case LOC_OPTIMIZED_OUT:
1284 printf_filtered ("%s has been optimized out of existence.\n",
1290 /* Add all locals (or args) symbols to collection list */
1292 add_local_symbols (struct collection_list *collect, CORE_ADDR pc,
1293 long frame_regno, long frame_offset, int type)
1296 struct block *block;
1299 block = block_for_pc (pc);
1302 QUIT; /* allow user to bail out with ^C */
1303 ALL_BLOCK_SYMBOLS (block, i, sym)
1305 switch (SYMBOL_CLASS (sym))
1308 warning ("don't know how to trace local symbol %s",
1314 if (type == 'L') /* collecting Locals */
1317 collect_symbol (collect, sym, frame_regno, frame_offset);
1324 case LOC_REGPARM_ADDR:
1325 case LOC_BASEREG_ARG:
1326 if (type == 'A') /* collecting Arguments */
1329 collect_symbol (collect, sym, frame_regno, frame_offset);
1333 if (BLOCK_FUNCTION (block))
1336 block = BLOCK_SUPERBLOCK (block);
1339 warning ("No %s found in scope.", type == 'L' ? "locals" : "args");
1342 /* worker function */
1344 clear_collection_list (struct collection_list *list)
1348 list->next_memrange = 0;
1349 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1351 free_agent_expr (list->aexpr_list[ndx]);
1352 list->aexpr_list[ndx] = NULL;
1354 list->next_aexpr_elt = 0;
1355 memset (list->regs_mask, 0, sizeof (list->regs_mask));
1358 /* reduce a collection list to string form (for gdb protocol) */
1360 stringify_collection_list (struct collection_list *list, char *string)
1362 char temp_buf[2048];
1366 char *(*str_list)[];
1370 count = 1 + list->next_memrange + list->next_aexpr_elt + 1;
1371 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1373 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1374 if (list->regs_mask[i] != 0) /* skip leading zeroes in regs_mask */
1376 if (list->regs_mask[i] != 0) /* prepare to send regs_mask to the stub */
1379 printf_filtered ("\nCollecting registers (mask): 0x");
1384 QUIT; /* allow user to bail out with ^C */
1386 printf_filtered ("%02X", list->regs_mask[i]);
1387 sprintf (end, "%02X", list->regs_mask[i]);
1390 (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
1394 printf_filtered ("\n");
1395 if (list->next_memrange > 0 && info_verbose)
1396 printf_filtered ("Collecting memranges: \n");
1397 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1399 QUIT; /* allow user to bail out with ^C */
1400 sprintf_vma (tmp2, list->list[i].start);
1403 printf_filtered ("(%d, %s, %ld)\n",
1406 (long) (list->list[i].end - list->list[i].start));
1408 if (count + 27 > MAX_AGENT_EXPR_LEN)
1410 (*str_list)[ndx] = savestring (temp_buf, count);
1416 sprintf (end, "M%X,%s,%lX",
1419 (long) (list->list[i].end - list->list[i].start));
1421 count += strlen (end);
1425 for (i = 0; i < list->next_aexpr_elt; i++)
1427 QUIT; /* allow user to bail out with ^C */
1428 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1430 (*str_list)[ndx] = savestring (temp_buf, count);
1435 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1436 end += 10; /* 'X' + 8 hex digits + ',' */
1439 end = mem2hex (list->aexpr_list[i]->buf, end, list->aexpr_list[i]->len);
1440 count += 2 * list->aexpr_list[i]->len;
1445 (*str_list)[ndx] = savestring (temp_buf, count);
1450 (*str_list)[ndx] = NULL;
1459 free_actions_list_cleanup_wrapper (void *al)
1461 free_actions_list (al);
1465 free_actions_list (char **actions_list)
1469 if (actions_list == 0)
1472 for (ndx = 0; actions_list[ndx]; ndx++)
1473 xfree (actions_list[ndx]);
1475 xfree (actions_list);
1478 /* render all actions into gdb protocol */
1480 encode_actions (struct tracepoint *t, char ***tdp_actions,
1481 char ***stepping_actions)
1483 static char tdp_buff[2048], step_buff[2048];
1485 struct expression *exp = NULL;
1486 struct action_line *action;
1488 struct value *tempval;
1489 struct collection_list *collect;
1490 struct cmd_list_element *cmd;
1491 struct agent_expr *aexpr;
1493 LONGEST frame_offset;
1496 clear_collection_list (&tracepoint_list);
1497 clear_collection_list (&stepping_list);
1498 collect = &tracepoint_list;
1500 *tdp_actions = NULL;
1501 *stepping_actions = NULL;
1503 TARGET_VIRTUAL_FRAME_POINTER (t->address, &frame_reg, &frame_offset);
1505 for (action = t->actions; action; action = action->next)
1507 QUIT; /* allow user to bail out with ^C */
1508 action_exp = action->action;
1509 while (isspace ((int) *action_exp))
1512 if (*action_exp == '#') /* comment line */
1515 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1517 error ("Bad action list item: %s", action_exp);
1519 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1522 { /* repeat over a comma-separated list */
1523 QUIT; /* allow user to bail out with ^C */
1524 while (isspace ((int) *action_exp))
1527 if (0 == strncasecmp ("$reg", action_exp, 4))
1529 for (i = 0; i < NUM_REGS; i++)
1530 add_register (collect, i);
1531 action_exp = strchr (action_exp, ','); /* more? */
1533 else if (0 == strncasecmp ("$arg", action_exp, 4))
1535 add_local_symbols (collect,
1540 action_exp = strchr (action_exp, ','); /* more? */
1542 else if (0 == strncasecmp ("$loc", action_exp, 4))
1544 add_local_symbols (collect,
1549 action_exp = strchr (action_exp, ','); /* more? */
1553 unsigned long addr, len;
1554 struct cleanup *old_chain = NULL;
1555 struct cleanup *old_chain1 = NULL;
1556 struct agent_reqs areqs;
1558 exp = parse_exp_1 (&action_exp,
1559 block_for_pc (t->address), 1);
1560 old_chain = make_cleanup (free_current_contents, &exp);
1562 switch (exp->elts[0].opcode)
1565 i = exp->elts[1].longconst;
1567 printf_filtered ("OP_REGISTER: ");
1568 add_register (collect, i);
1572 /* safe because we know it's a simple expression */
1573 tempval = evaluate_expression (exp);
1574 addr = VALUE_ADDRESS (tempval) + VALUE_OFFSET (tempval);
1575 len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
1576 add_memrange (collect, -1, addr, len);
1580 collect_symbol (collect,
1581 exp->elts[2].symbol,
1586 default: /* full-fledged expression */
1587 aexpr = gen_trace_for_expr (t->address, exp);
1589 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1591 ax_reqs (aexpr, &areqs);
1592 if (areqs.flaw != agent_flaw_none)
1593 error ("malformed expression");
1595 if (areqs.min_height < 0)
1596 error ("gdb: Internal error: expression has min height < 0");
1597 if (areqs.max_height > 20)
1598 error ("expression too complicated, try simplifying");
1600 discard_cleanups (old_chain1);
1601 add_aexpr (collect, aexpr);
1603 /* take care of the registers */
1604 if (areqs.reg_mask_len > 0)
1609 for (ndx1 = 0; ndx1 < areqs.reg_mask_len; ndx1++)
1611 QUIT; /* allow user to bail out with ^C */
1612 if (areqs.reg_mask[ndx1] != 0)
1614 /* assume chars have 8 bits */
1615 for (ndx2 = 0; ndx2 < 8; ndx2++)
1616 if (areqs.reg_mask[ndx1] & (1 << ndx2))
1617 /* it's used -- record it */
1618 add_register (collect, ndx1 * 8 + ndx2);
1624 do_cleanups (old_chain);
1627 while (action_exp && *action_exp++ == ',');
1629 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1631 collect = &stepping_list;
1633 else if (cmd_cfunc_eq (cmd, end_actions_pseudocommand))
1635 if (collect == &stepping_list) /* end stepping actions */
1636 collect = &tracepoint_list;
1638 break; /* end tracepoint actions */
1641 memrange_sortmerge (&tracepoint_list);
1642 memrange_sortmerge (&stepping_list);
1644 *tdp_actions = stringify_collection_list (&tracepoint_list, tdp_buff);
1645 *stepping_actions = stringify_collection_list (&stepping_list, step_buff);
1649 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1651 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1653 collect->aexpr_list =
1654 xrealloc (collect->aexpr_list,
1655 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1656 collect->aexpr_listsize *= 2;
1658 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1659 collect->next_aexpr_elt++;
1662 static char target_buf[2048];
1664 /* Set "transparent" memory ranges
1666 Allow trace mechanism to treat text-like sections
1667 (and perhaps all read-only sections) transparently,
1668 i.e. don't reject memory requests from these address ranges
1669 just because they haven't been collected. */
1672 remote_set_transparent_ranges (void)
1674 extern bfd *exec_bfd;
1681 return; /* no information to give. */
1683 strcpy (target_buf, "QTro");
1684 for (s = exec_bfd->sections; s; s = s->next)
1686 char tmp1[40], tmp2[40];
1688 if ((s->flags & SEC_LOAD) == 0 ||
1689 /* (s->flags & SEC_CODE) == 0 || */
1690 (s->flags & SEC_READONLY) == 0)
1695 size = bfd_get_section_size_before_reloc (s);
1696 sprintf_vma (tmp1, lma);
1697 sprintf_vma (tmp2, lma + size);
1698 sprintf (target_buf + strlen (target_buf),
1699 ":%s,%s", tmp1, tmp2);
1703 putpkt (target_buf);
1704 getpkt (target_buf, sizeof (target_buf), 0);
1710 Tell target to clear any previous trace experiment.
1711 Walk the list of tracepoints, and send them (and their actions)
1712 to the target. If no errors,
1713 Tell target to start a new trace experiment. */
1716 trace_start_command (char *args, int from_tty)
1717 { /* STUB_COMM MOSTLY_IMPLEMENTED */
1718 struct tracepoint *t;
1721 char **stepping_actions;
1723 struct cleanup *old_chain = NULL;
1725 dont_repeat (); /* like "run", dangerous to repeat accidentally */
1727 if (target_is_remote ())
1730 remote_get_noisy_reply (target_buf, sizeof (target_buf));
1731 if (strcmp (target_buf, "OK"))
1732 error ("Target does not support this command.");
1738 sprintf_vma (tmp, t->address);
1739 sprintf (buf, "QTDP:%x:%s:%c:%lx:%x", t->number, tmp, /* address */
1740 t->enabled_p ? 'E' : 'D',
1741 t->step_count, t->pass_count);
1746 remote_get_noisy_reply (target_buf, sizeof (target_buf));
1747 if (strcmp (target_buf, "OK"))
1748 error ("Target does not support tracepoints.");
1752 encode_actions (t, &tdp_actions, &stepping_actions);
1753 old_chain = make_cleanup (free_actions_list_cleanup_wrapper,
1755 (void) make_cleanup (free_actions_list_cleanup_wrapper,
1758 /* do_single_steps (t); */
1761 for (ndx = 0; tdp_actions[ndx]; ndx++)
1763 QUIT; /* allow user to bail out with ^C */
1764 sprintf (buf, "QTDP:-%x:%s:%s%c",
1765 t->number, tmp, /* address */
1767 ((tdp_actions[ndx + 1] || stepping_actions)
1770 remote_get_noisy_reply (target_buf, sizeof (target_buf));
1771 if (strcmp (target_buf, "OK"))
1772 error ("Error on target while setting tracepoints.");
1775 if (stepping_actions)
1777 for (ndx = 0; stepping_actions[ndx]; ndx++)
1779 QUIT; /* allow user to bail out with ^C */
1780 sprintf (buf, "QTDP:-%x:%s:%s%s%s",
1781 t->number, tmp, /* address */
1782 ((ndx == 0) ? "S" : ""),
1783 stepping_actions[ndx],
1784 (stepping_actions[ndx + 1] ? "-" : ""));
1786 remote_get_noisy_reply (target_buf, sizeof (target_buf));
1787 if (strcmp (target_buf, "OK"))
1788 error ("Error on target while setting tracepoints.");
1792 do_cleanups (old_chain);
1795 /* Tell target to treat text-like sections as transparent */
1796 remote_set_transparent_ranges ();
1797 /* Now insert traps and begin collecting data */
1799 remote_get_noisy_reply (target_buf, sizeof (target_buf));
1800 if (strcmp (target_buf, "OK"))
1801 error ("Bogus reply from target: %s", target_buf);
1802 set_traceframe_num (-1); /* all old traceframes invalidated */
1803 set_tracepoint_num (-1);
1804 set_traceframe_context (-1);
1805 trace_running_p = 1;
1806 if (trace_start_stop_hook)
1807 trace_start_stop_hook (1, from_tty);
1811 error ("Trace can only be run on remote targets.");
1816 trace_stop_command (char *args, int from_tty)
1817 { /* STUB_COMM IS_IMPLEMENTED */
1818 if (target_is_remote ())
1821 remote_get_noisy_reply (target_buf, sizeof (target_buf));
1822 if (strcmp (target_buf, "OK"))
1823 error ("Bogus reply from target: %s", target_buf);
1824 trace_running_p = 0;
1825 if (trace_start_stop_hook)
1826 trace_start_stop_hook (0, from_tty);
1829 error ("Trace can only be run on remote targets.");
1832 unsigned long trace_running_p;
1834 /* tstatus command */
1836 trace_status_command (char *args, int from_tty)
1837 { /* STUB_COMM IS_IMPLEMENTED */
1838 if (target_is_remote ())
1840 putpkt ("qTStatus");
1841 remote_get_noisy_reply (target_buf, sizeof (target_buf));
1843 if (target_buf[0] != 'T' ||
1844 (target_buf[1] != '0' && target_buf[1] != '1'))
1845 error ("Bogus reply from target: %s", target_buf);
1847 /* exported for use by the GUI */
1848 trace_running_p = (target_buf[1] == '1');
1851 error ("Trace can only be run on remote targets.");
1854 /* Worker function for the various flavors of the tfind command */
1856 finish_tfind_command (char *msg,
1860 int target_frameno = -1, target_tracept = -1;
1861 CORE_ADDR old_frame_addr;
1862 struct symbol *old_func;
1865 old_frame_addr = get_frame_base (get_current_frame ());
1866 old_func = find_pc_function (read_pc ());
1869 reply = remote_get_noisy_reply (msg, sizeof_msg);
1871 while (reply && *reply)
1875 if ((target_frameno = (int) strtol (++reply, &reply, 16)) == -1)
1877 /* A request for a non-existant trace frame has failed.
1878 Our response will be different, depending on FROM_TTY:
1880 If FROM_TTY is true, meaning that this command was
1881 typed interactively by the user, then give an error
1882 and DO NOT change the state of traceframe_number etc.
1884 However if FROM_TTY is false, meaning that we're either
1885 in a script, a loop, or a user-defined command, then
1886 DON'T give an error, but DO change the state of
1887 traceframe_number etc. to invalid.
1889 The rationalle is that if you typed the command, you
1890 might just have committed a typo or something, and you'd
1891 like to NOT lose your current debugging state. However
1892 if you're in a user-defined command or especially in a
1893 loop, then you need a way to detect that the command
1894 failed WITHOUT aborting. This allows you to write
1895 scripts that search thru the trace buffer until the end,
1896 and then continue on to do something else. */
1899 error ("Target failed to find requested trace frame.");
1903 printf_filtered ("End of trace buffer.\n");
1904 /* The following will not recurse, since it's special-cased */
1905 trace_find_command ("-1", from_tty);
1906 reply = NULL; /* break out of loop,
1907 (avoid recursive nonsense) */
1912 if ((target_tracept = (int) strtol (++reply, &reply, 16)) == -1)
1913 error ("Target failed to find requested trace frame.");
1915 case 'O': /* "OK"? */
1916 if (reply[1] == 'K' && reply[2] == '\0')
1919 error ("Bogus reply from target: %s", reply);
1922 error ("Bogus reply from target: %s", reply);
1925 flush_cached_frames ();
1926 registers_changed ();
1927 select_frame (get_current_frame ());
1928 set_traceframe_num (target_frameno);
1929 set_tracepoint_num (target_tracept);
1930 if (target_frameno == -1)
1931 set_traceframe_context (-1);
1933 set_traceframe_context (read_pc ());
1939 /* NOTE: in immitation of the step command, try to determine
1940 whether we have made a transition from one function to another.
1941 If so, we'll print the "stack frame" (ie. the new function and
1942 it's arguments) -- otherwise we'll just show the new source line.
1944 This determination is made by checking (1) whether the current
1945 function has changed, and (2) whether the current FP has changed.
1946 Hack: if the FP wasn't collected, either at the current or the
1947 previous frame, assume that the FP has NOT changed. */
1949 if (old_func == find_pc_function (read_pc ()) &&
1950 (old_frame_addr == 0 ||
1951 get_frame_base (get_current_frame ()) == 0 ||
1952 old_frame_addr == get_frame_base (get_current_frame ())))
1957 print_stack_frame (deprecated_selected_frame,
1958 frame_relative_level (deprecated_selected_frame),
1964 /* trace_find_command takes a trace frame number n,
1965 sends "QTFrame:<n>" to the target,
1966 and accepts a reply that may contain several optional pieces
1967 of information: a frame number, a tracepoint number, and an
1968 indication of whether this is a trap frame or a stepping frame.
1970 The minimal response is just "OK" (which indicates that the
1971 target does not give us a frame number or a tracepoint number).
1972 Instead of that, the target may send us a string containing
1974 F<hexnum> (gives the selected frame number)
1975 T<hexnum> (gives the selected tracepoint number)
1980 trace_find_command (char *args, int from_tty)
1981 { /* STUB_COMM PART_IMPLEMENTED */
1982 /* this should only be called with a numeric argument */
1985 if (target_is_remote ())
1987 if (trace_find_hook)
1988 trace_find_hook (args, from_tty);
1990 if (args == 0 || *args == 0)
1991 { /* TFIND with no args means find NEXT trace frame. */
1992 if (traceframe_number == -1)
1993 frameno = 0; /* "next" is first one */
1995 frameno = traceframe_number + 1;
1997 else if (0 == strcmp (args, "-"))
1999 if (traceframe_number == -1)
2000 error ("not debugging trace buffer");
2001 else if (from_tty && traceframe_number == 0)
2002 error ("already at start of trace buffer");
2004 frameno = traceframe_number - 1;
2007 frameno = parse_and_eval_long (args);
2010 error ("invalid input (%d is less than zero)", frameno);
2012 sprintf (target_buf, "QTFrame:%x", frameno);
2013 finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
2016 error ("Trace can only be run on remote targets.");
2021 trace_find_end_command (char *args, int from_tty)
2023 trace_find_command ("-1", from_tty);
2028 trace_find_none_command (char *args, int from_tty)
2030 trace_find_command ("-1", from_tty);
2035 trace_find_start_command (char *args, int from_tty)
2037 trace_find_command ("0", from_tty);
2040 /* tfind pc command */
2042 trace_find_pc_command (char *args, int from_tty)
2043 { /* STUB_COMM PART_IMPLEMENTED */
2047 if (target_is_remote ())
2049 if (args == 0 || *args == 0)
2050 pc = read_pc (); /* default is current pc */
2052 pc = parse_and_eval_address (args);
2054 sprintf_vma (tmp, pc);
2055 sprintf (target_buf, "QTFrame:pc:%s", tmp);
2056 finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
2059 error ("Trace can only be run on remote targets.");
2062 /* tfind tracepoint command */
2064 trace_find_tracepoint_command (char *args, int from_tty)
2065 { /* STUB_COMM PART_IMPLEMENTED */
2068 if (target_is_remote ())
2070 if (args == 0 || *args == 0)
2072 if (tracepoint_number == -1)
2073 error ("No current tracepoint -- please supply an argument.");
2075 tdp = tracepoint_number; /* default is current TDP */
2078 tdp = parse_and_eval_long (args);
2080 sprintf (target_buf, "QTFrame:tdp:%x", tdp);
2081 finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
2084 error ("Trace can only be run on remote targets.");
2087 /* TFIND LINE command:
2089 This command will take a sourceline for argument, just like BREAK
2090 or TRACE (ie. anything that "decode_line_1" can handle).
2092 With no argument, this command will find the next trace frame
2093 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2096 trace_find_line_command (char *args, int from_tty)
2097 { /* STUB_COMM PART_IMPLEMENTED */
2098 static CORE_ADDR start_pc, end_pc;
2099 struct symtabs_and_lines sals;
2100 struct symtab_and_line sal;
2101 struct cleanup *old_chain;
2102 char startpc_str[40], endpc_str[40];
2104 if (target_is_remote ())
2106 if (args == 0 || *args == 0)
2108 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2110 sals.sals = (struct symtab_and_line *)
2111 xmalloc (sizeof (struct symtab_and_line));
2116 sals = decode_line_spec (args, 1);
2120 old_chain = make_cleanup (xfree, sals.sals);
2121 if (sal.symtab == 0)
2123 printf_filtered ("TFIND: No line number information available");
2126 /* This is useful for "info line *0x7f34". If we can't tell the
2127 user about a source line, at least let them have the symbolic
2129 printf_filtered (" for address ");
2131 print_address (sal.pc, gdb_stdout);
2132 printf_filtered (";\n -- will attempt to find by PC. \n");
2136 printf_filtered (".\n");
2137 return; /* no line, no PC; what can we do? */
2140 else if (sal.line > 0
2141 && find_line_pc_range (sal, &start_pc, &end_pc))
2143 if (start_pc == end_pc)
2145 printf_filtered ("Line %d of \"%s\"",
2146 sal.line, sal.symtab->filename);
2148 printf_filtered (" is at address ");
2149 print_address (start_pc, gdb_stdout);
2151 printf_filtered (" but contains no code.\n");
2152 sal = find_pc_line (start_pc, 0);
2154 find_line_pc_range (sal, &start_pc, &end_pc) &&
2156 printf_filtered ("Attempting to find line %d instead.\n",
2159 error ("Cannot find a good line.");
2163 /* Is there any case in which we get here, and have an address
2164 which the user would want to see? If we have debugging symbols
2165 and no line numbers? */
2166 error ("Line number %d is out of range for \"%s\".\n",
2167 sal.line, sal.symtab->filename);
2169 sprintf_vma (startpc_str, start_pc);
2170 sprintf_vma (endpc_str, end_pc - 1);
2171 if (args && *args) /* find within range of stated line */
2172 sprintf (target_buf, "QTFrame:range:%s:%s", startpc_str, endpc_str);
2173 else /* find OUTSIDE OF range of CURRENT line */
2174 sprintf (target_buf, "QTFrame:outside:%s:%s", startpc_str, endpc_str);
2175 finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
2176 do_cleanups (old_chain);
2179 error ("Trace can only be run on remote targets.");
2182 /* tfind range command */
2184 trace_find_range_command (char *args, int from_tty)
2186 static CORE_ADDR start, stop;
2187 char start_str[40], stop_str[40];
2190 if (target_is_remote ())
2192 if (args == 0 || *args == 0)
2193 { /* XXX FIXME: what should default behavior be? */
2194 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2198 if (0 != (tmp = strchr (args, ',')))
2200 *tmp++ = '\0'; /* terminate start address */
2201 while (isspace ((int) *tmp))
2203 start = parse_and_eval_address (args);
2204 stop = parse_and_eval_address (tmp);
2207 { /* no explicit end address? */
2208 start = parse_and_eval_address (args);
2209 stop = start + 1; /* ??? */
2212 sprintf_vma (start_str, start);
2213 sprintf_vma (stop_str, stop);
2214 sprintf (target_buf, "QTFrame:range:%s:%s", start_str, stop_str);
2215 finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
2218 error ("Trace can only be run on remote targets.");
2221 /* tfind outside command */
2223 trace_find_outside_command (char *args, int from_tty)
2225 CORE_ADDR start, stop;
2226 char start_str[40], stop_str[40];
2229 if (target_is_remote ())
2231 if (args == 0 || *args == 0)
2232 { /* XXX FIXME: what should default behavior be? */
2233 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2237 if (0 != (tmp = strchr (args, ',')))
2239 *tmp++ = '\0'; /* terminate start address */
2240 while (isspace ((int) *tmp))
2242 start = parse_and_eval_address (args);
2243 stop = parse_and_eval_address (tmp);
2246 { /* no explicit end address? */
2247 start = parse_and_eval_address (args);
2248 stop = start + 1; /* ??? */
2251 sprintf_vma (start_str, start);
2252 sprintf_vma (stop_str, stop);
2253 sprintf (target_buf, "QTFrame:outside:%s:%s", start_str, stop_str);
2254 finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
2257 error ("Trace can only be run on remote targets.");
2260 /* save-tracepoints command */
2262 tracepoint_save_command (char *args, int from_tty)
2264 struct tracepoint *tp;
2265 struct action_line *line;
2267 char *i1 = " ", *i2 = " ";
2268 char *indent, *actionline, *pathname;
2271 if (args == 0 || *args == 0)
2272 error ("Argument required (file name in which to save tracepoints");
2274 if (tracepoint_chain == 0)
2276 warning ("save-tracepoints: no tracepoints to save.\n");
2280 pathname = tilde_expand (args);
2281 if (!(fp = fopen (pathname, "w")))
2282 error ("Unable to open file '%s' for saving tracepoints (%s)",
2283 args, safe_strerror (errno));
2286 ALL_TRACEPOINTS (tp)
2288 if (tp->addr_string)
2289 fprintf (fp, "trace %s\n", tp->addr_string);
2292 sprintf_vma (tmp, tp->address);
2293 fprintf (fp, "trace *0x%s\n", tmp);
2297 fprintf (fp, " passcount %d\n", tp->pass_count);
2301 fprintf (fp, " actions\n");
2303 for (line = tp->actions; line; line = line->next)
2305 struct cmd_list_element *cmd;
2307 QUIT; /* allow user to bail out with ^C */
2308 actionline = line->action;
2309 while (isspace ((int) *actionline))
2312 fprintf (fp, "%s%s\n", indent, actionline);
2313 if (*actionline != '#') /* skip for comment lines */
2315 cmd = lookup_cmd (&actionline, cmdlist, "", -1, 1);
2317 error ("Bad action list item: %s", actionline);
2318 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2320 else if (cmd_cfunc_eq (cmd, end_actions_pseudocommand))
2328 printf_filtered ("Tracepoints saved to file '%s'.\n", args);
2332 /* info scope command: list the locals for a scope. */
2334 scope_info (char *args, int from_tty)
2336 struct symtabs_and_lines sals;
2338 struct minimal_symbol *msym;
2339 struct block *block;
2340 char **canonical, *symname, *save_args = args;
2341 int i, j, count = 0;
2343 if (args == 0 || *args == 0)
2344 error ("requires an argument (function, line or *addr) to define a scope");
2346 sals = decode_line_1 (&args, 1, NULL, 0, &canonical);
2347 if (sals.nelts == 0)
2348 return; /* presumably decode_line_1 has already warned */
2350 /* Resolve line numbers to PC */
2351 resolve_sal_pc (&sals.sals[0]);
2352 block = block_for_pc (sals.sals[0].pc);
2356 QUIT; /* allow user to bail out with ^C */
2357 ALL_BLOCK_SYMBOLS (block, i, sym)
2359 QUIT; /* allow user to bail out with ^C */
2361 printf_filtered ("Scope for %s:\n", save_args);
2364 symname = SYMBOL_NAME (sym);
2365 if (symname == NULL || *symname == '\0')
2366 continue; /* probably botched, certainly useless */
2368 printf_filtered ("Symbol %s is ", symname);
2369 switch (SYMBOL_CLASS (sym))
2372 case LOC_UNDEF: /* messed up symbol? */
2373 printf_filtered ("a bogus symbol, class %d.\n",
2374 SYMBOL_CLASS (sym));
2375 count--; /* don't count this one */
2378 printf_filtered ("a constant with value %ld (0x%lx)",
2379 SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
2381 case LOC_CONST_BYTES:
2382 printf_filtered ("constant bytes: ");
2383 if (SYMBOL_TYPE (sym))
2384 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2385 fprintf_filtered (gdb_stdout, " %02x",
2386 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2389 printf_filtered ("in static storage at address ");
2390 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
2393 printf_filtered ("a local variable in register $%s",
2394 REGISTER_NAME (SYMBOL_VALUE (sym)));
2398 printf_filtered ("an argument at stack/frame offset %ld",
2399 SYMBOL_VALUE (sym));
2402 printf_filtered ("a local variable at frame offset %ld",
2403 SYMBOL_VALUE (sym));
2406 printf_filtered ("a reference argument at offset %ld",
2407 SYMBOL_VALUE (sym));
2410 printf_filtered ("an argument in register $%s",
2411 REGISTER_NAME (SYMBOL_VALUE (sym)));
2413 case LOC_REGPARM_ADDR:
2414 printf_filtered ("the address of an argument, in register $%s",
2415 REGISTER_NAME (SYMBOL_VALUE (sym)));
2418 printf_filtered ("a typedef.\n");
2421 printf_filtered ("a label at address ");
2422 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
2425 printf_filtered ("a function at address ");
2426 print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)), 1,
2430 printf_filtered ("a variable at offset %ld from register $%s",
2432 REGISTER_NAME (SYMBOL_BASEREG (sym)));
2434 case LOC_BASEREG_ARG:
2435 printf_filtered ("an argument at offset %ld from register $%s",
2437 REGISTER_NAME (SYMBOL_BASEREG (sym)));
2439 case LOC_UNRESOLVED:
2440 msym = lookup_minimal_symbol (SYMBOL_NAME (sym), NULL, NULL);
2442 printf_filtered ("Unresolved Static");
2445 printf_filtered ("static storage at address ");
2446 print_address_numeric (SYMBOL_VALUE_ADDRESS (msym), 1,
2450 case LOC_OPTIMIZED_OUT:
2451 printf_filtered ("optimized out.\n");
2454 if (SYMBOL_TYPE (sym))
2455 printf_filtered (", length %d.\n",
2456 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2458 if (BLOCK_FUNCTION (block))
2461 block = BLOCK_SUPERBLOCK (block);
2464 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2468 /* worker function (cleanup) */
2470 replace_comma (void *data)
2478 trace_dump_command (char *args, int from_tty)
2480 struct tracepoint *t;
2481 struct action_line *action;
2482 char *action_exp, *next_comma;
2483 struct cleanup *old_cleanups;
2484 int stepping_actions = 0;
2485 int stepping_frame = 0;
2487 if (!target_is_remote ())
2489 error ("Trace can only be run on remote targets.");
2493 if (tracepoint_number == -1)
2495 warning ("No current trace frame.");
2500 if (t->number == tracepoint_number)
2504 error ("No known tracepoint matches 'current' tracepoint #%d.",
2507 old_cleanups = make_cleanup (null_cleanup, NULL);
2509 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2510 tracepoint_number, traceframe_number);
2512 /* The current frame is a trap frame if the frame PC is equal
2513 to the tracepoint PC. If not, then the current frame was
2514 collected during single-stepping. */
2516 stepping_frame = (t->address != read_pc ());
2518 for (action = t->actions; action; action = action->next)
2520 struct cmd_list_element *cmd;
2522 QUIT; /* allow user to bail out with ^C */
2523 action_exp = action->action;
2524 while (isspace ((int) *action_exp))
2527 /* The collection actions to be done while stepping are
2528 bracketed by the commands "while-stepping" and "end". */
2530 if (*action_exp == '#') /* comment line */
2533 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2535 error ("Bad action list item: %s", action_exp);
2537 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2538 stepping_actions = 1;
2539 else if (cmd_cfunc_eq (cmd, end_actions_pseudocommand))
2540 stepping_actions = 0;
2541 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2543 /* Display the collected data.
2544 For the trap frame, display only what was collected at the trap.
2545 Likewise for stepping frames, display only what was collected
2546 while stepping. This means that the two boolean variables,
2547 STEPPING_FRAME and STEPPING_ACTIONS should be equal. */
2548 if (stepping_frame == stepping_actions)
2551 { /* repeat over a comma-separated list */
2552 QUIT; /* allow user to bail out with ^C */
2553 if (*action_exp == ',')
2555 while (isspace ((int) *action_exp))
2558 next_comma = strchr (action_exp, ',');
2560 if (0 == strncasecmp (action_exp, "$reg", 4))
2561 registers_info (NULL, from_tty);
2562 else if (0 == strncasecmp (action_exp, "$loc", 4))
2563 locals_info (NULL, from_tty);
2564 else if (0 == strncasecmp (action_exp, "$arg", 4))
2565 args_info (NULL, from_tty);
2570 make_cleanup (replace_comma, next_comma);
2573 printf_filtered ("%s = ", action_exp);
2574 output_command (action_exp, from_tty);
2575 printf_filtered ("\n");
2579 action_exp = next_comma;
2581 while (action_exp && *action_exp == ',');
2585 discard_cleanups (old_cleanups);
2588 /* Convert the memory pointed to by mem into hex, placing result in buf.
2589 * Return a pointer to the last char put in buf (null)
2590 * "stolen" from sparc-stub.c
2593 static const char hexchars[] = "0123456789abcdef";
2595 static unsigned char *
2596 mem2hex (unsigned char *mem, unsigned char *buf, int count)
2604 *buf++ = hexchars[ch >> 4];
2605 *buf++ = hexchars[ch & 0xf];
2614 get_traceframe_number (void)
2616 return traceframe_number;
2620 /* module initialization */
2622 _initialize_tracepoint (void)
2624 struct cmd_list_element *c;
2626 tracepoint_chain = 0;
2627 tracepoint_count = 0;
2628 traceframe_number = -1;
2629 tracepoint_number = -1;
2631 set_internalvar (lookup_internalvar ("tpnum"),
2632 value_from_longest (builtin_type_int, (LONGEST) 0));
2633 set_internalvar (lookup_internalvar ("trace_frame"),
2634 value_from_longest (builtin_type_int, (LONGEST) - 1));
2636 if (tracepoint_list.list == NULL)
2638 tracepoint_list.listsize = 128;
2639 tracepoint_list.list = xmalloc
2640 (tracepoint_list.listsize * sizeof (struct memrange));
2642 if (tracepoint_list.aexpr_list == NULL)
2644 tracepoint_list.aexpr_listsize = 128;
2645 tracepoint_list.aexpr_list = xmalloc
2646 (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
2649 if (stepping_list.list == NULL)
2651 stepping_list.listsize = 128;
2652 stepping_list.list = xmalloc
2653 (stepping_list.listsize * sizeof (struct memrange));
2656 if (stepping_list.aexpr_list == NULL)
2658 stepping_list.aexpr_listsize = 128;
2659 stepping_list.aexpr_list = xmalloc
2660 (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
2663 add_info ("scope", scope_info,
2664 "List the variables local to a scope");
2666 add_cmd ("tracepoints", class_trace, NULL,
2667 "Tracing of program execution without stopping the program.",
2670 add_info ("tracepoints", tracepoints_info,
2671 "Status of tracepoints, or tracepoint number NUMBER.\n\
2672 Convenience variable \"$tpnum\" contains the number of the\n\
2673 last tracepoint set.");
2675 add_info_alias ("tp", "tracepoints", 1);
2677 c = add_com ("save-tracepoints", class_trace, tracepoint_save_command,
2678 "Save current tracepoint definitions as a script.\n\
2679 Use the 'source' command in another debug session to restore them.");
2680 set_cmd_completer (c, filename_completer);
2682 add_com ("tdump", class_trace, trace_dump_command,
2683 "Print everything collected at the current tracepoint.");
2685 add_prefix_cmd ("tfind", class_trace, trace_find_command,
2686 "Select a trace frame;\n\
2687 No argument means forward by one frame; '-' meand backward by one frame.",
2688 &tfindlist, "tfind ", 1, &cmdlist);
2690 add_cmd ("outside", class_trace, trace_find_outside_command,
2691 "Select a trace frame whose PC is outside the given \
2692 range.\nUsage: tfind outside addr1, addr2",
2695 add_cmd ("range", class_trace, trace_find_range_command,
2696 "Select a trace frame whose PC is in the given range.\n\
2697 Usage: tfind range addr1,addr2",
2700 add_cmd ("line", class_trace, trace_find_line_command,
2701 "Select a trace frame by source line.\n\
2702 Argument can be a line number (with optional source file), \n\
2703 a function name, or '*' followed by an address.\n\
2704 Default argument is 'the next source line that was traced'.",
2707 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command,
2708 "Select a trace frame by tracepoint number.\n\
2709 Default is the tracepoint for the current trace frame.",
2712 add_cmd ("pc", class_trace, trace_find_pc_command,
2713 "Select a trace frame by PC.\n\
2714 Default is the current PC, or the PC of the current trace frame.",
2717 add_cmd ("end", class_trace, trace_find_end_command,
2718 "Synonym for 'none'.\n\
2719 De-select any trace frame and resume 'live' debugging.",
2722 add_cmd ("none", class_trace, trace_find_none_command,
2723 "De-select any trace frame and resume 'live' debugging.",
2726 add_cmd ("start", class_trace, trace_find_start_command,
2727 "Select the first trace frame in the trace buffer.",
2730 add_com ("tstatus", class_trace, trace_status_command,
2731 "Display the status of the current trace data collection.");
2733 add_com ("tstop", class_trace, trace_stop_command,
2734 "Stop trace data collection.");
2736 add_com ("tstart", class_trace, trace_start_command,
2737 "Start trace data collection.");
2739 add_com ("passcount", class_trace, trace_pass_command,
2740 "Set the passcount for a tracepoint.\n\
2741 The trace will end when the tracepoint has been passed 'count' times.\n\
2742 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
2743 if TPNUM is omitted, passcount refers to the last tracepoint defined.");
2745 add_com ("end", class_trace, end_actions_pseudocommand,
2746 "Ends a list of commands or actions.\n\
2747 Several GDB commands allow you to enter a list of commands or actions.\n\
2748 Entering \"end\" on a line by itself is the normal way to terminate\n\
2750 Note: the \"end\" command cannot be used at the gdb prompt.");
2752 add_com ("while-stepping", class_trace, while_stepping_pseudocommand,
2753 "Specify single-stepping behavior at a tracepoint.\n\
2754 Argument is number of instructions to trace in single-step mode\n\
2755 following the tracepoint. This command is normally followed by\n\
2756 one or more \"collect\" commands, to specify what to collect\n\
2757 while single-stepping.\n\n\
2758 Note: this command can only be used in a tracepoint \"actions\" list.");
2760 add_com_alias ("ws", "while-stepping", class_alias, 0);
2761 add_com_alias ("stepping", "while-stepping", class_alias, 0);
2763 add_com ("collect", class_trace, collect_pseudocommand,
2764 "Specify one or more data items to be collected at a tracepoint.\n\
2765 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
2766 collect all data (variables, registers) referenced by that expression.\n\
2767 Also accepts the following special arguments:\n\
2768 $regs -- all registers.\n\
2769 $args -- all function arguments.\n\
2770 $locals -- all variables local to the block/function scope.\n\
2771 Note: this command can only be used in a tracepoint \"actions\" list.");
2773 add_com ("actions", class_trace, trace_actions_command,
2774 "Specify the actions to be taken at a tracepoint.\n\
2775 Tracepoint actions may include collecting of specified data, \n\
2776 single-stepping, or enabling/disabling other tracepoints, \n\
2777 depending on target's capabilities.");
2779 add_cmd ("tracepoints", class_trace, delete_trace_command,
2780 "Delete specified tracepoints.\n\
2781 Arguments are tracepoint numbers, separated by spaces.\n\
2782 No argument means delete all tracepoints.",
2785 add_cmd ("tracepoints", class_trace, disable_trace_command,
2786 "Disable specified tracepoints.\n\
2787 Arguments are tracepoint numbers, separated by spaces.\n\
2788 No argument means disable all tracepoints.",
2791 add_cmd ("tracepoints", class_trace, enable_trace_command,
2792 "Enable specified tracepoints.\n\
2793 Arguments are tracepoint numbers, separated by spaces.\n\
2794 No argument means enable all tracepoints.",
2797 c = add_com ("trace", class_trace, trace_command,
2798 "Set a tracepoint at a specified line or function or address.\n\
2799 Argument may be a line number, function name, or '*' plus an address.\n\
2800 For a line number or function, trace at the start of its code.\n\
2801 If an address is specified, trace at that exact address.\n\n\
2802 Do \"help tracepoints\" for info on other tracepoint commands.");
2803 set_cmd_completer (c, location_completer);
2805 add_com_alias ("tp", "trace", class_alias, 0);
2806 add_com_alias ("tr", "trace", class_alias, 1);
2807 add_com_alias ("tra", "trace", class_alias, 1);
2808 add_com_alias ("trac", "trace", class_alias, 1);