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);
80 This module defines the following debugger commands:
81 trace : set a tracepoint on a function, line, or address.
82 info trace : list all debugger-defined tracepoints.
83 delete trace : delete one or more tracepoints.
84 enable trace : enable one or more tracepoints.
85 disable trace : disable one or more tracepoints.
86 actions : specify actions to be taken at a tracepoint.
87 passcount : specify a pass count for a tracepoint.
88 tstart : start a trace experiment.
89 tstop : stop a trace experiment.
90 tstatus : query the status of a trace experiment.
91 tfind : find a trace frame in the trace buffer.
92 tdump : print everything collected at the current tracepoint.
93 save-tracepoints : write tracepoint setup into a file.
95 This module defines the following user-visible debugger variables:
96 $trace_frame : sequence number of trace frame currently being debugged.
97 $trace_line : source line of trace frame currently being debugged.
98 $trace_file : source file of trace frame currently being debugged.
99 $tracepoint : tracepoint number of trace frame currently being debugged.
103 /* ======= Important global variables: ======= */
105 /* Chain of all tracepoints defined. */
106 struct tracepoint *tracepoint_chain;
108 /* Number of last tracepoint made. */
109 static int tracepoint_count;
111 /* Number of last traceframe collected. */
112 static int traceframe_number;
114 /* Tracepoint for last traceframe collected. */
115 static int tracepoint_number;
117 /* Symbol for function for last traceframe collected */
118 static struct symbol *traceframe_fun;
120 /* Symtab and line for last traceframe collected */
121 static struct symtab_and_line traceframe_sal;
123 /* Tracing command lists */
124 static struct cmd_list_element *tfindlist;
126 /* ======= Important command functions: ======= */
127 static void trace_command (char *, int);
128 static void tracepoints_info (char *, int);
129 static void delete_trace_command (char *, int);
130 static void enable_trace_command (char *, int);
131 static void disable_trace_command (char *, int);
132 static void trace_pass_command (char *, int);
133 static void trace_actions_command (char *, int);
134 static void trace_start_command (char *, int);
135 static void trace_stop_command (char *, int);
136 static void trace_status_command (char *, int);
137 static void trace_find_command (char *, int);
138 static void trace_find_pc_command (char *, int);
139 static void trace_find_tracepoint_command (char *, int);
140 static void trace_find_line_command (char *, int);
141 static void trace_find_range_command (char *, int);
142 static void trace_find_outside_command (char *, int);
143 static void tracepoint_save_command (char *, int);
144 static void trace_dump_command (char *, int);
146 /* support routines */
147 static void trace_mention (struct tracepoint *);
149 struct collection_list;
150 static void add_aexpr (struct collection_list *, struct agent_expr *);
151 static unsigned char *mem2hex (unsigned char *, unsigned char *, int);
152 static void add_register (struct collection_list *collection,
154 static struct cleanup *make_cleanup_free_actions (struct tracepoint *t);
155 static void free_actions_list (char **actions_list);
156 static void free_actions_list_cleanup_wrapper (void *);
158 extern void _initialize_tracepoint (void);
160 /* Utility: returns true if "target remote" */
162 target_is_remote (void)
164 if (current_target.to_shortname &&
165 strcmp (current_target.to_shortname, "remote") == 0)
171 /* Utility: generate error from an incoming stub packet. */
173 trace_error (char *buf)
176 return; /* not an error msg */
179 case '1': /* malformed packet error */
180 if (*++buf == '0') /* general case: */
181 error ("tracepoint.c: error in outgoing packet.");
183 error ("tracepoint.c: error in outgoing packet at field #%ld.",
184 strtol (buf, NULL, 16));
186 error ("trace API error 0x%s.", ++buf);
188 error ("Target returns error code '%s'.", buf);
192 /* Utility: wait for reply from stub, while accepting "O" packets */
194 remote_get_noisy_reply (char *buf,
197 do /* loop on reply from remote stub */
199 QUIT; /* allow user to bail out with ^C */
200 getpkt (buf, sizeof_buf, 0);
202 error ("Target does not support this command.");
203 else if (buf[0] == 'E')
205 else if (buf[0] == 'O' &&
207 remote_console_output (buf + 1); /* 'O' message from stub */
209 return buf; /* here's the actual reply */
214 /* Set tracepoint count to NUM. */
216 set_tracepoint_count (int num)
218 tracepoint_count = num;
219 set_internalvar (lookup_internalvar ("tpnum"),
220 value_from_longest (builtin_type_int, (LONGEST) num));
223 /* Set traceframe number to NUM. */
225 set_traceframe_num (int num)
227 traceframe_number = num;
228 set_internalvar (lookup_internalvar ("trace_frame"),
229 value_from_longest (builtin_type_int, (LONGEST) num));
232 /* Set tracepoint number to NUM. */
234 set_tracepoint_num (int num)
236 tracepoint_number = num;
237 set_internalvar (lookup_internalvar ("tracepoint"),
238 value_from_longest (builtin_type_int, (LONGEST) num));
241 /* Set externally visible debug variables for querying/printing
242 the traceframe context (line, function, file) */
245 set_traceframe_context (CORE_ADDR trace_pc)
247 static struct type *func_string, *file_string;
248 static struct type *func_range, *file_range;
249 struct value *func_val;
250 struct value *file_val;
251 static struct type *charstar;
254 if (charstar == (struct type *) NULL)
255 charstar = lookup_pointer_type (builtin_type_char);
257 if (trace_pc == -1) /* cease debugging any trace buffers */
260 traceframe_sal.pc = traceframe_sal.line = 0;
261 traceframe_sal.symtab = NULL;
262 set_internalvar (lookup_internalvar ("trace_func"),
263 value_from_pointer (charstar, (LONGEST) 0));
264 set_internalvar (lookup_internalvar ("trace_file"),
265 value_from_pointer (charstar, (LONGEST) 0));
266 set_internalvar (lookup_internalvar ("trace_line"),
267 value_from_pointer (builtin_type_int, (LONGEST) - 1));
271 /* save as globals for internal use */
272 traceframe_sal = find_pc_line (trace_pc, 0);
273 traceframe_fun = find_pc_function (trace_pc);
275 /* save linenumber as "$trace_line", a debugger variable visible to users */
276 set_internalvar (lookup_internalvar ("trace_line"),
277 value_from_longest (builtin_type_int,
278 (LONGEST) traceframe_sal.line));
280 /* save func name as "$trace_func", a debugger variable visible to users */
281 if (traceframe_fun == NULL ||
282 SYMBOL_NAME (traceframe_fun) == NULL)
283 set_internalvar (lookup_internalvar ("trace_func"),
284 value_from_pointer (charstar, (LONGEST) 0));
287 len = strlen (SYMBOL_NAME (traceframe_fun));
288 func_range = create_range_type (func_range,
289 builtin_type_int, 0, len - 1);
290 func_string = create_array_type (func_string,
291 builtin_type_char, func_range);
292 func_val = allocate_value (func_string);
293 VALUE_TYPE (func_val) = func_string;
294 memcpy (VALUE_CONTENTS_RAW (func_val),
295 SYMBOL_NAME (traceframe_fun),
297 func_val->modifiable = 0;
298 set_internalvar (lookup_internalvar ("trace_func"), func_val);
301 /* save file name as "$trace_file", a debugger variable visible to users */
302 if (traceframe_sal.symtab == NULL ||
303 traceframe_sal.symtab->filename == NULL)
304 set_internalvar (lookup_internalvar ("trace_file"),
305 value_from_pointer (charstar, (LONGEST) 0));
308 len = strlen (traceframe_sal.symtab->filename);
309 file_range = create_range_type (file_range,
310 builtin_type_int, 0, len - 1);
311 file_string = create_array_type (file_string,
312 builtin_type_char, file_range);
313 file_val = allocate_value (file_string);
314 VALUE_TYPE (file_val) = file_string;
315 memcpy (VALUE_CONTENTS_RAW (file_val),
316 traceframe_sal.symtab->filename,
318 file_val->modifiable = 0;
319 set_internalvar (lookup_internalvar ("trace_file"), file_val);
323 /* Low level routine to set a tracepoint.
324 Returns the tracepoint object so caller can set other things.
325 Does not set the tracepoint number!
326 Does not print anything.
328 ==> This routine should not be called if there is a chance of later
329 error(); otherwise it leaves a bogus tracepoint on the chain. Validate
330 your arguments BEFORE calling this routine! */
332 static struct tracepoint *
333 set_raw_tracepoint (struct symtab_and_line sal)
335 register struct tracepoint *t, *tc;
336 struct cleanup *old_chain;
338 t = (struct tracepoint *) xmalloc (sizeof (struct tracepoint));
339 old_chain = make_cleanup (xfree, t);
340 memset (t, 0, sizeof (*t));
342 if (sal.symtab == NULL)
343 t->source_file = NULL;
345 t->source_file = savestring (sal.symtab->filename,
346 strlen (sal.symtab->filename));
348 t->section = sal.section;
349 t->language = current_language->la_language;
350 t->input_radix = input_radix;
351 t->line_number = sal.line;
356 t->addr_string = NULL;
358 /* Add this tracepoint to the end of the chain
359 so that a list of tracepoints will come out in order
360 of increasing numbers. */
362 tc = tracepoint_chain;
364 tracepoint_chain = t;
371 discard_cleanups (old_chain);
375 /* Set a tracepoint according to ARG (function, linenum or *address) */
377 trace_command (char *arg, int from_tty)
379 char **canonical = (char **) NULL;
380 struct symtabs_and_lines sals;
381 struct symtab_and_line sal;
382 struct tracepoint *t;
383 char *addr_start = 0, *addr_end = 0;
387 error ("trace command requires an argument");
389 if (from_tty && info_verbose)
390 printf_filtered ("TRACE %s\n", arg);
393 sals = decode_line_1 (&arg, 1, (struct symtab *) NULL, 0, &canonical);
396 return; /* ??? Presumably decode_line_1 has already warned? */
398 /* Resolve all line numbers to PC's */
399 for (i = 0; i < sals.nelts; i++)
400 resolve_sal_pc (&sals.sals[i]);
402 /* Now set all the tracepoints. */
403 for (i = 0; i < sals.nelts; i++)
407 t = set_raw_tracepoint (sal);
408 set_tracepoint_count (tracepoint_count + 1);
409 t->number = tracepoint_count;
411 /* If a canonical line spec is needed use that instead of the
413 if (canonical != (char **) NULL && canonical[i] != NULL)
414 t->addr_string = canonical[i];
416 t->addr_string = savestring (addr_start, addr_end - addr_start);
423 printf_filtered ("Multiple tracepoints were set.\n");
424 printf_filtered ("Use 'delete trace' to delete unwanted tracepoints.\n");
428 /* Tell the user we have just set a tracepoint TP. */
431 trace_mention (struct tracepoint *tp)
433 printf_filtered ("Tracepoint %d", tp->number);
435 if (addressprint || (tp->source_file == NULL))
437 printf_filtered (" at ");
438 print_address_numeric (tp->address, 1, gdb_stdout);
441 printf_filtered (": file %s, line %d.",
442 tp->source_file, tp->line_number);
444 printf_filtered ("\n");
447 /* Print information on tracepoint number TPNUM_EXP, or all if omitted. */
450 tracepoints_info (char *tpnum_exp, int from_tty)
452 struct tracepoint *t;
453 struct action_line *action;
454 int found_a_tracepoint = 0;
455 char wrap_indent[80];
460 tpnum = parse_and_eval_long (tpnum_exp);
463 if (tpnum == -1 || tpnum == t->number)
465 extern int addressprint; /* print machine addresses? */
467 if (!found_a_tracepoint++)
469 printf_filtered ("Num Enb ");
472 if (TARGET_ADDR_BIT <= 32)
473 printf_filtered ("Address ");
475 printf_filtered ("Address ");
477 printf_filtered ("PassC StepC What\n");
479 strcpy (wrap_indent, " ");
482 if (TARGET_ADDR_BIT <= 32)
483 strcat (wrap_indent, " ");
485 strcat (wrap_indent, " ");
488 printf_filtered ("%-3d %-3s ", t->number,
489 t->enabled_p ? "y" : "n");
494 if (TARGET_ADDR_BIT <= 32)
495 tmp = local_hex_string_custom (t->address
496 & (CORE_ADDR) 0xffffffff,
499 tmp = local_hex_string_custom (t->address, "016l");
501 printf_filtered ("%s ", tmp);
503 printf_filtered ("%-5d %-5ld ", t->pass_count, t->step_count);
507 sym = find_pc_sect_function (t->address, t->section);
510 fputs_filtered ("in ", gdb_stdout);
511 fputs_filtered (SYMBOL_SOURCE_NAME (sym), gdb_stdout);
512 wrap_here (wrap_indent);
513 fputs_filtered (" at ", gdb_stdout);
515 fputs_filtered (t->source_file, gdb_stdout);
516 printf_filtered (":%d", t->line_number);
519 print_address_symbolic (t->address, gdb_stdout, demangle, " ");
521 printf_filtered ("\n");
524 printf_filtered (" Actions for tracepoint %d: \n", t->number);
525 for (action = t->actions; action; action = action->next)
527 printf_filtered ("\t%s\n", action->action);
531 if (!found_a_tracepoint)
534 printf_filtered ("No tracepoints.\n");
536 printf_filtered ("No tracepoint number %d.\n", tpnum);
540 /* Optimization: the code to parse an enable, disable, or delete TP command
541 is virtually identical except for whether it performs an enable, disable,
542 or delete. Therefore I've combined them into one function with an opcode.
544 enum tracepoint_opcode
551 /* This function implements enable, disable and delete commands. */
553 tracepoint_operation (struct tracepoint *t, int from_tty,
554 enum tracepoint_opcode opcode)
556 struct tracepoint *t2;
558 if (t == NULL) /* no tracepoint operand */
565 tracepoint_modify_event (t->number);
569 tracepoint_modify_event (t->number);
572 if (tracepoint_chain == t)
573 tracepoint_chain = t->next;
578 tracepoint_delete_event (t2->number);
584 xfree (t->addr_string);
586 xfree (t->source_file);
595 /* Utility: parse a tracepoint number and look it up in the list.
596 If MULTI_P is true, there might be a range of tracepoints in ARG.
597 if OPTIONAL_P is true, then if the argument is missing, the most
598 recent tracepoint (tracepoint_count) is returned. */
600 get_tracepoint_by_number (char **arg, int multi_p, int optional_p)
602 struct tracepoint *t;
604 char *instring = arg == NULL ? NULL : *arg;
606 if (arg == NULL || *arg == NULL || ! **arg)
609 tpnum = tracepoint_count;
611 error_no_arg ("tracepoint number");
614 tpnum = multi_p ? get_number_or_range (arg) : get_number (arg);
618 if (instring && *instring)
619 printf_filtered ("bad tracepoint number at or near '%s'\n", instring);
621 printf_filtered ("Tracepoint argument missing and no previous tracepoint\n");
626 if (t->number == tpnum)
631 /* FIXME: if we are in the middle of a range we don't want to give
632 a message. The current interface to get_number_or_range doesn't
633 allow us to discover this. */
634 printf_unfiltered ("No tracepoint number %d.\n", tpnum);
638 /* Utility: parse a list of tracepoint numbers, and call a func for each. */
640 map_args_over_tracepoints (char *args, int from_tty,
641 enum tracepoint_opcode opcode)
643 struct tracepoint *t, *tmp;
645 if (args == 0 || *args == 0) /* do them all */
646 ALL_TRACEPOINTS_SAFE (t, tmp)
647 tracepoint_operation (t, from_tty, opcode);
651 QUIT; /* give user option to bail out with ^C */
652 t = get_tracepoint_by_number (&args, 1, 0);
653 tracepoint_operation (t, from_tty, opcode);
654 while (*args == ' ' || *args == '\t')
659 /* The 'enable trace' command enables tracepoints. Not supported by all targets. */
661 enable_trace_command (char *args, int from_tty)
664 map_args_over_tracepoints (args, from_tty, enable_op);
667 /* The 'disable trace' command enables tracepoints. Not supported by all targets. */
669 disable_trace_command (char *args, int from_tty)
672 map_args_over_tracepoints (args, from_tty, disable_op);
675 /* Remove a tracepoint (or all if no argument) */
677 delete_trace_command (char *args, int from_tty)
680 if (!args || !*args) /* No args implies all tracepoints; */
681 if (from_tty) /* confirm only if from_tty... */
682 if (tracepoint_chain) /* and if there are tracepoints to delete! */
683 if (!query ("Delete all tracepoints? "))
686 map_args_over_tracepoints (args, from_tty, delete_op);
689 /* Set passcount for tracepoint.
691 First command argument is passcount, second is tracepoint number.
692 If tracepoint number omitted, apply to most recently defined.
693 Also accepts special argument "all". */
696 trace_pass_command (char *args, int from_tty)
698 struct tracepoint *t1 = (struct tracepoint *) -1, *t2;
702 if (args == 0 || *args == 0)
703 error ("passcount command requires an argument (count + optional TP num)");
705 count = strtoul (args, &args, 10); /* count comes first, then TP num */
707 while (*args && isspace ((int) *args))
710 if (*args && strncasecmp (args, "all", 3) == 0)
712 args += 3; /* skip special argument "all" */
715 error ("Junk at end of arguments.");
718 t1 = get_tracepoint_by_number (&args, 1, 1);
725 if (t1 == (struct tracepoint *) -1 || t1 == t2)
727 t2->pass_count = count;
728 tracepoint_modify_event (t2->number);
730 printf_filtered ("Setting tracepoint %d's passcount to %d\n",
734 t1 = get_tracepoint_by_number (&args, 1, 0);
740 /* ACTIONS functions: */
742 /* Prototypes for action-parsing utility commands */
743 static void read_actions (struct tracepoint *);
745 /* The three functions:
746 collect_pseudocommand,
747 while_stepping_pseudocommand, and
748 end_actions_pseudocommand
749 are placeholders for "commands" that are actually ONLY to be used
750 within a tracepoint action list. If the actual function is ever called,
751 it means that somebody issued the "command" at the top level,
752 which is always an error. */
755 end_actions_pseudocommand (char *args, int from_tty)
757 error ("This command cannot be used at the top level.");
761 while_stepping_pseudocommand (char *args, int from_tty)
763 error ("This command can only be used in a tracepoint actions list.");
767 collect_pseudocommand (char *args, int from_tty)
769 error ("This command can only be used in a tracepoint actions list.");
772 /* Enter a list of actions for a tracepoint. */
774 trace_actions_command (char *args, int from_tty)
776 struct tracepoint *t;
778 char *end_msg = "End with a line saying just \"end\".";
780 t = get_tracepoint_by_number (&args, 0, 1);
783 sprintf (tmpbuf, "Enter actions for tracepoint %d, one per line.",
788 if (readline_begin_hook)
789 (*readline_begin_hook) ("%s %s\n", tmpbuf, end_msg);
790 else if (input_from_terminal_p ())
791 printf_filtered ("%s\n%s\n", tmpbuf, end_msg);
795 t->step_count = 0; /* read_actions may set this */
798 if (readline_end_hook)
799 (*readline_end_hook) ();
800 /* tracepoints_changed () */
802 /* else just return */
805 /* worker function */
807 read_actions (struct tracepoint *t)
810 char *prompt1 = "> ", *prompt2 = " > ";
811 char *prompt = prompt1;
812 enum actionline_type linetype;
813 extern FILE *instream;
814 struct action_line *next = NULL, *temp;
815 struct cleanup *old_chain;
817 /* Control-C quits instantly if typed while in this loop
818 since it should not wait until the user types a newline. */
820 /* FIXME: kettenis/20010823: Something is wrong here. In this file
821 STOP_SIGNAL is never defined. So this code has been left out, at
822 least for quite a while now. Replacing STOP_SIGNAL with SIGTSTP
823 leads to compilation failures since the variable job_control
824 isn't declared. Leave this alone for now. */
829 signal (STOP_SIGNAL, handle_stop_sig);
831 signal (STOP_SIGNAL, stop_sig);
834 old_chain = make_cleanup_free_actions (t);
837 /* Make sure that all output has been output. Some machines may let
838 you get away with leaving out some of the gdb_flush, but not all. */
840 gdb_flush (gdb_stdout);
841 gdb_flush (gdb_stderr);
843 if (readline_hook && instream == NULL)
844 line = (*readline_hook) (prompt);
845 else if (instream == stdin && ISATTY (instream))
847 line = gdb_readline_wrapper (prompt);
848 if (line && *line) /* add it to command history */
852 line = gdb_readline (0);
854 linetype = validate_actionline (&line, t);
855 if (linetype == BADLINE)
856 continue; /* already warned -- collect another line */
858 temp = xmalloc (sizeof (struct action_line));
862 if (next == NULL) /* first action for this tracepoint? */
863 t->actions = next = temp;
870 if (linetype == STEPPING) /* begin "while-stepping" */
872 if (prompt == prompt2)
874 warning ("Already processing 'while-stepping'");
878 prompt = prompt2; /* change prompt for stepping actions */
880 else if (linetype == END)
882 if (prompt == prompt2)
884 prompt = prompt1; /* end of single-stepping actions */
887 { /* end of actions */
888 if (t->actions->next == NULL)
890 /* an "end" all by itself with no other actions means
891 this tracepoint has no actions. Discard empty list. */
900 signal (STOP_SIGNAL, SIG_DFL);
903 discard_cleanups (old_chain);
906 /* worker function */
908 validate_actionline (char **line, struct tracepoint *t)
910 struct cmd_list_element *c;
911 struct expression *exp = NULL;
912 struct cleanup *old_chain = NULL;
915 for (p = *line; isspace ((int) *p);)
918 /* symbol lookup etc. */
919 if (*p == '\0') /* empty line: just prompt for another line. */
922 if (*p == '#') /* comment line */
925 c = lookup_cmd (&p, cmdlist, "", -1, 1);
928 warning ("'%s' is not an action that I know, or is ambiguous.", p);
932 if (cmd_cfunc_eq (c, collect_pseudocommand))
934 struct agent_expr *aexpr;
935 struct agent_reqs areqs;
938 { /* repeat over a comma-separated list */
939 QUIT; /* allow user to bail out with ^C */
940 while (isspace ((int) *p))
943 if (*p == '$') /* look for special pseudo-symbols */
945 if ((0 == strncasecmp ("reg", p + 1, 3)) ||
946 (0 == strncasecmp ("arg", p + 1, 3)) ||
947 (0 == strncasecmp ("loc", p + 1, 3)))
952 /* else fall thru, treat p as an expression and parse it! */
954 exp = parse_exp_1 (&p, block_for_pc (t->address), 1);
955 old_chain = make_cleanup (free_current_contents, &exp);
957 if (exp->elts[0].opcode == OP_VAR_VALUE)
959 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
961 warning ("constant %s (value %ld) will not be collected.",
962 SYMBOL_NAME (exp->elts[2].symbol),
963 SYMBOL_VALUE (exp->elts[2].symbol));
966 else if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_OPTIMIZED_OUT)
968 warning ("%s is optimized away and cannot be collected.",
969 SYMBOL_NAME (exp->elts[2].symbol));
974 /* we have something to collect, make sure that the expr to
975 bytecode translator can handle it and that it's not too long */
976 aexpr = gen_trace_for_expr (t->address, exp);
977 make_cleanup_free_agent_expr (aexpr);
979 if (aexpr->len > MAX_AGENT_EXPR_LEN)
980 error ("expression too complicated, try simplifying");
982 ax_reqs (aexpr, &areqs);
983 (void) make_cleanup (xfree, areqs.reg_mask);
985 if (areqs.flaw != agent_flaw_none)
986 error ("malformed expression");
988 if (areqs.min_height < 0)
989 error ("gdb: Internal error: expression has min height < 0");
991 if (areqs.max_height > 20)
992 error ("expression too complicated, try simplifying");
994 do_cleanups (old_chain);
996 while (p && *p++ == ',');
999 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
1001 char *steparg; /* in case warning is necessary */
1003 while (isspace ((int) *p))
1008 (t->step_count = strtol (p, &p, 0)) == 0)
1010 warning ("'%s': bad step-count; command ignored.", *line);
1015 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
1019 warning ("'%s' is not a supported tracepoint action.", *line);
1024 /* worker function */
1026 free_actions (struct tracepoint *t)
1028 struct action_line *line, *next;
1030 for (line = t->actions; line; line = next)
1034 xfree (line->action);
1041 do_free_actions_cleanup (void *t)
1046 static struct cleanup *
1047 make_cleanup_free_actions (struct tracepoint *t)
1049 return make_cleanup (do_free_actions_cleanup, t);
1054 int type; /* 0 for absolute memory range, else basereg number */
1055 bfd_signed_vma start;
1059 struct collection_list
1061 unsigned char regs_mask[8]; /* room for up to 256 regs */
1064 struct memrange *list;
1065 long aexpr_listsize; /* size of array pointed to by expr_list elt */
1066 long next_aexpr_elt;
1067 struct agent_expr **aexpr_list;
1070 tracepoint_list, stepping_list;
1072 /* MEMRANGE functions: */
1074 static int memrange_cmp (const void *, const void *);
1076 /* compare memranges for qsort */
1078 memrange_cmp (const void *va, const void *vb)
1080 const struct memrange *a = va, *b = vb;
1082 if (a->type < b->type)
1084 if (a->type > b->type)
1088 if ((bfd_vma) a->start < (bfd_vma) b->start)
1090 if ((bfd_vma) a->start > (bfd_vma) b->start)
1095 if (a->start < b->start)
1097 if (a->start > b->start)
1103 /* Sort the memrange list using qsort, and merge adjacent memranges */
1105 memrange_sortmerge (struct collection_list *memranges)
1109 qsort (memranges->list, memranges->next_memrange,
1110 sizeof (struct memrange), memrange_cmp);
1111 if (memranges->next_memrange > 0)
1113 for (a = 0, b = 1; b < memranges->next_memrange; b++)
1115 if (memranges->list[a].type == memranges->list[b].type &&
1116 memranges->list[b].start - memranges->list[a].end <=
1117 MAX_REGISTER_VIRTUAL_SIZE)
1119 /* memrange b starts before memrange a ends; merge them. */
1120 if (memranges->list[b].end > memranges->list[a].end)
1121 memranges->list[a].end = memranges->list[b].end;
1122 continue; /* next b, same a */
1126 memcpy (&memranges->list[a], &memranges->list[b],
1127 sizeof (struct memrange));
1129 memranges->next_memrange = a + 1;
1133 /* Add a register to a collection list */
1135 add_register (struct collection_list *collection, unsigned int regno)
1138 printf_filtered ("collect register %d\n", regno);
1139 if (regno > (8 * sizeof (collection->regs_mask)))
1140 error ("Internal: register number %d too large for tracepoint",
1142 collection->regs_mask[regno / 8] |= 1 << (regno % 8);
1145 /* Add a memrange to a collection list */
1147 add_memrange (struct collection_list *memranges, int type, bfd_signed_vma base,
1152 printf_filtered ("(%d,", type);
1154 printf_filtered (",%ld)\n", len);
1157 /* type: 0 == memory, n == basereg */
1158 memranges->list[memranges->next_memrange].type = type;
1159 /* base: addr if memory, offset if reg relative. */
1160 memranges->list[memranges->next_memrange].start = base;
1161 /* len: we actually save end (base + len) for convenience */
1162 memranges->list[memranges->next_memrange].end = base + len;
1163 memranges->next_memrange++;
1164 if (memranges->next_memrange >= memranges->listsize)
1166 memranges->listsize *= 2;
1167 memranges->list = xrealloc (memranges->list,
1168 memranges->listsize);
1171 if (type != -1) /* better collect the base register! */
1172 add_register (memranges, type);
1175 /* Add a symbol to a collection list */
1177 collect_symbol (struct collection_list *collect, struct symbol *sym,
1178 long frame_regno, long frame_offset)
1182 bfd_signed_vma offset;
1184 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
1185 switch (SYMBOL_CLASS (sym))
1188 printf_filtered ("%s: don't know symbol class %d\n",
1189 SYMBOL_NAME (sym), SYMBOL_CLASS (sym));
1192 printf_filtered ("constant %s (value %ld) will not be collected.\n",
1193 SYMBOL_NAME (sym), SYMBOL_VALUE (sym));
1196 offset = SYMBOL_VALUE_ADDRESS (sym);
1201 sprintf_vma (tmp, offset);
1202 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1203 SYMBOL_NAME (sym), len, tmp /* address */);
1205 add_memrange (collect, -1, offset, len); /* 0 == memory */
1209 reg = SYMBOL_VALUE (sym);
1211 printf_filtered ("LOC_REG[parm] %s: ", SYMBOL_NAME (sym));
1212 add_register (collect, reg);
1213 /* check for doubles stored in two registers */
1214 /* FIXME: how about larger types stored in 3 or more regs? */
1215 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
1216 len > REGISTER_RAW_SIZE (reg))
1217 add_register (collect, reg + 1);
1220 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1221 printf_filtered (" (will not collect %s)\n",
1226 offset = frame_offset + SYMBOL_VALUE (sym);
1229 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1230 SYMBOL_NAME (sym), len);
1231 printf_vma (offset);
1232 printf_filtered (" from frame ptr reg %d\n", reg);
1234 add_memrange (collect, reg, offset, len);
1236 case LOC_REGPARM_ADDR:
1237 reg = SYMBOL_VALUE (sym);
1241 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1242 SYMBOL_NAME (sym), len);
1243 printf_vma (offset);
1244 printf_filtered (" from reg %d\n", reg);
1246 add_memrange (collect, reg, offset, len);
1251 offset = frame_offset + SYMBOL_VALUE (sym);
1254 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1255 SYMBOL_NAME (sym), len);
1256 printf_vma (offset);
1257 printf_filtered (" from frame ptr reg %d\n", reg);
1259 add_memrange (collect, reg, offset, len);
1262 case LOC_BASEREG_ARG:
1263 reg = SYMBOL_BASEREG (sym);
1264 offset = SYMBOL_VALUE (sym);
1267 printf_filtered ("LOC_BASEREG %s: collect %ld bytes at offset ",
1268 SYMBOL_NAME (sym), len);
1269 printf_vma (offset);
1270 printf_filtered (" from basereg %d\n", reg);
1272 add_memrange (collect, reg, offset, len);
1274 case LOC_UNRESOLVED:
1275 printf_filtered ("Don't know LOC_UNRESOLVED %s\n", SYMBOL_NAME (sym));
1277 case LOC_OPTIMIZED_OUT:
1278 printf_filtered ("%s has been optimized out of existence.\n",
1284 /* Add all locals (or args) symbols to collection list */
1286 add_local_symbols (struct collection_list *collect, CORE_ADDR pc,
1287 long frame_regno, long frame_offset, int type)
1290 struct block *block;
1293 block = block_for_pc (pc);
1296 QUIT; /* allow user to bail out with ^C */
1297 ALL_BLOCK_SYMBOLS (block, i, sym)
1299 switch (SYMBOL_CLASS (sym))
1302 warning ("don't know how to trace local symbol %s",
1308 if (type == 'L') /* collecting Locals */
1311 collect_symbol (collect, sym, frame_regno, frame_offset);
1318 case LOC_REGPARM_ADDR:
1319 case LOC_BASEREG_ARG:
1320 if (type == 'A') /* collecting Arguments */
1323 collect_symbol (collect, sym, frame_regno, frame_offset);
1327 if (BLOCK_FUNCTION (block))
1330 block = BLOCK_SUPERBLOCK (block);
1333 warning ("No %s found in scope.", type == 'L' ? "locals" : "args");
1336 /* worker function */
1338 clear_collection_list (struct collection_list *list)
1342 list->next_memrange = 0;
1343 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1345 free_agent_expr (list->aexpr_list[ndx]);
1346 list->aexpr_list[ndx] = NULL;
1348 list->next_aexpr_elt = 0;
1349 memset (list->regs_mask, 0, sizeof (list->regs_mask));
1352 /* reduce a collection list to string form (for gdb protocol) */
1354 stringify_collection_list (struct collection_list *list, char *string)
1356 char temp_buf[2048];
1360 char *(*str_list)[];
1364 count = 1 + list->next_memrange + list->next_aexpr_elt + 1;
1365 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1367 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1368 if (list->regs_mask[i] != 0) /* skip leading zeroes in regs_mask */
1370 if (list->regs_mask[i] != 0) /* prepare to send regs_mask to the stub */
1373 printf_filtered ("\nCollecting registers (mask): 0x");
1378 QUIT; /* allow user to bail out with ^C */
1380 printf_filtered ("%02X", list->regs_mask[i]);
1381 sprintf (end, "%02X", list->regs_mask[i]);
1384 (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
1388 printf_filtered ("\n");
1389 if (list->next_memrange > 0 && info_verbose)
1390 printf_filtered ("Collecting memranges: \n");
1391 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1393 QUIT; /* allow user to bail out with ^C */
1394 sprintf_vma (tmp2, list->list[i].start);
1397 printf_filtered ("(%d, %s, %ld)\n",
1400 (long) (list->list[i].end - list->list[i].start));
1402 if (count + 27 > MAX_AGENT_EXPR_LEN)
1404 (*str_list)[ndx] = savestring (temp_buf, count);
1410 sprintf (end, "M%X,%s,%lX",
1413 (long) (list->list[i].end - list->list[i].start));
1415 count += strlen (end);
1419 for (i = 0; i < list->next_aexpr_elt; i++)
1421 QUIT; /* allow user to bail out with ^C */
1422 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1424 (*str_list)[ndx] = savestring (temp_buf, count);
1429 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1430 end += 10; /* 'X' + 8 hex digits + ',' */
1433 end = mem2hex (list->aexpr_list[i]->buf, end, list->aexpr_list[i]->len);
1434 count += 2 * list->aexpr_list[i]->len;
1439 (*str_list)[ndx] = savestring (temp_buf, count);
1444 (*str_list)[ndx] = NULL;
1453 free_actions_list_cleanup_wrapper (void *al)
1455 free_actions_list (al);
1459 free_actions_list (char **actions_list)
1463 if (actions_list == 0)
1466 for (ndx = 0; actions_list[ndx]; ndx++)
1467 xfree (actions_list[ndx]);
1469 xfree (actions_list);
1472 /* render all actions into gdb protocol */
1474 encode_actions (struct tracepoint *t, char ***tdp_actions,
1475 char ***stepping_actions)
1477 static char tdp_buff[2048], step_buff[2048];
1479 struct expression *exp = NULL;
1480 struct action_line *action;
1482 struct value *tempval;
1483 struct collection_list *collect;
1484 struct cmd_list_element *cmd;
1485 struct agent_expr *aexpr;
1487 LONGEST frame_offset;
1490 clear_collection_list (&tracepoint_list);
1491 clear_collection_list (&stepping_list);
1492 collect = &tracepoint_list;
1494 *tdp_actions = NULL;
1495 *stepping_actions = NULL;
1497 TARGET_VIRTUAL_FRAME_POINTER (t->address, &frame_reg, &frame_offset);
1499 for (action = t->actions; action; action = action->next)
1501 QUIT; /* allow user to bail out with ^C */
1502 action_exp = action->action;
1503 while (isspace ((int) *action_exp))
1506 if (*action_exp == '#') /* comment line */
1509 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1511 error ("Bad action list item: %s", action_exp);
1513 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1516 { /* repeat over a comma-separated list */
1517 QUIT; /* allow user to bail out with ^C */
1518 while (isspace ((int) *action_exp))
1521 if (0 == strncasecmp ("$reg", action_exp, 4))
1523 for (i = 0; i < NUM_REGS; i++)
1524 add_register (collect, i);
1525 action_exp = strchr (action_exp, ','); /* more? */
1527 else if (0 == strncasecmp ("$arg", action_exp, 4))
1529 add_local_symbols (collect,
1534 action_exp = strchr (action_exp, ','); /* more? */
1536 else if (0 == strncasecmp ("$loc", action_exp, 4))
1538 add_local_symbols (collect,
1543 action_exp = strchr (action_exp, ','); /* more? */
1547 unsigned long addr, len;
1548 struct cleanup *old_chain = NULL;
1549 struct cleanup *old_chain1 = NULL;
1550 struct agent_reqs areqs;
1552 exp = parse_exp_1 (&action_exp,
1553 block_for_pc (t->address), 1);
1554 old_chain = make_cleanup (free_current_contents, &exp);
1556 switch (exp->elts[0].opcode)
1559 i = exp->elts[1].longconst;
1561 printf_filtered ("OP_REGISTER: ");
1562 add_register (collect, i);
1566 /* safe because we know it's a simple expression */
1567 tempval = evaluate_expression (exp);
1568 addr = VALUE_ADDRESS (tempval) + VALUE_OFFSET (tempval);
1569 len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
1570 add_memrange (collect, -1, addr, len);
1574 collect_symbol (collect,
1575 exp->elts[2].symbol,
1580 default: /* full-fledged expression */
1581 aexpr = gen_trace_for_expr (t->address, exp);
1583 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1585 ax_reqs (aexpr, &areqs);
1586 if (areqs.flaw != agent_flaw_none)
1587 error ("malformed expression");
1589 if (areqs.min_height < 0)
1590 error ("gdb: Internal error: expression has min height < 0");
1591 if (areqs.max_height > 20)
1592 error ("expression too complicated, try simplifying");
1594 discard_cleanups (old_chain1);
1595 add_aexpr (collect, aexpr);
1597 /* take care of the registers */
1598 if (areqs.reg_mask_len > 0)
1603 for (ndx1 = 0; ndx1 < areqs.reg_mask_len; ndx1++)
1605 QUIT; /* allow user to bail out with ^C */
1606 if (areqs.reg_mask[ndx1] != 0)
1608 /* assume chars have 8 bits */
1609 for (ndx2 = 0; ndx2 < 8; ndx2++)
1610 if (areqs.reg_mask[ndx1] & (1 << ndx2))
1611 /* it's used -- record it */
1612 add_register (collect, ndx1 * 8 + ndx2);
1618 do_cleanups (old_chain);
1621 while (action_exp && *action_exp++ == ',');
1623 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1625 collect = &stepping_list;
1627 else if (cmd_cfunc_eq (cmd, end_actions_pseudocommand))
1629 if (collect == &stepping_list) /* end stepping actions */
1630 collect = &tracepoint_list;
1632 break; /* end tracepoint actions */
1635 memrange_sortmerge (&tracepoint_list);
1636 memrange_sortmerge (&stepping_list);
1638 *tdp_actions = stringify_collection_list (&tracepoint_list, tdp_buff);
1639 *stepping_actions = stringify_collection_list (&stepping_list, step_buff);
1643 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1645 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1647 collect->aexpr_list =
1648 xrealloc (collect->aexpr_list,
1649 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1650 collect->aexpr_listsize *= 2;
1652 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1653 collect->next_aexpr_elt++;
1656 static char target_buf[2048];
1658 /* Set "transparent" memory ranges
1660 Allow trace mechanism to treat text-like sections
1661 (and perhaps all read-only sections) transparently,
1662 i.e. don't reject memory requests from these address ranges
1663 just because they haven't been collected. */
1666 remote_set_transparent_ranges (void)
1668 extern bfd *exec_bfd;
1675 return; /* no information to give. */
1677 strcpy (target_buf, "QTro");
1678 for (s = exec_bfd->sections; s; s = s->next)
1680 char tmp1[40], tmp2[40];
1682 if ((s->flags & SEC_LOAD) == 0 ||
1683 /* (s->flags & SEC_CODE) == 0 || */
1684 (s->flags & SEC_READONLY) == 0)
1689 size = bfd_get_section_size_before_reloc (s);
1690 sprintf_vma (tmp1, lma);
1691 sprintf_vma (tmp2, lma + size);
1692 sprintf (target_buf + strlen (target_buf),
1693 ":%s,%s", tmp1, tmp2);
1697 putpkt (target_buf);
1698 getpkt (target_buf, sizeof (target_buf), 0);
1704 Tell target to clear any previous trace experiment.
1705 Walk the list of tracepoints, and send them (and their actions)
1706 to the target. If no errors,
1707 Tell target to start a new trace experiment. */
1710 trace_start_command (char *args, int from_tty)
1711 { /* STUB_COMM MOSTLY_IMPLEMENTED */
1712 struct tracepoint *t;
1715 char **stepping_actions;
1717 struct cleanup *old_chain = NULL;
1719 dont_repeat (); /* like "run", dangerous to repeat accidentally */
1721 if (target_is_remote ())
1724 remote_get_noisy_reply (target_buf, sizeof (target_buf));
1725 if (strcmp (target_buf, "OK"))
1726 error ("Target does not support this command.");
1732 sprintf_vma (tmp, t->address);
1733 sprintf (buf, "QTDP:%x:%s:%c:%lx:%x", t->number, tmp, /* address */
1734 t->enabled_p ? 'E' : 'D',
1735 t->step_count, t->pass_count);
1740 remote_get_noisy_reply (target_buf, sizeof (target_buf));
1741 if (strcmp (target_buf, "OK"))
1742 error ("Target does not support tracepoints.");
1746 encode_actions (t, &tdp_actions, &stepping_actions);
1747 old_chain = make_cleanup (free_actions_list_cleanup_wrapper,
1749 (void) make_cleanup (free_actions_list_cleanup_wrapper,
1752 /* do_single_steps (t); */
1755 for (ndx = 0; tdp_actions[ndx]; ndx++)
1757 QUIT; /* allow user to bail out with ^C */
1758 sprintf (buf, "QTDP:-%x:%s:%s%c",
1759 t->number, tmp, /* address */
1761 ((tdp_actions[ndx + 1] || stepping_actions)
1764 remote_get_noisy_reply (target_buf, sizeof (target_buf));
1765 if (strcmp (target_buf, "OK"))
1766 error ("Error on target while setting tracepoints.");
1769 if (stepping_actions)
1771 for (ndx = 0; stepping_actions[ndx]; ndx++)
1773 QUIT; /* allow user to bail out with ^C */
1774 sprintf (buf, "QTDP:-%x:%s:%s%s%s",
1775 t->number, tmp, /* address */
1776 ((ndx == 0) ? "S" : ""),
1777 stepping_actions[ndx],
1778 (stepping_actions[ndx + 1] ? "-" : ""));
1780 remote_get_noisy_reply (target_buf, sizeof (target_buf));
1781 if (strcmp (target_buf, "OK"))
1782 error ("Error on target while setting tracepoints.");
1786 do_cleanups (old_chain);
1789 /* Tell target to treat text-like sections as transparent */
1790 remote_set_transparent_ranges ();
1791 /* Now insert traps and begin collecting data */
1793 remote_get_noisy_reply (target_buf, sizeof (target_buf));
1794 if (strcmp (target_buf, "OK"))
1795 error ("Bogus reply from target: %s", target_buf);
1796 set_traceframe_num (-1); /* all old traceframes invalidated */
1797 set_tracepoint_num (-1);
1798 set_traceframe_context (-1);
1799 trace_running_p = 1;
1800 if (trace_start_stop_hook)
1801 trace_start_stop_hook (1, from_tty);
1805 error ("Trace can only be run on remote targets.");
1810 trace_stop_command (char *args, int from_tty)
1811 { /* STUB_COMM IS_IMPLEMENTED */
1812 if (target_is_remote ())
1815 remote_get_noisy_reply (target_buf, sizeof (target_buf));
1816 if (strcmp (target_buf, "OK"))
1817 error ("Bogus reply from target: %s", target_buf);
1818 trace_running_p = 0;
1819 if (trace_start_stop_hook)
1820 trace_start_stop_hook (0, from_tty);
1823 error ("Trace can only be run on remote targets.");
1826 unsigned long trace_running_p;
1828 /* tstatus command */
1830 trace_status_command (char *args, int from_tty)
1831 { /* STUB_COMM IS_IMPLEMENTED */
1832 if (target_is_remote ())
1834 putpkt ("qTStatus");
1835 remote_get_noisy_reply (target_buf, sizeof (target_buf));
1837 if (target_buf[0] != 'T' ||
1838 (target_buf[1] != '0' && target_buf[1] != '1'))
1839 error ("Bogus reply from target: %s", target_buf);
1841 /* exported for use by the GUI */
1842 trace_running_p = (target_buf[1] == '1');
1845 error ("Trace can only be run on remote targets.");
1848 /* Worker function for the various flavors of the tfind command */
1850 finish_tfind_command (char *msg,
1854 int target_frameno = -1, target_tracept = -1;
1855 CORE_ADDR old_frame_addr;
1856 struct symbol *old_func;
1859 old_frame_addr = get_frame_base (get_current_frame ());
1860 old_func = find_pc_function (read_pc ());
1863 reply = remote_get_noisy_reply (msg, sizeof_msg);
1865 while (reply && *reply)
1869 if ((target_frameno = (int) strtol (++reply, &reply, 16)) == -1)
1871 /* A request for a non-existant trace frame has failed.
1872 Our response will be different, depending on FROM_TTY:
1874 If FROM_TTY is true, meaning that this command was
1875 typed interactively by the user, then give an error
1876 and DO NOT change the state of traceframe_number etc.
1878 However if FROM_TTY is false, meaning that we're either
1879 in a script, a loop, or a user-defined command, then
1880 DON'T give an error, but DO change the state of
1881 traceframe_number etc. to invalid.
1883 The rationalle is that if you typed the command, you
1884 might just have committed a typo or something, and you'd
1885 like to NOT lose your current debugging state. However
1886 if you're in a user-defined command or especially in a
1887 loop, then you need a way to detect that the command
1888 failed WITHOUT aborting. This allows you to write
1889 scripts that search thru the trace buffer until the end,
1890 and then continue on to do something else. */
1893 error ("Target failed to find requested trace frame.");
1897 printf_filtered ("End of trace buffer.\n");
1898 /* The following will not recurse, since it's special-cased */
1899 trace_find_command ("-1", from_tty);
1900 reply = NULL; /* break out of loop,
1901 (avoid recursive nonsense) */
1906 if ((target_tracept = (int) strtol (++reply, &reply, 16)) == -1)
1907 error ("Target failed to find requested trace frame.");
1909 case 'O': /* "OK"? */
1910 if (reply[1] == 'K' && reply[2] == '\0')
1913 error ("Bogus reply from target: %s", reply);
1916 error ("Bogus reply from target: %s", reply);
1919 flush_cached_frames ();
1920 registers_changed ();
1921 select_frame (get_current_frame ());
1922 set_traceframe_num (target_frameno);
1923 set_tracepoint_num (target_tracept);
1924 if (target_frameno == -1)
1925 set_traceframe_context (-1);
1927 set_traceframe_context (read_pc ());
1933 /* NOTE: in immitation of the step command, try to determine
1934 whether we have made a transition from one function to another.
1935 If so, we'll print the "stack frame" (ie. the new function and
1936 it's arguments) -- otherwise we'll just show the new source line.
1938 This determination is made by checking (1) whether the current
1939 function has changed, and (2) whether the current FP has changed.
1940 Hack: if the FP wasn't collected, either at the current or the
1941 previous frame, assume that the FP has NOT changed. */
1943 if (old_func == find_pc_function (read_pc ()) &&
1944 (old_frame_addr == 0 ||
1945 get_frame_base (get_current_frame ()) == 0 ||
1946 old_frame_addr == get_frame_base (get_current_frame ())))
1951 print_stack_frame (deprecated_selected_frame,
1952 frame_relative_level (deprecated_selected_frame),
1958 /* trace_find_command takes a trace frame number n,
1959 sends "QTFrame:<n>" to the target,
1960 and accepts a reply that may contain several optional pieces
1961 of information: a frame number, a tracepoint number, and an
1962 indication of whether this is a trap frame or a stepping frame.
1964 The minimal response is just "OK" (which indicates that the
1965 target does not give us a frame number or a tracepoint number).
1966 Instead of that, the target may send us a string containing
1968 F<hexnum> (gives the selected frame number)
1969 T<hexnum> (gives the selected tracepoint number)
1974 trace_find_command (char *args, int from_tty)
1975 { /* STUB_COMM PART_IMPLEMENTED */
1976 /* this should only be called with a numeric argument */
1979 if (target_is_remote ())
1981 if (trace_find_hook)
1982 trace_find_hook (args, from_tty);
1984 if (args == 0 || *args == 0)
1985 { /* TFIND with no args means find NEXT trace frame. */
1986 if (traceframe_number == -1)
1987 frameno = 0; /* "next" is first one */
1989 frameno = traceframe_number + 1;
1991 else if (0 == strcmp (args, "-"))
1993 if (traceframe_number == -1)
1994 error ("not debugging trace buffer");
1995 else if (from_tty && traceframe_number == 0)
1996 error ("already at start of trace buffer");
1998 frameno = traceframe_number - 1;
2001 frameno = parse_and_eval_long (args);
2004 error ("invalid input (%d is less than zero)", frameno);
2006 sprintf (target_buf, "QTFrame:%x", frameno);
2007 finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
2010 error ("Trace can only be run on remote targets.");
2015 trace_find_end_command (char *args, int from_tty)
2017 trace_find_command ("-1", from_tty);
2022 trace_find_none_command (char *args, int from_tty)
2024 trace_find_command ("-1", from_tty);
2029 trace_find_start_command (char *args, int from_tty)
2031 trace_find_command ("0", from_tty);
2034 /* tfind pc command */
2036 trace_find_pc_command (char *args, int from_tty)
2037 { /* STUB_COMM PART_IMPLEMENTED */
2041 if (target_is_remote ())
2043 if (args == 0 || *args == 0)
2044 pc = read_pc (); /* default is current pc */
2046 pc = parse_and_eval_address (args);
2048 sprintf_vma (tmp, pc);
2049 sprintf (target_buf, "QTFrame:pc:%s", tmp);
2050 finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
2053 error ("Trace can only be run on remote targets.");
2056 /* tfind tracepoint command */
2058 trace_find_tracepoint_command (char *args, int from_tty)
2059 { /* STUB_COMM PART_IMPLEMENTED */
2062 if (target_is_remote ())
2064 if (args == 0 || *args == 0)
2066 if (tracepoint_number == -1)
2067 error ("No current tracepoint -- please supply an argument.");
2069 tdp = tracepoint_number; /* default is current TDP */
2072 tdp = parse_and_eval_long (args);
2074 sprintf (target_buf, "QTFrame:tdp:%x", tdp);
2075 finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
2078 error ("Trace can only be run on remote targets.");
2081 /* TFIND LINE command:
2083 This command will take a sourceline for argument, just like BREAK
2084 or TRACE (ie. anything that "decode_line_1" can handle).
2086 With no argument, this command will find the next trace frame
2087 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2090 trace_find_line_command (char *args, int from_tty)
2091 { /* STUB_COMM PART_IMPLEMENTED */
2092 static CORE_ADDR start_pc, end_pc;
2093 struct symtabs_and_lines sals;
2094 struct symtab_and_line sal;
2095 struct cleanup *old_chain;
2096 char startpc_str[40], endpc_str[40];
2098 if (target_is_remote ())
2100 if (args == 0 || *args == 0)
2102 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2104 sals.sals = (struct symtab_and_line *)
2105 xmalloc (sizeof (struct symtab_and_line));
2110 sals = decode_line_spec (args, 1);
2114 old_chain = make_cleanup (xfree, sals.sals);
2115 if (sal.symtab == 0)
2117 printf_filtered ("TFIND: No line number information available");
2120 /* This is useful for "info line *0x7f34". If we can't tell the
2121 user about a source line, at least let them have the symbolic
2123 printf_filtered (" for address ");
2125 print_address (sal.pc, gdb_stdout);
2126 printf_filtered (";\n -- will attempt to find by PC. \n");
2130 printf_filtered (".\n");
2131 return; /* no line, no PC; what can we do? */
2134 else if (sal.line > 0
2135 && find_line_pc_range (sal, &start_pc, &end_pc))
2137 if (start_pc == end_pc)
2139 printf_filtered ("Line %d of \"%s\"",
2140 sal.line, sal.symtab->filename);
2142 printf_filtered (" is at address ");
2143 print_address (start_pc, gdb_stdout);
2145 printf_filtered (" but contains no code.\n");
2146 sal = find_pc_line (start_pc, 0);
2148 find_line_pc_range (sal, &start_pc, &end_pc) &&
2150 printf_filtered ("Attempting to find line %d instead.\n",
2153 error ("Cannot find a good line.");
2157 /* Is there any case in which we get here, and have an address
2158 which the user would want to see? If we have debugging symbols
2159 and no line numbers? */
2160 error ("Line number %d is out of range for \"%s\".\n",
2161 sal.line, sal.symtab->filename);
2163 sprintf_vma (startpc_str, start_pc);
2164 sprintf_vma (endpc_str, end_pc - 1);
2165 if (args && *args) /* find within range of stated line */
2166 sprintf (target_buf, "QTFrame:range:%s:%s", startpc_str, endpc_str);
2167 else /* find OUTSIDE OF range of CURRENT line */
2168 sprintf (target_buf, "QTFrame:outside:%s:%s", startpc_str, endpc_str);
2169 finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
2170 do_cleanups (old_chain);
2173 error ("Trace can only be run on remote targets.");
2176 /* tfind range command */
2178 trace_find_range_command (char *args, int from_tty)
2180 static CORE_ADDR start, stop;
2181 char start_str[40], stop_str[40];
2184 if (target_is_remote ())
2186 if (args == 0 || *args == 0)
2187 { /* XXX FIXME: what should default behavior be? */
2188 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2192 if (0 != (tmp = strchr (args, ',')))
2194 *tmp++ = '\0'; /* terminate start address */
2195 while (isspace ((int) *tmp))
2197 start = parse_and_eval_address (args);
2198 stop = parse_and_eval_address (tmp);
2201 { /* no explicit end address? */
2202 start = parse_and_eval_address (args);
2203 stop = start + 1; /* ??? */
2206 sprintf_vma (start_str, start);
2207 sprintf_vma (stop_str, stop);
2208 sprintf (target_buf, "QTFrame:range:%s:%s", start_str, stop_str);
2209 finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
2212 error ("Trace can only be run on remote targets.");
2215 /* tfind outside command */
2217 trace_find_outside_command (char *args, int from_tty)
2219 CORE_ADDR start, stop;
2220 char start_str[40], stop_str[40];
2223 if (target_is_remote ())
2225 if (args == 0 || *args == 0)
2226 { /* XXX FIXME: what should default behavior be? */
2227 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2231 if (0 != (tmp = strchr (args, ',')))
2233 *tmp++ = '\0'; /* terminate start address */
2234 while (isspace ((int) *tmp))
2236 start = parse_and_eval_address (args);
2237 stop = parse_and_eval_address (tmp);
2240 { /* no explicit end address? */
2241 start = parse_and_eval_address (args);
2242 stop = start + 1; /* ??? */
2245 sprintf_vma (start_str, start);
2246 sprintf_vma (stop_str, stop);
2247 sprintf (target_buf, "QTFrame:outside:%s:%s", start_str, stop_str);
2248 finish_tfind_command (target_buf, sizeof (target_buf), from_tty);
2251 error ("Trace can only be run on remote targets.");
2254 /* save-tracepoints command */
2256 tracepoint_save_command (char *args, int from_tty)
2258 struct tracepoint *tp;
2259 struct action_line *line;
2261 char *i1 = " ", *i2 = " ";
2262 char *indent, *actionline, *pathname;
2265 if (args == 0 || *args == 0)
2266 error ("Argument required (file name in which to save tracepoints");
2268 if (tracepoint_chain == 0)
2270 warning ("save-tracepoints: no tracepoints to save.\n");
2274 pathname = tilde_expand (args);
2275 if (!(fp = fopen (pathname, "w")))
2276 error ("Unable to open file '%s' for saving tracepoints (%s)",
2277 args, safe_strerror (errno));
2280 ALL_TRACEPOINTS (tp)
2282 if (tp->addr_string)
2283 fprintf (fp, "trace %s\n", tp->addr_string);
2286 sprintf_vma (tmp, tp->address);
2287 fprintf (fp, "trace *0x%s\n", tmp);
2291 fprintf (fp, " passcount %d\n", tp->pass_count);
2295 fprintf (fp, " actions\n");
2297 for (line = tp->actions; line; line = line->next)
2299 struct cmd_list_element *cmd;
2301 QUIT; /* allow user to bail out with ^C */
2302 actionline = line->action;
2303 while (isspace ((int) *actionline))
2306 fprintf (fp, "%s%s\n", indent, actionline);
2307 if (*actionline != '#') /* skip for comment lines */
2309 cmd = lookup_cmd (&actionline, cmdlist, "", -1, 1);
2311 error ("Bad action list item: %s", actionline);
2312 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2314 else if (cmd_cfunc_eq (cmd, end_actions_pseudocommand))
2322 printf_filtered ("Tracepoints saved to file '%s'.\n", args);
2326 /* info scope command: list the locals for a scope. */
2328 scope_info (char *args, int from_tty)
2330 struct symtabs_and_lines sals;
2332 struct minimal_symbol *msym;
2333 struct block *block;
2334 char **canonical, *symname, *save_args = args;
2335 int i, j, count = 0;
2337 if (args == 0 || *args == 0)
2338 error ("requires an argument (function, line or *addr) to define a scope");
2340 sals = decode_line_1 (&args, 1, NULL, 0, &canonical);
2341 if (sals.nelts == 0)
2342 return; /* presumably decode_line_1 has already warned */
2344 /* Resolve line numbers to PC */
2345 resolve_sal_pc (&sals.sals[0]);
2346 block = block_for_pc (sals.sals[0].pc);
2350 QUIT; /* allow user to bail out with ^C */
2351 ALL_BLOCK_SYMBOLS (block, i, sym)
2353 QUIT; /* allow user to bail out with ^C */
2355 printf_filtered ("Scope for %s:\n", save_args);
2358 symname = SYMBOL_NAME (sym);
2359 if (symname == NULL || *symname == '\0')
2360 continue; /* probably botched, certainly useless */
2362 printf_filtered ("Symbol %s is ", symname);
2363 switch (SYMBOL_CLASS (sym))
2366 case LOC_UNDEF: /* messed up symbol? */
2367 printf_filtered ("a bogus symbol, class %d.\n",
2368 SYMBOL_CLASS (sym));
2369 count--; /* don't count this one */
2372 printf_filtered ("a constant with value %ld (0x%lx)",
2373 SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
2375 case LOC_CONST_BYTES:
2376 printf_filtered ("constant bytes: ");
2377 if (SYMBOL_TYPE (sym))
2378 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2379 fprintf_filtered (gdb_stdout, " %02x",
2380 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2383 printf_filtered ("in static storage at address ");
2384 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
2387 printf_filtered ("a local variable in register $%s",
2388 REGISTER_NAME (SYMBOL_VALUE (sym)));
2392 printf_filtered ("an argument at stack/frame offset %ld",
2393 SYMBOL_VALUE (sym));
2396 printf_filtered ("a local variable at frame offset %ld",
2397 SYMBOL_VALUE (sym));
2400 printf_filtered ("a reference argument at offset %ld",
2401 SYMBOL_VALUE (sym));
2404 printf_filtered ("an argument in register $%s",
2405 REGISTER_NAME (SYMBOL_VALUE (sym)));
2407 case LOC_REGPARM_ADDR:
2408 printf_filtered ("the address of an argument, in register $%s",
2409 REGISTER_NAME (SYMBOL_VALUE (sym)));
2412 printf_filtered ("a typedef.\n");
2415 printf_filtered ("a label at address ");
2416 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, gdb_stdout);
2419 printf_filtered ("a function at address ");
2420 print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)), 1,
2424 printf_filtered ("a variable at offset %ld from register $%s",
2426 REGISTER_NAME (SYMBOL_BASEREG (sym)));
2428 case LOC_BASEREG_ARG:
2429 printf_filtered ("an argument at offset %ld from register $%s",
2431 REGISTER_NAME (SYMBOL_BASEREG (sym)));
2433 case LOC_UNRESOLVED:
2434 msym = lookup_minimal_symbol (SYMBOL_NAME (sym), NULL, NULL);
2436 printf_filtered ("Unresolved Static");
2439 printf_filtered ("static storage at address ");
2440 print_address_numeric (SYMBOL_VALUE_ADDRESS (msym), 1,
2444 case LOC_OPTIMIZED_OUT:
2445 printf_filtered ("optimized out.\n");
2448 if (SYMBOL_TYPE (sym))
2449 printf_filtered (", length %d.\n",
2450 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2452 if (BLOCK_FUNCTION (block))
2455 block = BLOCK_SUPERBLOCK (block);
2458 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2462 /* worker function (cleanup) */
2464 replace_comma (void *data)
2472 trace_dump_command (char *args, int from_tty)
2474 struct tracepoint *t;
2475 struct action_line *action;
2476 char *action_exp, *next_comma;
2477 struct cleanup *old_cleanups;
2478 int stepping_actions = 0;
2479 int stepping_frame = 0;
2481 if (!target_is_remote ())
2483 error ("Trace can only be run on remote targets.");
2487 if (tracepoint_number == -1)
2489 warning ("No current trace frame.");
2494 if (t->number == tracepoint_number)
2498 error ("No known tracepoint matches 'current' tracepoint #%d.",
2501 old_cleanups = make_cleanup (null_cleanup, NULL);
2503 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2504 tracepoint_number, traceframe_number);
2506 /* The current frame is a trap frame if the frame PC is equal
2507 to the tracepoint PC. If not, then the current frame was
2508 collected during single-stepping. */
2510 stepping_frame = (t->address != read_pc ());
2512 for (action = t->actions; action; action = action->next)
2514 struct cmd_list_element *cmd;
2516 QUIT; /* allow user to bail out with ^C */
2517 action_exp = action->action;
2518 while (isspace ((int) *action_exp))
2521 /* The collection actions to be done while stepping are
2522 bracketed by the commands "while-stepping" and "end". */
2524 if (*action_exp == '#') /* comment line */
2527 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2529 error ("Bad action list item: %s", action_exp);
2531 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2532 stepping_actions = 1;
2533 else if (cmd_cfunc_eq (cmd, end_actions_pseudocommand))
2534 stepping_actions = 0;
2535 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2537 /* Display the collected data.
2538 For the trap frame, display only what was collected at the trap.
2539 Likewise for stepping frames, display only what was collected
2540 while stepping. This means that the two boolean variables,
2541 STEPPING_FRAME and STEPPING_ACTIONS should be equal. */
2542 if (stepping_frame == stepping_actions)
2545 { /* repeat over a comma-separated list */
2546 QUIT; /* allow user to bail out with ^C */
2547 if (*action_exp == ',')
2549 while (isspace ((int) *action_exp))
2552 next_comma = strchr (action_exp, ',');
2554 if (0 == strncasecmp (action_exp, "$reg", 4))
2555 registers_info (NULL, from_tty);
2556 else if (0 == strncasecmp (action_exp, "$loc", 4))
2557 locals_info (NULL, from_tty);
2558 else if (0 == strncasecmp (action_exp, "$arg", 4))
2559 args_info (NULL, from_tty);
2564 make_cleanup (replace_comma, next_comma);
2567 printf_filtered ("%s = ", action_exp);
2568 output_command (action_exp, from_tty);
2569 printf_filtered ("\n");
2573 action_exp = next_comma;
2575 while (action_exp && *action_exp == ',');
2579 discard_cleanups (old_cleanups);
2582 /* Convert the memory pointed to by mem into hex, placing result in buf.
2583 * Return a pointer to the last char put in buf (null)
2584 * "stolen" from sparc-stub.c
2587 static const char hexchars[] = "0123456789abcdef";
2589 static unsigned char *
2590 mem2hex (unsigned char *mem, unsigned char *buf, int count)
2598 *buf++ = hexchars[ch >> 4];
2599 *buf++ = hexchars[ch & 0xf];
2608 get_traceframe_number (void)
2610 return traceframe_number;
2614 /* module initialization */
2616 _initialize_tracepoint (void)
2618 struct cmd_list_element *c;
2620 tracepoint_chain = 0;
2621 tracepoint_count = 0;
2622 traceframe_number = -1;
2623 tracepoint_number = -1;
2625 set_internalvar (lookup_internalvar ("tpnum"),
2626 value_from_longest (builtin_type_int, (LONGEST) 0));
2627 set_internalvar (lookup_internalvar ("trace_frame"),
2628 value_from_longest (builtin_type_int, (LONGEST) - 1));
2630 if (tracepoint_list.list == NULL)
2632 tracepoint_list.listsize = 128;
2633 tracepoint_list.list = xmalloc
2634 (tracepoint_list.listsize * sizeof (struct memrange));
2636 if (tracepoint_list.aexpr_list == NULL)
2638 tracepoint_list.aexpr_listsize = 128;
2639 tracepoint_list.aexpr_list = xmalloc
2640 (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
2643 if (stepping_list.list == NULL)
2645 stepping_list.listsize = 128;
2646 stepping_list.list = xmalloc
2647 (stepping_list.listsize * sizeof (struct memrange));
2650 if (stepping_list.aexpr_list == NULL)
2652 stepping_list.aexpr_listsize = 128;
2653 stepping_list.aexpr_list = xmalloc
2654 (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
2657 add_info ("scope", scope_info,
2658 "List the variables local to a scope");
2660 add_cmd ("tracepoints", class_trace, NULL,
2661 "Tracing of program execution without stopping the program.",
2664 add_info ("tracepoints", tracepoints_info,
2665 "Status of tracepoints, or tracepoint number NUMBER.\n\
2666 Convenience variable \"$tpnum\" contains the number of the\n\
2667 last tracepoint set.");
2669 add_info_alias ("tp", "tracepoints", 1);
2671 c = add_com ("save-tracepoints", class_trace, tracepoint_save_command,
2672 "Save current tracepoint definitions as a script.\n\
2673 Use the 'source' command in another debug session to restore them.");
2674 set_cmd_completer (c, filename_completer);
2676 add_com ("tdump", class_trace, trace_dump_command,
2677 "Print everything collected at the current tracepoint.");
2679 add_prefix_cmd ("tfind", class_trace, trace_find_command,
2680 "Select a trace frame;\n\
2681 No argument means forward by one frame; '-' meand backward by one frame.",
2682 &tfindlist, "tfind ", 1, &cmdlist);
2684 add_cmd ("outside", class_trace, trace_find_outside_command,
2685 "Select a trace frame whose PC is outside the given \
2686 range.\nUsage: tfind outside addr1, addr2",
2689 add_cmd ("range", class_trace, trace_find_range_command,
2690 "Select a trace frame whose PC is in the given range.\n\
2691 Usage: tfind range addr1,addr2",
2694 add_cmd ("line", class_trace, trace_find_line_command,
2695 "Select a trace frame by source line.\n\
2696 Argument can be a line number (with optional source file), \n\
2697 a function name, or '*' followed by an address.\n\
2698 Default argument is 'the next source line that was traced'.",
2701 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command,
2702 "Select a trace frame by tracepoint number.\n\
2703 Default is the tracepoint for the current trace frame.",
2706 add_cmd ("pc", class_trace, trace_find_pc_command,
2707 "Select a trace frame by PC.\n\
2708 Default is the current PC, or the PC of the current trace frame.",
2711 add_cmd ("end", class_trace, trace_find_end_command,
2712 "Synonym for 'none'.\n\
2713 De-select any trace frame and resume 'live' debugging.",
2716 add_cmd ("none", class_trace, trace_find_none_command,
2717 "De-select any trace frame and resume 'live' debugging.",
2720 add_cmd ("start", class_trace, trace_find_start_command,
2721 "Select the first trace frame in the trace buffer.",
2724 add_com ("tstatus", class_trace, trace_status_command,
2725 "Display the status of the current trace data collection.");
2727 add_com ("tstop", class_trace, trace_stop_command,
2728 "Stop trace data collection.");
2730 add_com ("tstart", class_trace, trace_start_command,
2731 "Start trace data collection.");
2733 add_com ("passcount", class_trace, trace_pass_command,
2734 "Set the passcount for a tracepoint.\n\
2735 The trace will end when the tracepoint has been passed 'count' times.\n\
2736 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
2737 if TPNUM is omitted, passcount refers to the last tracepoint defined.");
2739 add_com ("end", class_trace, end_actions_pseudocommand,
2740 "Ends a list of commands or actions.\n\
2741 Several GDB commands allow you to enter a list of commands or actions.\n\
2742 Entering \"end\" on a line by itself is the normal way to terminate\n\
2744 Note: the \"end\" command cannot be used at the gdb prompt.");
2746 add_com ("while-stepping", class_trace, while_stepping_pseudocommand,
2747 "Specify single-stepping behavior at a tracepoint.\n\
2748 Argument is number of instructions to trace in single-step mode\n\
2749 following the tracepoint. This command is normally followed by\n\
2750 one or more \"collect\" commands, to specify what to collect\n\
2751 while single-stepping.\n\n\
2752 Note: this command can only be used in a tracepoint \"actions\" list.");
2754 add_com_alias ("ws", "while-stepping", class_alias, 0);
2755 add_com_alias ("stepping", "while-stepping", class_alias, 0);
2757 add_com ("collect", class_trace, collect_pseudocommand,
2758 "Specify one or more data items to be collected at a tracepoint.\n\
2759 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
2760 collect all data (variables, registers) referenced by that expression.\n\
2761 Also accepts the following special arguments:\n\
2762 $regs -- all registers.\n\
2763 $args -- all function arguments.\n\
2764 $locals -- all variables local to the block/function scope.\n\
2765 Note: this command can only be used in a tracepoint \"actions\" list.");
2767 add_com ("actions", class_trace, trace_actions_command,
2768 "Specify the actions to be taken at a tracepoint.\n\
2769 Tracepoint actions may include collecting of specified data, \n\
2770 single-stepping, or enabling/disabling other tracepoints, \n\
2771 depending on target's capabilities.");
2773 add_cmd ("tracepoints", class_trace, delete_trace_command,
2774 "Delete specified tracepoints.\n\
2775 Arguments are tracepoint numbers, separated by spaces.\n\
2776 No argument means delete all tracepoints.",
2779 add_cmd ("tracepoints", class_trace, disable_trace_command,
2780 "Disable specified tracepoints.\n\
2781 Arguments are tracepoint numbers, separated by spaces.\n\
2782 No argument means disable all tracepoints.",
2785 add_cmd ("tracepoints", class_trace, enable_trace_command,
2786 "Enable specified tracepoints.\n\
2787 Arguments are tracepoint numbers, separated by spaces.\n\
2788 No argument means enable all tracepoints.",
2791 c = add_com ("trace", class_trace, trace_command,
2792 "Set a tracepoint at a specified line or function or address.\n\
2793 Argument may be a line number, function name, or '*' plus an address.\n\
2794 For a line number or function, trace at the start of its code.\n\
2795 If an address is specified, trace at that exact address.\n\n\
2796 Do \"help tracepoints\" for info on other tracepoint commands.");
2797 set_cmd_completer (c, location_completer);
2799 add_com_alias ("tp", "trace", class_alias, 0);
2800 add_com_alias ("tr", "trace", class_alias, 1);
2801 add_com_alias ("tra", "trace", class_alias, 1);
2802 add_com_alias ("trac", "trace", class_alias, 1);