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 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 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 int addressprint
; /* Print machine addresses? */
73 /* GDB commands implemented in other modules:
76 extern void output_command (char *, int);
81 This module defines the following debugger commands:
82 trace : set a tracepoint on a function, line, or address.
83 info trace : list all debugger-defined tracepoints.
84 delete trace : delete one or more tracepoints.
85 enable trace : enable one or more tracepoints.
86 disable trace : disable one or more tracepoints.
87 actions : specify actions to be taken at a tracepoint.
88 passcount : specify a pass count for a tracepoint.
89 tstart : start a trace experiment.
90 tstop : stop a trace experiment.
91 tstatus : query the status of a trace experiment.
92 tfind : find a trace frame in the trace buffer.
93 tdump : print everything collected at the current tracepoint.
94 save-tracepoints : write tracepoint setup into a file.
96 This module defines the following user-visible debugger variables:
97 $trace_frame : sequence number of trace frame currently being debugged.
98 $trace_line : source line of trace frame currently being debugged.
99 $trace_file : source file of trace frame currently being debugged.
100 $tracepoint : tracepoint number of trace frame currently being debugged.
104 /* ======= Important global variables: ======= */
106 /* Chain of all tracepoints defined. */
107 struct tracepoint
*tracepoint_chain
;
109 /* Number of last tracepoint made. */
110 static int tracepoint_count
;
112 /* Number of last traceframe collected. */
113 static int traceframe_number
;
115 /* Tracepoint for last traceframe collected. */
116 static int tracepoint_number
;
118 /* Symbol for function for last traceframe collected */
119 static struct symbol
*traceframe_fun
;
121 /* Symtab and line for last traceframe collected */
122 static struct symtab_and_line traceframe_sal
;
124 /* Tracing command lists */
125 static struct cmd_list_element
*tfindlist
;
127 /* ======= Important command functions: ======= */
128 static void trace_command (char *, int);
129 static void tracepoints_info (char *, int);
130 static void delete_trace_command (char *, int);
131 static void enable_trace_command (char *, int);
132 static void disable_trace_command (char *, int);
133 static void trace_pass_command (char *, int);
134 static void trace_actions_command (char *, int);
135 static void trace_start_command (char *, int);
136 static void trace_stop_command (char *, int);
137 static void trace_status_command (char *, int);
138 static void trace_find_command (char *, int);
139 static void trace_find_pc_command (char *, int);
140 static void trace_find_tracepoint_command (char *, int);
141 static void trace_find_line_command (char *, int);
142 static void trace_find_range_command (char *, int);
143 static void trace_find_outside_command (char *, int);
144 static void tracepoint_save_command (char *, int);
145 static void trace_dump_command (char *, int);
147 /* support routines */
148 static void trace_mention (struct tracepoint
*);
150 struct collection_list
;
151 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
152 static char *mem2hex (gdb_byte
*, char *, int);
153 static void add_register (struct collection_list
*collection
,
155 static struct cleanup
*make_cleanup_free_actions (struct tracepoint
*t
);
156 static void free_actions_list (char **actions_list
);
157 static void free_actions_list_cleanup_wrapper (void *);
159 extern void _initialize_tracepoint (void);
161 /* Utility: returns true if "target remote" */
163 target_is_remote (void)
165 if (current_target
.to_shortname
&&
166 (strcmp (current_target
.to_shortname
, "remote") == 0
167 || strcmp (current_target
.to_shortname
, "extended-remote") == 0))
173 /* Utility: generate error from an incoming stub packet. */
175 trace_error (char *buf
)
178 return; /* not an error msg */
181 case '1': /* malformed packet error */
182 if (*++buf
== '0') /* general case: */
183 error (_("tracepoint.c: error in outgoing packet."));
185 error (_("tracepoint.c: error in outgoing packet at field #%ld."),
186 strtol (buf
, NULL
, 16));
188 error (_("trace API error 0x%s."), ++buf
);
190 error (_("Target returns error code '%s'."), buf
);
194 /* Utility: wait for reply from stub, while accepting "O" packets. */
196 remote_get_noisy_reply (char **buf_p
,
199 do /* Loop on reply from remote stub. */
202 QUIT
; /* allow user to bail out with ^C */
203 getpkt (buf_p
, sizeof_buf
, 0);
206 error (_("Target does not support this command."));
207 else if (buf
[0] == 'E')
209 else if (buf
[0] == 'O' &&
211 remote_console_output (buf
+ 1); /* 'O' message from stub */
213 return buf
; /* here's the actual reply */
218 /* Set tracepoint count to NUM. */
220 set_tracepoint_count (int num
)
222 tracepoint_count
= num
;
223 set_internalvar (lookup_internalvar ("tpnum"),
224 value_from_longest (builtin_type_int
, (LONGEST
) num
));
227 /* Set traceframe number to NUM. */
229 set_traceframe_num (int num
)
231 traceframe_number
= num
;
232 set_internalvar (lookup_internalvar ("trace_frame"),
233 value_from_longest (builtin_type_int
, (LONGEST
) num
));
236 /* Set tracepoint number to NUM. */
238 set_tracepoint_num (int num
)
240 tracepoint_number
= num
;
241 set_internalvar (lookup_internalvar ("tracepoint"),
242 value_from_longest (builtin_type_int
,
246 /* Set externally visible debug variables for querying/printing
247 the traceframe context (line, function, file) */
250 set_traceframe_context (CORE_ADDR trace_pc
)
252 static struct type
*func_string
, *file_string
;
253 static struct type
*func_range
, *file_range
;
254 struct value
*func_val
;
255 struct value
*file_val
;
256 static struct type
*charstar
;
259 if (charstar
== (struct type
*) NULL
)
260 charstar
= lookup_pointer_type (builtin_type_char
);
262 if (trace_pc
== -1) /* Cease debugging any trace buffers. */
265 traceframe_sal
.pc
= traceframe_sal
.line
= 0;
266 traceframe_sal
.symtab
= NULL
;
267 set_internalvar (lookup_internalvar ("trace_func"),
268 value_from_pointer (charstar
, (LONGEST
) 0));
269 set_internalvar (lookup_internalvar ("trace_file"),
270 value_from_pointer (charstar
, (LONGEST
) 0));
271 set_internalvar (lookup_internalvar ("trace_line"),
272 value_from_longest (builtin_type_int
,
277 /* Save as globals for internal use. */
278 traceframe_sal
= find_pc_line (trace_pc
, 0);
279 traceframe_fun
= find_pc_function (trace_pc
);
281 /* Save linenumber as "$trace_line", a debugger variable visible to
283 set_internalvar (lookup_internalvar ("trace_line"),
284 value_from_longest (builtin_type_int
,
285 (LONGEST
) traceframe_sal
.line
));
287 /* Save func name as "$trace_func", a debugger variable visible to
289 if (traceframe_fun
== NULL
||
290 DEPRECATED_SYMBOL_NAME (traceframe_fun
) == NULL
)
291 set_internalvar (lookup_internalvar ("trace_func"),
292 value_from_pointer (charstar
, (LONGEST
) 0));
295 len
= strlen (DEPRECATED_SYMBOL_NAME (traceframe_fun
));
296 func_range
= create_range_type (func_range
,
297 builtin_type_int
, 0, len
- 1);
298 func_string
= create_array_type (func_string
,
299 builtin_type_char
, func_range
);
300 func_val
= allocate_value (func_string
);
301 deprecated_set_value_type (func_val
, func_string
);
302 memcpy (value_contents_raw (func_val
),
303 DEPRECATED_SYMBOL_NAME (traceframe_fun
),
305 deprecated_set_value_modifiable (func_val
, 0);
306 set_internalvar (lookup_internalvar ("trace_func"), func_val
);
309 /* Save file name as "$trace_file", a debugger variable visible to
311 if (traceframe_sal
.symtab
== NULL
||
312 traceframe_sal
.symtab
->filename
== NULL
)
313 set_internalvar (lookup_internalvar ("trace_file"),
314 value_from_pointer (charstar
, (LONGEST
) 0));
317 len
= strlen (traceframe_sal
.symtab
->filename
);
318 file_range
= create_range_type (file_range
,
319 builtin_type_int
, 0, len
- 1);
320 file_string
= create_array_type (file_string
,
321 builtin_type_char
, file_range
);
322 file_val
= allocate_value (file_string
);
323 deprecated_set_value_type (file_val
, file_string
);
324 memcpy (value_contents_raw (file_val
),
325 traceframe_sal
.symtab
->filename
,
327 deprecated_set_value_modifiable (file_val
, 0);
328 set_internalvar (lookup_internalvar ("trace_file"), file_val
);
332 /* Low level routine to set a tracepoint.
333 Returns the tracepoint object so caller can set other things.
334 Does not set the tracepoint number!
335 Does not print anything.
337 ==> This routine should not be called if there is a chance of later
338 error(); otherwise it leaves a bogus tracepoint on the chain.
339 Validate your arguments BEFORE calling this routine! */
341 static struct tracepoint
*
342 set_raw_tracepoint (struct symtab_and_line sal
)
344 struct tracepoint
*t
, *tc
;
345 struct cleanup
*old_chain
;
347 t
= (struct tracepoint
*) xmalloc (sizeof (struct tracepoint
));
348 old_chain
= make_cleanup (xfree
, t
);
349 memset (t
, 0, sizeof (*t
));
351 if (sal
.symtab
== NULL
)
352 t
->source_file
= NULL
;
354 t
->source_file
= savestring (sal
.symtab
->filename
,
355 strlen (sal
.symtab
->filename
));
357 t
->section
= sal
.section
;
358 t
->language
= current_language
->la_language
;
359 t
->input_radix
= input_radix
;
360 t
->line_number
= sal
.line
;
365 t
->addr_string
= NULL
;
367 /* Add this tracepoint to the end of the chain
368 so that a list of tracepoints will come out in order
369 of increasing numbers. */
371 tc
= tracepoint_chain
;
373 tracepoint_chain
= t
;
380 discard_cleanups (old_chain
);
384 /* Set a tracepoint according to ARG (function, linenum or *address). */
386 trace_command (char *arg
, int from_tty
)
388 char **canonical
= (char **) NULL
;
389 struct symtabs_and_lines sals
;
390 struct symtab_and_line sal
;
391 struct tracepoint
*t
;
392 char *addr_start
= 0, *addr_end
= 0;
396 error (_("trace command requires an argument"));
398 if (from_tty
&& info_verbose
)
399 printf_filtered ("TRACE %s\n", arg
);
402 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
403 0, &canonical
, NULL
);
406 return; /* ??? Presumably decode_line_1 has already warned? */
408 /* Resolve all line numbers to PC's */
409 for (i
= 0; i
< sals
.nelts
; i
++)
410 resolve_sal_pc (&sals
.sals
[i
]);
412 /* Now set all the tracepoints. */
413 for (i
= 0; i
< sals
.nelts
; i
++)
417 t
= set_raw_tracepoint (sal
);
418 set_tracepoint_count (tracepoint_count
+ 1);
419 t
->number
= tracepoint_count
;
421 /* If a canonical line spec is needed use that instead of the
423 if (canonical
!= (char **) NULL
&& canonical
[i
] != NULL
)
424 t
->addr_string
= canonical
[i
];
426 t
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
433 printf_filtered ("Multiple tracepoints were set.\n");
434 printf_filtered ("Use 'delete trace' to delete unwanted tracepoints.\n");
438 /* Tell the user we have just set a tracepoint TP. */
441 trace_mention (struct tracepoint
*tp
)
443 printf_filtered ("Tracepoint %d", tp
->number
);
445 if (addressprint
|| (tp
->source_file
== NULL
))
447 printf_filtered (" at ");
448 deprecated_print_address_numeric (tp
->address
, 1, gdb_stdout
);
451 printf_filtered (": file %s, line %d.",
452 tp
->source_file
, tp
->line_number
);
454 printf_filtered ("\n");
457 /* Print information on tracepoint number TPNUM_EXP, or all if
461 tracepoints_info (char *tpnum_exp
, int from_tty
)
463 struct tracepoint
*t
;
464 struct action_line
*action
;
465 int found_a_tracepoint
= 0;
466 char wrap_indent
[80];
471 tpnum
= parse_and_eval_long (tpnum_exp
);
474 if (tpnum
== -1 || tpnum
== t
->number
)
476 extern int addressprint
; /* Print machine addresses? */
478 if (!found_a_tracepoint
++)
480 printf_filtered ("Num Enb ");
483 if (TARGET_ADDR_BIT
<= 32)
484 printf_filtered ("Address ");
486 printf_filtered ("Address ");
488 printf_filtered ("PassC StepC What\n");
490 strcpy (wrap_indent
, " ");
493 if (TARGET_ADDR_BIT
<= 32)
494 strcat (wrap_indent
, " ");
496 strcat (wrap_indent
, " ");
499 printf_filtered ("%-3d %-3s ", t
->number
,
500 t
->enabled_p
? "y" : "n");
505 if (TARGET_ADDR_BIT
<= 32)
506 tmp
= hex_string_custom (t
->address
& (CORE_ADDR
) 0xffffffff,
509 tmp
= hex_string_custom (t
->address
, 16);
511 printf_filtered ("%s ", tmp
);
513 printf_filtered ("%-5d %-5ld ", t
->pass_count
, t
->step_count
);
517 sym
= find_pc_sect_function (t
->address
, t
->section
);
520 fputs_filtered ("in ", gdb_stdout
);
521 fputs_filtered (SYMBOL_PRINT_NAME (sym
), gdb_stdout
);
522 wrap_here (wrap_indent
);
523 fputs_filtered (" at ", gdb_stdout
);
525 fputs_filtered (t
->source_file
, gdb_stdout
);
526 printf_filtered (":%d", t
->line_number
);
529 print_address_symbolic (t
->address
, gdb_stdout
, demangle
, " ");
531 printf_filtered ("\n");
534 printf_filtered (" Actions for tracepoint %d: \n", t
->number
);
535 for (action
= t
->actions
; action
; action
= action
->next
)
537 printf_filtered ("\t%s\n", action
->action
);
541 if (!found_a_tracepoint
)
544 printf_filtered ("No tracepoints.\n");
546 printf_filtered ("No tracepoint number %d.\n", tpnum
);
550 /* Optimization: the code to parse an enable, disable, or delete TP
551 command is virtually identical except for whether it performs an
552 enable, disable, or delete. Therefore I've combined them into one
553 function with an opcode. */
554 enum tracepoint_opcode
561 /* This function implements enable, disable and delete commands. */
563 tracepoint_operation (struct tracepoint
*t
, int from_tty
,
564 enum tracepoint_opcode opcode
)
566 struct tracepoint
*t2
;
568 if (t
== NULL
) /* no tracepoint operand */
575 tracepoint_modify_event (t
->number
);
579 tracepoint_modify_event (t
->number
);
582 if (tracepoint_chain
== t
)
583 tracepoint_chain
= t
->next
;
588 tracepoint_delete_event (t2
->number
);
594 xfree (t
->addr_string
);
596 xfree (t
->source_file
);
605 /* Utility: parse a tracepoint number and look it up in the list.
606 If MULTI_P is true, there might be a range of tracepoints in ARG.
607 if OPTIONAL_P is true, then if the argument is missing, the most
608 recent tracepoint (tracepoint_count) is returned. */
610 get_tracepoint_by_number (char **arg
, int multi_p
, int optional_p
)
612 struct tracepoint
*t
;
614 char *instring
= arg
== NULL
? NULL
: *arg
;
616 if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
619 tpnum
= tracepoint_count
;
621 error_no_arg (_("tracepoint number"));
624 tpnum
= multi_p
? get_number_or_range (arg
) : get_number (arg
);
628 if (instring
&& *instring
)
629 printf_filtered ("bad tracepoint number at or near '%s'\n",
632 printf_filtered ("Tracepoint argument missing and no previous tracepoint\n");
637 if (t
->number
== tpnum
)
642 /* FIXME: if we are in the middle of a range we don't want to give
643 a message. The current interface to get_number_or_range doesn't
644 allow us to discover this. */
645 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
650 parse a list of tracepoint numbers, and call a func for each. */
652 map_args_over_tracepoints (char *args
, int from_tty
,
653 enum tracepoint_opcode opcode
)
655 struct tracepoint
*t
, *tmp
;
657 if (args
== 0 || *args
== 0) /* do them all */
658 ALL_TRACEPOINTS_SAFE (t
, tmp
)
659 tracepoint_operation (t
, from_tty
, opcode
);
663 QUIT
; /* Give user option to bail out with ^C. */
664 t
= get_tracepoint_by_number (&args
, 1, 0);
665 tracepoint_operation (t
, from_tty
, opcode
);
666 while (*args
== ' ' || *args
== '\t')
671 /* The 'enable trace' command enables tracepoints.
672 Not supported by all targets. */
674 enable_trace_command (char *args
, int from_tty
)
677 map_args_over_tracepoints (args
, from_tty
, enable_op
);
680 /* The 'disable trace' command disables tracepoints.
681 Not supported by all targets. */
683 disable_trace_command (char *args
, int from_tty
)
686 map_args_over_tracepoints (args
, from_tty
, disable_op
);
689 /* Remove a tracepoint (or all if no argument) */
691 delete_trace_command (char *args
, int from_tty
)
694 if (!args
|| !*args
) /* No args implies all tracepoints; */
695 if (from_tty
) /* confirm only if from_tty... */
696 if (tracepoint_chain
) /* and if there are tracepoints to
698 if (!query ("Delete all tracepoints? "))
701 map_args_over_tracepoints (args
, from_tty
, delete_op
);
704 /* Set passcount for tracepoint.
706 First command argument is passcount, second is tracepoint number.
707 If tracepoint number omitted, apply to most recently defined.
708 Also accepts special argument "all". */
711 trace_pass_command (char *args
, int from_tty
)
713 struct tracepoint
*t1
= (struct tracepoint
*) -1, *t2
;
717 if (args
== 0 || *args
== 0)
718 error (_("passcount command requires an argument (count + optional TP num)"));
720 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
722 while (*args
&& isspace ((int) *args
))
725 if (*args
&& strncasecmp (args
, "all", 3) == 0)
727 args
+= 3; /* Skip special argument "all". */
730 error (_("Junk at end of arguments."));
733 t1
= get_tracepoint_by_number (&args
, 1, 1);
740 if (t1
== (struct tracepoint
*) -1 || t1
== t2
)
742 t2
->pass_count
= count
;
743 tracepoint_modify_event (t2
->number
);
745 printf_filtered ("Setting tracepoint %d's passcount to %d\n",
749 t1
= get_tracepoint_by_number (&args
, 1, 0);
755 /* ACTIONS functions: */
757 /* Prototypes for action-parsing utility commands */
758 static void read_actions (struct tracepoint
*);
760 /* The three functions:
761 collect_pseudocommand,
762 while_stepping_pseudocommand, and
763 end_actions_pseudocommand
764 are placeholders for "commands" that are actually ONLY to be used
765 within a tracepoint action list. If the actual function is ever called,
766 it means that somebody issued the "command" at the top level,
767 which is always an error. */
770 end_actions_pseudocommand (char *args
, int from_tty
)
772 error (_("This command cannot be used at the top level."));
776 while_stepping_pseudocommand (char *args
, int from_tty
)
778 error (_("This command can only be used in a tracepoint actions list."));
782 collect_pseudocommand (char *args
, int from_tty
)
784 error (_("This command can only be used in a tracepoint actions list."));
787 /* Enter a list of actions for a tracepoint. */
789 trace_actions_command (char *args
, int from_tty
)
791 struct tracepoint
*t
;
793 char *end_msg
= "End with a line saying just \"end\".";
795 t
= get_tracepoint_by_number (&args
, 0, 1);
798 sprintf (tmpbuf
, "Enter actions for tracepoint %d, one per line.",
803 if (deprecated_readline_begin_hook
)
804 (*deprecated_readline_begin_hook
) ("%s %s\n", tmpbuf
, end_msg
);
805 else if (input_from_terminal_p ())
806 printf_filtered ("%s\n%s\n", tmpbuf
, end_msg
);
810 t
->step_count
= 0; /* read_actions may set this */
813 if (deprecated_readline_end_hook
)
814 (*deprecated_readline_end_hook
) ();
815 /* tracepoints_changed () */
817 /* else just return */
820 /* worker function */
822 read_actions (struct tracepoint
*t
)
825 char *prompt1
= "> ", *prompt2
= " > ";
826 char *prompt
= prompt1
;
827 enum actionline_type linetype
;
828 extern FILE *instream
;
829 struct action_line
*next
= NULL
, *temp
;
830 struct cleanup
*old_chain
;
832 /* Control-C quits instantly if typed while in this loop
833 since it should not wait until the user types a newline. */
835 /* FIXME: kettenis/20010823: Something is wrong here. In this file
836 STOP_SIGNAL is never defined. So this code has been left out, at
837 least for quite a while now. Replacing STOP_SIGNAL with SIGTSTP
838 leads to compilation failures since the variable job_control
839 isn't declared. Leave this alone for now. */
842 signal (STOP_SIGNAL
, handle_stop_sig
);
844 old_chain
= make_cleanup_free_actions (t
);
847 /* Make sure that all output has been output. Some machines may
848 let you get away with leaving out some of the gdb_flush, but
851 gdb_flush (gdb_stdout
);
852 gdb_flush (gdb_stderr
);
854 if (deprecated_readline_hook
&& instream
== NULL
)
855 line
= (*deprecated_readline_hook
) (prompt
);
856 else if (instream
== stdin
&& ISATTY (instream
))
858 line
= gdb_readline_wrapper (prompt
);
859 if (line
&& *line
) /* add it to command history */
863 line
= gdb_readline (0);
868 linetype
= validate_actionline (&line
, t
);
869 if (linetype
== BADLINE
)
870 continue; /* already warned -- collect another line */
872 temp
= xmalloc (sizeof (struct action_line
));
876 if (next
== NULL
) /* first action for this tracepoint? */
877 t
->actions
= next
= temp
;
884 if (linetype
== STEPPING
) /* begin "while-stepping" */
886 if (prompt
== prompt2
)
888 warning (_("Already processing 'while-stepping'"));
892 prompt
= prompt2
; /* change prompt for stepping actions */
894 else if (linetype
== END
)
896 if (prompt
== prompt2
)
898 prompt
= prompt1
; /* end of single-stepping actions */
901 { /* end of actions */
902 if (t
->actions
->next
== NULL
)
904 /* An "end" all by itself with no other actions
905 means this tracepoint has no actions.
906 Discard empty list. */
915 signal (STOP_SIGNAL
, SIG_DFL
);
918 discard_cleanups (old_chain
);
921 /* worker function */
923 validate_actionline (char **line
, struct tracepoint
*t
)
925 struct cmd_list_element
*c
;
926 struct expression
*exp
= NULL
;
927 struct cleanup
*old_chain
= NULL
;
930 /* if EOF is typed, *line is NULL */
934 for (p
= *line
; isspace ((int) *p
);)
937 /* Symbol lookup etc. */
938 if (*p
== '\0') /* empty line: just prompt for another line. */
941 if (*p
== '#') /* comment line */
944 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
947 warning (_("'%s' is not an action that I know, or is ambiguous."),
952 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
954 struct agent_expr
*aexpr
;
955 struct agent_reqs areqs
;
958 { /* repeat over a comma-separated list */
959 QUIT
; /* allow user to bail out with ^C */
960 while (isspace ((int) *p
))
963 if (*p
== '$') /* look for special pseudo-symbols */
965 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
966 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
967 (0 == strncasecmp ("loc", p
+ 1, 3)))
972 /* else fall thru, treat p as an expression and parse it! */
974 exp
= parse_exp_1 (&p
, block_for_pc (t
->address
), 1);
975 old_chain
= make_cleanup (free_current_contents
, &exp
);
977 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
979 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
981 warning (_("constant %s (value %ld) will not be collected."),
982 DEPRECATED_SYMBOL_NAME (exp
->elts
[2].symbol
),
983 SYMBOL_VALUE (exp
->elts
[2].symbol
));
986 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
988 warning (_("%s is optimized away and cannot be collected."),
989 DEPRECATED_SYMBOL_NAME (exp
->elts
[2].symbol
));
994 /* We have something to collect, make sure that the expr to
995 bytecode translator can handle it and that it's not too
997 aexpr
= gen_trace_for_expr (t
->address
, exp
);
998 make_cleanup_free_agent_expr (aexpr
);
1000 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
1001 error (_("expression too complicated, try simplifying"));
1003 ax_reqs (aexpr
, &areqs
);
1004 (void) make_cleanup (xfree
, areqs
.reg_mask
);
1006 if (areqs
.flaw
!= agent_flaw_none
)
1007 error (_("malformed expression"));
1009 if (areqs
.min_height
< 0)
1010 error (_("gdb: Internal error: expression has min height < 0"));
1012 if (areqs
.max_height
> 20)
1013 error (_("expression too complicated, try simplifying"));
1015 do_cleanups (old_chain
);
1017 while (p
&& *p
++ == ',');
1020 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
1022 char *steparg
; /* in case warning is necessary */
1024 while (isspace ((int) *p
))
1029 (t
->step_count
= strtol (p
, &p
, 0)) == 0)
1031 warning (_("'%s': bad step-count; command ignored."), *line
);
1036 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
1040 warning (_("'%s' is not a supported tracepoint action."), *line
);
1045 /* worker function */
1047 free_actions (struct tracepoint
*t
)
1049 struct action_line
*line
, *next
;
1051 for (line
= t
->actions
; line
; line
= next
)
1055 xfree (line
->action
);
1062 do_free_actions_cleanup (void *t
)
1067 static struct cleanup
*
1068 make_cleanup_free_actions (struct tracepoint
*t
)
1070 return make_cleanup (do_free_actions_cleanup
, t
);
1074 memrange_absolute
= -1
1079 int type
; /* memrange_absolute for absolute memory range,
1080 else basereg number */
1081 bfd_signed_vma start
;
1085 struct collection_list
1087 unsigned char regs_mask
[32]; /* room for up to 256 regs */
1090 struct memrange
*list
;
1091 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
1092 long next_aexpr_elt
;
1093 struct agent_expr
**aexpr_list
;
1096 tracepoint_list
, stepping_list
;
1098 /* MEMRANGE functions: */
1100 static int memrange_cmp (const void *, const void *);
1102 /* compare memranges for qsort */
1104 memrange_cmp (const void *va
, const void *vb
)
1106 const struct memrange
*a
= va
, *b
= vb
;
1108 if (a
->type
< b
->type
)
1110 if (a
->type
> b
->type
)
1112 if (a
->type
== memrange_absolute
)
1114 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
1116 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
1121 if (a
->start
< b
->start
)
1123 if (a
->start
> b
->start
)
1129 /* Sort the memrange list using qsort, and merge adjacent memranges. */
1131 memrange_sortmerge (struct collection_list
*memranges
)
1135 qsort (memranges
->list
, memranges
->next_memrange
,
1136 sizeof (struct memrange
), memrange_cmp
);
1137 if (memranges
->next_memrange
> 0)
1139 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
1141 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
1142 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
1145 /* memrange b starts before memrange a ends; merge them. */
1146 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
1147 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
1148 continue; /* next b, same a */
1152 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
1153 sizeof (struct memrange
));
1155 memranges
->next_memrange
= a
+ 1;
1159 /* Add a register to a collection list. */
1161 add_register (struct collection_list
*collection
, unsigned int regno
)
1164 printf_filtered ("collect register %d\n", regno
);
1165 if (regno
> (8 * sizeof (collection
->regs_mask
)))
1166 error (_("Internal: register number %d too large for tracepoint"),
1168 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
1171 /* Add a memrange to a collection list */
1173 add_memrange (struct collection_list
*memranges
,
1174 int type
, bfd_signed_vma base
,
1179 printf_filtered ("(%d,", type
);
1181 printf_filtered (",%ld)\n", len
);
1184 /* type: memrange_absolute == memory, other n == basereg */
1185 memranges
->list
[memranges
->next_memrange
].type
= type
;
1186 /* base: addr if memory, offset if reg relative. */
1187 memranges
->list
[memranges
->next_memrange
].start
= base
;
1188 /* len: we actually save end (base + len) for convenience */
1189 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
1190 memranges
->next_memrange
++;
1191 if (memranges
->next_memrange
>= memranges
->listsize
)
1193 memranges
->listsize
*= 2;
1194 memranges
->list
= xrealloc (memranges
->list
,
1195 memranges
->listsize
);
1198 if (type
!= memrange_absolute
) /* Better collect the base register! */
1199 add_register (memranges
, type
);
1202 /* Add a symbol to a collection list. */
1204 collect_symbol (struct collection_list
*collect
,
1206 long frame_regno
, long frame_offset
)
1210 bfd_signed_vma offset
;
1212 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
1213 switch (SYMBOL_CLASS (sym
))
1216 printf_filtered ("%s: don't know symbol class %d\n",
1217 DEPRECATED_SYMBOL_NAME (sym
),
1218 SYMBOL_CLASS (sym
));
1221 printf_filtered ("constant %s (value %ld) will not be collected.\n",
1222 DEPRECATED_SYMBOL_NAME (sym
), SYMBOL_VALUE (sym
));
1225 offset
= SYMBOL_VALUE_ADDRESS (sym
);
1230 sprintf_vma (tmp
, offset
);
1231 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1232 DEPRECATED_SYMBOL_NAME (sym
), len
,
1235 add_memrange (collect
, memrange_absolute
, offset
, len
);
1239 reg
= SYMBOL_VALUE (sym
);
1241 printf_filtered ("LOC_REG[parm] %s: ",
1242 DEPRECATED_SYMBOL_NAME (sym
));
1243 add_register (collect
, reg
);
1244 /* Check for doubles stored in two registers. */
1245 /* FIXME: how about larger types stored in 3 or more regs? */
1246 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1247 len
> register_size (current_gdbarch
, reg
))
1248 add_register (collect
, reg
+ 1);
1251 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1252 printf_filtered (" (will not collect %s)\n",
1253 DEPRECATED_SYMBOL_NAME (sym
));
1257 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1260 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1261 DEPRECATED_SYMBOL_NAME (sym
), len
);
1262 printf_vma (offset
);
1263 printf_filtered (" from frame ptr reg %d\n", reg
);
1265 add_memrange (collect
, reg
, offset
, len
);
1267 case LOC_REGPARM_ADDR
:
1268 reg
= SYMBOL_VALUE (sym
);
1272 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1273 DEPRECATED_SYMBOL_NAME (sym
), len
);
1274 printf_vma (offset
);
1275 printf_filtered (" from reg %d\n", reg
);
1277 add_memrange (collect
, reg
, offset
, len
);
1282 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1285 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1286 DEPRECATED_SYMBOL_NAME (sym
), len
);
1287 printf_vma (offset
);
1288 printf_filtered (" from frame ptr reg %d\n", reg
);
1290 add_memrange (collect
, reg
, offset
, len
);
1293 case LOC_BASEREG_ARG
:
1294 reg
= SYMBOL_BASEREG (sym
);
1295 offset
= SYMBOL_VALUE (sym
);
1298 printf_filtered ("LOC_BASEREG %s: collect %ld bytes at offset ",
1299 DEPRECATED_SYMBOL_NAME (sym
), len
);
1300 printf_vma (offset
);
1301 printf_filtered (" from basereg %d\n", reg
);
1303 add_memrange (collect
, reg
, offset
, len
);
1305 case LOC_UNRESOLVED
:
1306 printf_filtered ("Don't know LOC_UNRESOLVED %s\n",
1307 DEPRECATED_SYMBOL_NAME (sym
));
1309 case LOC_OPTIMIZED_OUT
:
1310 printf_filtered ("%s has been optimized out of existence.\n",
1311 DEPRECATED_SYMBOL_NAME (sym
));
1316 /* Add all locals (or args) symbols to collection list */
1318 add_local_symbols (struct collection_list
*collect
, CORE_ADDR pc
,
1319 long frame_regno
, long frame_offset
, int type
)
1322 struct block
*block
;
1323 struct dict_iterator iter
;
1326 block
= block_for_pc (pc
);
1329 QUIT
; /* allow user to bail out with ^C */
1330 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
1332 switch (SYMBOL_CLASS (sym
))
1335 warning (_("don't know how to trace local symbol %s"),
1336 DEPRECATED_SYMBOL_NAME (sym
));
1341 if (type
== 'L') /* collecting Locals */
1344 collect_symbol (collect
, sym
, frame_regno
,
1352 case LOC_REGPARM_ADDR
:
1353 case LOC_BASEREG_ARG
:
1354 if (type
== 'A') /* collecting Arguments */
1357 collect_symbol (collect
, sym
, frame_regno
,
1362 if (BLOCK_FUNCTION (block
))
1365 block
= BLOCK_SUPERBLOCK (block
);
1368 warning (_("No %s found in scope."),
1369 type
== 'L' ? "locals" : "args");
1372 /* worker function */
1374 clear_collection_list (struct collection_list
*list
)
1378 list
->next_memrange
= 0;
1379 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1381 free_agent_expr (list
->aexpr_list
[ndx
]);
1382 list
->aexpr_list
[ndx
] = NULL
;
1384 list
->next_aexpr_elt
= 0;
1385 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1388 /* reduce a collection list to string form (for gdb protocol) */
1390 stringify_collection_list (struct collection_list
*list
, char *string
)
1392 char temp_buf
[2048];
1396 char *(*str_list
)[];
1400 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1401 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1403 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1404 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1406 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1409 printf_filtered ("\nCollecting registers (mask): 0x");
1414 QUIT
; /* allow user to bail out with ^C */
1416 printf_filtered ("%02X", list
->regs_mask
[i
]);
1417 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1420 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1424 printf_filtered ("\n");
1425 if (list
->next_memrange
> 0 && info_verbose
)
1426 printf_filtered ("Collecting memranges: \n");
1427 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1429 QUIT
; /* allow user to bail out with ^C */
1430 sprintf_vma (tmp2
, list
->list
[i
].start
);
1433 printf_filtered ("(%d, %s, %ld)\n",
1436 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1438 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1440 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1447 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1449 /* The "%X" conversion specifier expects an unsigned argument,
1450 so passing -1 (memrange_absolute) to it directly gives you
1451 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1453 if (list
->list
[i
].type
== memrange_absolute
)
1454 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1456 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1459 count
+= strlen (end
);
1460 end
= temp_buf
+ count
;
1463 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1465 QUIT
; /* allow user to bail out with ^C */
1466 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1468 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1473 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1474 end
+= 10; /* 'X' + 8 hex digits + ',' */
1477 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1478 end
, list
->aexpr_list
[i
]->len
);
1479 count
+= 2 * list
->aexpr_list
[i
]->len
;
1484 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1489 (*str_list
)[ndx
] = NULL
;
1498 free_actions_list_cleanup_wrapper (void *al
)
1500 free_actions_list (al
);
1504 free_actions_list (char **actions_list
)
1508 if (actions_list
== 0)
1511 for (ndx
= 0; actions_list
[ndx
]; ndx
++)
1512 xfree (actions_list
[ndx
]);
1514 xfree (actions_list
);
1517 /* Render all actions into gdb protocol. */
1519 encode_actions (struct tracepoint
*t
, char ***tdp_actions
,
1520 char ***stepping_actions
)
1522 static char tdp_buff
[2048], step_buff
[2048];
1524 struct expression
*exp
= NULL
;
1525 struct action_line
*action
;
1527 struct value
*tempval
;
1528 struct collection_list
*collect
;
1529 struct cmd_list_element
*cmd
;
1530 struct agent_expr
*aexpr
;
1532 LONGEST frame_offset
;
1535 clear_collection_list (&tracepoint_list
);
1536 clear_collection_list (&stepping_list
);
1537 collect
= &tracepoint_list
;
1539 *tdp_actions
= NULL
;
1540 *stepping_actions
= NULL
;
1542 gdbarch_virtual_frame_pointer (current_gdbarch
,
1543 t
->address
, &frame_reg
, &frame_offset
);
1545 for (action
= t
->actions
; action
; action
= action
->next
)
1547 QUIT
; /* allow user to bail out with ^C */
1548 action_exp
= action
->action
;
1549 while (isspace ((int) *action_exp
))
1552 if (*action_exp
== '#') /* comment line */
1555 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1557 error (_("Bad action list item: %s"), action_exp
);
1559 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1562 { /* repeat over a comma-separated list */
1563 QUIT
; /* allow user to bail out with ^C */
1564 while (isspace ((int) *action_exp
))
1567 if (0 == strncasecmp ("$reg", action_exp
, 4))
1569 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
1570 add_register (collect
, i
);
1571 action_exp
= strchr (action_exp
, ','); /* more? */
1573 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1575 add_local_symbols (collect
,
1580 action_exp
= strchr (action_exp
, ','); /* more? */
1582 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1584 add_local_symbols (collect
,
1589 action_exp
= strchr (action_exp
, ','); /* more? */
1593 unsigned long addr
, len
;
1594 struct cleanup
*old_chain
= NULL
;
1595 struct cleanup
*old_chain1
= NULL
;
1596 struct agent_reqs areqs
;
1598 exp
= parse_exp_1 (&action_exp
,
1599 block_for_pc (t
->address
), 1);
1600 old_chain
= make_cleanup (free_current_contents
, &exp
);
1602 switch (exp
->elts
[0].opcode
)
1605 i
= exp
->elts
[1].longconst
;
1607 printf_filtered ("OP_REGISTER: ");
1608 add_register (collect
, i
);
1612 /* safe because we know it's a simple expression */
1613 tempval
= evaluate_expression (exp
);
1614 addr
= VALUE_ADDRESS (tempval
) + value_offset (tempval
);
1615 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1616 add_memrange (collect
, memrange_absolute
, addr
, len
);
1620 collect_symbol (collect
,
1621 exp
->elts
[2].symbol
,
1626 default: /* full-fledged expression */
1627 aexpr
= gen_trace_for_expr (t
->address
, exp
);
1629 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1631 ax_reqs (aexpr
, &areqs
);
1632 if (areqs
.flaw
!= agent_flaw_none
)
1633 error (_("malformed expression"));
1635 if (areqs
.min_height
< 0)
1636 error (_("gdb: Internal error: expression has min height < 0"));
1637 if (areqs
.max_height
> 20)
1638 error (_("expression too complicated, try simplifying"));
1640 discard_cleanups (old_chain1
);
1641 add_aexpr (collect
, aexpr
);
1643 /* take care of the registers */
1644 if (areqs
.reg_mask_len
> 0)
1649 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1651 QUIT
; /* allow user to bail out with ^C */
1652 if (areqs
.reg_mask
[ndx1
] != 0)
1654 /* assume chars have 8 bits */
1655 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1656 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1657 /* it's used -- record it */
1658 add_register (collect
,
1665 do_cleanups (old_chain
);
1668 while (action_exp
&& *action_exp
++ == ',');
1670 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1672 collect
= &stepping_list
;
1674 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
1676 if (collect
== &stepping_list
) /* end stepping actions */
1677 collect
= &tracepoint_list
;
1679 break; /* end tracepoint actions */
1682 memrange_sortmerge (&tracepoint_list
);
1683 memrange_sortmerge (&stepping_list
);
1685 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1687 *stepping_actions
= stringify_collection_list (&stepping_list
,
1692 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1694 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1696 collect
->aexpr_list
=
1697 xrealloc (collect
->aexpr_list
,
1698 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1699 collect
->aexpr_listsize
*= 2;
1701 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1702 collect
->next_aexpr_elt
++;
1705 static char *target_buf
;
1706 static long target_buf_size
;
1708 /* Set "transparent" memory ranges
1710 Allow trace mechanism to treat text-like sections
1711 (and perhaps all read-only sections) transparently,
1712 i.e. don't reject memory requests from these address ranges
1713 just because they haven't been collected. */
1716 remote_set_transparent_ranges (void)
1718 extern bfd
*exec_bfd
;
1725 return; /* No information to give. */
1727 strcpy (target_buf
, "QTro");
1728 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
1730 char tmp1
[40], tmp2
[40];
1732 if ((s
->flags
& SEC_LOAD
) == 0 ||
1733 /* (s->flags & SEC_CODE) == 0 || */
1734 (s
->flags
& SEC_READONLY
) == 0)
1739 size
= bfd_get_section_size (s
);
1740 sprintf_vma (tmp1
, lma
);
1741 sprintf_vma (tmp2
, lma
+ size
);
1742 sprintf (target_buf
+ strlen (target_buf
),
1743 ":%s,%s", tmp1
, tmp2
);
1747 putpkt (target_buf
);
1748 getpkt (&target_buf
, &target_buf_size
, 0);
1754 Tell target to clear any previous trace experiment.
1755 Walk the list of tracepoints, and send them (and their actions)
1756 to the target. If no errors,
1757 Tell target to start a new trace experiment. */
1760 trace_start_command (char *args
, int from_tty
)
1762 struct tracepoint
*t
;
1765 char **stepping_actions
;
1767 struct cleanup
*old_chain
= NULL
;
1769 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1771 if (target_is_remote ())
1774 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1775 if (strcmp (target_buf
, "OK"))
1776 error (_("Target does not support this command."));
1782 sprintf_vma (tmp
, t
->address
);
1783 sprintf (buf
, "QTDP:%x:%s:%c:%lx:%x", t
->number
,
1785 t
->enabled_p
? 'E' : 'D',
1786 t
->step_count
, t
->pass_count
);
1791 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1792 if (strcmp (target_buf
, "OK"))
1793 error (_("Target does not support tracepoints."));
1797 encode_actions (t
, &tdp_actions
, &stepping_actions
);
1798 old_chain
= make_cleanup (free_actions_list_cleanup_wrapper
,
1800 (void) make_cleanup (free_actions_list_cleanup_wrapper
,
1803 /* do_single_steps (t); */
1806 for (ndx
= 0; tdp_actions
[ndx
]; ndx
++)
1808 QUIT
; /* allow user to bail out with ^C */
1809 sprintf (buf
, "QTDP:-%x:%s:%s%c",
1810 t
->number
, tmp
, /* address */
1812 ((tdp_actions
[ndx
+ 1] || stepping_actions
)
1815 remote_get_noisy_reply (&target_buf
,
1817 if (strcmp (target_buf
, "OK"))
1818 error (_("Error on target while setting tracepoints."));
1821 if (stepping_actions
)
1823 for (ndx
= 0; stepping_actions
[ndx
]; ndx
++)
1825 QUIT
; /* allow user to bail out with ^C */
1826 sprintf (buf
, "QTDP:-%x:%s:%s%s%s",
1827 t
->number
, tmp
, /* address */
1828 ((ndx
== 0) ? "S" : ""),
1829 stepping_actions
[ndx
],
1830 (stepping_actions
[ndx
+ 1] ? "-" : ""));
1832 remote_get_noisy_reply (&target_buf
,
1834 if (strcmp (target_buf
, "OK"))
1835 error (_("Error on target while setting tracepoints."));
1839 do_cleanups (old_chain
);
1842 /* Tell target to treat text-like sections as transparent. */
1843 remote_set_transparent_ranges ();
1844 /* Now insert traps and begin collecting data. */
1846 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1847 if (strcmp (target_buf
, "OK"))
1848 error (_("Bogus reply from target: %s"), target_buf
);
1849 set_traceframe_num (-1); /* All old traceframes invalidated. */
1850 set_tracepoint_num (-1);
1851 set_traceframe_context (-1);
1852 trace_running_p
= 1;
1853 if (deprecated_trace_start_stop_hook
)
1854 deprecated_trace_start_stop_hook (1, from_tty
);
1858 error (_("Trace can only be run on remote targets."));
1863 trace_stop_command (char *args
, int from_tty
)
1865 if (target_is_remote ())
1868 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1869 if (strcmp (target_buf
, "OK"))
1870 error (_("Bogus reply from target: %s"), target_buf
);
1871 trace_running_p
= 0;
1872 if (deprecated_trace_start_stop_hook
)
1873 deprecated_trace_start_stop_hook (0, from_tty
);
1876 error (_("Trace can only be run on remote targets."));
1879 unsigned long trace_running_p
;
1881 /* tstatus command */
1883 trace_status_command (char *args
, int from_tty
)
1885 if (target_is_remote ())
1887 putpkt ("qTStatus");
1888 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1890 if (target_buf
[0] != 'T' ||
1891 (target_buf
[1] != '0' && target_buf
[1] != '1'))
1892 error (_("Bogus reply from target: %s"), target_buf
);
1894 /* exported for use by the GUI */
1895 trace_running_p
= (target_buf
[1] == '1');
1898 error (_("Trace can only be run on remote targets."));
1901 /* Worker function for the various flavors of the tfind command. */
1903 finish_tfind_command (char **msg
,
1907 int target_frameno
= -1, target_tracept
= -1;
1908 CORE_ADDR old_frame_addr
;
1909 struct symbol
*old_func
;
1912 old_frame_addr
= get_frame_base (get_current_frame ());
1913 old_func
= find_pc_function (read_pc ());
1916 reply
= remote_get_noisy_reply (msg
, sizeof_msg
);
1918 while (reply
&& *reply
)
1922 if ((target_frameno
= (int) strtol (++reply
, &reply
, 16)) == -1)
1924 /* A request for a non-existant trace frame has failed.
1925 Our response will be different, depending on FROM_TTY:
1927 If FROM_TTY is true, meaning that this command was
1928 typed interactively by the user, then give an error
1929 and DO NOT change the state of traceframe_number etc.
1931 However if FROM_TTY is false, meaning that we're either
1932 in a script, a loop, or a user-defined command, then
1933 DON'T give an error, but DO change the state of
1934 traceframe_number etc. to invalid.
1936 The rationalle is that if you typed the command, you
1937 might just have committed a typo or something, and you'd
1938 like to NOT lose your current debugging state. However
1939 if you're in a user-defined command or especially in a
1940 loop, then you need a way to detect that the command
1941 failed WITHOUT aborting. This allows you to write
1942 scripts that search thru the trace buffer until the end,
1943 and then continue on to do something else. */
1946 error (_("Target failed to find requested trace frame."));
1950 printf_filtered ("End of trace buffer.\n");
1951 /* The following will not recurse, since it's
1953 trace_find_command ("-1", from_tty
);
1954 reply
= NULL
; /* Break out of loop
1955 (avoid recursive nonsense). */
1960 if ((target_tracept
= (int) strtol (++reply
, &reply
, 16)) == -1)
1961 error (_("Target failed to find requested trace frame."));
1963 case 'O': /* "OK"? */
1964 if (reply
[1] == 'K' && reply
[2] == '\0')
1967 error (_("Bogus reply from target: %s"), reply
);
1970 error (_("Bogus reply from target: %s"), reply
);
1973 reinit_frame_cache ();
1974 registers_changed ();
1975 set_traceframe_num (target_frameno
);
1976 set_tracepoint_num (target_tracept
);
1977 if (target_frameno
== -1)
1978 set_traceframe_context (-1);
1980 set_traceframe_context (read_pc ());
1984 enum print_what print_what
;
1986 /* NOTE: in immitation of the step command, try to determine
1987 whether we have made a transition from one function to
1988 another. If so, we'll print the "stack frame" (ie. the new
1989 function and it's arguments) -- otherwise we'll just show the
1992 This determination is made by checking (1) whether the
1993 current function has changed, and (2) whether the current FP
1994 has changed. Hack: if the FP wasn't collected, either at the
1995 current or the previous frame, assume that the FP has NOT
1998 if (old_func
== find_pc_function (read_pc ()) &&
1999 (old_frame_addr
== 0 ||
2000 get_frame_base (get_current_frame ()) == 0 ||
2001 old_frame_addr
== get_frame_base (get_current_frame ())))
2002 print_what
= SRC_LINE
;
2004 print_what
= SRC_AND_LOC
;
2006 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2011 /* trace_find_command takes a trace frame number n,
2012 sends "QTFrame:<n>" to the target,
2013 and accepts a reply that may contain several optional pieces
2014 of information: a frame number, a tracepoint number, and an
2015 indication of whether this is a trap frame or a stepping frame.
2017 The minimal response is just "OK" (which indicates that the
2018 target does not give us a frame number or a tracepoint number).
2019 Instead of that, the target may send us a string containing
2021 F<hexnum> (gives the selected frame number)
2022 T<hexnum> (gives the selected tracepoint number)
2027 trace_find_command (char *args
, int from_tty
)
2028 { /* this should only be called with a numeric argument */
2031 if (target_is_remote ())
2033 if (deprecated_trace_find_hook
)
2034 deprecated_trace_find_hook (args
, from_tty
);
2036 if (args
== 0 || *args
== 0)
2037 { /* TFIND with no args means find NEXT trace frame. */
2038 if (traceframe_number
== -1)
2039 frameno
= 0; /* "next" is first one */
2041 frameno
= traceframe_number
+ 1;
2043 else if (0 == strcmp (args
, "-"))
2045 if (traceframe_number
== -1)
2046 error (_("not debugging trace buffer"));
2047 else if (from_tty
&& traceframe_number
== 0)
2048 error (_("already at start of trace buffer"));
2050 frameno
= traceframe_number
- 1;
2053 frameno
= parse_and_eval_long (args
);
2056 error (_("invalid input (%d is less than zero)"), frameno
);
2058 sprintf (target_buf
, "QTFrame:%x", frameno
);
2059 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2062 error (_("Trace can only be run on remote targets."));
2067 trace_find_end_command (char *args
, int from_tty
)
2069 trace_find_command ("-1", from_tty
);
2074 trace_find_none_command (char *args
, int from_tty
)
2076 trace_find_command ("-1", from_tty
);
2081 trace_find_start_command (char *args
, int from_tty
)
2083 trace_find_command ("0", from_tty
);
2086 /* tfind pc command */
2088 trace_find_pc_command (char *args
, int from_tty
)
2093 if (target_is_remote ())
2095 if (args
== 0 || *args
== 0)
2096 pc
= read_pc (); /* default is current pc */
2098 pc
= parse_and_eval_address (args
);
2100 sprintf_vma (tmp
, pc
);
2101 sprintf (target_buf
, "QTFrame:pc:%s", tmp
);
2102 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2105 error (_("Trace can only be run on remote targets."));
2108 /* tfind tracepoint command */
2110 trace_find_tracepoint_command (char *args
, int from_tty
)
2114 if (target_is_remote ())
2116 if (args
== 0 || *args
== 0)
2118 if (tracepoint_number
== -1)
2119 error (_("No current tracepoint -- please supply an argument."));
2121 tdp
= tracepoint_number
; /* default is current TDP */
2124 tdp
= parse_and_eval_long (args
);
2126 sprintf (target_buf
, "QTFrame:tdp:%x", tdp
);
2127 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2130 error (_("Trace can only be run on remote targets."));
2133 /* TFIND LINE command:
2135 This command will take a sourceline for argument, just like BREAK
2136 or TRACE (ie. anything that "decode_line_1" can handle).
2138 With no argument, this command will find the next trace frame
2139 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2142 trace_find_line_command (char *args
, int from_tty
)
2144 static CORE_ADDR start_pc
, end_pc
;
2145 struct symtabs_and_lines sals
;
2146 struct symtab_and_line sal
;
2147 struct cleanup
*old_chain
;
2148 char startpc_str
[40], endpc_str
[40];
2150 if (target_is_remote ())
2152 if (args
== 0 || *args
== 0)
2154 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2156 sals
.sals
= (struct symtab_and_line
*)
2157 xmalloc (sizeof (struct symtab_and_line
));
2162 sals
= decode_line_spec (args
, 1);
2166 old_chain
= make_cleanup (xfree
, sals
.sals
);
2167 if (sal
.symtab
== 0)
2169 printf_filtered ("TFIND: No line number information available");
2172 /* This is useful for "info line *0x7f34". If we can't
2173 tell the user about a source line, at least let them
2174 have the symbolic address. */
2175 printf_filtered (" for address ");
2177 print_address (sal
.pc
, gdb_stdout
);
2178 printf_filtered (";\n -- will attempt to find by PC. \n");
2182 printf_filtered (".\n");
2183 return; /* No line, no PC; what can we do? */
2186 else if (sal
.line
> 0
2187 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2189 if (start_pc
== end_pc
)
2191 printf_filtered ("Line %d of \"%s\"",
2192 sal
.line
, sal
.symtab
->filename
);
2194 printf_filtered (" is at address ");
2195 print_address (start_pc
, gdb_stdout
);
2197 printf_filtered (" but contains no code.\n");
2198 sal
= find_pc_line (start_pc
, 0);
2200 find_line_pc_range (sal
, &start_pc
, &end_pc
) &&
2202 printf_filtered ("Attempting to find line %d instead.\n",
2205 error (_("Cannot find a good line."));
2209 /* Is there any case in which we get here, and have an address
2210 which the user would want to see? If we have debugging
2211 symbols and no line numbers? */
2212 error (_("Line number %d is out of range for \"%s\"."),
2213 sal
.line
, sal
.symtab
->filename
);
2215 sprintf_vma (startpc_str
, start_pc
);
2216 sprintf_vma (endpc_str
, end_pc
- 1);
2217 /* Find within range of stated line. */
2219 sprintf (target_buf
, "QTFrame:range:%s:%s",
2220 startpc_str
, endpc_str
);
2221 /* Find OUTSIDE OF range of CURRENT line. */
2223 sprintf (target_buf
, "QTFrame:outside:%s:%s",
2224 startpc_str
, endpc_str
);
2225 finish_tfind_command (&target_buf
, &target_buf_size
,
2227 do_cleanups (old_chain
);
2230 error (_("Trace can only be run on remote targets."));
2233 /* tfind range command */
2235 trace_find_range_command (char *args
, int from_tty
)
2237 static CORE_ADDR start
, stop
;
2238 char start_str
[40], stop_str
[40];
2241 if (target_is_remote ())
2243 if (args
== 0 || *args
== 0)
2244 { /* XXX FIXME: what should default behavior be? */
2245 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2249 if (0 != (tmp
= strchr (args
, ',')))
2251 *tmp
++ = '\0'; /* terminate start address */
2252 while (isspace ((int) *tmp
))
2254 start
= parse_and_eval_address (args
);
2255 stop
= parse_and_eval_address (tmp
);
2258 { /* no explicit end address? */
2259 start
= parse_and_eval_address (args
);
2260 stop
= start
+ 1; /* ??? */
2263 sprintf_vma (start_str
, start
);
2264 sprintf_vma (stop_str
, stop
);
2265 sprintf (target_buf
, "QTFrame:range:%s:%s", start_str
, stop_str
);
2266 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2269 error (_("Trace can only be run on remote targets."));
2272 /* tfind outside command */
2274 trace_find_outside_command (char *args
, int from_tty
)
2276 CORE_ADDR start
, stop
;
2277 char start_str
[40], stop_str
[40];
2280 if (target_is_remote ())
2282 if (args
== 0 || *args
== 0)
2283 { /* XXX FIXME: what should default behavior be? */
2284 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2288 if (0 != (tmp
= strchr (args
, ',')))
2290 *tmp
++ = '\0'; /* terminate start address */
2291 while (isspace ((int) *tmp
))
2293 start
= parse_and_eval_address (args
);
2294 stop
= parse_and_eval_address (tmp
);
2297 { /* no explicit end address? */
2298 start
= parse_and_eval_address (args
);
2299 stop
= start
+ 1; /* ??? */
2302 sprintf_vma (start_str
, start
);
2303 sprintf_vma (stop_str
, stop
);
2304 sprintf (target_buf
, "QTFrame:outside:%s:%s", start_str
, stop_str
);
2305 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2308 error (_("Trace can only be run on remote targets."));
2311 /* save-tracepoints command */
2313 tracepoint_save_command (char *args
, int from_tty
)
2315 struct tracepoint
*tp
;
2316 struct action_line
*line
;
2318 char *i1
= " ", *i2
= " ";
2319 char *indent
, *actionline
, *pathname
;
2322 if (args
== 0 || *args
== 0)
2323 error (_("Argument required (file name in which to save tracepoints)"));
2325 if (tracepoint_chain
== 0)
2327 warning (_("save-tracepoints: no tracepoints to save."));
2331 pathname
= tilde_expand (args
);
2332 if (!(fp
= fopen (pathname
, "w")))
2333 error (_("Unable to open file '%s' for saving tracepoints (%s)"),
2334 args
, safe_strerror (errno
));
2337 ALL_TRACEPOINTS (tp
)
2339 if (tp
->addr_string
)
2340 fprintf (fp
, "trace %s\n", tp
->addr_string
);
2343 sprintf_vma (tmp
, tp
->address
);
2344 fprintf (fp
, "trace *0x%s\n", tmp
);
2348 fprintf (fp
, " passcount %d\n", tp
->pass_count
);
2352 fprintf (fp
, " actions\n");
2354 for (line
= tp
->actions
; line
; line
= line
->next
)
2356 struct cmd_list_element
*cmd
;
2358 QUIT
; /* allow user to bail out with ^C */
2359 actionline
= line
->action
;
2360 while (isspace ((int) *actionline
))
2363 fprintf (fp
, "%s%s\n", indent
, actionline
);
2364 if (*actionline
!= '#') /* skip for comment lines */
2366 cmd
= lookup_cmd (&actionline
, cmdlist
, "", -1, 1);
2368 error (_("Bad action list item: %s"), actionline
);
2369 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2371 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2379 printf_filtered ("Tracepoints saved to file '%s'.\n", args
);
2383 /* info scope command: list the locals for a scope. */
2385 scope_info (char *args
, int from_tty
)
2387 struct symtabs_and_lines sals
;
2389 struct minimal_symbol
*msym
;
2390 struct block
*block
;
2391 char **canonical
, *symname
, *save_args
= args
;
2392 struct dict_iterator iter
;
2395 if (args
== 0 || *args
== 0)
2396 error (_("requires an argument (function, line or *addr) to define a scope"));
2398 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2399 if (sals
.nelts
== 0)
2400 return; /* presumably decode_line_1 has already warned */
2402 /* Resolve line numbers to PC */
2403 resolve_sal_pc (&sals
.sals
[0]);
2404 block
= block_for_pc (sals
.sals
[0].pc
);
2408 QUIT
; /* allow user to bail out with ^C */
2409 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2411 QUIT
; /* allow user to bail out with ^C */
2413 printf_filtered ("Scope for %s:\n", save_args
);
2416 symname
= DEPRECATED_SYMBOL_NAME (sym
);
2417 if (symname
== NULL
|| *symname
== '\0')
2418 continue; /* probably botched, certainly useless */
2420 printf_filtered ("Symbol %s is ", symname
);
2421 switch (SYMBOL_CLASS (sym
))
2424 case LOC_UNDEF
: /* messed up symbol? */
2425 printf_filtered ("a bogus symbol, class %d.\n",
2426 SYMBOL_CLASS (sym
));
2427 count
--; /* don't count this one */
2430 printf_filtered ("a constant with value %ld (0x%lx)",
2431 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2433 case LOC_CONST_BYTES
:
2434 printf_filtered ("constant bytes: ");
2435 if (SYMBOL_TYPE (sym
))
2436 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2437 fprintf_filtered (gdb_stdout
, " %02x",
2438 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2441 printf_filtered ("in static storage at address ");
2442 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
),
2446 printf_filtered ("a local variable in register $%s",
2447 gdbarch_register_name
2448 (current_gdbarch
, SYMBOL_VALUE (sym
)));
2452 printf_filtered ("an argument at stack/frame offset %ld",
2453 SYMBOL_VALUE (sym
));
2456 printf_filtered ("a local variable at frame offset %ld",
2457 SYMBOL_VALUE (sym
));
2460 printf_filtered ("a reference argument at offset %ld",
2461 SYMBOL_VALUE (sym
));
2464 printf_filtered ("an argument in register $%s",
2465 gdbarch_register_name
2466 (current_gdbarch
, SYMBOL_VALUE (sym
)));
2468 case LOC_REGPARM_ADDR
:
2469 printf_filtered ("the address of an argument, in register $%s",
2470 gdbarch_register_name
2471 (current_gdbarch
, SYMBOL_VALUE (sym
)));
2474 printf_filtered ("a typedef.\n");
2477 printf_filtered ("a label at address ");
2478 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
),
2482 printf_filtered ("a function at address ");
2483 deprecated_print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)),
2487 printf_filtered ("a variable at offset %ld from register $%s",
2489 gdbarch_register_name
2490 (current_gdbarch
, SYMBOL_BASEREG (sym
)));
2492 case LOC_BASEREG_ARG
:
2493 printf_filtered ("an argument at offset %ld from register $%s",
2495 gdbarch_register_name
2496 (current_gdbarch
, SYMBOL_BASEREG (sym
)));
2498 case LOC_UNRESOLVED
:
2499 msym
= lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (sym
),
2502 printf_filtered ("Unresolved Static");
2505 printf_filtered ("static storage at address ");
2506 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (msym
), 1,
2510 case LOC_OPTIMIZED_OUT
:
2511 printf_filtered ("optimized out.\n");
2513 case LOC_HP_THREAD_LOCAL_STATIC
:
2514 printf_filtered ("HP thread local static ");
2517 printf_filtered ("extern (local indirect) at address ");
2518 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
),
2522 case LOC_COMPUTED_ARG
:
2523 SYMBOL_OPS (sym
)->describe_location (sym
, gdb_stdout
);
2526 if (SYMBOL_TYPE (sym
))
2527 printf_filtered (", length %d.\n",
2528 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2530 if (BLOCK_FUNCTION (block
))
2533 block
= BLOCK_SUPERBLOCK (block
);
2536 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2540 /* worker function (cleanup) */
2542 replace_comma (void *data
)
2550 trace_dump_command (char *args
, int from_tty
)
2552 struct tracepoint
*t
;
2553 struct action_line
*action
;
2554 char *action_exp
, *next_comma
;
2555 struct cleanup
*old_cleanups
;
2556 int stepping_actions
= 0;
2557 int stepping_frame
= 0;
2559 if (!target_is_remote ())
2561 error (_("Trace can only be run on remote targets."));
2565 if (tracepoint_number
== -1)
2567 warning (_("No current trace frame."));
2572 if (t
->number
== tracepoint_number
)
2576 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2579 old_cleanups
= make_cleanup (null_cleanup
, NULL
);
2581 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2582 tracepoint_number
, traceframe_number
);
2584 /* The current frame is a trap frame if the frame PC is equal
2585 to the tracepoint PC. If not, then the current frame was
2586 collected during single-stepping. */
2588 stepping_frame
= (t
->address
!= (read_pc () - gdbarch_decr_pc_after_break
2589 (current_gdbarch
)));
2591 for (action
= t
->actions
; action
; action
= action
->next
)
2593 struct cmd_list_element
*cmd
;
2595 QUIT
; /* allow user to bail out with ^C */
2596 action_exp
= action
->action
;
2597 while (isspace ((int) *action_exp
))
2600 /* The collection actions to be done while stepping are
2601 bracketed by the commands "while-stepping" and "end". */
2603 if (*action_exp
== '#') /* comment line */
2606 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2608 error (_("Bad action list item: %s"), action_exp
);
2610 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2611 stepping_actions
= 1;
2612 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2613 stepping_actions
= 0;
2614 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2616 /* Display the collected data.
2617 For the trap frame, display only what was collected at
2618 the trap. Likewise for stepping frames, display only
2619 what was collected while stepping. This means that the
2620 two boolean variables, STEPPING_FRAME and
2621 STEPPING_ACTIONS should be equal. */
2622 if (stepping_frame
== stepping_actions
)
2625 { /* repeat over a comma-separated list */
2626 QUIT
; /* allow user to bail out with ^C */
2627 if (*action_exp
== ',')
2629 while (isspace ((int) *action_exp
))
2632 next_comma
= strchr (action_exp
, ',');
2634 if (0 == strncasecmp (action_exp
, "$reg", 4))
2635 registers_info (NULL
, from_tty
);
2636 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2637 locals_info (NULL
, from_tty
);
2638 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2639 args_info (NULL
, from_tty
);
2644 make_cleanup (replace_comma
, next_comma
);
2647 printf_filtered ("%s = ", action_exp
);
2648 output_command (action_exp
, from_tty
);
2649 printf_filtered ("\n");
2653 action_exp
= next_comma
;
2655 while (action_exp
&& *action_exp
== ',');
2659 discard_cleanups (old_cleanups
);
2662 /* Convert the memory pointed to by mem into hex, placing result in buf.
2663 * Return a pointer to the last char put in buf (null)
2664 * "stolen" from sparc-stub.c
2667 static const char hexchars
[] = "0123456789abcdef";
2670 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2678 *buf
++ = hexchars
[ch
>> 4];
2679 *buf
++ = hexchars
[ch
& 0xf];
2688 get_traceframe_number (void)
2690 return traceframe_number
;
2694 /* module initialization */
2696 _initialize_tracepoint (void)
2698 struct cmd_list_element
*c
;
2700 tracepoint_chain
= 0;
2701 tracepoint_count
= 0;
2702 traceframe_number
= -1;
2703 tracepoint_number
= -1;
2705 if (tracepoint_list
.list
== NULL
)
2707 tracepoint_list
.listsize
= 128;
2708 tracepoint_list
.list
= xmalloc
2709 (tracepoint_list
.listsize
* sizeof (struct memrange
));
2711 if (tracepoint_list
.aexpr_list
== NULL
)
2713 tracepoint_list
.aexpr_listsize
= 128;
2714 tracepoint_list
.aexpr_list
= xmalloc
2715 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
2718 if (stepping_list
.list
== NULL
)
2720 stepping_list
.listsize
= 128;
2721 stepping_list
.list
= xmalloc
2722 (stepping_list
.listsize
* sizeof (struct memrange
));
2725 if (stepping_list
.aexpr_list
== NULL
)
2727 stepping_list
.aexpr_listsize
= 128;
2728 stepping_list
.aexpr_list
= xmalloc
2729 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
2732 add_info ("scope", scope_info
,
2733 _("List the variables local to a scope"));
2735 add_cmd ("tracepoints", class_trace
, NULL
,
2736 _("Tracing of program execution without stopping the program."),
2739 add_info ("tracepoints", tracepoints_info
, _("\
2740 Status of tracepoints, or tracepoint number NUMBER.\n\
2741 Convenience variable \"$tpnum\" contains the number of the\n\
2742 last tracepoint set."));
2744 add_info_alias ("tp", "tracepoints", 1);
2746 c
= add_com ("save-tracepoints", class_trace
, tracepoint_save_command
, _("\
2747 Save current tracepoint definitions as a script.\n\
2748 Use the 'source' command in another debug session to restore them."));
2749 set_cmd_completer (c
, filename_completer
);
2751 add_com ("tdump", class_trace
, trace_dump_command
,
2752 _("Print everything collected at the current tracepoint."));
2754 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
2755 Select a trace frame;\n\
2756 No argument means forward by one frame; '-' means backward by one frame."),
2757 &tfindlist
, "tfind ", 1, &cmdlist
);
2759 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
2760 Select a trace frame whose PC is outside the given range.\n\
2761 Usage: tfind outside addr1, addr2"),
2764 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
2765 Select a trace frame whose PC is in the given range.\n\
2766 Usage: tfind range addr1,addr2"),
2769 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
2770 Select a trace frame by source line.\n\
2771 Argument can be a line number (with optional source file), \n\
2772 a function name, or '*' followed by an address.\n\
2773 Default argument is 'the next source line that was traced'."),
2776 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
2777 Select a trace frame by tracepoint number.\n\
2778 Default is the tracepoint for the current trace frame."),
2781 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
2782 Select a trace frame by PC.\n\
2783 Default is the current PC, or the PC of the current trace frame."),
2786 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
2787 Synonym for 'none'.\n\
2788 De-select any trace frame and resume 'live' debugging."),
2791 add_cmd ("none", class_trace
, trace_find_none_command
,
2792 _("De-select any trace frame and resume 'live' debugging."),
2795 add_cmd ("start", class_trace
, trace_find_start_command
,
2796 _("Select the first trace frame in the trace buffer."),
2799 add_com ("tstatus", class_trace
, trace_status_command
,
2800 _("Display the status of the current trace data collection."));
2802 add_com ("tstop", class_trace
, trace_stop_command
,
2803 _("Stop trace data collection."));
2805 add_com ("tstart", class_trace
, trace_start_command
,
2806 _("Start trace data collection."));
2808 add_com ("passcount", class_trace
, trace_pass_command
, _("\
2809 Set the passcount for a tracepoint.\n\
2810 The trace will end when the tracepoint has been passed 'count' times.\n\
2811 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
2812 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
2814 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
2815 Ends a list of commands or actions.\n\
2816 Several GDB commands allow you to enter a list of commands or actions.\n\
2817 Entering \"end\" on a line by itself is the normal way to terminate\n\
2819 Note: the \"end\" command cannot be used at the gdb prompt."));
2821 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
2822 Specify single-stepping behavior at a tracepoint.\n\
2823 Argument is number of instructions to trace in single-step mode\n\
2824 following the tracepoint. This command is normally followed by\n\
2825 one or more \"collect\" commands, to specify what to collect\n\
2826 while single-stepping.\n\n\
2827 Note: this command can only be used in a tracepoint \"actions\" list."));
2829 add_com_alias ("ws", "while-stepping", class_alias
, 0);
2830 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
2832 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
2833 Specify one or more data items to be collected at a tracepoint.\n\
2834 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
2835 collect all data (variables, registers) referenced by that expression.\n\
2836 Also accepts the following special arguments:\n\
2837 $regs -- all registers.\n\
2838 $args -- all function arguments.\n\
2839 $locals -- all variables local to the block/function scope.\n\
2840 Note: this command can only be used in a tracepoint \"actions\" list."));
2842 add_com ("actions", class_trace
, trace_actions_command
, _("\
2843 Specify the actions to be taken at a tracepoint.\n\
2844 Tracepoint actions may include collecting of specified data, \n\
2845 single-stepping, or enabling/disabling other tracepoints, \n\
2846 depending on target's capabilities."));
2848 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
2849 Delete specified tracepoints.\n\
2850 Arguments are tracepoint numbers, separated by spaces.\n\
2851 No argument means delete all tracepoints."),
2854 add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
2855 Disable specified tracepoints.\n\
2856 Arguments are tracepoint numbers, separated by spaces.\n\
2857 No argument means disable all tracepoints."),
2860 add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
2861 Enable specified tracepoints.\n\
2862 Arguments are tracepoint numbers, separated by spaces.\n\
2863 No argument means enable all tracepoints."),
2866 c
= add_com ("trace", class_trace
, trace_command
, _("\
2867 Set a tracepoint at a specified line or function or address.\n\
2868 Argument may be a line number, function name, or '*' plus an address.\n\
2869 For a line number or function, trace at the start of its code.\n\
2870 If an address is specified, trace at that exact address.\n\n\
2871 Do \"help tracepoints\" for info on other tracepoint commands."));
2872 set_cmd_completer (c
, location_completer
);
2874 add_com_alias ("tp", "trace", class_alias
, 0);
2875 add_com_alias ("tr", "trace", class_alias
, 1);
2876 add_com_alias ("tra", "trace", class_alias
, 1);
2877 add_com_alias ("trac", "trace", class_alias
, 1);
2879 target_buf_size
= 2048;
2880 target_buf
= xmalloc (target_buf_size
);