1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free
4 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 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., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
27 #include "expression.h"
32 #include "gdb_string.h"
34 #include "tracepoint.h"
38 #include "completer.h"
39 #include "gdb-events.h"
41 #include "dictionary.h"
46 /* readline include files */
47 #include "readline/readline.h"
48 #include "readline/history.h"
50 /* readline defines this. */
57 /* Maximum length of an agent aexpression.
58 This accounts for the fact that packets are limited to 400 bytes
59 (which includes everything -- including the checksum), and assumes
60 the worst case of maximum length for each of the pieces of a
63 NOTE: expressions get mem2hex'ed otherwise this would be twice as
64 large. (400 - 31)/2 == 184 */
65 #define MAX_AGENT_EXPR_LEN 184
68 extern void (*deprecated_readline_begin_hook
) (char *, ...);
69 extern char *(*deprecated_readline_hook
) (char *);
70 extern void (*deprecated_readline_end_hook
) (void);
71 extern void x_command (char *, int);
72 extern int addressprint
; /* Print machine addresses? */
74 /* GDB commands implemented in other modules:
77 extern void output_command (char *, int);
82 This module defines the following debugger commands:
83 trace : set a tracepoint on a function, line, or address.
84 info trace : list all debugger-defined tracepoints.
85 delete trace : delete one or more tracepoints.
86 enable trace : enable one or more tracepoints.
87 disable trace : disable one or more tracepoints.
88 actions : specify actions to be taken at a tracepoint.
89 passcount : specify a pass count for a tracepoint.
90 tstart : start a trace experiment.
91 tstop : stop a trace experiment.
92 tstatus : query the status of a trace experiment.
93 tfind : find a trace frame in the trace buffer.
94 tdump : print everything collected at the current tracepoint.
95 save-tracepoints : write tracepoint setup into a file.
97 This module defines the following user-visible debugger variables:
98 $trace_frame : sequence number of trace frame currently being debugged.
99 $trace_line : source line of trace frame currently being debugged.
100 $trace_file : source file of trace frame currently being debugged.
101 $tracepoint : tracepoint number of trace frame currently being debugged.
105 /* ======= Important global variables: ======= */
107 /* Chain of all tracepoints defined. */
108 struct tracepoint
*tracepoint_chain
;
110 /* Number of last tracepoint made. */
111 static int tracepoint_count
;
113 /* Number of last traceframe collected. */
114 static int traceframe_number
;
116 /* Tracepoint for last traceframe collected. */
117 static int tracepoint_number
;
119 /* Symbol for function for last traceframe collected */
120 static struct symbol
*traceframe_fun
;
122 /* Symtab and line for last traceframe collected */
123 static struct symtab_and_line traceframe_sal
;
125 /* Tracing command lists */
126 static struct cmd_list_element
*tfindlist
;
128 /* ======= Important command functions: ======= */
129 static void trace_command (char *, int);
130 static void tracepoints_info (char *, int);
131 static void delete_trace_command (char *, int);
132 static void enable_trace_command (char *, int);
133 static void disable_trace_command (char *, int);
134 static void trace_pass_command (char *, int);
135 static void trace_actions_command (char *, int);
136 static void trace_start_command (char *, int);
137 static void trace_stop_command (char *, int);
138 static void trace_status_command (char *, int);
139 static void trace_find_command (char *, int);
140 static void trace_find_pc_command (char *, int);
141 static void trace_find_tracepoint_command (char *, int);
142 static void trace_find_line_command (char *, int);
143 static void trace_find_range_command (char *, int);
144 static void trace_find_outside_command (char *, int);
145 static void tracepoint_save_command (char *, int);
146 static void trace_dump_command (char *, int);
148 /* support routines */
149 static void trace_mention (struct tracepoint
*);
151 struct collection_list
;
152 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
153 static char *mem2hex (gdb_byte
*, char *, int);
154 static void add_register (struct collection_list
*collection
,
156 static struct cleanup
*make_cleanup_free_actions (struct tracepoint
*t
);
157 static void free_actions_list (char **actions_list
);
158 static void free_actions_list_cleanup_wrapper (void *);
160 extern void _initialize_tracepoint (void);
162 /* Utility: returns true if "target remote" */
164 target_is_remote (void)
166 if (current_target
.to_shortname
&&
167 (strcmp (current_target
.to_shortname
, "remote") == 0
168 || strcmp (current_target
.to_shortname
, "extended-remote") == 0))
174 /* Utility: generate error from an incoming stub packet. */
176 trace_error (char *buf
)
179 return; /* not an error msg */
182 case '1': /* malformed packet error */
183 if (*++buf
== '0') /* general case: */
184 error (_("tracepoint.c: error in outgoing packet."));
186 error (_("tracepoint.c: error in outgoing packet at field #%ld."),
187 strtol (buf
, NULL
, 16));
189 error (_("trace API error 0x%s."), ++buf
);
191 error (_("Target returns error code '%s'."), buf
);
195 /* Utility: wait for reply from stub, while accepting "O" packets. */
197 remote_get_noisy_reply (char *buf
,
200 do /* Loop on reply from remote stub. */
202 QUIT
; /* allow user to bail out with ^C */
203 getpkt (buf
, 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_int
, (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_int
, (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_int
,
245 /* Set externally visible debug variables for querying/printing
246 the traceframe context (line, function, file) */
249 set_traceframe_context (CORE_ADDR trace_pc
)
251 static struct type
*func_string
, *file_string
;
252 static struct type
*func_range
, *file_range
;
253 struct value
*func_val
;
254 struct value
*file_val
;
255 static struct type
*charstar
;
258 if (charstar
== (struct type
*) NULL
)
259 charstar
= lookup_pointer_type (builtin_type_char
);
261 if (trace_pc
== -1) /* Cease debugging any trace buffers. */
264 traceframe_sal
.pc
= traceframe_sal
.line
= 0;
265 traceframe_sal
.symtab
= NULL
;
266 set_internalvar (lookup_internalvar ("trace_func"),
267 value_from_pointer (charstar
, (LONGEST
) 0));
268 set_internalvar (lookup_internalvar ("trace_file"),
269 value_from_pointer (charstar
, (LONGEST
) 0));
270 set_internalvar (lookup_internalvar ("trace_line"),
271 value_from_longest (builtin_type_int
,
276 /* Save as globals for internal use. */
277 traceframe_sal
= find_pc_line (trace_pc
, 0);
278 traceframe_fun
= find_pc_function (trace_pc
);
280 /* Save linenumber as "$trace_line", a debugger variable visible to
282 set_internalvar (lookup_internalvar ("trace_line"),
283 value_from_longest (builtin_type_int
,
284 (LONGEST
) traceframe_sal
.line
));
286 /* Save func name as "$trace_func", a debugger variable visible to
288 if (traceframe_fun
== NULL
||
289 DEPRECATED_SYMBOL_NAME (traceframe_fun
) == NULL
)
290 set_internalvar (lookup_internalvar ("trace_func"),
291 value_from_pointer (charstar
, (LONGEST
) 0));
294 len
= strlen (DEPRECATED_SYMBOL_NAME (traceframe_fun
));
295 func_range
= create_range_type (func_range
,
296 builtin_type_int
, 0, len
- 1);
297 func_string
= create_array_type (func_string
,
298 builtin_type_char
, func_range
);
299 func_val
= allocate_value (func_string
);
300 deprecated_set_value_type (func_val
, func_string
);
301 memcpy (value_contents_raw (func_val
),
302 DEPRECATED_SYMBOL_NAME (traceframe_fun
),
304 deprecated_set_value_modifiable (func_val
, 0);
305 set_internalvar (lookup_internalvar ("trace_func"), func_val
);
308 /* Save file name as "$trace_file", a debugger variable visible to
310 if (traceframe_sal
.symtab
== NULL
||
311 traceframe_sal
.symtab
->filename
== NULL
)
312 set_internalvar (lookup_internalvar ("trace_file"),
313 value_from_pointer (charstar
, (LONGEST
) 0));
316 len
= strlen (traceframe_sal
.symtab
->filename
);
317 file_range
= create_range_type (file_range
,
318 builtin_type_int
, 0, len
- 1);
319 file_string
= create_array_type (file_string
,
320 builtin_type_char
, file_range
);
321 file_val
= allocate_value (file_string
);
322 deprecated_set_value_type (file_val
, file_string
);
323 memcpy (value_contents_raw (file_val
),
324 traceframe_sal
.symtab
->filename
,
326 deprecated_set_value_modifiable (file_val
, 0);
327 set_internalvar (lookup_internalvar ("trace_file"), file_val
);
331 /* Low level routine to set a tracepoint.
332 Returns the tracepoint object so caller can set other things.
333 Does not set the tracepoint number!
334 Does not print anything.
336 ==> This routine should not be called if there is a chance of later
337 error(); otherwise it leaves a bogus tracepoint on the chain.
338 Validate your arguments BEFORE calling this routine! */
340 static struct tracepoint
*
341 set_raw_tracepoint (struct symtab_and_line sal
)
343 struct tracepoint
*t
, *tc
;
344 struct cleanup
*old_chain
;
346 t
= (struct tracepoint
*) xmalloc (sizeof (struct tracepoint
));
347 old_chain
= make_cleanup (xfree
, t
);
348 memset (t
, 0, sizeof (*t
));
350 if (sal
.symtab
== NULL
)
351 t
->source_file
= NULL
;
353 t
->source_file
= savestring (sal
.symtab
->filename
,
354 strlen (sal
.symtab
->filename
));
356 t
->section
= sal
.section
;
357 t
->language
= current_language
->la_language
;
358 t
->input_radix
= input_radix
;
359 t
->line_number
= sal
.line
;
364 t
->addr_string
= NULL
;
366 /* Add this tracepoint to the end of the chain
367 so that a list of tracepoints will come out in order
368 of increasing numbers. */
370 tc
= tracepoint_chain
;
372 tracepoint_chain
= t
;
379 discard_cleanups (old_chain
);
383 /* Set a tracepoint according to ARG (function, linenum or *address). */
385 trace_command (char *arg
, int from_tty
)
387 char **canonical
= (char **) NULL
;
388 struct symtabs_and_lines sals
;
389 struct symtab_and_line sal
;
390 struct tracepoint
*t
;
391 char *addr_start
= 0, *addr_end
= 0;
395 error (_("trace command requires an argument"));
397 if (from_tty
&& info_verbose
)
398 printf_filtered ("TRACE %s\n", arg
);
401 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
402 0, &canonical
, NULL
);
405 return; /* ??? Presumably decode_line_1 has already warned? */
407 /* Resolve all line numbers to PC's */
408 for (i
= 0; i
< sals
.nelts
; i
++)
409 resolve_sal_pc (&sals
.sals
[i
]);
411 /* Now set all the tracepoints. */
412 for (i
= 0; i
< sals
.nelts
; i
++)
416 t
= set_raw_tracepoint (sal
);
417 set_tracepoint_count (tracepoint_count
+ 1);
418 t
->number
= tracepoint_count
;
420 /* If a canonical line spec is needed use that instead of the
422 if (canonical
!= (char **) NULL
&& canonical
[i
] != NULL
)
423 t
->addr_string
= canonical
[i
];
425 t
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
432 printf_filtered ("Multiple tracepoints were set.\n");
433 printf_filtered ("Use 'delete trace' to delete unwanted tracepoints.\n");
437 /* Tell the user we have just set a tracepoint TP. */
440 trace_mention (struct tracepoint
*tp
)
442 printf_filtered ("Tracepoint %d", tp
->number
);
444 if (addressprint
|| (tp
->source_file
== NULL
))
446 printf_filtered (" at ");
447 deprecated_print_address_numeric (tp
->address
, 1, gdb_stdout
);
450 printf_filtered (": file %s, line %d.",
451 tp
->source_file
, tp
->line_number
);
453 printf_filtered ("\n");
456 /* Print information on tracepoint number TPNUM_EXP, or all if
460 tracepoints_info (char *tpnum_exp
, int from_tty
)
462 struct tracepoint
*t
;
463 struct action_line
*action
;
464 int found_a_tracepoint
= 0;
465 char wrap_indent
[80];
470 tpnum
= parse_and_eval_long (tpnum_exp
);
473 if (tpnum
== -1 || tpnum
== t
->number
)
475 extern int addressprint
; /* Print machine addresses? */
477 if (!found_a_tracepoint
++)
479 printf_filtered ("Num Enb ");
482 if (TARGET_ADDR_BIT
<= 32)
483 printf_filtered ("Address ");
485 printf_filtered ("Address ");
487 printf_filtered ("PassC StepC What\n");
489 strcpy (wrap_indent
, " ");
492 if (TARGET_ADDR_BIT
<= 32)
493 strcat (wrap_indent
, " ");
495 strcat (wrap_indent
, " ");
498 printf_filtered ("%-3d %-3s ", t
->number
,
499 t
->enabled_p
? "y" : "n");
504 if (TARGET_ADDR_BIT
<= 32)
505 tmp
= hex_string_custom (t
->address
& (CORE_ADDR
) 0xffffffff,
508 tmp
= hex_string_custom (t
->address
, 16);
510 printf_filtered ("%s ", tmp
);
512 printf_filtered ("%-5d %-5ld ", t
->pass_count
, t
->step_count
);
516 sym
= find_pc_sect_function (t
->address
, t
->section
);
519 fputs_filtered ("in ", gdb_stdout
);
520 fputs_filtered (SYMBOL_PRINT_NAME (sym
), gdb_stdout
);
521 wrap_here (wrap_indent
);
522 fputs_filtered (" at ", gdb_stdout
);
524 fputs_filtered (t
->source_file
, gdb_stdout
);
525 printf_filtered (":%d", t
->line_number
);
528 print_address_symbolic (t
->address
, gdb_stdout
, demangle
, " ");
530 printf_filtered ("\n");
533 printf_filtered (" Actions for tracepoint %d: \n", t
->number
);
534 for (action
= t
->actions
; action
; action
= action
->next
)
536 printf_filtered ("\t%s\n", action
->action
);
540 if (!found_a_tracepoint
)
543 printf_filtered ("No tracepoints.\n");
545 printf_filtered ("No tracepoint number %d.\n", tpnum
);
549 /* Optimization: the code to parse an enable, disable, or delete TP
550 command is virtually identical except for whether it performs an
551 enable, disable, or delete. Therefore I've combined them into one
552 function with an opcode. */
553 enum tracepoint_opcode
560 /* This function implements enable, disable and delete commands. */
562 tracepoint_operation (struct tracepoint
*t
, int from_tty
,
563 enum tracepoint_opcode opcode
)
565 struct tracepoint
*t2
;
567 if (t
== NULL
) /* no tracepoint operand */
574 tracepoint_modify_event (t
->number
);
578 tracepoint_modify_event (t
->number
);
581 if (tracepoint_chain
== t
)
582 tracepoint_chain
= t
->next
;
587 tracepoint_delete_event (t2
->number
);
593 xfree (t
->addr_string
);
595 xfree (t
->source_file
);
604 /* Utility: parse a tracepoint number and look it up in the list.
605 If MULTI_P is true, there might be a range of tracepoints in ARG.
606 if OPTIONAL_P is true, then if the argument is missing, the most
607 recent tracepoint (tracepoint_count) is returned. */
609 get_tracepoint_by_number (char **arg
, int multi_p
, int optional_p
)
611 struct tracepoint
*t
;
613 char *instring
= arg
== NULL
? NULL
: *arg
;
615 if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
618 tpnum
= tracepoint_count
;
620 error_no_arg (_("tracepoint number"));
623 tpnum
= multi_p
? get_number_or_range (arg
) : get_number (arg
);
627 if (instring
&& *instring
)
628 printf_filtered ("bad tracepoint number at or near '%s'\n",
631 printf_filtered ("Tracepoint argument missing and no previous tracepoint\n");
636 if (t
->number
== tpnum
)
641 /* FIXME: if we are in the middle of a range we don't want to give
642 a message. The current interface to get_number_or_range doesn't
643 allow us to discover this. */
644 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
649 parse a list of tracepoint numbers, and call a func for each. */
651 map_args_over_tracepoints (char *args
, int from_tty
,
652 enum tracepoint_opcode opcode
)
654 struct tracepoint
*t
, *tmp
;
656 if (args
== 0 || *args
== 0) /* do them all */
657 ALL_TRACEPOINTS_SAFE (t
, tmp
)
658 tracepoint_operation (t
, from_tty
, opcode
);
662 QUIT
; /* Give user option to bail out with ^C. */
663 t
= get_tracepoint_by_number (&args
, 1, 0);
664 tracepoint_operation (t
, from_tty
, opcode
);
665 while (*args
== ' ' || *args
== '\t')
670 /* The 'enable trace' command enables tracepoints.
671 Not supported by all targets. */
673 enable_trace_command (char *args
, int from_tty
)
676 map_args_over_tracepoints (args
, from_tty
, enable_op
);
679 /* The 'disable trace' command disables tracepoints.
680 Not supported by all targets. */
682 disable_trace_command (char *args
, int from_tty
)
685 map_args_over_tracepoints (args
, from_tty
, disable_op
);
688 /* Remove a tracepoint (or all if no argument) */
690 delete_trace_command (char *args
, int from_tty
)
693 if (!args
|| !*args
) /* No args implies all tracepoints; */
694 if (from_tty
) /* confirm only if from_tty... */
695 if (tracepoint_chain
) /* and if there are tracepoints to
697 if (!query ("Delete all tracepoints? "))
700 map_args_over_tracepoints (args
, from_tty
, delete_op
);
703 /* Set passcount for tracepoint.
705 First command argument is passcount, second is tracepoint number.
706 If tracepoint number omitted, apply to most recently defined.
707 Also accepts special argument "all". */
710 trace_pass_command (char *args
, int from_tty
)
712 struct tracepoint
*t1
= (struct tracepoint
*) -1, *t2
;
716 if (args
== 0 || *args
== 0)
717 error (_("passcount command requires an argument (count + optional TP num)"));
719 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
721 while (*args
&& isspace ((int) *args
))
724 if (*args
&& strncasecmp (args
, "all", 3) == 0)
726 args
+= 3; /* Skip special argument "all". */
729 error (_("Junk at end of arguments."));
732 t1
= get_tracepoint_by_number (&args
, 1, 1);
739 if (t1
== (struct tracepoint
*) -1 || t1
== t2
)
741 t2
->pass_count
= count
;
742 tracepoint_modify_event (t2
->number
);
744 printf_filtered ("Setting tracepoint %d's passcount to %d\n",
748 t1
= get_tracepoint_by_number (&args
, 1, 0);
754 /* ACTIONS functions: */
756 /* Prototypes for action-parsing utility commands */
757 static void read_actions (struct tracepoint
*);
759 /* The three functions:
760 collect_pseudocommand,
761 while_stepping_pseudocommand, and
762 end_actions_pseudocommand
763 are placeholders for "commands" that are actually ONLY to be used
764 within a tracepoint action list. If the actual function is ever called,
765 it means that somebody issued the "command" at the top level,
766 which is always an error. */
769 end_actions_pseudocommand (char *args
, int from_tty
)
771 error (_("This command cannot be used at the top level."));
775 while_stepping_pseudocommand (char *args
, int from_tty
)
777 error (_("This command can only be used in a tracepoint actions list."));
781 collect_pseudocommand (char *args
, int from_tty
)
783 error (_("This command can only be used in a tracepoint actions list."));
786 /* Enter a list of actions for a tracepoint. */
788 trace_actions_command (char *args
, int from_tty
)
790 struct tracepoint
*t
;
792 char *end_msg
= "End with a line saying just \"end\".";
794 t
= get_tracepoint_by_number (&args
, 0, 1);
797 sprintf (tmpbuf
, "Enter actions for tracepoint %d, one per line.",
802 if (deprecated_readline_begin_hook
)
803 (*deprecated_readline_begin_hook
) ("%s %s\n", tmpbuf
, end_msg
);
804 else if (input_from_terminal_p ())
805 printf_filtered ("%s\n%s\n", tmpbuf
, end_msg
);
809 t
->step_count
= 0; /* read_actions may set this */
812 if (deprecated_readline_end_hook
)
813 (*deprecated_readline_end_hook
) ();
814 /* tracepoints_changed () */
816 /* else just return */
819 /* worker function */
821 read_actions (struct tracepoint
*t
)
824 char *prompt1
= "> ", *prompt2
= " > ";
825 char *prompt
= prompt1
;
826 enum actionline_type linetype
;
827 extern FILE *instream
;
828 struct action_line
*next
= NULL
, *temp
;
829 struct cleanup
*old_chain
;
831 /* Control-C quits instantly if typed while in this loop
832 since it should not wait until the user types a newline. */
834 /* FIXME: kettenis/20010823: Something is wrong here. In this file
835 STOP_SIGNAL is never defined. So this code has been left out, at
836 least for quite a while now. Replacing STOP_SIGNAL with SIGTSTP
837 leads to compilation failures since the variable job_control
838 isn't declared. Leave this alone for now. */
841 signal (STOP_SIGNAL
, handle_stop_sig
);
843 old_chain
= make_cleanup_free_actions (t
);
846 /* Make sure that all output has been output. Some machines may
847 let you get away with leaving out some of the gdb_flush, but
850 gdb_flush (gdb_stdout
);
851 gdb_flush (gdb_stderr
);
853 if (deprecated_readline_hook
&& instream
== NULL
)
854 line
= (*deprecated_readline_hook
) (prompt
);
855 else if (instream
== stdin
&& ISATTY (instream
))
857 line
= gdb_readline_wrapper (prompt
);
858 if (line
&& *line
) /* add it to command history */
862 line
= gdb_readline (0);
867 linetype
= validate_actionline (&line
, t
);
868 if (linetype
== BADLINE
)
869 continue; /* already warned -- collect another line */
871 temp
= xmalloc (sizeof (struct action_line
));
875 if (next
== NULL
) /* first action for this tracepoint? */
876 t
->actions
= next
= temp
;
883 if (linetype
== STEPPING
) /* begin "while-stepping" */
885 if (prompt
== prompt2
)
887 warning (_("Already processing 'while-stepping'"));
891 prompt
= prompt2
; /* change prompt for stepping actions */
893 else if (linetype
== END
)
895 if (prompt
== prompt2
)
897 prompt
= prompt1
; /* end of single-stepping actions */
900 { /* end of actions */
901 if (t
->actions
->next
== NULL
)
903 /* An "end" all by itself with no other actions
904 means this tracepoint has no actions.
905 Discard empty list. */
914 signal (STOP_SIGNAL
, SIG_DFL
);
917 discard_cleanups (old_chain
);
920 /* worker function */
922 validate_actionline (char **line
, struct tracepoint
*t
)
924 struct cmd_list_element
*c
;
925 struct expression
*exp
= NULL
;
926 struct cleanup
*old_chain
= NULL
;
929 /* if EOF is typed, *line is NULL */
933 for (p
= *line
; isspace ((int) *p
);)
936 /* Symbol lookup etc. */
937 if (*p
== '\0') /* empty line: just prompt for another line. */
940 if (*p
== '#') /* comment line */
943 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
946 warning (_("'%s' is not an action that I know, or is ambiguous."),
951 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
953 struct agent_expr
*aexpr
;
954 struct agent_reqs areqs
;
957 { /* repeat over a comma-separated list */
958 QUIT
; /* allow user to bail out with ^C */
959 while (isspace ((int) *p
))
962 if (*p
== '$') /* look for special pseudo-symbols */
964 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
965 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
966 (0 == strncasecmp ("loc", p
+ 1, 3)))
971 /* else fall thru, treat p as an expression and parse it! */
973 exp
= parse_exp_1 (&p
, block_for_pc (t
->address
), 1);
974 old_chain
= make_cleanup (free_current_contents
, &exp
);
976 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
978 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
980 warning (_("constant %s (value %ld) will not be collected."),
981 DEPRECATED_SYMBOL_NAME (exp
->elts
[2].symbol
),
982 SYMBOL_VALUE (exp
->elts
[2].symbol
));
985 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
987 warning (_("%s is optimized away and cannot be collected."),
988 DEPRECATED_SYMBOL_NAME (exp
->elts
[2].symbol
));
993 /* We have something to collect, make sure that the expr to
994 bytecode translator can handle it and that it's not too
996 aexpr
= gen_trace_for_expr (t
->address
, exp
);
997 make_cleanup_free_agent_expr (aexpr
);
999 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
1000 error (_("expression too complicated, try simplifying"));
1002 ax_reqs (aexpr
, &areqs
);
1003 (void) make_cleanup (xfree
, areqs
.reg_mask
);
1005 if (areqs
.flaw
!= agent_flaw_none
)
1006 error (_("malformed expression"));
1008 if (areqs
.min_height
< 0)
1009 error (_("gdb: Internal error: expression has min height < 0"));
1011 if (areqs
.max_height
> 20)
1012 error (_("expression too complicated, try simplifying"));
1014 do_cleanups (old_chain
);
1016 while (p
&& *p
++ == ',');
1019 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
1021 char *steparg
; /* in case warning is necessary */
1023 while (isspace ((int) *p
))
1028 (t
->step_count
= strtol (p
, &p
, 0)) == 0)
1030 warning (_("'%s': bad step-count; command ignored."), *line
);
1035 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
1039 warning (_("'%s' is not a supported tracepoint action."), *line
);
1044 /* worker function */
1046 free_actions (struct tracepoint
*t
)
1048 struct action_line
*line
, *next
;
1050 for (line
= t
->actions
; line
; line
= next
)
1054 xfree (line
->action
);
1061 do_free_actions_cleanup (void *t
)
1066 static struct cleanup
*
1067 make_cleanup_free_actions (struct tracepoint
*t
)
1069 return make_cleanup (do_free_actions_cleanup
, t
);
1073 memrange_absolute
= -1
1078 int type
; /* memrange_absolute for absolute memory range,
1079 else basereg number */
1080 bfd_signed_vma start
;
1084 struct collection_list
1086 unsigned char regs_mask
[32]; /* room for up to 256 regs */
1089 struct memrange
*list
;
1090 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
1091 long next_aexpr_elt
;
1092 struct agent_expr
**aexpr_list
;
1095 tracepoint_list
, stepping_list
;
1097 /* MEMRANGE functions: */
1099 static int memrange_cmp (const void *, const void *);
1101 /* compare memranges for qsort */
1103 memrange_cmp (const void *va
, const void *vb
)
1105 const struct memrange
*a
= va
, *b
= vb
;
1107 if (a
->type
< b
->type
)
1109 if (a
->type
> b
->type
)
1111 if (a
->type
== memrange_absolute
)
1113 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
1115 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
1120 if (a
->start
< b
->start
)
1122 if (a
->start
> b
->start
)
1128 /* Sort the memrange list using qsort, and merge adjacent memranges. */
1130 memrange_sortmerge (struct collection_list
*memranges
)
1134 qsort (memranges
->list
, memranges
->next_memrange
,
1135 sizeof (struct memrange
), memrange_cmp
);
1136 if (memranges
->next_memrange
> 0)
1138 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
1140 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
1141 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
1144 /* memrange b starts before memrange a ends; merge them. */
1145 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
1146 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
1147 continue; /* next b, same a */
1151 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
1152 sizeof (struct memrange
));
1154 memranges
->next_memrange
= a
+ 1;
1158 /* Add a register to a collection list. */
1160 add_register (struct collection_list
*collection
, unsigned int regno
)
1163 printf_filtered ("collect register %d\n", regno
);
1164 if (regno
> (8 * sizeof (collection
->regs_mask
)))
1165 error (_("Internal: register number %d too large for tracepoint"),
1167 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
1170 /* Add a memrange to a collection list */
1172 add_memrange (struct collection_list
*memranges
,
1173 int type
, bfd_signed_vma base
,
1178 printf_filtered ("(%d,", type
);
1180 printf_filtered (",%ld)\n", len
);
1183 /* type: memrange_absolute == memory, other n == basereg */
1184 memranges
->list
[memranges
->next_memrange
].type
= type
;
1185 /* base: addr if memory, offset if reg relative. */
1186 memranges
->list
[memranges
->next_memrange
].start
= base
;
1187 /* len: we actually save end (base + len) for convenience */
1188 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
1189 memranges
->next_memrange
++;
1190 if (memranges
->next_memrange
>= memranges
->listsize
)
1192 memranges
->listsize
*= 2;
1193 memranges
->list
= xrealloc (memranges
->list
,
1194 memranges
->listsize
);
1197 if (type
!= memrange_absolute
) /* Better collect the base register! */
1198 add_register (memranges
, type
);
1201 /* Add a symbol to a collection list. */
1203 collect_symbol (struct collection_list
*collect
,
1205 long frame_regno
, long frame_offset
)
1209 bfd_signed_vma offset
;
1211 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
1212 switch (SYMBOL_CLASS (sym
))
1215 printf_filtered ("%s: don't know symbol class %d\n",
1216 DEPRECATED_SYMBOL_NAME (sym
),
1217 SYMBOL_CLASS (sym
));
1220 printf_filtered ("constant %s (value %ld) will not be collected.\n",
1221 DEPRECATED_SYMBOL_NAME (sym
), SYMBOL_VALUE (sym
));
1224 offset
= SYMBOL_VALUE_ADDRESS (sym
);
1229 sprintf_vma (tmp
, offset
);
1230 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1231 DEPRECATED_SYMBOL_NAME (sym
), len
,
1234 add_memrange (collect
, memrange_absolute
, offset
, len
);
1238 reg
= SYMBOL_VALUE (sym
);
1240 printf_filtered ("LOC_REG[parm] %s: ",
1241 DEPRECATED_SYMBOL_NAME (sym
));
1242 add_register (collect
, reg
);
1243 /* Check for doubles stored in two registers. */
1244 /* FIXME: how about larger types stored in 3 or more regs? */
1245 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1246 len
> register_size (current_gdbarch
, reg
))
1247 add_register (collect
, reg
+ 1);
1250 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1251 printf_filtered (" (will not collect %s)\n",
1252 DEPRECATED_SYMBOL_NAME (sym
));
1256 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1259 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1260 DEPRECATED_SYMBOL_NAME (sym
), len
);
1261 printf_vma (offset
);
1262 printf_filtered (" from frame ptr reg %d\n", reg
);
1264 add_memrange (collect
, reg
, offset
, len
);
1266 case LOC_REGPARM_ADDR
:
1267 reg
= SYMBOL_VALUE (sym
);
1271 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1272 DEPRECATED_SYMBOL_NAME (sym
), len
);
1273 printf_vma (offset
);
1274 printf_filtered (" from reg %d\n", reg
);
1276 add_memrange (collect
, reg
, offset
, len
);
1281 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1284 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1285 DEPRECATED_SYMBOL_NAME (sym
), len
);
1286 printf_vma (offset
);
1287 printf_filtered (" from frame ptr reg %d\n", reg
);
1289 add_memrange (collect
, reg
, offset
, len
);
1292 case LOC_BASEREG_ARG
:
1293 reg
= SYMBOL_BASEREG (sym
);
1294 offset
= SYMBOL_VALUE (sym
);
1297 printf_filtered ("LOC_BASEREG %s: collect %ld bytes at offset ",
1298 DEPRECATED_SYMBOL_NAME (sym
), len
);
1299 printf_vma (offset
);
1300 printf_filtered (" from basereg %d\n", reg
);
1302 add_memrange (collect
, reg
, offset
, len
);
1304 case LOC_UNRESOLVED
:
1305 printf_filtered ("Don't know LOC_UNRESOLVED %s\n",
1306 DEPRECATED_SYMBOL_NAME (sym
));
1308 case LOC_OPTIMIZED_OUT
:
1309 printf_filtered ("%s has been optimized out of existence.\n",
1310 DEPRECATED_SYMBOL_NAME (sym
));
1315 /* Add all locals (or args) symbols to collection list */
1317 add_local_symbols (struct collection_list
*collect
, CORE_ADDR pc
,
1318 long frame_regno
, long frame_offset
, int type
)
1321 struct block
*block
;
1322 struct dict_iterator iter
;
1325 block
= block_for_pc (pc
);
1328 QUIT
; /* allow user to bail out with ^C */
1329 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
1331 switch (SYMBOL_CLASS (sym
))
1334 warning (_("don't know how to trace local symbol %s"),
1335 DEPRECATED_SYMBOL_NAME (sym
));
1340 if (type
== 'L') /* collecting Locals */
1343 collect_symbol (collect
, sym
, frame_regno
,
1351 case LOC_REGPARM_ADDR
:
1352 case LOC_BASEREG_ARG
:
1353 if (type
== 'A') /* collecting Arguments */
1356 collect_symbol (collect
, sym
, frame_regno
,
1361 if (BLOCK_FUNCTION (block
))
1364 block
= BLOCK_SUPERBLOCK (block
);
1367 warning (_("No %s found in scope."),
1368 type
== 'L' ? "locals" : "args");
1371 /* worker function */
1373 clear_collection_list (struct collection_list
*list
)
1377 list
->next_memrange
= 0;
1378 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1380 free_agent_expr (list
->aexpr_list
[ndx
]);
1381 list
->aexpr_list
[ndx
] = NULL
;
1383 list
->next_aexpr_elt
= 0;
1384 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1387 /* reduce a collection list to string form (for gdb protocol) */
1389 stringify_collection_list (struct collection_list
*list
, char *string
)
1391 char temp_buf
[2048];
1395 char *(*str_list
)[];
1399 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1400 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1402 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1403 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1405 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1408 printf_filtered ("\nCollecting registers (mask): 0x");
1413 QUIT
; /* allow user to bail out with ^C */
1415 printf_filtered ("%02X", list
->regs_mask
[i
]);
1416 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1419 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1423 printf_filtered ("\n");
1424 if (list
->next_memrange
> 0 && info_verbose
)
1425 printf_filtered ("Collecting memranges: \n");
1426 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1428 QUIT
; /* allow user to bail out with ^C */
1429 sprintf_vma (tmp2
, list
->list
[i
].start
);
1432 printf_filtered ("(%d, %s, %ld)\n",
1435 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1437 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1439 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1446 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1448 /* The "%X" conversion specifier expects an unsigned argument,
1449 so passing -1 (memrange_absolute) to it directly gives you
1450 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1452 if (list
->list
[i
].type
== memrange_absolute
)
1453 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1455 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1458 count
+= strlen (end
);
1459 end
= temp_buf
+ count
;
1462 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1464 QUIT
; /* allow user to bail out with ^C */
1465 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1467 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1472 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1473 end
+= 10; /* 'X' + 8 hex digits + ',' */
1476 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1477 end
, list
->aexpr_list
[i
]->len
);
1478 count
+= 2 * list
->aexpr_list
[i
]->len
;
1483 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1488 (*str_list
)[ndx
] = NULL
;
1497 free_actions_list_cleanup_wrapper (void *al
)
1499 free_actions_list (al
);
1503 free_actions_list (char **actions_list
)
1507 if (actions_list
== 0)
1510 for (ndx
= 0; actions_list
[ndx
]; ndx
++)
1511 xfree (actions_list
[ndx
]);
1513 xfree (actions_list
);
1516 /* Render all actions into gdb protocol. */
1518 encode_actions (struct tracepoint
*t
, char ***tdp_actions
,
1519 char ***stepping_actions
)
1521 static char tdp_buff
[2048], step_buff
[2048];
1523 struct expression
*exp
= NULL
;
1524 struct action_line
*action
;
1526 struct value
*tempval
;
1527 struct collection_list
*collect
;
1528 struct cmd_list_element
*cmd
;
1529 struct agent_expr
*aexpr
;
1531 LONGEST frame_offset
;
1534 clear_collection_list (&tracepoint_list
);
1535 clear_collection_list (&stepping_list
);
1536 collect
= &tracepoint_list
;
1538 *tdp_actions
= NULL
;
1539 *stepping_actions
= NULL
;
1541 TARGET_VIRTUAL_FRAME_POINTER (t
->address
, &frame_reg
, &frame_offset
);
1543 for (action
= t
->actions
; action
; action
= action
->next
)
1545 QUIT
; /* allow user to bail out with ^C */
1546 action_exp
= action
->action
;
1547 while (isspace ((int) *action_exp
))
1550 if (*action_exp
== '#') /* comment line */
1553 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1555 error (_("Bad action list item: %s"), action_exp
);
1557 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1560 { /* repeat over a comma-separated list */
1561 QUIT
; /* allow user to bail out with ^C */
1562 while (isspace ((int) *action_exp
))
1565 if (0 == strncasecmp ("$reg", action_exp
, 4))
1567 for (i
= 0; i
< NUM_REGS
; i
++)
1568 add_register (collect
, i
);
1569 action_exp
= strchr (action_exp
, ','); /* more? */
1571 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1573 add_local_symbols (collect
,
1578 action_exp
= strchr (action_exp
, ','); /* more? */
1580 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1582 add_local_symbols (collect
,
1587 action_exp
= strchr (action_exp
, ','); /* more? */
1591 unsigned long addr
, len
;
1592 struct cleanup
*old_chain
= NULL
;
1593 struct cleanup
*old_chain1
= NULL
;
1594 struct agent_reqs areqs
;
1596 exp
= parse_exp_1 (&action_exp
,
1597 block_for_pc (t
->address
), 1);
1598 old_chain
= make_cleanup (free_current_contents
, &exp
);
1600 switch (exp
->elts
[0].opcode
)
1603 i
= exp
->elts
[1].longconst
;
1605 printf_filtered ("OP_REGISTER: ");
1606 add_register (collect
, i
);
1610 /* safe because we know it's a simple expression */
1611 tempval
= evaluate_expression (exp
);
1612 addr
= VALUE_ADDRESS (tempval
) + value_offset (tempval
);
1613 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1614 add_memrange (collect
, memrange_absolute
, addr
, len
);
1618 collect_symbol (collect
,
1619 exp
->elts
[2].symbol
,
1624 default: /* full-fledged expression */
1625 aexpr
= gen_trace_for_expr (t
->address
, exp
);
1627 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1629 ax_reqs (aexpr
, &areqs
);
1630 if (areqs
.flaw
!= agent_flaw_none
)
1631 error (_("malformed expression"));
1633 if (areqs
.min_height
< 0)
1634 error (_("gdb: Internal error: expression has min height < 0"));
1635 if (areqs
.max_height
> 20)
1636 error (_("expression too complicated, try simplifying"));
1638 discard_cleanups (old_chain1
);
1639 add_aexpr (collect
, aexpr
);
1641 /* take care of the registers */
1642 if (areqs
.reg_mask_len
> 0)
1647 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1649 QUIT
; /* allow user to bail out with ^C */
1650 if (areqs
.reg_mask
[ndx1
] != 0)
1652 /* assume chars have 8 bits */
1653 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1654 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1655 /* it's used -- record it */
1656 add_register (collect
,
1663 do_cleanups (old_chain
);
1666 while (action_exp
&& *action_exp
++ == ',');
1668 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1670 collect
= &stepping_list
;
1672 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
1674 if (collect
== &stepping_list
) /* end stepping actions */
1675 collect
= &tracepoint_list
;
1677 break; /* end tracepoint actions */
1680 memrange_sortmerge (&tracepoint_list
);
1681 memrange_sortmerge (&stepping_list
);
1683 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1685 *stepping_actions
= stringify_collection_list (&stepping_list
,
1690 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1692 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1694 collect
->aexpr_list
=
1695 xrealloc (collect
->aexpr_list
,
1696 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1697 collect
->aexpr_listsize
*= 2;
1699 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1700 collect
->next_aexpr_elt
++;
1703 static char target_buf
[2048];
1705 /* Set "transparent" memory ranges
1707 Allow trace mechanism to treat text-like sections
1708 (and perhaps all read-only sections) transparently,
1709 i.e. don't reject memory requests from these address ranges
1710 just because they haven't been collected. */
1713 remote_set_transparent_ranges (void)
1715 extern bfd
*exec_bfd
;
1722 return; /* No information to give. */
1724 strcpy (target_buf
, "QTro");
1725 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
1727 char tmp1
[40], tmp2
[40];
1729 if ((s
->flags
& SEC_LOAD
) == 0 ||
1730 /* (s->flags & SEC_CODE) == 0 || */
1731 (s
->flags
& SEC_READONLY
) == 0)
1736 size
= bfd_get_section_size (s
);
1737 sprintf_vma (tmp1
, lma
);
1738 sprintf_vma (tmp2
, lma
+ size
);
1739 sprintf (target_buf
+ strlen (target_buf
),
1740 ":%s,%s", tmp1
, tmp2
);
1744 putpkt (target_buf
);
1745 getpkt (target_buf
, sizeof (target_buf
), 0);
1751 Tell target to clear any previous trace experiment.
1752 Walk the list of tracepoints, and send them (and their actions)
1753 to the target. If no errors,
1754 Tell target to start a new trace experiment. */
1757 trace_start_command (char *args
, int from_tty
)
1759 struct tracepoint
*t
;
1762 char **stepping_actions
;
1764 struct cleanup
*old_chain
= NULL
;
1766 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1768 if (target_is_remote ())
1771 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1772 if (strcmp (target_buf
, "OK"))
1773 error (_("Target does not support this command."));
1779 sprintf_vma (tmp
, t
->address
);
1780 sprintf (buf
, "QTDP:%x:%s:%c:%lx:%x", t
->number
,
1782 t
->enabled_p
? 'E' : 'D',
1783 t
->step_count
, t
->pass_count
);
1788 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1789 if (strcmp (target_buf
, "OK"))
1790 error (_("Target does not support tracepoints."));
1794 encode_actions (t
, &tdp_actions
, &stepping_actions
);
1795 old_chain
= make_cleanup (free_actions_list_cleanup_wrapper
,
1797 (void) make_cleanup (free_actions_list_cleanup_wrapper
,
1800 /* do_single_steps (t); */
1803 for (ndx
= 0; tdp_actions
[ndx
]; ndx
++)
1805 QUIT
; /* allow user to bail out with ^C */
1806 sprintf (buf
, "QTDP:-%x:%s:%s%c",
1807 t
->number
, tmp
, /* address */
1809 ((tdp_actions
[ndx
+ 1] || stepping_actions
)
1812 remote_get_noisy_reply (target_buf
,
1813 sizeof (target_buf
));
1814 if (strcmp (target_buf
, "OK"))
1815 error (_("Error on target while setting tracepoints."));
1818 if (stepping_actions
)
1820 for (ndx
= 0; stepping_actions
[ndx
]; ndx
++)
1822 QUIT
; /* allow user to bail out with ^C */
1823 sprintf (buf
, "QTDP:-%x:%s:%s%s%s",
1824 t
->number
, tmp
, /* address */
1825 ((ndx
== 0) ? "S" : ""),
1826 stepping_actions
[ndx
],
1827 (stepping_actions
[ndx
+ 1] ? "-" : ""));
1829 remote_get_noisy_reply (target_buf
,
1830 sizeof (target_buf
));
1831 if (strcmp (target_buf
, "OK"))
1832 error (_("Error on target while setting tracepoints."));
1836 do_cleanups (old_chain
);
1839 /* Tell target to treat text-like sections as transparent. */
1840 remote_set_transparent_ranges ();
1841 /* Now insert traps and begin collecting data. */
1843 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1844 if (strcmp (target_buf
, "OK"))
1845 error (_("Bogus reply from target: %s"), target_buf
);
1846 set_traceframe_num (-1); /* All old traceframes invalidated. */
1847 set_tracepoint_num (-1);
1848 set_traceframe_context (-1);
1849 trace_running_p
= 1;
1850 if (deprecated_trace_start_stop_hook
)
1851 deprecated_trace_start_stop_hook (1, from_tty
);
1855 error (_("Trace can only be run on remote targets."));
1860 trace_stop_command (char *args
, int from_tty
)
1862 if (target_is_remote ())
1865 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1866 if (strcmp (target_buf
, "OK"))
1867 error (_("Bogus reply from target: %s"), target_buf
);
1868 trace_running_p
= 0;
1869 if (deprecated_trace_start_stop_hook
)
1870 deprecated_trace_start_stop_hook (0, from_tty
);
1873 error (_("Trace can only be run on remote targets."));
1876 unsigned long trace_running_p
;
1878 /* tstatus command */
1880 trace_status_command (char *args
, int from_tty
)
1882 if (target_is_remote ())
1884 putpkt ("qTStatus");
1885 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1887 if (target_buf
[0] != 'T' ||
1888 (target_buf
[1] != '0' && target_buf
[1] != '1'))
1889 error (_("Bogus reply from target: %s"), target_buf
);
1891 /* exported for use by the GUI */
1892 trace_running_p
= (target_buf
[1] == '1');
1895 error (_("Trace can only be run on remote targets."));
1898 /* Worker function for the various flavors of the tfind command. */
1900 finish_tfind_command (char *msg
,
1904 int target_frameno
= -1, target_tracept
= -1;
1905 CORE_ADDR old_frame_addr
;
1906 struct symbol
*old_func
;
1909 old_frame_addr
= get_frame_base (get_current_frame ());
1910 old_func
= find_pc_function (read_pc ());
1913 reply
= remote_get_noisy_reply (msg
, sizeof_msg
);
1915 while (reply
&& *reply
)
1919 if ((target_frameno
= (int) strtol (++reply
, &reply
, 16)) == -1)
1921 /* A request for a non-existant trace frame has failed.
1922 Our response will be different, depending on FROM_TTY:
1924 If FROM_TTY is true, meaning that this command was
1925 typed interactively by the user, then give an error
1926 and DO NOT change the state of traceframe_number etc.
1928 However if FROM_TTY is false, meaning that we're either
1929 in a script, a loop, or a user-defined command, then
1930 DON'T give an error, but DO change the state of
1931 traceframe_number etc. to invalid.
1933 The rationalle is that if you typed the command, you
1934 might just have committed a typo or something, and you'd
1935 like to NOT lose your current debugging state. However
1936 if you're in a user-defined command or especially in a
1937 loop, then you need a way to detect that the command
1938 failed WITHOUT aborting. This allows you to write
1939 scripts that search thru the trace buffer until the end,
1940 and then continue on to do something else. */
1943 error (_("Target failed to find requested trace frame."));
1947 printf_filtered ("End of trace buffer.\n");
1948 /* The following will not recurse, since it's
1950 trace_find_command ("-1", from_tty
);
1951 reply
= NULL
; /* Break out of loop
1952 (avoid recursive nonsense). */
1957 if ((target_tracept
= (int) strtol (++reply
, &reply
, 16)) == -1)
1958 error (_("Target failed to find requested trace frame."));
1960 case 'O': /* "OK"? */
1961 if (reply
[1] == 'K' && reply
[2] == '\0')
1964 error (_("Bogus reply from target: %s"), reply
);
1967 error (_("Bogus reply from target: %s"), reply
);
1970 flush_cached_frames ();
1971 registers_changed ();
1972 select_frame (get_current_frame ());
1973 set_traceframe_num (target_frameno
);
1974 set_tracepoint_num (target_tracept
);
1975 if (target_frameno
== -1)
1976 set_traceframe_context (-1);
1978 set_traceframe_context (read_pc ());
1982 enum print_what print_what
;
1984 /* NOTE: in immitation of the step command, try to determine
1985 whether we have made a transition from one function to
1986 another. If so, we'll print the "stack frame" (ie. the new
1987 function and it's arguments) -- otherwise we'll just show the
1990 This determination is made by checking (1) whether the
1991 current function has changed, and (2) whether the current FP
1992 has changed. Hack: if the FP wasn't collected, either at the
1993 current or the previous frame, assume that the FP has NOT
1996 if (old_func
== find_pc_function (read_pc ()) &&
1997 (old_frame_addr
== 0 ||
1998 get_frame_base (get_current_frame ()) == 0 ||
1999 old_frame_addr
== get_frame_base (get_current_frame ())))
2000 print_what
= SRC_LINE
;
2002 print_what
= SRC_AND_LOC
;
2004 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2009 /* trace_find_command takes a trace frame number n,
2010 sends "QTFrame:<n>" to the target,
2011 and accepts a reply that may contain several optional pieces
2012 of information: a frame number, a tracepoint number, and an
2013 indication of whether this is a trap frame or a stepping frame.
2015 The minimal response is just "OK" (which indicates that the
2016 target does not give us a frame number or a tracepoint number).
2017 Instead of that, the target may send us a string containing
2019 F<hexnum> (gives the selected frame number)
2020 T<hexnum> (gives the selected tracepoint number)
2025 trace_find_command (char *args
, int from_tty
)
2026 { /* this should only be called with a numeric argument */
2029 if (target_is_remote ())
2031 if (deprecated_trace_find_hook
)
2032 deprecated_trace_find_hook (args
, from_tty
);
2034 if (args
== 0 || *args
== 0)
2035 { /* TFIND with no args means find NEXT trace frame. */
2036 if (traceframe_number
== -1)
2037 frameno
= 0; /* "next" is first one */
2039 frameno
= traceframe_number
+ 1;
2041 else if (0 == strcmp (args
, "-"))
2043 if (traceframe_number
== -1)
2044 error (_("not debugging trace buffer"));
2045 else if (from_tty
&& traceframe_number
== 0)
2046 error (_("already at start of trace buffer"));
2048 frameno
= traceframe_number
- 1;
2051 frameno
= parse_and_eval_long (args
);
2054 error (_("invalid input (%d is less than zero)"), frameno
);
2056 sprintf (target_buf
, "QTFrame:%x", frameno
);
2057 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2060 error (_("Trace can only be run on remote targets."));
2065 trace_find_end_command (char *args
, int from_tty
)
2067 trace_find_command ("-1", from_tty
);
2072 trace_find_none_command (char *args
, int from_tty
)
2074 trace_find_command ("-1", from_tty
);
2079 trace_find_start_command (char *args
, int from_tty
)
2081 trace_find_command ("0", from_tty
);
2084 /* tfind pc command */
2086 trace_find_pc_command (char *args
, int from_tty
)
2091 if (target_is_remote ())
2093 if (args
== 0 || *args
== 0)
2094 pc
= read_pc (); /* default is current pc */
2096 pc
= parse_and_eval_address (args
);
2098 sprintf_vma (tmp
, pc
);
2099 sprintf (target_buf
, "QTFrame:pc:%s", tmp
);
2100 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2103 error (_("Trace can only be run on remote targets."));
2106 /* tfind tracepoint command */
2108 trace_find_tracepoint_command (char *args
, int from_tty
)
2112 if (target_is_remote ())
2114 if (args
== 0 || *args
== 0)
2116 if (tracepoint_number
== -1)
2117 error (_("No current tracepoint -- please supply an argument."));
2119 tdp
= tracepoint_number
; /* default is current TDP */
2122 tdp
= parse_and_eval_long (args
);
2124 sprintf (target_buf
, "QTFrame:tdp:%x", tdp
);
2125 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2128 error (_("Trace can only be run on remote targets."));
2131 /* TFIND LINE command:
2133 This command will take a sourceline for argument, just like BREAK
2134 or TRACE (ie. anything that "decode_line_1" can handle).
2136 With no argument, this command will find the next trace frame
2137 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2140 trace_find_line_command (char *args
, int from_tty
)
2142 static CORE_ADDR start_pc
, end_pc
;
2143 struct symtabs_and_lines sals
;
2144 struct symtab_and_line sal
;
2145 struct cleanup
*old_chain
;
2146 char startpc_str
[40], endpc_str
[40];
2148 if (target_is_remote ())
2150 if (args
== 0 || *args
== 0)
2152 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2154 sals
.sals
= (struct symtab_and_line
*)
2155 xmalloc (sizeof (struct symtab_and_line
));
2160 sals
= decode_line_spec (args
, 1);
2164 old_chain
= make_cleanup (xfree
, sals
.sals
);
2165 if (sal
.symtab
== 0)
2167 printf_filtered ("TFIND: No line number information available");
2170 /* This is useful for "info line *0x7f34". If we can't
2171 tell the user about a source line, at least let them
2172 have the symbolic address. */
2173 printf_filtered (" for address ");
2175 print_address (sal
.pc
, gdb_stdout
);
2176 printf_filtered (";\n -- will attempt to find by PC. \n");
2180 printf_filtered (".\n");
2181 return; /* No line, no PC; what can we do? */
2184 else if (sal
.line
> 0
2185 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2187 if (start_pc
== end_pc
)
2189 printf_filtered ("Line %d of \"%s\"",
2190 sal
.line
, sal
.symtab
->filename
);
2192 printf_filtered (" is at address ");
2193 print_address (start_pc
, gdb_stdout
);
2195 printf_filtered (" but contains no code.\n");
2196 sal
= find_pc_line (start_pc
, 0);
2198 find_line_pc_range (sal
, &start_pc
, &end_pc
) &&
2200 printf_filtered ("Attempting to find line %d instead.\n",
2203 error (_("Cannot find a good line."));
2207 /* Is there any case in which we get here, and have an address
2208 which the user would want to see? If we have debugging
2209 symbols and no line numbers? */
2210 error (_("Line number %d is out of range for \"%s\"."),
2211 sal
.line
, sal
.symtab
->filename
);
2213 sprintf_vma (startpc_str
, start_pc
);
2214 sprintf_vma (endpc_str
, end_pc
- 1);
2215 /* Find within range of stated line. */
2217 sprintf (target_buf
, "QTFrame:range:%s:%s",
2218 startpc_str
, endpc_str
);
2219 /* Find OUTSIDE OF range of CURRENT line. */
2221 sprintf (target_buf
, "QTFrame:outside:%s:%s",
2222 startpc_str
, endpc_str
);
2223 finish_tfind_command (target_buf
, sizeof (target_buf
),
2225 do_cleanups (old_chain
);
2228 error (_("Trace can only be run on remote targets."));
2231 /* tfind range command */
2233 trace_find_range_command (char *args
, int from_tty
)
2235 static CORE_ADDR start
, stop
;
2236 char start_str
[40], stop_str
[40];
2239 if (target_is_remote ())
2241 if (args
== 0 || *args
== 0)
2242 { /* XXX FIXME: what should default behavior be? */
2243 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2247 if (0 != (tmp
= strchr (args
, ',')))
2249 *tmp
++ = '\0'; /* terminate start address */
2250 while (isspace ((int) *tmp
))
2252 start
= parse_and_eval_address (args
);
2253 stop
= parse_and_eval_address (tmp
);
2256 { /* no explicit end address? */
2257 start
= parse_and_eval_address (args
);
2258 stop
= start
+ 1; /* ??? */
2261 sprintf_vma (start_str
, start
);
2262 sprintf_vma (stop_str
, stop
);
2263 sprintf (target_buf
, "QTFrame:range:%s:%s", start_str
, stop_str
);
2264 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2267 error (_("Trace can only be run on remote targets."));
2270 /* tfind outside command */
2272 trace_find_outside_command (char *args
, int from_tty
)
2274 CORE_ADDR start
, stop
;
2275 char start_str
[40], stop_str
[40];
2278 if (target_is_remote ())
2280 if (args
== 0 || *args
== 0)
2281 { /* XXX FIXME: what should default behavior be? */
2282 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2286 if (0 != (tmp
= strchr (args
, ',')))
2288 *tmp
++ = '\0'; /* terminate start address */
2289 while (isspace ((int) *tmp
))
2291 start
= parse_and_eval_address (args
);
2292 stop
= parse_and_eval_address (tmp
);
2295 { /* no explicit end address? */
2296 start
= parse_and_eval_address (args
);
2297 stop
= start
+ 1; /* ??? */
2300 sprintf_vma (start_str
, start
);
2301 sprintf_vma (stop_str
, stop
);
2302 sprintf (target_buf
, "QTFrame:outside:%s:%s", start_str
, stop_str
);
2303 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2306 error (_("Trace can only be run on remote targets."));
2309 /* save-tracepoints command */
2311 tracepoint_save_command (char *args
, int from_tty
)
2313 struct tracepoint
*tp
;
2314 struct action_line
*line
;
2316 char *i1
= " ", *i2
= " ";
2317 char *indent
, *actionline
, *pathname
;
2320 if (args
== 0 || *args
== 0)
2321 error (_("Argument required (file name in which to save tracepoints"));
2323 if (tracepoint_chain
== 0)
2325 warning (_("save-tracepoints: no tracepoints to save."));
2329 pathname
= tilde_expand (args
);
2330 if (!(fp
= fopen (pathname
, "w")))
2331 error (_("Unable to open file '%s' for saving tracepoints (%s)"),
2332 args
, safe_strerror (errno
));
2335 ALL_TRACEPOINTS (tp
)
2337 if (tp
->addr_string
)
2338 fprintf (fp
, "trace %s\n", tp
->addr_string
);
2341 sprintf_vma (tmp
, tp
->address
);
2342 fprintf (fp
, "trace *0x%s\n", tmp
);
2346 fprintf (fp
, " passcount %d\n", tp
->pass_count
);
2350 fprintf (fp
, " actions\n");
2352 for (line
= tp
->actions
; line
; line
= line
->next
)
2354 struct cmd_list_element
*cmd
;
2356 QUIT
; /* allow user to bail out with ^C */
2357 actionline
= line
->action
;
2358 while (isspace ((int) *actionline
))
2361 fprintf (fp
, "%s%s\n", indent
, actionline
);
2362 if (*actionline
!= '#') /* skip for comment lines */
2364 cmd
= lookup_cmd (&actionline
, cmdlist
, "", -1, 1);
2366 error (_("Bad action list item: %s"), actionline
);
2367 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2369 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2377 printf_filtered ("Tracepoints saved to file '%s'.\n", args
);
2381 /* info scope command: list the locals for a scope. */
2383 scope_info (char *args
, int from_tty
)
2385 struct symtabs_and_lines sals
;
2387 struct minimal_symbol
*msym
;
2388 struct block
*block
;
2389 char **canonical
, *symname
, *save_args
= args
;
2390 struct dict_iterator iter
;
2393 if (args
== 0 || *args
== 0)
2394 error (_("requires an argument (function, line or *addr) to define a scope"));
2396 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2397 if (sals
.nelts
== 0)
2398 return; /* presumably decode_line_1 has already warned */
2400 /* Resolve line numbers to PC */
2401 resolve_sal_pc (&sals
.sals
[0]);
2402 block
= block_for_pc (sals
.sals
[0].pc
);
2406 QUIT
; /* allow user to bail out with ^C */
2407 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2409 QUIT
; /* allow user to bail out with ^C */
2411 printf_filtered ("Scope for %s:\n", save_args
);
2414 symname
= DEPRECATED_SYMBOL_NAME (sym
);
2415 if (symname
== NULL
|| *symname
== '\0')
2416 continue; /* probably botched, certainly useless */
2418 printf_filtered ("Symbol %s is ", symname
);
2419 switch (SYMBOL_CLASS (sym
))
2422 case LOC_UNDEF
: /* messed up symbol? */
2423 printf_filtered ("a bogus symbol, class %d.\n",
2424 SYMBOL_CLASS (sym
));
2425 count
--; /* don't count this one */
2428 printf_filtered ("a constant with value %ld (0x%lx)",
2429 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2431 case LOC_CONST_BYTES
:
2432 printf_filtered ("constant bytes: ");
2433 if (SYMBOL_TYPE (sym
))
2434 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2435 fprintf_filtered (gdb_stdout
, " %02x",
2436 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2439 printf_filtered ("in static storage at address ");
2440 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
),
2444 printf_filtered ("a local variable in register $%s",
2445 REGISTER_NAME (SYMBOL_VALUE (sym
)));
2449 printf_filtered ("an argument at stack/frame offset %ld",
2450 SYMBOL_VALUE (sym
));
2453 printf_filtered ("a local variable at frame offset %ld",
2454 SYMBOL_VALUE (sym
));
2457 printf_filtered ("a reference argument at offset %ld",
2458 SYMBOL_VALUE (sym
));
2461 printf_filtered ("an argument in register $%s",
2462 REGISTER_NAME (SYMBOL_VALUE (sym
)));
2464 case LOC_REGPARM_ADDR
:
2465 printf_filtered ("the address of an argument, in register $%s",
2466 REGISTER_NAME (SYMBOL_VALUE (sym
)));
2469 printf_filtered ("a typedef.\n");
2472 printf_filtered ("a label at address ");
2473 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
),
2477 printf_filtered ("a function at address ");
2478 deprecated_print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)),
2482 printf_filtered ("a variable at offset %ld from register $%s",
2484 REGISTER_NAME (SYMBOL_BASEREG (sym
)));
2486 case LOC_BASEREG_ARG
:
2487 printf_filtered ("an argument at offset %ld from register $%s",
2489 REGISTER_NAME (SYMBOL_BASEREG (sym
)));
2491 case LOC_UNRESOLVED
:
2492 msym
= lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (sym
),
2495 printf_filtered ("Unresolved Static");
2498 printf_filtered ("static storage at address ");
2499 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (msym
), 1,
2503 case LOC_OPTIMIZED_OUT
:
2504 printf_filtered ("optimized out.\n");
2506 case LOC_HP_THREAD_LOCAL_STATIC
:
2507 printf_filtered ("HP thread local static ");
2510 printf_filtered ("extern (local indirect) at address ");
2511 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
),
2515 case LOC_COMPUTED_ARG
:
2516 SYMBOL_OPS (sym
)->describe_location (sym
, gdb_stdout
);
2519 if (SYMBOL_TYPE (sym
))
2520 printf_filtered (", length %d.\n",
2521 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2523 if (BLOCK_FUNCTION (block
))
2526 block
= BLOCK_SUPERBLOCK (block
);
2529 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2533 /* worker function (cleanup) */
2535 replace_comma (void *data
)
2543 trace_dump_command (char *args
, int from_tty
)
2545 struct tracepoint
*t
;
2546 struct action_line
*action
;
2547 char *action_exp
, *next_comma
;
2548 struct cleanup
*old_cleanups
;
2549 int stepping_actions
= 0;
2550 int stepping_frame
= 0;
2552 if (!target_is_remote ())
2554 error (_("Trace can only be run on remote targets."));
2558 if (tracepoint_number
== -1)
2560 warning (_("No current trace frame."));
2565 if (t
->number
== tracepoint_number
)
2569 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2572 old_cleanups
= make_cleanup (null_cleanup
, NULL
);
2574 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2575 tracepoint_number
, traceframe_number
);
2577 /* The current frame is a trap frame if the frame PC is equal
2578 to the tracepoint PC. If not, then the current frame was
2579 collected during single-stepping. */
2581 stepping_frame
= (t
->address
!= (read_pc () - DECR_PC_AFTER_BREAK
));
2583 for (action
= t
->actions
; action
; action
= action
->next
)
2585 struct cmd_list_element
*cmd
;
2587 QUIT
; /* allow user to bail out with ^C */
2588 action_exp
= action
->action
;
2589 while (isspace ((int) *action_exp
))
2592 /* The collection actions to be done while stepping are
2593 bracketed by the commands "while-stepping" and "end". */
2595 if (*action_exp
== '#') /* comment line */
2598 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2600 error (_("Bad action list item: %s"), action_exp
);
2602 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2603 stepping_actions
= 1;
2604 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2605 stepping_actions
= 0;
2606 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2608 /* Display the collected data.
2609 For the trap frame, display only what was collected at
2610 the trap. Likewise for stepping frames, display only
2611 what was collected while stepping. This means that the
2612 two boolean variables, STEPPING_FRAME and
2613 STEPPING_ACTIONS should be equal. */
2614 if (stepping_frame
== stepping_actions
)
2617 { /* repeat over a comma-separated list */
2618 QUIT
; /* allow user to bail out with ^C */
2619 if (*action_exp
== ',')
2621 while (isspace ((int) *action_exp
))
2624 next_comma
= strchr (action_exp
, ',');
2626 if (0 == strncasecmp (action_exp
, "$reg", 4))
2627 registers_info (NULL
, from_tty
);
2628 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2629 locals_info (NULL
, from_tty
);
2630 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2631 args_info (NULL
, from_tty
);
2636 make_cleanup (replace_comma
, next_comma
);
2639 printf_filtered ("%s = ", action_exp
);
2640 output_command (action_exp
, from_tty
);
2641 printf_filtered ("\n");
2645 action_exp
= next_comma
;
2647 while (action_exp
&& *action_exp
== ',');
2651 discard_cleanups (old_cleanups
);
2654 /* Convert the memory pointed to by mem into hex, placing result in buf.
2655 * Return a pointer to the last char put in buf (null)
2656 * "stolen" from sparc-stub.c
2659 static const char hexchars
[] = "0123456789abcdef";
2662 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2670 *buf
++ = hexchars
[ch
>> 4];
2671 *buf
++ = hexchars
[ch
& 0xf];
2680 get_traceframe_number (void)
2682 return traceframe_number
;
2686 /* module initialization */
2688 _initialize_tracepoint (void)
2690 struct cmd_list_element
*c
;
2692 tracepoint_chain
= 0;
2693 tracepoint_count
= 0;
2694 traceframe_number
= -1;
2695 tracepoint_number
= -1;
2697 set_internalvar (lookup_internalvar ("tpnum"),
2698 value_from_longest (builtin_type_int
, (LONGEST
) 0));
2699 set_internalvar (lookup_internalvar ("trace_frame"),
2700 value_from_longest (builtin_type_int
, (LONGEST
) - 1));
2702 if (tracepoint_list
.list
== NULL
)
2704 tracepoint_list
.listsize
= 128;
2705 tracepoint_list
.list
= xmalloc
2706 (tracepoint_list
.listsize
* sizeof (struct memrange
));
2708 if (tracepoint_list
.aexpr_list
== NULL
)
2710 tracepoint_list
.aexpr_listsize
= 128;
2711 tracepoint_list
.aexpr_list
= xmalloc
2712 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
2715 if (stepping_list
.list
== NULL
)
2717 stepping_list
.listsize
= 128;
2718 stepping_list
.list
= xmalloc
2719 (stepping_list
.listsize
* sizeof (struct memrange
));
2722 if (stepping_list
.aexpr_list
== NULL
)
2724 stepping_list
.aexpr_listsize
= 128;
2725 stepping_list
.aexpr_list
= xmalloc
2726 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
2729 add_info ("scope", scope_info
,
2730 _("List the variables local to a scope"));
2732 add_cmd ("tracepoints", class_trace
, NULL
,
2733 _("Tracing of program execution without stopping the program."),
2736 add_info ("tracepoints", tracepoints_info
, _("\
2737 Status of tracepoints, or tracepoint number NUMBER.\n\
2738 Convenience variable \"$tpnum\" contains the number of the\n\
2739 last tracepoint set."));
2741 add_info_alias ("tp", "tracepoints", 1);
2743 c
= add_com ("save-tracepoints", class_trace
, tracepoint_save_command
, _("\
2744 Save current tracepoint definitions as a script.\n\
2745 Use the 'source' command in another debug session to restore them."));
2746 set_cmd_completer (c
, filename_completer
);
2748 add_com ("tdump", class_trace
, trace_dump_command
,
2749 _("Print everything collected at the current tracepoint."));
2751 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
2752 Select a trace frame;\n\
2753 No argument means forward by one frame; '-' means backward by one frame."),
2754 &tfindlist
, "tfind ", 1, &cmdlist
);
2756 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
2757 Select a trace frame whose PC is outside the given range.\n\
2758 Usage: tfind outside addr1, addr2"),
2761 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
2762 Select a trace frame whose PC is in the given range.\n\
2763 Usage: tfind range addr1,addr2"),
2766 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
2767 Select a trace frame by source line.\n\
2768 Argument can be a line number (with optional source file), \n\
2769 a function name, or '*' followed by an address.\n\
2770 Default argument is 'the next source line that was traced'."),
2773 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
2774 Select a trace frame by tracepoint number.\n\
2775 Default is the tracepoint for the current trace frame."),
2778 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
2779 Select a trace frame by PC.\n\
2780 Default is the current PC, or the PC of the current trace frame."),
2783 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
2784 Synonym for 'none'.\n\
2785 De-select any trace frame and resume 'live' debugging."),
2788 add_cmd ("none", class_trace
, trace_find_none_command
,
2789 _("De-select any trace frame and resume 'live' debugging."),
2792 add_cmd ("start", class_trace
, trace_find_start_command
,
2793 _("Select the first trace frame in the trace buffer."),
2796 add_com ("tstatus", class_trace
, trace_status_command
,
2797 _("Display the status of the current trace data collection."));
2799 add_com ("tstop", class_trace
, trace_stop_command
,
2800 _("Stop trace data collection."));
2802 add_com ("tstart", class_trace
, trace_start_command
,
2803 _("Start trace data collection."));
2805 add_com ("passcount", class_trace
, trace_pass_command
, _("\
2806 Set the passcount for a tracepoint.\n\
2807 The trace will end when the tracepoint has been passed 'count' times.\n\
2808 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
2809 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
2811 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
2812 Ends a list of commands or actions.\n\
2813 Several GDB commands allow you to enter a list of commands or actions.\n\
2814 Entering \"end\" on a line by itself is the normal way to terminate\n\
2816 Note: the \"end\" command cannot be used at the gdb prompt."));
2818 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
2819 Specify single-stepping behavior at a tracepoint.\n\
2820 Argument is number of instructions to trace in single-step mode\n\
2821 following the tracepoint. This command is normally followed by\n\
2822 one or more \"collect\" commands, to specify what to collect\n\
2823 while single-stepping.\n\n\
2824 Note: this command can only be used in a tracepoint \"actions\" list."));
2826 add_com_alias ("ws", "while-stepping", class_alias
, 0);
2827 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
2829 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
2830 Specify one or more data items to be collected at a tracepoint.\n\
2831 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
2832 collect all data (variables, registers) referenced by that expression.\n\
2833 Also accepts the following special arguments:\n\
2834 $regs -- all registers.\n\
2835 $args -- all function arguments.\n\
2836 $locals -- all variables local to the block/function scope.\n\
2837 Note: this command can only be used in a tracepoint \"actions\" list."));
2839 add_com ("actions", class_trace
, trace_actions_command
, _("\
2840 Specify the actions to be taken at a tracepoint.\n\
2841 Tracepoint actions may include collecting of specified data, \n\
2842 single-stepping, or enabling/disabling other tracepoints, \n\
2843 depending on target's capabilities."));
2845 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
2846 Delete specified tracepoints.\n\
2847 Arguments are tracepoint numbers, separated by spaces.\n\
2848 No argument means delete all tracepoints."),
2851 add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
2852 Disable specified tracepoints.\n\
2853 Arguments are tracepoint numbers, separated by spaces.\n\
2854 No argument means disable all tracepoints."),
2857 add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
2858 Enable specified tracepoints.\n\
2859 Arguments are tracepoint numbers, separated by spaces.\n\
2860 No argument means enable all tracepoints."),
2863 c
= add_com ("trace", class_trace
, trace_command
, _("\
2864 Set a tracepoint at a specified line or function or address.\n\
2865 Argument may be a line number, function name, or '*' plus an address.\n\
2866 For a line number or function, trace at the start of its code.\n\
2867 If an address is specified, trace at that exact address.\n\n\
2868 Do \"help tracepoints\" for info on other tracepoint commands."));
2869 set_cmd_completer (c
, location_completer
);
2871 add_com_alias ("tp", "trace", class_alias
, 0);
2872 add_com_alias ("tr", "trace", class_alias
, 1);
2873 add_com_alias ("tra", "trace", class_alias
, 1);
2874 add_com_alias ("trac", "trace", class_alias
, 1);