1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
4 2007, 2008 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "expression.h"
30 #include "gdb_string.h"
32 #include "tracepoint.h"
36 #include "completer.h"
38 #include "dictionary.h"
40 #include "user-regs.h"
45 /* readline include files */
46 #include "readline/readline.h"
47 #include "readline/history.h"
49 /* readline defines this. */
56 /* Maximum length of an agent aexpression.
57 This accounts for the fact that packets are limited to 400 bytes
58 (which includes everything -- including the checksum), and assumes
59 the worst case of maximum length for each of the pieces of a
62 NOTE: expressions get mem2hex'ed otherwise this would be twice as
63 large. (400 - 31)/2 == 184 */
64 #define MAX_AGENT_EXPR_LEN 184
67 extern void (*deprecated_readline_begin_hook
) (char *, ...);
68 extern char *(*deprecated_readline_hook
) (char *);
69 extern void (*deprecated_readline_end_hook
) (void);
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 char *mem2hex (gdb_byte
*, 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
166 || strcmp (current_target
.to_shortname
, "extended-remote") == 0))
172 /* Utility: generate error from an incoming stub packet. */
174 trace_error (char *buf
)
177 return; /* not an error msg */
180 case '1': /* malformed packet error */
181 if (*++buf
== '0') /* general case: */
182 error (_("tracepoint.c: error in outgoing packet."));
184 error (_("tracepoint.c: error in outgoing packet at field #%ld."),
185 strtol (buf
, NULL
, 16));
187 error (_("trace API error 0x%s."), ++buf
);
189 error (_("Target returns error code '%s'."), buf
);
193 /* Utility: wait for reply from stub, while accepting "O" packets. */
195 remote_get_noisy_reply (char **buf_p
,
198 do /* Loop on reply from remote stub. */
201 QUIT
; /* allow user to bail out with ^C */
202 getpkt (buf_p
, sizeof_buf
, 0);
205 error (_("Target does not support this command."));
206 else if (buf
[0] == 'E')
208 else if (buf
[0] == 'O' &&
210 remote_console_output (buf
+ 1); /* 'O' message from stub */
212 return buf
; /* here's the actual reply */
217 /* Set tracepoint count to NUM. */
219 set_tracepoint_count (int num
)
221 tracepoint_count
= num
;
222 set_internalvar (lookup_internalvar ("tpnum"),
223 value_from_longest (builtin_type_int32
, (LONGEST
) num
));
226 /* Set traceframe number to NUM. */
228 set_traceframe_num (int num
)
230 traceframe_number
= num
;
231 set_internalvar (lookup_internalvar ("trace_frame"),
232 value_from_longest (builtin_type_int32
, (LONGEST
) num
));
235 /* Set tracepoint number to NUM. */
237 set_tracepoint_num (int num
)
239 tracepoint_number
= num
;
240 set_internalvar (lookup_internalvar ("tracepoint"),
241 value_from_longest (builtin_type_int32
, (LONGEST
) num
));
244 /* Set externally visible debug variables for querying/printing
245 the traceframe context (line, function, file) */
248 set_traceframe_context (CORE_ADDR trace_pc
)
250 static struct type
*func_string
, *file_string
;
251 static struct type
*func_range
, *file_range
;
252 struct value
*func_val
;
253 struct value
*file_val
;
256 if (trace_pc
== -1) /* Cease debugging any trace buffers. */
259 traceframe_sal
.pc
= traceframe_sal
.line
= 0;
260 traceframe_sal
.symtab
= NULL
;
261 set_internalvar (lookup_internalvar ("trace_func"),
262 allocate_value (builtin_type_void
));
263 set_internalvar (lookup_internalvar ("trace_file"),
264 allocate_value (builtin_type_void
));
265 set_internalvar (lookup_internalvar ("trace_line"),
266 value_from_longest (builtin_type_int32
,
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
277 set_internalvar (lookup_internalvar ("trace_line"),
278 value_from_longest (builtin_type_int32
,
279 (LONGEST
) traceframe_sal
.line
));
281 /* Save func name as "$trace_func", a debugger variable visible to
283 if (traceframe_fun
== NULL
||
284 SYMBOL_LINKAGE_NAME (traceframe_fun
) == NULL
)
285 set_internalvar (lookup_internalvar ("trace_func"),
286 allocate_value (builtin_type_void
));
289 len
= strlen (SYMBOL_LINKAGE_NAME (traceframe_fun
));
290 func_range
= create_range_type (func_range
,
291 builtin_type_int32
, 0, len
- 1);
292 func_string
= create_array_type (func_string
,
293 builtin_type_true_char
, func_range
);
294 func_val
= allocate_value (func_string
);
295 deprecated_set_value_type (func_val
, func_string
);
296 memcpy (value_contents_raw (func_val
),
297 SYMBOL_LINKAGE_NAME (traceframe_fun
),
299 deprecated_set_value_modifiable (func_val
, 0);
300 set_internalvar (lookup_internalvar ("trace_func"), func_val
);
303 /* Save file name as "$trace_file", a debugger variable visible to
305 if (traceframe_sal
.symtab
== NULL
||
306 traceframe_sal
.symtab
->filename
== NULL
)
307 set_internalvar (lookup_internalvar ("trace_file"),
308 allocate_value (builtin_type_void
));
311 len
= strlen (traceframe_sal
.symtab
->filename
);
312 file_range
= create_range_type (file_range
,
313 builtin_type_int32
, 0, len
- 1);
314 file_string
= create_array_type (file_string
,
315 builtin_type_true_char
, file_range
);
316 file_val
= allocate_value (file_string
);
317 deprecated_set_value_type (file_val
, file_string
);
318 memcpy (value_contents_raw (file_val
),
319 traceframe_sal
.symtab
->filename
,
321 deprecated_set_value_modifiable (file_val
, 0);
322 set_internalvar (lookup_internalvar ("trace_file"), file_val
);
326 /* Low level routine to set a tracepoint.
327 Returns the tracepoint object so caller can set other things.
328 Does not set the tracepoint number!
329 Does not print anything.
331 ==> This routine should not be called if there is a chance of later
332 error(); otherwise it leaves a bogus tracepoint on the chain.
333 Validate your arguments BEFORE calling this routine! */
335 static struct tracepoint
*
336 set_raw_tracepoint (struct symtab_and_line sal
)
338 struct tracepoint
*t
, *tc
;
339 struct cleanup
*old_chain
;
341 t
= (struct tracepoint
*) xmalloc (sizeof (struct tracepoint
));
342 old_chain
= make_cleanup (xfree
, t
);
343 memset (t
, 0, sizeof (*t
));
345 if (sal
.symtab
== NULL
)
346 t
->source_file
= NULL
;
348 t
->source_file
= savestring (sal
.symtab
->filename
,
349 strlen (sal
.symtab
->filename
));
351 t
->section
= sal
.section
;
352 t
->language
= current_language
->la_language
;
353 t
->input_radix
= input_radix
;
354 t
->line_number
= sal
.line
;
359 t
->addr_string
= NULL
;
361 /* Add this tracepoint to the end of the chain
362 so that a list of tracepoints will come out in order
363 of increasing numbers. */
365 tc
= tracepoint_chain
;
367 tracepoint_chain
= t
;
374 discard_cleanups (old_chain
);
378 /* Set a tracepoint according to ARG (function, linenum or *address). */
380 trace_command (char *arg
, int from_tty
)
382 char **canonical
= (char **) NULL
;
383 struct symtabs_and_lines sals
;
384 struct symtab_and_line sal
;
385 struct tracepoint
*t
;
386 char *addr_start
= 0, *addr_end
= 0;
390 error (_("trace command requires an argument"));
392 if (from_tty
&& info_verbose
)
393 printf_filtered ("TRACE %s\n", arg
);
396 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
397 0, &canonical
, NULL
);
400 return; /* ??? Presumably decode_line_1 has already warned? */
402 /* Resolve all line numbers to PC's */
403 for (i
= 0; i
< sals
.nelts
; i
++)
404 resolve_sal_pc (&sals
.sals
[i
]);
406 /* Now set all the tracepoints. */
407 for (i
= 0; i
< sals
.nelts
; i
++)
411 t
= set_raw_tracepoint (sal
);
412 set_tracepoint_count (tracepoint_count
+ 1);
413 t
->number
= tracepoint_count
;
415 /* If a canonical line spec is needed use that instead of the
417 if (canonical
!= (char **) NULL
&& canonical
[i
] != NULL
)
418 t
->addr_string
= canonical
[i
];
420 t
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
427 printf_filtered ("Multiple tracepoints were set.\n");
428 printf_filtered ("Use 'delete trace' to delete unwanted tracepoints.\n");
432 /* Tell the user we have just set a tracepoint TP. */
435 trace_mention (struct tracepoint
*tp
)
437 printf_filtered ("Tracepoint %d", tp
->number
);
439 if (addressprint
|| (tp
->source_file
== NULL
))
441 printf_filtered (" at ");
442 printf_filtered ("%s", paddress (tp
->address
));
445 printf_filtered (": file %s, line %d.",
446 tp
->source_file
, tp
->line_number
);
448 printf_filtered ("\n");
451 /* Print information on tracepoint number TPNUM_EXP, or all if
455 tracepoints_info (char *tpnum_exp
, int from_tty
)
457 struct tracepoint
*t
;
458 struct action_line
*action
;
459 int found_a_tracepoint
= 0;
460 char wrap_indent
[80];
465 tpnum
= parse_and_eval_long (tpnum_exp
);
468 if (tpnum
== -1 || tpnum
== t
->number
)
470 extern int addressprint
; /* Print machine addresses? */
472 if (!found_a_tracepoint
++)
474 printf_filtered ("Num Enb ");
477 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
478 printf_filtered ("Address ");
480 printf_filtered ("Address ");
482 printf_filtered ("PassC StepC What\n");
484 strcpy (wrap_indent
, " ");
487 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
488 strcat (wrap_indent
, " ");
490 strcat (wrap_indent
, " ");
493 printf_filtered ("%-3d %-3s ", t
->number
,
494 t
->enabled_p
? "y" : "n");
499 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
500 tmp
= hex_string_custom (t
->address
& (CORE_ADDR
) 0xffffffff,
503 tmp
= hex_string_custom (t
->address
, 16);
505 printf_filtered ("%s ", tmp
);
507 printf_filtered ("%-5d %-5ld ", t
->pass_count
, t
->step_count
);
511 sym
= find_pc_sect_function (t
->address
, t
->section
);
514 fputs_filtered ("in ", gdb_stdout
);
515 fputs_filtered (SYMBOL_PRINT_NAME (sym
), gdb_stdout
);
516 wrap_here (wrap_indent
);
517 fputs_filtered (" at ", gdb_stdout
);
519 fputs_filtered (t
->source_file
, gdb_stdout
);
520 printf_filtered (":%d", t
->line_number
);
523 print_address_symbolic (t
->address
, gdb_stdout
, demangle
, " ");
525 printf_filtered ("\n");
528 printf_filtered (" Actions for tracepoint %d: \n", t
->number
);
529 for (action
= t
->actions
; action
; action
= action
->next
)
531 printf_filtered ("\t%s\n", action
->action
);
535 if (!found_a_tracepoint
)
538 printf_filtered ("No tracepoints.\n");
540 printf_filtered ("No tracepoint number %d.\n", tpnum
);
544 /* Optimization: the code to parse an enable, disable, or delete TP
545 command is virtually identical except for whether it performs an
546 enable, disable, or delete. Therefore I've combined them into one
547 function with an opcode. */
548 enum tracepoint_opcode
555 /* This function implements enable, disable and delete commands. */
557 tracepoint_operation (struct tracepoint
*t
, int from_tty
,
558 enum tracepoint_opcode opcode
)
560 struct tracepoint
*t2
;
562 if (t
== NULL
) /* no tracepoint operand */
569 observer_notify_tracepoint_modified (t
->number
);
573 observer_notify_tracepoint_modified (t
->number
);
576 if (tracepoint_chain
== t
)
577 tracepoint_chain
= t
->next
;
586 observer_notify_tracepoint_deleted (t
->number
);
589 xfree (t
->addr_string
);
591 xfree (t
->source_file
);
600 /* Utility: parse a tracepoint number and look it up in the list.
601 If MULTI_P is true, there might be a range of tracepoints in ARG.
602 if OPTIONAL_P is true, then if the argument is missing, the most
603 recent tracepoint (tracepoint_count) is returned. */
605 get_tracepoint_by_number (char **arg
, int multi_p
, int optional_p
)
607 struct tracepoint
*t
;
609 char *instring
= arg
== NULL
? NULL
: *arg
;
611 if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
614 tpnum
= tracepoint_count
;
616 error_no_arg (_("tracepoint number"));
619 tpnum
= multi_p
? get_number_or_range (arg
) : get_number (arg
);
623 if (instring
&& *instring
)
624 printf_filtered ("bad tracepoint number at or near '%s'\n",
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
);
645 parse a list of tracepoint numbers, and call a func for each. */
647 map_args_over_tracepoints (char *args
, int from_tty
,
648 enum tracepoint_opcode opcode
)
650 struct tracepoint
*t
, *tmp
;
652 if (args
== 0 || *args
== 0) /* do them all */
653 ALL_TRACEPOINTS_SAFE (t
, tmp
)
654 tracepoint_operation (t
, from_tty
, opcode
);
658 QUIT
; /* Give user option to bail out with ^C. */
659 t
= get_tracepoint_by_number (&args
, 1, 0);
660 tracepoint_operation (t
, from_tty
, opcode
);
661 while (*args
== ' ' || *args
== '\t')
666 /* The 'enable trace' command enables tracepoints.
667 Not supported by all targets. */
669 enable_trace_command (char *args
, int from_tty
)
672 map_args_over_tracepoints (args
, from_tty
, enable_op
);
675 /* The 'disable trace' command disables tracepoints.
676 Not supported by all targets. */
678 disable_trace_command (char *args
, int from_tty
)
681 map_args_over_tracepoints (args
, from_tty
, disable_op
);
684 /* Remove a tracepoint (or all if no argument) */
686 delete_trace_command (char *args
, int from_tty
)
689 if (!args
|| !*args
) /* No args implies all tracepoints; */
690 if (from_tty
) /* confirm only if from_tty... */
691 if (tracepoint_chain
) /* and if there are tracepoints to
693 if (!query ("Delete all tracepoints? "))
696 map_args_over_tracepoints (args
, from_tty
, delete_op
);
699 /* Set passcount for tracepoint.
701 First command argument is passcount, second is tracepoint number.
702 If tracepoint number omitted, apply to most recently defined.
703 Also accepts special argument "all". */
706 trace_pass_command (char *args
, int from_tty
)
708 struct tracepoint
*t1
= (struct tracepoint
*) -1, *t2
;
712 if (args
== 0 || *args
== 0)
713 error (_("passcount command requires an argument (count + optional TP num)"));
715 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
717 while (*args
&& isspace ((int) *args
))
720 if (*args
&& strncasecmp (args
, "all", 3) == 0)
722 args
+= 3; /* Skip special argument "all". */
725 error (_("Junk at end of arguments."));
728 t1
= get_tracepoint_by_number (&args
, 1, 1);
735 if (t1
== (struct tracepoint
*) -1 || t1
== t2
)
737 t2
->pass_count
= count
;
738 observer_notify_tracepoint_modified (t2
->number
);
740 printf_filtered ("Setting tracepoint %d's passcount to %d\n",
744 t1
= get_tracepoint_by_number (&args
, 1, 0);
750 /* ACTIONS functions: */
752 /* Prototypes for action-parsing utility commands */
753 static void read_actions (struct tracepoint
*);
755 /* The three functions:
756 collect_pseudocommand,
757 while_stepping_pseudocommand, and
758 end_actions_pseudocommand
759 are placeholders for "commands" that are actually ONLY to be used
760 within a tracepoint action list. If the actual function is ever called,
761 it means that somebody issued the "command" at the top level,
762 which is always an error. */
765 end_actions_pseudocommand (char *args
, int from_tty
)
767 error (_("This command cannot be used at the top level."));
771 while_stepping_pseudocommand (char *args
, int from_tty
)
773 error (_("This command can only be used in a tracepoint actions list."));
777 collect_pseudocommand (char *args
, int from_tty
)
779 error (_("This command can only be used in a tracepoint actions list."));
782 /* Enter a list of actions for a tracepoint. */
784 trace_actions_command (char *args
, int from_tty
)
786 struct tracepoint
*t
;
788 char *end_msg
= "End with a line saying just \"end\".";
790 t
= get_tracepoint_by_number (&args
, 0, 1);
793 sprintf (tmpbuf
, "Enter actions for tracepoint %d, one per line.",
798 if (deprecated_readline_begin_hook
)
799 (*deprecated_readline_begin_hook
) ("%s %s\n", tmpbuf
, end_msg
);
800 else if (input_from_terminal_p ())
801 printf_filtered ("%s\n%s\n", tmpbuf
, end_msg
);
805 t
->step_count
= 0; /* read_actions may set this */
808 if (deprecated_readline_end_hook
)
809 (*deprecated_readline_end_hook
) ();
810 /* tracepoints_changed () */
812 /* else just return */
815 /* worker function */
817 read_actions (struct tracepoint
*t
)
820 char *prompt1
= "> ", *prompt2
= " > ";
821 char *prompt
= prompt1
;
822 enum actionline_type linetype
;
823 extern FILE *instream
;
824 struct action_line
*next
= NULL
, *temp
;
825 struct cleanup
*old_chain
;
827 /* Control-C quits instantly if typed while in this loop
828 since it should not wait until the user types a newline. */
830 /* FIXME: kettenis/20010823: Something is wrong here. In this file
831 STOP_SIGNAL is never defined. So this code has been left out, at
832 least for quite a while now. Replacing STOP_SIGNAL with SIGTSTP
833 leads to compilation failures since the variable job_control
834 isn't declared. Leave this alone for now. */
837 signal (STOP_SIGNAL
, handle_stop_sig
);
839 old_chain
= make_cleanup_free_actions (t
);
842 /* Make sure that all output has been output. Some machines may
843 let you get away with leaving out some of the gdb_flush, but
846 gdb_flush (gdb_stdout
);
847 gdb_flush (gdb_stderr
);
849 if (deprecated_readline_hook
&& instream
== NULL
)
850 line
= (*deprecated_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);
862 line
= xstrdup ("end");
863 printf_filtered ("end\n");
866 linetype
= validate_actionline (&line
, t
);
867 if (linetype
== BADLINE
)
868 continue; /* already warned -- collect another line */
870 temp
= xmalloc (sizeof (struct action_line
));
874 if (next
== NULL
) /* first action for this tracepoint? */
875 t
->actions
= next
= temp
;
882 if (linetype
== STEPPING
) /* begin "while-stepping" */
884 if (prompt
== prompt2
)
886 warning (_("Already processing 'while-stepping'"));
890 prompt
= prompt2
; /* change prompt for stepping actions */
892 else if (linetype
== END
)
894 if (prompt
== prompt2
)
896 prompt
= prompt1
; /* end of single-stepping actions */
899 { /* end of actions */
900 if (t
->actions
->next
== NULL
)
902 /* An "end" all by itself with no other actions
903 means this tracepoint has no actions.
904 Discard empty list. */
913 signal (STOP_SIGNAL
, SIG_DFL
);
916 discard_cleanups (old_chain
);
919 /* worker function */
921 validate_actionline (char **line
, struct tracepoint
*t
)
923 struct cmd_list_element
*c
;
924 struct expression
*exp
= NULL
;
925 struct cleanup
*old_chain
= NULL
;
928 /* if EOF is typed, *line is NULL */
932 for (p
= *line
; isspace ((int) *p
);)
935 /* Symbol lookup etc. */
936 if (*p
== '\0') /* empty line: just prompt for another line. */
939 if (*p
== '#') /* comment line */
942 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
945 warning (_("'%s' is not an action that I know, or is ambiguous."),
950 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
952 struct agent_expr
*aexpr
;
953 struct agent_reqs areqs
;
956 { /* repeat over a comma-separated list */
957 QUIT
; /* allow user to bail out with ^C */
958 while (isspace ((int) *p
))
961 if (*p
== '$') /* look for special pseudo-symbols */
963 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
964 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
965 (0 == strncasecmp ("loc", p
+ 1, 3)))
970 /* else fall thru, treat p as an expression and parse it! */
972 exp
= parse_exp_1 (&p
, block_for_pc (t
->address
), 1);
973 old_chain
= make_cleanup (free_current_contents
, &exp
);
975 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
977 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
979 warning (_("constant %s (value %ld) will not be collected."),
980 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
),
981 SYMBOL_VALUE (exp
->elts
[2].symbol
));
984 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
986 warning (_("%s is optimized away and cannot be collected."),
987 SYMBOL_PRINT_NAME (exp
->elts
[2].symbol
));
992 /* We have something to collect, make sure that the expr to
993 bytecode translator can handle it and that it's not too
995 aexpr
= gen_trace_for_expr (t
->address
, exp
);
996 make_cleanup_free_agent_expr (aexpr
);
998 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
999 error (_("expression too complicated, try simplifying"));
1001 ax_reqs (aexpr
, &areqs
);
1002 (void) make_cleanup (xfree
, areqs
.reg_mask
);
1004 if (areqs
.flaw
!= agent_flaw_none
)
1005 error (_("malformed expression"));
1007 if (areqs
.min_height
< 0)
1008 error (_("gdb: Internal error: expression has min height < 0"));
1010 if (areqs
.max_height
> 20)
1011 error (_("expression too complicated, try simplifying"));
1013 do_cleanups (old_chain
);
1015 while (p
&& *p
++ == ',');
1018 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
1020 char *steparg
; /* in case warning is necessary */
1022 while (isspace ((int) *p
))
1027 (t
->step_count
= strtol (p
, &p
, 0)) == 0)
1029 warning (_("'%s': bad step-count; command ignored."), *line
);
1034 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
1038 warning (_("'%s' is not a supported tracepoint action."), *line
);
1043 /* worker function */
1045 free_actions (struct tracepoint
*t
)
1047 struct action_line
*line
, *next
;
1049 for (line
= t
->actions
; line
; line
= next
)
1053 xfree (line
->action
);
1060 do_free_actions_cleanup (void *t
)
1065 static struct cleanup
*
1066 make_cleanup_free_actions (struct tracepoint
*t
)
1068 return make_cleanup (do_free_actions_cleanup
, t
);
1072 memrange_absolute
= -1
1077 int type
; /* memrange_absolute for absolute memory range,
1078 else basereg number */
1079 bfd_signed_vma start
;
1083 struct collection_list
1085 unsigned char regs_mask
[32]; /* room for up to 256 regs */
1088 struct memrange
*list
;
1089 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
1090 long next_aexpr_elt
;
1091 struct agent_expr
**aexpr_list
;
1094 tracepoint_list
, stepping_list
;
1096 /* MEMRANGE functions: */
1098 static int memrange_cmp (const void *, const void *);
1100 /* compare memranges for qsort */
1102 memrange_cmp (const void *va
, const void *vb
)
1104 const struct memrange
*a
= va
, *b
= vb
;
1106 if (a
->type
< b
->type
)
1108 if (a
->type
> b
->type
)
1110 if (a
->type
== memrange_absolute
)
1112 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
1114 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
1119 if (a
->start
< b
->start
)
1121 if (a
->start
> b
->start
)
1127 /* Sort the memrange list using qsort, and merge adjacent memranges. */
1129 memrange_sortmerge (struct collection_list
*memranges
)
1133 qsort (memranges
->list
, memranges
->next_memrange
,
1134 sizeof (struct memrange
), memrange_cmp
);
1135 if (memranges
->next_memrange
> 0)
1137 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
1139 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
1140 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
1143 /* memrange b starts before memrange a ends; merge them. */
1144 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
1145 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
1146 continue; /* next b, same a */
1150 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
1151 sizeof (struct memrange
));
1153 memranges
->next_memrange
= a
+ 1;
1157 /* Add a register to a collection list. */
1159 add_register (struct collection_list
*collection
, unsigned int regno
)
1162 printf_filtered ("collect register %d\n", regno
);
1163 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
1164 error (_("Internal: register number %d too large for tracepoint"),
1166 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
1169 /* Add a memrange to a collection list */
1171 add_memrange (struct collection_list
*memranges
,
1172 int type
, bfd_signed_vma base
,
1177 printf_filtered ("(%d,", type
);
1179 printf_filtered (",%ld)\n", len
);
1182 /* type: memrange_absolute == memory, other n == basereg */
1183 memranges
->list
[memranges
->next_memrange
].type
= type
;
1184 /* base: addr if memory, offset if reg relative. */
1185 memranges
->list
[memranges
->next_memrange
].start
= base
;
1186 /* len: we actually save end (base + len) for convenience */
1187 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
1188 memranges
->next_memrange
++;
1189 if (memranges
->next_memrange
>= memranges
->listsize
)
1191 memranges
->listsize
*= 2;
1192 memranges
->list
= xrealloc (memranges
->list
,
1193 memranges
->listsize
);
1196 if (type
!= memrange_absolute
) /* Better collect the base register! */
1197 add_register (memranges
, type
);
1200 /* Add a symbol to a collection list. */
1202 collect_symbol (struct collection_list
*collect
,
1204 long frame_regno
, long frame_offset
)
1208 bfd_signed_vma offset
;
1210 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
1211 switch (SYMBOL_CLASS (sym
))
1214 printf_filtered ("%s: don't know symbol class %d\n",
1215 SYMBOL_PRINT_NAME (sym
),
1216 SYMBOL_CLASS (sym
));
1219 printf_filtered ("constant %s (value %ld) will not be collected.\n",
1220 SYMBOL_PRINT_NAME (sym
), SYMBOL_VALUE (sym
));
1223 offset
= SYMBOL_VALUE_ADDRESS (sym
);
1228 sprintf_vma (tmp
, offset
);
1229 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1230 SYMBOL_PRINT_NAME (sym
), len
,
1233 add_memrange (collect
, memrange_absolute
, offset
, len
);
1236 reg
= SYMBOL_VALUE (sym
);
1238 printf_filtered ("LOC_REG[parm] %s: ",
1239 SYMBOL_PRINT_NAME (sym
));
1240 add_register (collect
, reg
);
1241 /* Check for doubles stored in two registers. */
1242 /* FIXME: how about larger types stored in 3 or more regs? */
1243 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1244 len
> register_size (current_gdbarch
, reg
))
1245 add_register (collect
, reg
+ 1);
1248 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1249 printf_filtered (" (will not collect %s)\n",
1250 SYMBOL_PRINT_NAME (sym
));
1254 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1257 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1258 SYMBOL_PRINT_NAME (sym
), len
);
1259 printf_vma (offset
);
1260 printf_filtered (" from frame ptr reg %d\n", reg
);
1262 add_memrange (collect
, reg
, offset
, len
);
1264 case LOC_REGPARM_ADDR
:
1265 reg
= SYMBOL_VALUE (sym
);
1269 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1270 SYMBOL_PRINT_NAME (sym
), len
);
1271 printf_vma (offset
);
1272 printf_filtered (" from reg %d\n", reg
);
1274 add_memrange (collect
, reg
, offset
, len
);
1278 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1281 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1282 SYMBOL_PRINT_NAME (sym
), len
);
1283 printf_vma (offset
);
1284 printf_filtered (" from frame ptr reg %d\n", reg
);
1286 add_memrange (collect
, reg
, offset
, len
);
1288 case LOC_UNRESOLVED
:
1289 printf_filtered ("Don't know LOC_UNRESOLVED %s\n",
1290 SYMBOL_PRINT_NAME (sym
));
1292 case LOC_OPTIMIZED_OUT
:
1293 printf_filtered ("%s has been optimized out of existence.\n",
1294 SYMBOL_PRINT_NAME (sym
));
1299 /* Add all locals (or args) symbols to collection list */
1301 add_local_symbols (struct collection_list
*collect
, CORE_ADDR pc
,
1302 long frame_regno
, long frame_offset
, int type
)
1305 struct block
*block
;
1306 struct dict_iterator iter
;
1309 block
= block_for_pc (pc
);
1312 QUIT
; /* allow user to bail out with ^C */
1313 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
1315 if (SYMBOL_IS_ARGUMENT (sym
)
1316 ? type
== 'A' /* collecting Arguments */
1317 : type
== 'L') /* collecting Locals */
1320 collect_symbol (collect
, sym
, frame_regno
,
1324 if (BLOCK_FUNCTION (block
))
1327 block
= BLOCK_SUPERBLOCK (block
);
1330 warning (_("No %s found in scope."),
1331 type
== 'L' ? "locals" : "args");
1334 /* worker function */
1336 clear_collection_list (struct collection_list
*list
)
1340 list
->next_memrange
= 0;
1341 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1343 free_agent_expr (list
->aexpr_list
[ndx
]);
1344 list
->aexpr_list
[ndx
] = NULL
;
1346 list
->next_aexpr_elt
= 0;
1347 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1350 /* reduce a collection list to string form (for gdb protocol) */
1352 stringify_collection_list (struct collection_list
*list
, char *string
)
1354 char temp_buf
[2048];
1358 char *(*str_list
)[];
1362 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1363 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1365 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1366 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1368 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1371 printf_filtered ("\nCollecting registers (mask): 0x");
1376 QUIT
; /* allow user to bail out with ^C */
1378 printf_filtered ("%02X", list
->regs_mask
[i
]);
1379 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1382 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1386 printf_filtered ("\n");
1387 if (list
->next_memrange
> 0 && info_verbose
)
1388 printf_filtered ("Collecting memranges: \n");
1389 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1391 QUIT
; /* allow user to bail out with ^C */
1392 sprintf_vma (tmp2
, list
->list
[i
].start
);
1395 printf_filtered ("(%d, %s, %ld)\n",
1398 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1400 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1402 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1409 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1411 /* The "%X" conversion specifier expects an unsigned argument,
1412 so passing -1 (memrange_absolute) to it directly gives you
1413 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1415 if (list
->list
[i
].type
== memrange_absolute
)
1416 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1418 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1421 count
+= strlen (end
);
1422 end
= temp_buf
+ count
;
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
,
1440 end
, list
->aexpr_list
[i
]->len
);
1441 count
+= 2 * list
->aexpr_list
[i
]->len
;
1446 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1451 (*str_list
)[ndx
] = NULL
;
1463 free_actions_list_cleanup_wrapper (void *al
)
1465 free_actions_list (al
);
1469 free_actions_list (char **actions_list
)
1473 if (actions_list
== 0)
1476 for (ndx
= 0; actions_list
[ndx
]; ndx
++)
1477 xfree (actions_list
[ndx
]);
1479 xfree (actions_list
);
1482 /* Render all actions into gdb protocol. */
1484 encode_actions (struct tracepoint
*t
, char ***tdp_actions
,
1485 char ***stepping_actions
)
1487 static char tdp_buff
[2048], step_buff
[2048];
1489 struct expression
*exp
= NULL
;
1490 struct action_line
*action
;
1492 struct value
*tempval
;
1493 struct collection_list
*collect
;
1494 struct cmd_list_element
*cmd
;
1495 struct agent_expr
*aexpr
;
1497 LONGEST frame_offset
;
1500 clear_collection_list (&tracepoint_list
);
1501 clear_collection_list (&stepping_list
);
1502 collect
= &tracepoint_list
;
1504 *tdp_actions
= NULL
;
1505 *stepping_actions
= NULL
;
1507 gdbarch_virtual_frame_pointer (current_gdbarch
,
1508 t
->address
, &frame_reg
, &frame_offset
);
1510 for (action
= t
->actions
; action
; action
= action
->next
)
1512 QUIT
; /* allow user to bail out with ^C */
1513 action_exp
= action
->action
;
1514 while (isspace ((int) *action_exp
))
1517 if (*action_exp
== '#') /* comment line */
1520 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1522 error (_("Bad action list item: %s"), action_exp
);
1524 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1527 { /* repeat over a comma-separated list */
1528 QUIT
; /* allow user to bail out with ^C */
1529 while (isspace ((int) *action_exp
))
1532 if (0 == strncasecmp ("$reg", action_exp
, 4))
1534 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
1535 add_register (collect
, i
);
1536 action_exp
= strchr (action_exp
, ','); /* more? */
1538 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1540 add_local_symbols (collect
,
1545 action_exp
= strchr (action_exp
, ','); /* more? */
1547 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1549 add_local_symbols (collect
,
1554 action_exp
= strchr (action_exp
, ','); /* more? */
1558 unsigned long addr
, len
;
1559 struct cleanup
*old_chain
= NULL
;
1560 struct cleanup
*old_chain1
= NULL
;
1561 struct agent_reqs areqs
;
1563 exp
= parse_exp_1 (&action_exp
,
1564 block_for_pc (t
->address
), 1);
1565 old_chain
= make_cleanup (free_current_contents
, &exp
);
1567 switch (exp
->elts
[0].opcode
)
1571 const char *name
= &exp
->elts
[2].string
;
1573 i
= user_reg_map_name_to_regnum (current_gdbarch
,
1574 name
, strlen (name
));
1576 internal_error (__FILE__
, __LINE__
,
1577 _("Register $%s not available"),
1580 printf_filtered ("OP_REGISTER: ");
1581 add_register (collect
, i
);
1586 /* safe because we know it's a simple expression */
1587 tempval
= evaluate_expression (exp
);
1588 addr
= VALUE_ADDRESS (tempval
) + value_offset (tempval
);
1589 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1590 add_memrange (collect
, memrange_absolute
, addr
, len
);
1594 collect_symbol (collect
,
1595 exp
->elts
[2].symbol
,
1600 default: /* full-fledged expression */
1601 aexpr
= gen_trace_for_expr (t
->address
, exp
);
1603 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1605 ax_reqs (aexpr
, &areqs
);
1606 if (areqs
.flaw
!= agent_flaw_none
)
1607 error (_("malformed expression"));
1609 if (areqs
.min_height
< 0)
1610 error (_("gdb: Internal error: expression has min height < 0"));
1611 if (areqs
.max_height
> 20)
1612 error (_("expression too complicated, try simplifying"));
1614 discard_cleanups (old_chain1
);
1615 add_aexpr (collect
, aexpr
);
1617 /* take care of the registers */
1618 if (areqs
.reg_mask_len
> 0)
1623 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1625 QUIT
; /* allow user to bail out with ^C */
1626 if (areqs
.reg_mask
[ndx1
] != 0)
1628 /* assume chars have 8 bits */
1629 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1630 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1631 /* it's used -- record it */
1632 add_register (collect
,
1639 do_cleanups (old_chain
);
1642 while (action_exp
&& *action_exp
++ == ',');
1644 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1646 collect
= &stepping_list
;
1648 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
1650 if (collect
== &stepping_list
) /* end stepping actions */
1651 collect
= &tracepoint_list
;
1653 break; /* end tracepoint actions */
1656 memrange_sortmerge (&tracepoint_list
);
1657 memrange_sortmerge (&stepping_list
);
1659 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1661 *stepping_actions
= stringify_collection_list (&stepping_list
,
1666 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1668 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1670 collect
->aexpr_list
=
1671 xrealloc (collect
->aexpr_list
,
1672 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1673 collect
->aexpr_listsize
*= 2;
1675 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1676 collect
->next_aexpr_elt
++;
1679 static char *target_buf
;
1680 static long target_buf_size
;
1682 /* Set "transparent" memory ranges
1684 Allow trace mechanism to treat text-like sections
1685 (and perhaps all read-only sections) transparently,
1686 i.e. don't reject memory requests from these address ranges
1687 just because they haven't been collected. */
1690 remote_set_transparent_ranges (void)
1692 extern bfd
*exec_bfd
;
1699 return; /* No information to give. */
1701 strcpy (target_buf
, "QTro");
1702 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
1704 char tmp1
[40], tmp2
[40];
1706 if ((s
->flags
& SEC_LOAD
) == 0 ||
1707 /* (s->flags & SEC_CODE) == 0 || */
1708 (s
->flags
& SEC_READONLY
) == 0)
1713 size
= bfd_get_section_size (s
);
1714 sprintf_vma (tmp1
, lma
);
1715 sprintf_vma (tmp2
, lma
+ size
);
1716 sprintf (target_buf
+ strlen (target_buf
),
1717 ":%s,%s", tmp1
, tmp2
);
1721 putpkt (target_buf
);
1722 getpkt (&target_buf
, &target_buf_size
, 0);
1728 Tell target to clear any previous trace experiment.
1729 Walk the list of tracepoints, and send them (and their actions)
1730 to the target. If no errors,
1731 Tell target to start a new trace experiment. */
1734 trace_start_command (char *args
, int from_tty
)
1736 struct tracepoint
*t
;
1739 char **stepping_actions
;
1741 struct cleanup
*old_chain
= NULL
;
1743 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1745 if (target_is_remote ())
1748 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1749 if (strcmp (target_buf
, "OK"))
1750 error (_("Target does not support this command."));
1756 sprintf_vma (tmp
, t
->address
);
1757 sprintf (buf
, "QTDP:%x:%s:%c:%lx:%x", t
->number
,
1759 t
->enabled_p
? 'E' : 'D',
1760 t
->step_count
, t
->pass_count
);
1765 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1766 if (strcmp (target_buf
, "OK"))
1767 error (_("Target does not support tracepoints."));
1771 encode_actions (t
, &tdp_actions
, &stepping_actions
);
1772 old_chain
= make_cleanup (free_actions_list_cleanup_wrapper
,
1774 (void) make_cleanup (free_actions_list_cleanup_wrapper
,
1777 /* do_single_steps (t); */
1780 for (ndx
= 0; tdp_actions
[ndx
]; ndx
++)
1782 QUIT
; /* allow user to bail out with ^C */
1783 sprintf (buf
, "QTDP:-%x:%s:%s%c",
1784 t
->number
, tmp
, /* address */
1786 ((tdp_actions
[ndx
+ 1] || stepping_actions
)
1789 remote_get_noisy_reply (&target_buf
,
1791 if (strcmp (target_buf
, "OK"))
1792 error (_("Error on target while setting tracepoints."));
1795 if (stepping_actions
)
1797 for (ndx
= 0; stepping_actions
[ndx
]; ndx
++)
1799 QUIT
; /* allow user to bail out with ^C */
1800 sprintf (buf
, "QTDP:-%x:%s:%s%s%s",
1801 t
->number
, tmp
, /* address */
1802 ((ndx
== 0) ? "S" : ""),
1803 stepping_actions
[ndx
],
1804 (stepping_actions
[ndx
+ 1] ? "-" : ""));
1806 remote_get_noisy_reply (&target_buf
,
1808 if (strcmp (target_buf
, "OK"))
1809 error (_("Error on target while setting tracepoints."));
1813 do_cleanups (old_chain
);
1816 /* Tell target to treat text-like sections as transparent. */
1817 remote_set_transparent_ranges ();
1818 /* Now insert traps and begin collecting data. */
1820 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1821 if (strcmp (target_buf
, "OK"))
1822 error (_("Bogus reply from target: %s"), target_buf
);
1823 set_traceframe_num (-1); /* All old traceframes invalidated. */
1824 set_tracepoint_num (-1);
1825 set_traceframe_context (-1);
1826 trace_running_p
= 1;
1827 if (deprecated_trace_start_stop_hook
)
1828 deprecated_trace_start_stop_hook (1, from_tty
);
1832 error (_("Trace can only be run on remote targets."));
1837 trace_stop_command (char *args
, int from_tty
)
1839 if (target_is_remote ())
1842 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1843 if (strcmp (target_buf
, "OK"))
1844 error (_("Bogus reply from target: %s"), target_buf
);
1845 trace_running_p
= 0;
1846 if (deprecated_trace_start_stop_hook
)
1847 deprecated_trace_start_stop_hook (0, from_tty
);
1850 error (_("Trace can only be run on remote targets."));
1853 unsigned long trace_running_p
;
1855 /* tstatus command */
1857 trace_status_command (char *args
, int from_tty
)
1859 if (target_is_remote ())
1861 putpkt ("qTStatus");
1862 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1864 if (target_buf
[0] != 'T' ||
1865 (target_buf
[1] != '0' && target_buf
[1] != '1'))
1866 error (_("Bogus reply from target: %s"), target_buf
);
1868 /* exported for use by the GUI */
1869 trace_running_p
= (target_buf
[1] == '1');
1872 error (_("Trace can only be run on remote targets."));
1875 /* Worker function for the various flavors of the tfind command. */
1877 finish_tfind_command (char **msg
,
1881 int target_frameno
= -1, target_tracept
= -1;
1882 CORE_ADDR old_frame_addr
;
1883 struct symbol
*old_func
;
1886 old_frame_addr
= get_frame_base (get_current_frame ());
1887 old_func
= find_pc_function (read_pc ());
1890 reply
= remote_get_noisy_reply (msg
, sizeof_msg
);
1892 while (reply
&& *reply
)
1896 if ((target_frameno
= (int) strtol (++reply
, &reply
, 16)) == -1)
1898 /* A request for a non-existant trace frame has failed.
1899 Our response will be different, depending on FROM_TTY:
1901 If FROM_TTY is true, meaning that this command was
1902 typed interactively by the user, then give an error
1903 and DO NOT change the state of traceframe_number etc.
1905 However if FROM_TTY is false, meaning that we're either
1906 in a script, a loop, or a user-defined command, then
1907 DON'T give an error, but DO change the state of
1908 traceframe_number etc. to invalid.
1910 The rationalle is that if you typed the command, you
1911 might just have committed a typo or something, and you'd
1912 like to NOT lose your current debugging state. However
1913 if you're in a user-defined command or especially in a
1914 loop, then you need a way to detect that the command
1915 failed WITHOUT aborting. This allows you to write
1916 scripts that search thru the trace buffer until the end,
1917 and then continue on to do something else. */
1920 error (_("Target failed to find requested trace frame."));
1924 printf_filtered ("End of trace buffer.\n");
1925 /* The following will not recurse, since it's
1927 trace_find_command ("-1", from_tty
);
1928 reply
= NULL
; /* Break out of loop
1929 (avoid recursive nonsense). */
1934 if ((target_tracept
= (int) strtol (++reply
, &reply
, 16)) == -1)
1935 error (_("Target failed to find requested trace frame."));
1937 case 'O': /* "OK"? */
1938 if (reply
[1] == 'K' && reply
[2] == '\0')
1941 error (_("Bogus reply from target: %s"), reply
);
1944 error (_("Bogus reply from target: %s"), reply
);
1947 reinit_frame_cache ();
1948 registers_changed ();
1949 set_traceframe_num (target_frameno
);
1950 set_tracepoint_num (target_tracept
);
1951 if (target_frameno
== -1)
1952 set_traceframe_context (-1);
1954 set_traceframe_context (read_pc ());
1958 enum print_what print_what
;
1960 /* NOTE: in immitation of the step command, try to determine
1961 whether we have made a transition from one function to
1962 another. If so, we'll print the "stack frame" (ie. the new
1963 function and it's arguments) -- otherwise we'll just show the
1966 This determination is made by checking (1) whether the
1967 current function has changed, and (2) whether the current FP
1968 has changed. Hack: if the FP wasn't collected, either at the
1969 current or the previous frame, assume that the FP has NOT
1972 if (old_func
== find_pc_function (read_pc ()) &&
1973 (old_frame_addr
== 0 ||
1974 get_frame_base (get_current_frame ()) == 0 ||
1975 old_frame_addr
== get_frame_base (get_current_frame ())))
1976 print_what
= SRC_LINE
;
1978 print_what
= SRC_AND_LOC
;
1980 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
1985 /* trace_find_command takes a trace frame number n,
1986 sends "QTFrame:<n>" to the target,
1987 and accepts a reply that may contain several optional pieces
1988 of information: a frame number, a tracepoint number, and an
1989 indication of whether this is a trap frame or a stepping frame.
1991 The minimal response is just "OK" (which indicates that the
1992 target does not give us a frame number or a tracepoint number).
1993 Instead of that, the target may send us a string containing
1995 F<hexnum> (gives the selected frame number)
1996 T<hexnum> (gives the selected tracepoint number)
2001 trace_find_command (char *args
, int from_tty
)
2002 { /* this should only be called with a numeric argument */
2005 if (target_is_remote ())
2007 if (deprecated_trace_find_hook
)
2008 deprecated_trace_find_hook (args
, from_tty
);
2010 if (args
== 0 || *args
== 0)
2011 { /* TFIND with no args means find NEXT trace frame. */
2012 if (traceframe_number
== -1)
2013 frameno
= 0; /* "next" is first one */
2015 frameno
= traceframe_number
+ 1;
2017 else if (0 == strcmp (args
, "-"))
2019 if (traceframe_number
== -1)
2020 error (_("not debugging trace buffer"));
2021 else if (from_tty
&& traceframe_number
== 0)
2022 error (_("already at start of trace buffer"));
2024 frameno
= traceframe_number
- 1;
2027 frameno
= parse_and_eval_long (args
);
2030 error (_("invalid input (%d is less than zero)"), frameno
);
2032 sprintf (target_buf
, "QTFrame:%x", frameno
);
2033 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2036 error (_("Trace can only be run on remote targets."));
2041 trace_find_end_command (char *args
, int from_tty
)
2043 trace_find_command ("-1", from_tty
);
2048 trace_find_none_command (char *args
, int from_tty
)
2050 trace_find_command ("-1", from_tty
);
2055 trace_find_start_command (char *args
, int from_tty
)
2057 trace_find_command ("0", from_tty
);
2060 /* tfind pc command */
2062 trace_find_pc_command (char *args
, int from_tty
)
2067 if (target_is_remote ())
2069 if (args
== 0 || *args
== 0)
2070 pc
= read_pc (); /* default is current pc */
2072 pc
= parse_and_eval_address (args
);
2074 sprintf_vma (tmp
, pc
);
2075 sprintf (target_buf
, "QTFrame:pc:%s", tmp
);
2076 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2079 error (_("Trace can only be run on remote targets."));
2082 /* tfind tracepoint command */
2084 trace_find_tracepoint_command (char *args
, int from_tty
)
2088 if (target_is_remote ())
2090 if (args
== 0 || *args
== 0)
2092 if (tracepoint_number
== -1)
2093 error (_("No current tracepoint -- please supply an argument."));
2095 tdp
= tracepoint_number
; /* default is current TDP */
2098 tdp
= parse_and_eval_long (args
);
2100 sprintf (target_buf
, "QTFrame:tdp:%x", tdp
);
2101 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2104 error (_("Trace can only be run on remote targets."));
2107 /* TFIND LINE command:
2109 This command will take a sourceline for argument, just like BREAK
2110 or TRACE (ie. anything that "decode_line_1" can handle).
2112 With no argument, this command will find the next trace frame
2113 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2116 trace_find_line_command (char *args
, int from_tty
)
2118 static CORE_ADDR start_pc
, end_pc
;
2119 struct symtabs_and_lines sals
;
2120 struct symtab_and_line sal
;
2121 struct cleanup
*old_chain
;
2122 char startpc_str
[40], endpc_str
[40];
2124 if (target_is_remote ())
2126 if (args
== 0 || *args
== 0)
2128 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2130 sals
.sals
= (struct symtab_and_line
*)
2131 xmalloc (sizeof (struct symtab_and_line
));
2136 sals
= decode_line_spec (args
, 1);
2140 old_chain
= make_cleanup (xfree
, sals
.sals
);
2141 if (sal
.symtab
== 0)
2143 printf_filtered ("TFIND: No line number information available");
2146 /* This is useful for "info line *0x7f34". If we can't
2147 tell the user about a source line, at least let them
2148 have the symbolic address. */
2149 printf_filtered (" for address ");
2151 print_address (sal
.pc
, gdb_stdout
);
2152 printf_filtered (";\n -- will attempt to find by PC. \n");
2156 printf_filtered (".\n");
2157 return; /* No line, no PC; what can we do? */
2160 else if (sal
.line
> 0
2161 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2163 if (start_pc
== end_pc
)
2165 printf_filtered ("Line %d of \"%s\"",
2166 sal
.line
, sal
.symtab
->filename
);
2168 printf_filtered (" is at address ");
2169 print_address (start_pc
, gdb_stdout
);
2171 printf_filtered (" but contains no code.\n");
2172 sal
= find_pc_line (start_pc
, 0);
2174 find_line_pc_range (sal
, &start_pc
, &end_pc
) &&
2176 printf_filtered ("Attempting to find line %d instead.\n",
2179 error (_("Cannot find a good line."));
2183 /* Is there any case in which we get here, and have an address
2184 which the user would want to see? If we have debugging
2185 symbols and no line numbers? */
2186 error (_("Line number %d is out of range for \"%s\"."),
2187 sal
.line
, sal
.symtab
->filename
);
2189 sprintf_vma (startpc_str
, start_pc
);
2190 sprintf_vma (endpc_str
, end_pc
- 1);
2191 /* Find within range of stated line. */
2193 sprintf (target_buf
, "QTFrame:range:%s:%s",
2194 startpc_str
, endpc_str
);
2195 /* Find OUTSIDE OF range of CURRENT line. */
2197 sprintf (target_buf
, "QTFrame:outside:%s:%s",
2198 startpc_str
, endpc_str
);
2199 finish_tfind_command (&target_buf
, &target_buf_size
,
2201 do_cleanups (old_chain
);
2204 error (_("Trace can only be run on remote targets."));
2207 /* tfind range command */
2209 trace_find_range_command (char *args
, int from_tty
)
2211 static CORE_ADDR start
, stop
;
2212 char start_str
[40], stop_str
[40];
2215 if (target_is_remote ())
2217 if (args
== 0 || *args
== 0)
2218 { /* XXX FIXME: what should default behavior be? */
2219 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2223 if (0 != (tmp
= strchr (args
, ',')))
2225 *tmp
++ = '\0'; /* terminate start address */
2226 while (isspace ((int) *tmp
))
2228 start
= parse_and_eval_address (args
);
2229 stop
= parse_and_eval_address (tmp
);
2232 { /* no explicit end address? */
2233 start
= parse_and_eval_address (args
);
2234 stop
= start
+ 1; /* ??? */
2237 sprintf_vma (start_str
, start
);
2238 sprintf_vma (stop_str
, stop
);
2239 sprintf (target_buf
, "QTFrame:range:%s:%s", start_str
, stop_str
);
2240 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2243 error (_("Trace can only be run on remote targets."));
2246 /* tfind outside command */
2248 trace_find_outside_command (char *args
, int from_tty
)
2250 CORE_ADDR start
, stop
;
2251 char start_str
[40], stop_str
[40];
2254 if (target_is_remote ())
2256 if (args
== 0 || *args
== 0)
2257 { /* XXX FIXME: what should default behavior be? */
2258 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2262 if (0 != (tmp
= strchr (args
, ',')))
2264 *tmp
++ = '\0'; /* terminate start address */
2265 while (isspace ((int) *tmp
))
2267 start
= parse_and_eval_address (args
);
2268 stop
= parse_and_eval_address (tmp
);
2271 { /* no explicit end address? */
2272 start
= parse_and_eval_address (args
);
2273 stop
= start
+ 1; /* ??? */
2276 sprintf_vma (start_str
, start
);
2277 sprintf_vma (stop_str
, stop
);
2278 sprintf (target_buf
, "QTFrame:outside:%s:%s", start_str
, stop_str
);
2279 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2282 error (_("Trace can only be run on remote targets."));
2285 /* save-tracepoints command */
2287 tracepoint_save_command (char *args
, int from_tty
)
2289 struct tracepoint
*tp
;
2290 struct action_line
*line
;
2292 char *i1
= " ", *i2
= " ";
2293 char *indent
, *actionline
, *pathname
;
2296 if (args
== 0 || *args
== 0)
2297 error (_("Argument required (file name in which to save tracepoints)"));
2299 if (tracepoint_chain
== 0)
2301 warning (_("save-tracepoints: no tracepoints to save."));
2305 pathname
= tilde_expand (args
);
2306 if (!(fp
= fopen (pathname
, "w")))
2307 error (_("Unable to open file '%s' for saving tracepoints (%s)"),
2308 args
, safe_strerror (errno
));
2311 ALL_TRACEPOINTS (tp
)
2313 if (tp
->addr_string
)
2314 fprintf (fp
, "trace %s\n", tp
->addr_string
);
2317 sprintf_vma (tmp
, tp
->address
);
2318 fprintf (fp
, "trace *0x%s\n", tmp
);
2322 fprintf (fp
, " passcount %d\n", tp
->pass_count
);
2326 fprintf (fp
, " actions\n");
2328 for (line
= tp
->actions
; line
; line
= line
->next
)
2330 struct cmd_list_element
*cmd
;
2332 QUIT
; /* allow user to bail out with ^C */
2333 actionline
= line
->action
;
2334 while (isspace ((int) *actionline
))
2337 fprintf (fp
, "%s%s\n", indent
, actionline
);
2338 if (*actionline
!= '#') /* skip for comment lines */
2340 cmd
= lookup_cmd (&actionline
, cmdlist
, "", -1, 1);
2342 error (_("Bad action list item: %s"), actionline
);
2343 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2345 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2353 printf_filtered ("Tracepoints saved to file '%s'.\n", args
);
2357 /* info scope command: list the locals for a scope. */
2359 scope_info (char *args
, int from_tty
)
2361 struct symtabs_and_lines sals
;
2363 struct minimal_symbol
*msym
;
2364 struct block
*block
;
2365 char **canonical
, *symname
, *save_args
= args
;
2366 struct dict_iterator iter
;
2369 if (args
== 0 || *args
== 0)
2370 error (_("requires an argument (function, line or *addr) to define a scope"));
2372 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2373 if (sals
.nelts
== 0)
2374 return; /* presumably decode_line_1 has already warned */
2376 /* Resolve line numbers to PC */
2377 resolve_sal_pc (&sals
.sals
[0]);
2378 block
= block_for_pc (sals
.sals
[0].pc
);
2382 QUIT
; /* allow user to bail out with ^C */
2383 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2385 QUIT
; /* allow user to bail out with ^C */
2387 printf_filtered ("Scope for %s:\n", save_args
);
2390 symname
= SYMBOL_PRINT_NAME (sym
);
2391 if (symname
== NULL
|| *symname
== '\0')
2392 continue; /* probably botched, certainly useless */
2394 printf_filtered ("Symbol %s is ", symname
);
2395 switch (SYMBOL_CLASS (sym
))
2398 case LOC_UNDEF
: /* messed up symbol? */
2399 printf_filtered ("a bogus symbol, class %d.\n",
2400 SYMBOL_CLASS (sym
));
2401 count
--; /* don't count this one */
2404 printf_filtered ("a constant with value %ld (0x%lx)",
2405 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2407 case LOC_CONST_BYTES
:
2408 printf_filtered ("constant bytes: ");
2409 if (SYMBOL_TYPE (sym
))
2410 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2411 fprintf_filtered (gdb_stdout
, " %02x",
2412 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2415 printf_filtered ("in static storage at address ");
2416 printf_filtered ("%s", paddress (SYMBOL_VALUE_ADDRESS (sym
)));
2419 if (SYMBOL_IS_ARGUMENT (sym
))
2420 printf_filtered ("an argument in register $%s",
2421 gdbarch_register_name
2422 (current_gdbarch
, SYMBOL_VALUE (sym
)));
2424 printf_filtered ("a local variable in register $%s",
2425 gdbarch_register_name
2426 (current_gdbarch
, SYMBOL_VALUE (sym
)));
2429 printf_filtered ("an argument at stack/frame offset %ld",
2430 SYMBOL_VALUE (sym
));
2433 printf_filtered ("a local variable at frame offset %ld",
2434 SYMBOL_VALUE (sym
));
2437 printf_filtered ("a reference argument at offset %ld",
2438 SYMBOL_VALUE (sym
));
2440 case LOC_REGPARM_ADDR
:
2441 printf_filtered ("the address of an argument, in register $%s",
2442 gdbarch_register_name
2443 (current_gdbarch
, SYMBOL_VALUE (sym
)));
2446 printf_filtered ("a typedef.\n");
2449 printf_filtered ("a label at address ");
2450 printf_filtered ("%s", paddress (SYMBOL_VALUE_ADDRESS (sym
)));
2453 printf_filtered ("a function at address ");
2454 printf_filtered ("%s", paddress (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2456 case LOC_UNRESOLVED
:
2457 msym
= lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym
),
2460 printf_filtered ("Unresolved Static");
2463 printf_filtered ("static storage at address ");
2464 printf_filtered ("%s", paddress (SYMBOL_VALUE_ADDRESS (msym
)));
2467 case LOC_OPTIMIZED_OUT
:
2468 printf_filtered ("optimized out.\n");
2471 SYMBOL_OPS (sym
)->describe_location (sym
, gdb_stdout
);
2474 if (SYMBOL_TYPE (sym
))
2475 printf_filtered (", length %d.\n",
2476 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2478 if (BLOCK_FUNCTION (block
))
2481 block
= BLOCK_SUPERBLOCK (block
);
2484 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2488 /* worker function (cleanup) */
2490 replace_comma (void *data
)
2498 trace_dump_command (char *args
, int from_tty
)
2500 struct regcache
*regcache
;
2501 struct gdbarch
*gdbarch
;
2502 struct tracepoint
*t
;
2503 struct action_line
*action
;
2504 char *action_exp
, *next_comma
;
2505 struct cleanup
*old_cleanups
;
2506 int stepping_actions
= 0;
2507 int stepping_frame
= 0;
2509 if (!target_is_remote ())
2511 error (_("Trace can only be run on remote targets."));
2515 if (tracepoint_number
== -1)
2517 warning (_("No current trace frame."));
2522 if (t
->number
== tracepoint_number
)
2526 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2529 old_cleanups
= make_cleanup (null_cleanup
, NULL
);
2531 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2532 tracepoint_number
, traceframe_number
);
2534 /* The current frame is a trap frame if the frame PC is equal
2535 to the tracepoint PC. If not, then the current frame was
2536 collected during single-stepping. */
2538 regcache
= get_current_regcache ();
2539 gdbarch
= get_regcache_arch (regcache
);
2541 stepping_frame
= (t
->address
!= (regcache_read_pc (regcache
)
2542 - gdbarch_decr_pc_after_break (gdbarch
)));
2544 for (action
= t
->actions
; action
; action
= action
->next
)
2546 struct cmd_list_element
*cmd
;
2548 QUIT
; /* allow user to bail out with ^C */
2549 action_exp
= action
->action
;
2550 while (isspace ((int) *action_exp
))
2553 /* The collection actions to be done while stepping are
2554 bracketed by the commands "while-stepping" and "end". */
2556 if (*action_exp
== '#') /* comment line */
2559 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2561 error (_("Bad action list item: %s"), action_exp
);
2563 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2564 stepping_actions
= 1;
2565 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2566 stepping_actions
= 0;
2567 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2569 /* Display the collected data.
2570 For the trap frame, display only what was collected at
2571 the trap. Likewise for stepping frames, display only
2572 what was collected while stepping. This means that the
2573 two boolean variables, STEPPING_FRAME and
2574 STEPPING_ACTIONS should be equal. */
2575 if (stepping_frame
== stepping_actions
)
2578 { /* repeat over a comma-separated list */
2579 QUIT
; /* allow user to bail out with ^C */
2580 if (*action_exp
== ',')
2582 while (isspace ((int) *action_exp
))
2585 next_comma
= strchr (action_exp
, ',');
2587 if (0 == strncasecmp (action_exp
, "$reg", 4))
2588 registers_info (NULL
, from_tty
);
2589 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2590 locals_info (NULL
, from_tty
);
2591 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2592 args_info (NULL
, from_tty
);
2597 make_cleanup (replace_comma
, next_comma
);
2600 printf_filtered ("%s = ", action_exp
);
2601 output_command (action_exp
, from_tty
);
2602 printf_filtered ("\n");
2606 action_exp
= next_comma
;
2608 while (action_exp
&& *action_exp
== ',');
2612 discard_cleanups (old_cleanups
);
2615 /* Convert the memory pointed to by mem into hex, placing result in buf.
2616 * Return a pointer to the last char put in buf (null)
2617 * "stolen" from sparc-stub.c
2620 static const char hexchars
[] = "0123456789abcdef";
2623 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2631 *buf
++ = hexchars
[ch
>> 4];
2632 *buf
++ = hexchars
[ch
& 0xf];
2641 get_traceframe_number (void)
2643 return traceframe_number
;
2647 /* module initialization */
2649 _initialize_tracepoint (void)
2651 struct cmd_list_element
*c
;
2653 tracepoint_chain
= 0;
2654 tracepoint_count
= 0;
2655 traceframe_number
= -1;
2656 tracepoint_number
= -1;
2658 if (tracepoint_list
.list
== NULL
)
2660 tracepoint_list
.listsize
= 128;
2661 tracepoint_list
.list
= xmalloc
2662 (tracepoint_list
.listsize
* sizeof (struct memrange
));
2664 if (tracepoint_list
.aexpr_list
== NULL
)
2666 tracepoint_list
.aexpr_listsize
= 128;
2667 tracepoint_list
.aexpr_list
= xmalloc
2668 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
2671 if (stepping_list
.list
== NULL
)
2673 stepping_list
.listsize
= 128;
2674 stepping_list
.list
= xmalloc
2675 (stepping_list
.listsize
* sizeof (struct memrange
));
2678 if (stepping_list
.aexpr_list
== NULL
)
2680 stepping_list
.aexpr_listsize
= 128;
2681 stepping_list
.aexpr_list
= xmalloc
2682 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
2685 add_info ("scope", scope_info
,
2686 _("List the variables local to a scope"));
2688 add_cmd ("tracepoints", class_trace
, NULL
,
2689 _("Tracing of program execution without stopping the program."),
2692 add_info ("tracepoints", tracepoints_info
, _("\
2693 Status of tracepoints, or tracepoint number NUMBER.\n\
2694 Convenience variable \"$tpnum\" contains the number of the\n\
2695 last tracepoint set."));
2697 add_info_alias ("tp", "tracepoints", 1);
2699 c
= add_com ("save-tracepoints", class_trace
, tracepoint_save_command
, _("\
2700 Save current tracepoint definitions as a script.\n\
2701 Use the 'source' command in another debug session to restore them."));
2702 set_cmd_completer (c
, filename_completer
);
2704 add_com ("tdump", class_trace
, trace_dump_command
,
2705 _("Print everything collected at the current tracepoint."));
2707 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
2708 Select a trace frame;\n\
2709 No argument means forward by one frame; '-' means backward by one frame."),
2710 &tfindlist
, "tfind ", 1, &cmdlist
);
2712 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
2713 Select a trace frame whose PC is outside the given range.\n\
2714 Usage: tfind outside addr1, addr2"),
2717 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
2718 Select a trace frame whose PC is in the given range.\n\
2719 Usage: tfind range addr1,addr2"),
2722 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
2723 Select a trace frame by source line.\n\
2724 Argument can be a line number (with optional source file), \n\
2725 a function name, or '*' followed by an address.\n\
2726 Default argument is 'the next source line that was traced'."),
2729 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
2730 Select a trace frame by tracepoint number.\n\
2731 Default is the tracepoint for the current trace frame."),
2734 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
2735 Select a trace frame by PC.\n\
2736 Default is the current PC, or the PC of the current trace frame."),
2739 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
2740 Synonym for 'none'.\n\
2741 De-select any trace frame and resume 'live' debugging."),
2744 add_cmd ("none", class_trace
, trace_find_none_command
,
2745 _("De-select any trace frame and resume 'live' debugging."),
2748 add_cmd ("start", class_trace
, trace_find_start_command
,
2749 _("Select the first trace frame in the trace buffer."),
2752 add_com ("tstatus", class_trace
, trace_status_command
,
2753 _("Display the status of the current trace data collection."));
2755 add_com ("tstop", class_trace
, trace_stop_command
,
2756 _("Stop trace data collection."));
2758 add_com ("tstart", class_trace
, trace_start_command
,
2759 _("Start trace data collection."));
2761 add_com ("passcount", class_trace
, trace_pass_command
, _("\
2762 Set the passcount for a tracepoint.\n\
2763 The trace will end when the tracepoint has been passed 'count' times.\n\
2764 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
2765 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
2767 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
2768 Ends a list of commands or actions.\n\
2769 Several GDB commands allow you to enter a list of commands or actions.\n\
2770 Entering \"end\" on a line by itself is the normal way to terminate\n\
2772 Note: the \"end\" command cannot be used at the gdb prompt."));
2774 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
2775 Specify single-stepping behavior at a tracepoint.\n\
2776 Argument is number of instructions to trace in single-step mode\n\
2777 following the tracepoint. This command is normally followed by\n\
2778 one or more \"collect\" commands, to specify what to collect\n\
2779 while single-stepping.\n\n\
2780 Note: this command can only be used in a tracepoint \"actions\" list."));
2782 add_com_alias ("ws", "while-stepping", class_alias
, 0);
2783 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
2785 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
2786 Specify one or more data items to be collected at a tracepoint.\n\
2787 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
2788 collect all data (variables, registers) referenced by that expression.\n\
2789 Also accepts the following special arguments:\n\
2790 $regs -- all registers.\n\
2791 $args -- all function arguments.\n\
2792 $locals -- all variables local to the block/function scope.\n\
2793 Note: this command can only be used in a tracepoint \"actions\" list."));
2795 add_com ("actions", class_trace
, trace_actions_command
, _("\
2796 Specify the actions to be taken at a tracepoint.\n\
2797 Tracepoint actions may include collecting of specified data, \n\
2798 single-stepping, or enabling/disabling other tracepoints, \n\
2799 depending on target's capabilities."));
2801 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
2802 Delete specified tracepoints.\n\
2803 Arguments are tracepoint numbers, separated by spaces.\n\
2804 No argument means delete all tracepoints."),
2807 add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
2808 Disable specified tracepoints.\n\
2809 Arguments are tracepoint numbers, separated by spaces.\n\
2810 No argument means disable all tracepoints."),
2813 add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
2814 Enable specified tracepoints.\n\
2815 Arguments are tracepoint numbers, separated by spaces.\n\
2816 No argument means enable all tracepoints."),
2819 c
= add_com ("trace", class_trace
, trace_command
, _("\
2820 Set a tracepoint at a specified line or function or address.\n\
2821 Argument may be a line number, function name, or '*' plus an address.\n\
2822 For a line number or function, trace at the start of its code.\n\
2823 If an address is specified, trace at that exact address.\n\n\
2824 Do \"help tracepoints\" for info on other tracepoint commands."));
2825 set_cmd_completer (c
, location_completer
);
2827 add_com_alias ("tp", "trace", class_alias
, 0);
2828 add_com_alias ("tr", "trace", class_alias
, 1);
2829 add_com_alias ("tra", "trace", class_alias
, 1);
2830 add_com_alias ("trac", "trace", class_alias
, 1);
2832 target_buf_size
= 2048;
2833 target_buf
= xmalloc (target_buf_size
);