1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
4 2007, 2008 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "expression.h"
30 #include "gdb_string.h"
32 #include "tracepoint.h"
36 #include "completer.h"
37 #include "gdb-events.h"
39 #include "dictionary.h"
44 /* readline include files */
45 #include "readline/readline.h"
46 #include "readline/history.h"
48 /* readline defines this. */
55 /* Maximum length of an agent aexpression.
56 This accounts for the fact that packets are limited to 400 bytes
57 (which includes everything -- including the checksum), and assumes
58 the worst case of maximum length for each of the pieces of a
61 NOTE: expressions get mem2hex'ed otherwise this would be twice as
62 large. (400 - 31)/2 == 184 */
63 #define MAX_AGENT_EXPR_LEN 184
66 extern void (*deprecated_readline_begin_hook
) (char *, ...);
67 extern char *(*deprecated_readline_hook
) (char *);
68 extern void (*deprecated_readline_end_hook
) (void);
69 extern int addressprint
; /* Print machine addresses? */
71 /* GDB commands implemented in other modules:
74 extern void output_command (char *, int);
79 This module defines the following debugger commands:
80 trace : set a tracepoint on a function, line, or address.
81 info trace : list all debugger-defined tracepoints.
82 delete trace : delete one or more tracepoints.
83 enable trace : enable one or more tracepoints.
84 disable trace : disable one or more tracepoints.
85 actions : specify actions to be taken at a tracepoint.
86 passcount : specify a pass count for a tracepoint.
87 tstart : start a trace experiment.
88 tstop : stop a trace experiment.
89 tstatus : query the status of a trace experiment.
90 tfind : find a trace frame in the trace buffer.
91 tdump : print everything collected at the current tracepoint.
92 save-tracepoints : write tracepoint setup into a file.
94 This module defines the following user-visible debugger variables:
95 $trace_frame : sequence number of trace frame currently being debugged.
96 $trace_line : source line of trace frame currently being debugged.
97 $trace_file : source file of trace frame currently being debugged.
98 $tracepoint : tracepoint number of trace frame currently being debugged.
102 /* ======= Important global variables: ======= */
104 /* Chain of all tracepoints defined. */
105 struct tracepoint
*tracepoint_chain
;
107 /* Number of last tracepoint made. */
108 static int tracepoint_count
;
110 /* Number of last traceframe collected. */
111 static int traceframe_number
;
113 /* Tracepoint for last traceframe collected. */
114 static int tracepoint_number
;
116 /* Symbol for function for last traceframe collected */
117 static struct symbol
*traceframe_fun
;
119 /* Symtab and line for last traceframe collected */
120 static struct symtab_and_line traceframe_sal
;
122 /* Tracing command lists */
123 static struct cmd_list_element
*tfindlist
;
125 /* ======= Important command functions: ======= */
126 static void trace_command (char *, int);
127 static void tracepoints_info (char *, int);
128 static void delete_trace_command (char *, int);
129 static void enable_trace_command (char *, int);
130 static void disable_trace_command (char *, int);
131 static void trace_pass_command (char *, int);
132 static void trace_actions_command (char *, int);
133 static void trace_start_command (char *, int);
134 static void trace_stop_command (char *, int);
135 static void trace_status_command (char *, int);
136 static void trace_find_command (char *, int);
137 static void trace_find_pc_command (char *, int);
138 static void trace_find_tracepoint_command (char *, int);
139 static void trace_find_line_command (char *, int);
140 static void trace_find_range_command (char *, int);
141 static void trace_find_outside_command (char *, int);
142 static void tracepoint_save_command (char *, int);
143 static void trace_dump_command (char *, int);
145 /* support routines */
146 static void trace_mention (struct tracepoint
*);
148 struct collection_list
;
149 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
150 static char *mem2hex (gdb_byte
*, char *, int);
151 static void add_register (struct collection_list
*collection
,
153 static struct cleanup
*make_cleanup_free_actions (struct tracepoint
*t
);
154 static void free_actions_list (char **actions_list
);
155 static void free_actions_list_cleanup_wrapper (void *);
157 extern void _initialize_tracepoint (void);
159 /* Utility: returns true if "target remote" */
161 target_is_remote (void)
163 if (current_target
.to_shortname
&&
164 (strcmp (current_target
.to_shortname
, "remote") == 0
165 || strcmp (current_target
.to_shortname
, "extended-remote") == 0))
171 /* Utility: generate error from an incoming stub packet. */
173 trace_error (char *buf
)
176 return; /* not an error msg */
179 case '1': /* malformed packet error */
180 if (*++buf
== '0') /* general case: */
181 error (_("tracepoint.c: error in outgoing packet."));
183 error (_("tracepoint.c: error in outgoing packet at field #%ld."),
184 strtol (buf
, NULL
, 16));
186 error (_("trace API error 0x%s."), ++buf
);
188 error (_("Target returns error code '%s'."), buf
);
192 /* Utility: wait for reply from stub, while accepting "O" packets. */
194 remote_get_noisy_reply (char **buf_p
,
197 do /* Loop on reply from remote stub. */
200 QUIT
; /* allow user to bail out with ^C */
201 getpkt (buf_p
, sizeof_buf
, 0);
204 error (_("Target does not support this command."));
205 else if (buf
[0] == 'E')
207 else if (buf
[0] == 'O' &&
209 remote_console_output (buf
+ 1); /* 'O' message from stub */
211 return buf
; /* here's the actual reply */
216 /* Set tracepoint count to NUM. */
218 set_tracepoint_count (int num
)
220 tracepoint_count
= num
;
221 set_internalvar (lookup_internalvar ("tpnum"),
222 value_from_longest (builtin_type_int
, (LONGEST
) num
));
225 /* Set traceframe number to NUM. */
227 set_traceframe_num (int num
)
229 traceframe_number
= num
;
230 set_internalvar (lookup_internalvar ("trace_frame"),
231 value_from_longest (builtin_type_int
, (LONGEST
) num
));
234 /* Set tracepoint number to NUM. */
236 set_tracepoint_num (int num
)
238 tracepoint_number
= num
;
239 set_internalvar (lookup_internalvar ("tracepoint"),
240 value_from_longest (builtin_type_int
,
244 /* Set externally visible debug variables for querying/printing
245 the traceframe context (line, function, file) */
248 set_traceframe_context (CORE_ADDR trace_pc
)
250 static struct type
*func_string
, *file_string
;
251 static struct type
*func_range
, *file_range
;
252 struct value
*func_val
;
253 struct value
*file_val
;
254 static struct type
*charstar
;
257 if (charstar
== (struct type
*) NULL
)
258 charstar
= lookup_pointer_type (builtin_type_char
);
260 if (trace_pc
== -1) /* Cease debugging any trace buffers. */
263 traceframe_sal
.pc
= traceframe_sal
.line
= 0;
264 traceframe_sal
.symtab
= NULL
;
265 set_internalvar (lookup_internalvar ("trace_func"),
266 value_from_pointer (charstar
, (LONGEST
) 0));
267 set_internalvar (lookup_internalvar ("trace_file"),
268 value_from_pointer (charstar
, (LONGEST
) 0));
269 set_internalvar (lookup_internalvar ("trace_line"),
270 value_from_longest (builtin_type_int
,
275 /* Save as globals for internal use. */
276 traceframe_sal
= find_pc_line (trace_pc
, 0);
277 traceframe_fun
= find_pc_function (trace_pc
);
279 /* Save linenumber as "$trace_line", a debugger variable visible to
281 set_internalvar (lookup_internalvar ("trace_line"),
282 value_from_longest (builtin_type_int
,
283 (LONGEST
) traceframe_sal
.line
));
285 /* Save func name as "$trace_func", a debugger variable visible to
287 if (traceframe_fun
== NULL
||
288 DEPRECATED_SYMBOL_NAME (traceframe_fun
) == NULL
)
289 set_internalvar (lookup_internalvar ("trace_func"),
290 value_from_pointer (charstar
, (LONGEST
) 0));
293 len
= strlen (DEPRECATED_SYMBOL_NAME (traceframe_fun
));
294 func_range
= create_range_type (func_range
,
295 builtin_type_int
, 0, len
- 1);
296 func_string
= create_array_type (func_string
,
297 builtin_type_char
, func_range
);
298 func_val
= allocate_value (func_string
);
299 deprecated_set_value_type (func_val
, func_string
);
300 memcpy (value_contents_raw (func_val
),
301 DEPRECATED_SYMBOL_NAME (traceframe_fun
),
303 deprecated_set_value_modifiable (func_val
, 0);
304 set_internalvar (lookup_internalvar ("trace_func"), func_val
);
307 /* Save file name as "$trace_file", a debugger variable visible to
309 if (traceframe_sal
.symtab
== NULL
||
310 traceframe_sal
.symtab
->filename
== NULL
)
311 set_internalvar (lookup_internalvar ("trace_file"),
312 value_from_pointer (charstar
, (LONGEST
) 0));
315 len
= strlen (traceframe_sal
.symtab
->filename
);
316 file_range
= create_range_type (file_range
,
317 builtin_type_int
, 0, len
- 1);
318 file_string
= create_array_type (file_string
,
319 builtin_type_char
, file_range
);
320 file_val
= allocate_value (file_string
);
321 deprecated_set_value_type (file_val
, file_string
);
322 memcpy (value_contents_raw (file_val
),
323 traceframe_sal
.symtab
->filename
,
325 deprecated_set_value_modifiable (file_val
, 0);
326 set_internalvar (lookup_internalvar ("trace_file"), file_val
);
330 /* Low level routine to set a tracepoint.
331 Returns the tracepoint object so caller can set other things.
332 Does not set the tracepoint number!
333 Does not print anything.
335 ==> This routine should not be called if there is a chance of later
336 error(); otherwise it leaves a bogus tracepoint on the chain.
337 Validate your arguments BEFORE calling this routine! */
339 static struct tracepoint
*
340 set_raw_tracepoint (struct symtab_and_line sal
)
342 struct tracepoint
*t
, *tc
;
343 struct cleanup
*old_chain
;
345 t
= (struct tracepoint
*) xmalloc (sizeof (struct tracepoint
));
346 old_chain
= make_cleanup (xfree
, t
);
347 memset (t
, 0, sizeof (*t
));
349 if (sal
.symtab
== NULL
)
350 t
->source_file
= NULL
;
352 t
->source_file
= savestring (sal
.symtab
->filename
,
353 strlen (sal
.symtab
->filename
));
355 t
->section
= sal
.section
;
356 t
->language
= current_language
->la_language
;
357 t
->input_radix
= input_radix
;
358 t
->line_number
= sal
.line
;
363 t
->addr_string
= NULL
;
365 /* Add this tracepoint to the end of the chain
366 so that a list of tracepoints will come out in order
367 of increasing numbers. */
369 tc
= tracepoint_chain
;
371 tracepoint_chain
= t
;
378 discard_cleanups (old_chain
);
382 /* Set a tracepoint according to ARG (function, linenum or *address). */
384 trace_command (char *arg
, int from_tty
)
386 char **canonical
= (char **) NULL
;
387 struct symtabs_and_lines sals
;
388 struct symtab_and_line sal
;
389 struct tracepoint
*t
;
390 char *addr_start
= 0, *addr_end
= 0;
394 error (_("trace command requires an argument"));
396 if (from_tty
&& info_verbose
)
397 printf_filtered ("TRACE %s\n", arg
);
400 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
401 0, &canonical
, NULL
);
404 return; /* ??? Presumably decode_line_1 has already warned? */
406 /* Resolve all line numbers to PC's */
407 for (i
= 0; i
< sals
.nelts
; i
++)
408 resolve_sal_pc (&sals
.sals
[i
]);
410 /* Now set all the tracepoints. */
411 for (i
= 0; i
< sals
.nelts
; i
++)
415 t
= set_raw_tracepoint (sal
);
416 set_tracepoint_count (tracepoint_count
+ 1);
417 t
->number
= tracepoint_count
;
419 /* If a canonical line spec is needed use that instead of the
421 if (canonical
!= (char **) NULL
&& canonical
[i
] != NULL
)
422 t
->addr_string
= canonical
[i
];
424 t
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
431 printf_filtered ("Multiple tracepoints were set.\n");
432 printf_filtered ("Use 'delete trace' to delete unwanted tracepoints.\n");
436 /* Tell the user we have just set a tracepoint TP. */
439 trace_mention (struct tracepoint
*tp
)
441 printf_filtered ("Tracepoint %d", tp
->number
);
443 if (addressprint
|| (tp
->source_file
== NULL
))
445 printf_filtered (" at ");
446 printf_filtered ("%s", paddress (tp
->address
));
449 printf_filtered (": file %s, line %d.",
450 tp
->source_file
, tp
->line_number
);
452 printf_filtered ("\n");
455 /* Print information on tracepoint number TPNUM_EXP, or all if
459 tracepoints_info (char *tpnum_exp
, int from_tty
)
461 struct tracepoint
*t
;
462 struct action_line
*action
;
463 int found_a_tracepoint
= 0;
464 char wrap_indent
[80];
469 tpnum
= parse_and_eval_long (tpnum_exp
);
472 if (tpnum
== -1 || tpnum
== t
->number
)
474 extern int addressprint
; /* Print machine addresses? */
476 if (!found_a_tracepoint
++)
478 printf_filtered ("Num Enb ");
481 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
482 printf_filtered ("Address ");
484 printf_filtered ("Address ");
486 printf_filtered ("PassC StepC What\n");
488 strcpy (wrap_indent
, " ");
491 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
492 strcat (wrap_indent
, " ");
494 strcat (wrap_indent
, " ");
497 printf_filtered ("%-3d %-3s ", t
->number
,
498 t
->enabled_p
? "y" : "n");
503 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
504 tmp
= hex_string_custom (t
->address
& (CORE_ADDR
) 0xffffffff,
507 tmp
= hex_string_custom (t
->address
, 16);
509 printf_filtered ("%s ", tmp
);
511 printf_filtered ("%-5d %-5ld ", t
->pass_count
, t
->step_count
);
515 sym
= find_pc_sect_function (t
->address
, t
->section
);
518 fputs_filtered ("in ", gdb_stdout
);
519 fputs_filtered (SYMBOL_PRINT_NAME (sym
), gdb_stdout
);
520 wrap_here (wrap_indent
);
521 fputs_filtered (" at ", gdb_stdout
);
523 fputs_filtered (t
->source_file
, gdb_stdout
);
524 printf_filtered (":%d", t
->line_number
);
527 print_address_symbolic (t
->address
, gdb_stdout
, demangle
, " ");
529 printf_filtered ("\n");
532 printf_filtered (" Actions for tracepoint %d: \n", t
->number
);
533 for (action
= t
->actions
; action
; action
= action
->next
)
535 printf_filtered ("\t%s\n", action
->action
);
539 if (!found_a_tracepoint
)
542 printf_filtered ("No tracepoints.\n");
544 printf_filtered ("No tracepoint number %d.\n", tpnum
);
548 /* Optimization: the code to parse an enable, disable, or delete TP
549 command is virtually identical except for whether it performs an
550 enable, disable, or delete. Therefore I've combined them into one
551 function with an opcode. */
552 enum tracepoint_opcode
559 /* This function implements enable, disable and delete commands. */
561 tracepoint_operation (struct tracepoint
*t
, int from_tty
,
562 enum tracepoint_opcode opcode
)
564 struct tracepoint
*t2
;
566 if (t
== NULL
) /* no tracepoint operand */
573 tracepoint_modify_event (t
->number
);
577 tracepoint_modify_event (t
->number
);
580 if (tracepoint_chain
== t
)
581 tracepoint_chain
= t
->next
;
590 tracepoint_delete_event (t
->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
;
1500 free_actions_list_cleanup_wrapper (void *al
)
1502 free_actions_list (al
);
1506 free_actions_list (char **actions_list
)
1510 if (actions_list
== 0)
1513 for (ndx
= 0; actions_list
[ndx
]; ndx
++)
1514 xfree (actions_list
[ndx
]);
1516 xfree (actions_list
);
1519 /* Render all actions into gdb protocol. */
1521 encode_actions (struct tracepoint
*t
, char ***tdp_actions
,
1522 char ***stepping_actions
)
1524 static char tdp_buff
[2048], step_buff
[2048];
1526 struct expression
*exp
= NULL
;
1527 struct action_line
*action
;
1529 struct value
*tempval
;
1530 struct collection_list
*collect
;
1531 struct cmd_list_element
*cmd
;
1532 struct agent_expr
*aexpr
;
1534 LONGEST frame_offset
;
1537 clear_collection_list (&tracepoint_list
);
1538 clear_collection_list (&stepping_list
);
1539 collect
= &tracepoint_list
;
1541 *tdp_actions
= NULL
;
1542 *stepping_actions
= NULL
;
1544 gdbarch_virtual_frame_pointer (current_gdbarch
,
1545 t
->address
, &frame_reg
, &frame_offset
);
1547 for (action
= t
->actions
; action
; action
= action
->next
)
1549 QUIT
; /* allow user to bail out with ^C */
1550 action_exp
= action
->action
;
1551 while (isspace ((int) *action_exp
))
1554 if (*action_exp
== '#') /* comment line */
1557 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1559 error (_("Bad action list item: %s"), action_exp
);
1561 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1564 { /* repeat over a comma-separated list */
1565 QUIT
; /* allow user to bail out with ^C */
1566 while (isspace ((int) *action_exp
))
1569 if (0 == strncasecmp ("$reg", action_exp
, 4))
1571 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
1572 add_register (collect
, i
);
1573 action_exp
= strchr (action_exp
, ','); /* more? */
1575 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1577 add_local_symbols (collect
,
1582 action_exp
= strchr (action_exp
, ','); /* more? */
1584 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1586 add_local_symbols (collect
,
1591 action_exp
= strchr (action_exp
, ','); /* more? */
1595 unsigned long addr
, len
;
1596 struct cleanup
*old_chain
= NULL
;
1597 struct cleanup
*old_chain1
= NULL
;
1598 struct agent_reqs areqs
;
1600 exp
= parse_exp_1 (&action_exp
,
1601 block_for_pc (t
->address
), 1);
1602 old_chain
= make_cleanup (free_current_contents
, &exp
);
1604 switch (exp
->elts
[0].opcode
)
1608 const char *name
= &exp
->elts
[2].string
;
1610 i
= frame_map_name_to_regnum (deprecated_safe_get_selected_frame (),
1611 name
, strlen (name
));
1613 internal_error (__FILE__
, __LINE__
,
1614 _("Register $%s not available"),
1617 printf_filtered ("OP_REGISTER: ");
1618 add_register (collect
, i
);
1623 /* safe because we know it's a simple expression */
1624 tempval
= evaluate_expression (exp
);
1625 addr
= VALUE_ADDRESS (tempval
) + value_offset (tempval
);
1626 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1627 add_memrange (collect
, memrange_absolute
, addr
, len
);
1631 collect_symbol (collect
,
1632 exp
->elts
[2].symbol
,
1637 default: /* full-fledged expression */
1638 aexpr
= gen_trace_for_expr (t
->address
, exp
);
1640 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1642 ax_reqs (aexpr
, &areqs
);
1643 if (areqs
.flaw
!= agent_flaw_none
)
1644 error (_("malformed expression"));
1646 if (areqs
.min_height
< 0)
1647 error (_("gdb: Internal error: expression has min height < 0"));
1648 if (areqs
.max_height
> 20)
1649 error (_("expression too complicated, try simplifying"));
1651 discard_cleanups (old_chain1
);
1652 add_aexpr (collect
, aexpr
);
1654 /* take care of the registers */
1655 if (areqs
.reg_mask_len
> 0)
1660 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1662 QUIT
; /* allow user to bail out with ^C */
1663 if (areqs
.reg_mask
[ndx1
] != 0)
1665 /* assume chars have 8 bits */
1666 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1667 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1668 /* it's used -- record it */
1669 add_register (collect
,
1676 do_cleanups (old_chain
);
1679 while (action_exp
&& *action_exp
++ == ',');
1681 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1683 collect
= &stepping_list
;
1685 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
1687 if (collect
== &stepping_list
) /* end stepping actions */
1688 collect
= &tracepoint_list
;
1690 break; /* end tracepoint actions */
1693 memrange_sortmerge (&tracepoint_list
);
1694 memrange_sortmerge (&stepping_list
);
1696 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1698 *stepping_actions
= stringify_collection_list (&stepping_list
,
1703 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1705 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1707 collect
->aexpr_list
=
1708 xrealloc (collect
->aexpr_list
,
1709 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1710 collect
->aexpr_listsize
*= 2;
1712 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1713 collect
->next_aexpr_elt
++;
1716 static char *target_buf
;
1717 static long target_buf_size
;
1719 /* Set "transparent" memory ranges
1721 Allow trace mechanism to treat text-like sections
1722 (and perhaps all read-only sections) transparently,
1723 i.e. don't reject memory requests from these address ranges
1724 just because they haven't been collected. */
1727 remote_set_transparent_ranges (void)
1729 extern bfd
*exec_bfd
;
1736 return; /* No information to give. */
1738 strcpy (target_buf
, "QTro");
1739 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
1741 char tmp1
[40], tmp2
[40];
1743 if ((s
->flags
& SEC_LOAD
) == 0 ||
1744 /* (s->flags & SEC_CODE) == 0 || */
1745 (s
->flags
& SEC_READONLY
) == 0)
1750 size
= bfd_get_section_size (s
);
1751 sprintf_vma (tmp1
, lma
);
1752 sprintf_vma (tmp2
, lma
+ size
);
1753 sprintf (target_buf
+ strlen (target_buf
),
1754 ":%s,%s", tmp1
, tmp2
);
1758 putpkt (target_buf
);
1759 getpkt (&target_buf
, &target_buf_size
, 0);
1765 Tell target to clear any previous trace experiment.
1766 Walk the list of tracepoints, and send them (and their actions)
1767 to the target. If no errors,
1768 Tell target to start a new trace experiment. */
1771 trace_start_command (char *args
, int from_tty
)
1773 struct tracepoint
*t
;
1776 char **stepping_actions
;
1778 struct cleanup
*old_chain
= NULL
;
1780 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1782 if (target_is_remote ())
1785 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1786 if (strcmp (target_buf
, "OK"))
1787 error (_("Target does not support this command."));
1793 sprintf_vma (tmp
, t
->address
);
1794 sprintf (buf
, "QTDP:%x:%s:%c:%lx:%x", t
->number
,
1796 t
->enabled_p
? 'E' : 'D',
1797 t
->step_count
, t
->pass_count
);
1802 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1803 if (strcmp (target_buf
, "OK"))
1804 error (_("Target does not support tracepoints."));
1808 encode_actions (t
, &tdp_actions
, &stepping_actions
);
1809 old_chain
= make_cleanup (free_actions_list_cleanup_wrapper
,
1811 (void) make_cleanup (free_actions_list_cleanup_wrapper
,
1814 /* do_single_steps (t); */
1817 for (ndx
= 0; tdp_actions
[ndx
]; ndx
++)
1819 QUIT
; /* allow user to bail out with ^C */
1820 sprintf (buf
, "QTDP:-%x:%s:%s%c",
1821 t
->number
, tmp
, /* address */
1823 ((tdp_actions
[ndx
+ 1] || stepping_actions
)
1826 remote_get_noisy_reply (&target_buf
,
1828 if (strcmp (target_buf
, "OK"))
1829 error (_("Error on target while setting tracepoints."));
1832 if (stepping_actions
)
1834 for (ndx
= 0; stepping_actions
[ndx
]; ndx
++)
1836 QUIT
; /* allow user to bail out with ^C */
1837 sprintf (buf
, "QTDP:-%x:%s:%s%s%s",
1838 t
->number
, tmp
, /* address */
1839 ((ndx
== 0) ? "S" : ""),
1840 stepping_actions
[ndx
],
1841 (stepping_actions
[ndx
+ 1] ? "-" : ""));
1843 remote_get_noisy_reply (&target_buf
,
1845 if (strcmp (target_buf
, "OK"))
1846 error (_("Error on target while setting tracepoints."));
1850 do_cleanups (old_chain
);
1853 /* Tell target to treat text-like sections as transparent. */
1854 remote_set_transparent_ranges ();
1855 /* Now insert traps and begin collecting data. */
1857 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1858 if (strcmp (target_buf
, "OK"))
1859 error (_("Bogus reply from target: %s"), target_buf
);
1860 set_traceframe_num (-1); /* All old traceframes invalidated. */
1861 set_tracepoint_num (-1);
1862 set_traceframe_context (-1);
1863 trace_running_p
= 1;
1864 if (deprecated_trace_start_stop_hook
)
1865 deprecated_trace_start_stop_hook (1, from_tty
);
1869 error (_("Trace can only be run on remote targets."));
1874 trace_stop_command (char *args
, int from_tty
)
1876 if (target_is_remote ())
1879 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1880 if (strcmp (target_buf
, "OK"))
1881 error (_("Bogus reply from target: %s"), target_buf
);
1882 trace_running_p
= 0;
1883 if (deprecated_trace_start_stop_hook
)
1884 deprecated_trace_start_stop_hook (0, from_tty
);
1887 error (_("Trace can only be run on remote targets."));
1890 unsigned long trace_running_p
;
1892 /* tstatus command */
1894 trace_status_command (char *args
, int from_tty
)
1896 if (target_is_remote ())
1898 putpkt ("qTStatus");
1899 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1901 if (target_buf
[0] != 'T' ||
1902 (target_buf
[1] != '0' && target_buf
[1] != '1'))
1903 error (_("Bogus reply from target: %s"), target_buf
);
1905 /* exported for use by the GUI */
1906 trace_running_p
= (target_buf
[1] == '1');
1909 error (_("Trace can only be run on remote targets."));
1912 /* Worker function for the various flavors of the tfind command. */
1914 finish_tfind_command (char **msg
,
1918 int target_frameno
= -1, target_tracept
= -1;
1919 CORE_ADDR old_frame_addr
;
1920 struct symbol
*old_func
;
1923 old_frame_addr
= get_frame_base (get_current_frame ());
1924 old_func
= find_pc_function (read_pc ());
1927 reply
= remote_get_noisy_reply (msg
, sizeof_msg
);
1929 while (reply
&& *reply
)
1933 if ((target_frameno
= (int) strtol (++reply
, &reply
, 16)) == -1)
1935 /* A request for a non-existant trace frame has failed.
1936 Our response will be different, depending on FROM_TTY:
1938 If FROM_TTY is true, meaning that this command was
1939 typed interactively by the user, then give an error
1940 and DO NOT change the state of traceframe_number etc.
1942 However if FROM_TTY is false, meaning that we're either
1943 in a script, a loop, or a user-defined command, then
1944 DON'T give an error, but DO change the state of
1945 traceframe_number etc. to invalid.
1947 The rationalle is that if you typed the command, you
1948 might just have committed a typo or something, and you'd
1949 like to NOT lose your current debugging state. However
1950 if you're in a user-defined command or especially in a
1951 loop, then you need a way to detect that the command
1952 failed WITHOUT aborting. This allows you to write
1953 scripts that search thru the trace buffer until the end,
1954 and then continue on to do something else. */
1957 error (_("Target failed to find requested trace frame."));
1961 printf_filtered ("End of trace buffer.\n");
1962 /* The following will not recurse, since it's
1964 trace_find_command ("-1", from_tty
);
1965 reply
= NULL
; /* Break out of loop
1966 (avoid recursive nonsense). */
1971 if ((target_tracept
= (int) strtol (++reply
, &reply
, 16)) == -1)
1972 error (_("Target failed to find requested trace frame."));
1974 case 'O': /* "OK"? */
1975 if (reply
[1] == 'K' && reply
[2] == '\0')
1978 error (_("Bogus reply from target: %s"), reply
);
1981 error (_("Bogus reply from target: %s"), reply
);
1984 reinit_frame_cache ();
1985 registers_changed ();
1986 set_traceframe_num (target_frameno
);
1987 set_tracepoint_num (target_tracept
);
1988 if (target_frameno
== -1)
1989 set_traceframe_context (-1);
1991 set_traceframe_context (read_pc ());
1995 enum print_what print_what
;
1997 /* NOTE: in immitation of the step command, try to determine
1998 whether we have made a transition from one function to
1999 another. If so, we'll print the "stack frame" (ie. the new
2000 function and it's arguments) -- otherwise we'll just show the
2003 This determination is made by checking (1) whether the
2004 current function has changed, and (2) whether the current FP
2005 has changed. Hack: if the FP wasn't collected, either at the
2006 current or the previous frame, assume that the FP has NOT
2009 if (old_func
== find_pc_function (read_pc ()) &&
2010 (old_frame_addr
== 0 ||
2011 get_frame_base (get_current_frame ()) == 0 ||
2012 old_frame_addr
== get_frame_base (get_current_frame ())))
2013 print_what
= SRC_LINE
;
2015 print_what
= SRC_AND_LOC
;
2017 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2022 /* trace_find_command takes a trace frame number n,
2023 sends "QTFrame:<n>" to the target,
2024 and accepts a reply that may contain several optional pieces
2025 of information: a frame number, a tracepoint number, and an
2026 indication of whether this is a trap frame or a stepping frame.
2028 The minimal response is just "OK" (which indicates that the
2029 target does not give us a frame number or a tracepoint number).
2030 Instead of that, the target may send us a string containing
2032 F<hexnum> (gives the selected frame number)
2033 T<hexnum> (gives the selected tracepoint number)
2038 trace_find_command (char *args
, int from_tty
)
2039 { /* this should only be called with a numeric argument */
2042 if (target_is_remote ())
2044 if (deprecated_trace_find_hook
)
2045 deprecated_trace_find_hook (args
, from_tty
);
2047 if (args
== 0 || *args
== 0)
2048 { /* TFIND with no args means find NEXT trace frame. */
2049 if (traceframe_number
== -1)
2050 frameno
= 0; /* "next" is first one */
2052 frameno
= traceframe_number
+ 1;
2054 else if (0 == strcmp (args
, "-"))
2056 if (traceframe_number
== -1)
2057 error (_("not debugging trace buffer"));
2058 else if (from_tty
&& traceframe_number
== 0)
2059 error (_("already at start of trace buffer"));
2061 frameno
= traceframe_number
- 1;
2064 frameno
= parse_and_eval_long (args
);
2067 error (_("invalid input (%d is less than zero)"), frameno
);
2069 sprintf (target_buf
, "QTFrame:%x", frameno
);
2070 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2073 error (_("Trace can only be run on remote targets."));
2078 trace_find_end_command (char *args
, int from_tty
)
2080 trace_find_command ("-1", from_tty
);
2085 trace_find_none_command (char *args
, int from_tty
)
2087 trace_find_command ("-1", from_tty
);
2092 trace_find_start_command (char *args
, int from_tty
)
2094 trace_find_command ("0", from_tty
);
2097 /* tfind pc command */
2099 trace_find_pc_command (char *args
, int from_tty
)
2104 if (target_is_remote ())
2106 if (args
== 0 || *args
== 0)
2107 pc
= read_pc (); /* default is current pc */
2109 pc
= parse_and_eval_address (args
);
2111 sprintf_vma (tmp
, pc
);
2112 sprintf (target_buf
, "QTFrame:pc:%s", tmp
);
2113 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2116 error (_("Trace can only be run on remote targets."));
2119 /* tfind tracepoint command */
2121 trace_find_tracepoint_command (char *args
, int from_tty
)
2125 if (target_is_remote ())
2127 if (args
== 0 || *args
== 0)
2129 if (tracepoint_number
== -1)
2130 error (_("No current tracepoint -- please supply an argument."));
2132 tdp
= tracepoint_number
; /* default is current TDP */
2135 tdp
= parse_and_eval_long (args
);
2137 sprintf (target_buf
, "QTFrame:tdp:%x", tdp
);
2138 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2141 error (_("Trace can only be run on remote targets."));
2144 /* TFIND LINE command:
2146 This command will take a sourceline for argument, just like BREAK
2147 or TRACE (ie. anything that "decode_line_1" can handle).
2149 With no argument, this command will find the next trace frame
2150 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2153 trace_find_line_command (char *args
, int from_tty
)
2155 static CORE_ADDR start_pc
, end_pc
;
2156 struct symtabs_and_lines sals
;
2157 struct symtab_and_line sal
;
2158 struct cleanup
*old_chain
;
2159 char startpc_str
[40], endpc_str
[40];
2161 if (target_is_remote ())
2163 if (args
== 0 || *args
== 0)
2165 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2167 sals
.sals
= (struct symtab_and_line
*)
2168 xmalloc (sizeof (struct symtab_and_line
));
2173 sals
= decode_line_spec (args
, 1);
2177 old_chain
= make_cleanup (xfree
, sals
.sals
);
2178 if (sal
.symtab
== 0)
2180 printf_filtered ("TFIND: No line number information available");
2183 /* This is useful for "info line *0x7f34". If we can't
2184 tell the user about a source line, at least let them
2185 have the symbolic address. */
2186 printf_filtered (" for address ");
2188 print_address (sal
.pc
, gdb_stdout
);
2189 printf_filtered (";\n -- will attempt to find by PC. \n");
2193 printf_filtered (".\n");
2194 return; /* No line, no PC; what can we do? */
2197 else if (sal
.line
> 0
2198 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2200 if (start_pc
== end_pc
)
2202 printf_filtered ("Line %d of \"%s\"",
2203 sal
.line
, sal
.symtab
->filename
);
2205 printf_filtered (" is at address ");
2206 print_address (start_pc
, gdb_stdout
);
2208 printf_filtered (" but contains no code.\n");
2209 sal
= find_pc_line (start_pc
, 0);
2211 find_line_pc_range (sal
, &start_pc
, &end_pc
) &&
2213 printf_filtered ("Attempting to find line %d instead.\n",
2216 error (_("Cannot find a good line."));
2220 /* Is there any case in which we get here, and have an address
2221 which the user would want to see? If we have debugging
2222 symbols and no line numbers? */
2223 error (_("Line number %d is out of range for \"%s\"."),
2224 sal
.line
, sal
.symtab
->filename
);
2226 sprintf_vma (startpc_str
, start_pc
);
2227 sprintf_vma (endpc_str
, end_pc
- 1);
2228 /* Find within range of stated line. */
2230 sprintf (target_buf
, "QTFrame:range:%s:%s",
2231 startpc_str
, endpc_str
);
2232 /* Find OUTSIDE OF range of CURRENT line. */
2234 sprintf (target_buf
, "QTFrame:outside:%s:%s",
2235 startpc_str
, endpc_str
);
2236 finish_tfind_command (&target_buf
, &target_buf_size
,
2238 do_cleanups (old_chain
);
2241 error (_("Trace can only be run on remote targets."));
2244 /* tfind range command */
2246 trace_find_range_command (char *args
, int from_tty
)
2248 static CORE_ADDR start
, stop
;
2249 char start_str
[40], stop_str
[40];
2252 if (target_is_remote ())
2254 if (args
== 0 || *args
== 0)
2255 { /* XXX FIXME: what should default behavior be? */
2256 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2260 if (0 != (tmp
= strchr (args
, ',')))
2262 *tmp
++ = '\0'; /* terminate start address */
2263 while (isspace ((int) *tmp
))
2265 start
= parse_and_eval_address (args
);
2266 stop
= parse_and_eval_address (tmp
);
2269 { /* no explicit end address? */
2270 start
= parse_and_eval_address (args
);
2271 stop
= start
+ 1; /* ??? */
2274 sprintf_vma (start_str
, start
);
2275 sprintf_vma (stop_str
, stop
);
2276 sprintf (target_buf
, "QTFrame:range:%s:%s", start_str
, stop_str
);
2277 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2280 error (_("Trace can only be run on remote targets."));
2283 /* tfind outside command */
2285 trace_find_outside_command (char *args
, int from_tty
)
2287 CORE_ADDR start
, stop
;
2288 char start_str
[40], stop_str
[40];
2291 if (target_is_remote ())
2293 if (args
== 0 || *args
== 0)
2294 { /* XXX FIXME: what should default behavior be? */
2295 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2299 if (0 != (tmp
= strchr (args
, ',')))
2301 *tmp
++ = '\0'; /* terminate start address */
2302 while (isspace ((int) *tmp
))
2304 start
= parse_and_eval_address (args
);
2305 stop
= parse_and_eval_address (tmp
);
2308 { /* no explicit end address? */
2309 start
= parse_and_eval_address (args
);
2310 stop
= start
+ 1; /* ??? */
2313 sprintf_vma (start_str
, start
);
2314 sprintf_vma (stop_str
, stop
);
2315 sprintf (target_buf
, "QTFrame:outside:%s:%s", start_str
, stop_str
);
2316 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2319 error (_("Trace can only be run on remote targets."));
2322 /* save-tracepoints command */
2324 tracepoint_save_command (char *args
, int from_tty
)
2326 struct tracepoint
*tp
;
2327 struct action_line
*line
;
2329 char *i1
= " ", *i2
= " ";
2330 char *indent
, *actionline
, *pathname
;
2333 if (args
== 0 || *args
== 0)
2334 error (_("Argument required (file name in which to save tracepoints)"));
2336 if (tracepoint_chain
== 0)
2338 warning (_("save-tracepoints: no tracepoints to save."));
2342 pathname
= tilde_expand (args
);
2343 if (!(fp
= fopen (pathname
, "w")))
2344 error (_("Unable to open file '%s' for saving tracepoints (%s)"),
2345 args
, safe_strerror (errno
));
2348 ALL_TRACEPOINTS (tp
)
2350 if (tp
->addr_string
)
2351 fprintf (fp
, "trace %s\n", tp
->addr_string
);
2354 sprintf_vma (tmp
, tp
->address
);
2355 fprintf (fp
, "trace *0x%s\n", tmp
);
2359 fprintf (fp
, " passcount %d\n", tp
->pass_count
);
2363 fprintf (fp
, " actions\n");
2365 for (line
= tp
->actions
; line
; line
= line
->next
)
2367 struct cmd_list_element
*cmd
;
2369 QUIT
; /* allow user to bail out with ^C */
2370 actionline
= line
->action
;
2371 while (isspace ((int) *actionline
))
2374 fprintf (fp
, "%s%s\n", indent
, actionline
);
2375 if (*actionline
!= '#') /* skip for comment lines */
2377 cmd
= lookup_cmd (&actionline
, cmdlist
, "", -1, 1);
2379 error (_("Bad action list item: %s"), actionline
);
2380 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2382 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2390 printf_filtered ("Tracepoints saved to file '%s'.\n", args
);
2394 /* info scope command: list the locals for a scope. */
2396 scope_info (char *args
, int from_tty
)
2398 struct symtabs_and_lines sals
;
2400 struct minimal_symbol
*msym
;
2401 struct block
*block
;
2402 char **canonical
, *symname
, *save_args
= args
;
2403 struct dict_iterator iter
;
2406 if (args
== 0 || *args
== 0)
2407 error (_("requires an argument (function, line or *addr) to define a scope"));
2409 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2410 if (sals
.nelts
== 0)
2411 return; /* presumably decode_line_1 has already warned */
2413 /* Resolve line numbers to PC */
2414 resolve_sal_pc (&sals
.sals
[0]);
2415 block
= block_for_pc (sals
.sals
[0].pc
);
2419 QUIT
; /* allow user to bail out with ^C */
2420 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2422 QUIT
; /* allow user to bail out with ^C */
2424 printf_filtered ("Scope for %s:\n", save_args
);
2427 symname
= DEPRECATED_SYMBOL_NAME (sym
);
2428 if (symname
== NULL
|| *symname
== '\0')
2429 continue; /* probably botched, certainly useless */
2431 printf_filtered ("Symbol %s is ", symname
);
2432 switch (SYMBOL_CLASS (sym
))
2435 case LOC_UNDEF
: /* messed up symbol? */
2436 printf_filtered ("a bogus symbol, class %d.\n",
2437 SYMBOL_CLASS (sym
));
2438 count
--; /* don't count this one */
2441 printf_filtered ("a constant with value %ld (0x%lx)",
2442 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2444 case LOC_CONST_BYTES
:
2445 printf_filtered ("constant bytes: ");
2446 if (SYMBOL_TYPE (sym
))
2447 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2448 fprintf_filtered (gdb_stdout
, " %02x",
2449 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2452 printf_filtered ("in static storage at address ");
2453 printf_filtered ("%s", paddress (SYMBOL_VALUE_ADDRESS (sym
)));
2456 printf_filtered ("a local variable in register $%s",
2457 gdbarch_register_name
2458 (current_gdbarch
, SYMBOL_VALUE (sym
)));
2462 printf_filtered ("an argument at stack/frame offset %ld",
2463 SYMBOL_VALUE (sym
));
2466 printf_filtered ("a local variable at frame offset %ld",
2467 SYMBOL_VALUE (sym
));
2470 printf_filtered ("a reference argument at offset %ld",
2471 SYMBOL_VALUE (sym
));
2474 printf_filtered ("an argument in register $%s",
2475 gdbarch_register_name
2476 (current_gdbarch
, SYMBOL_VALUE (sym
)));
2478 case LOC_REGPARM_ADDR
:
2479 printf_filtered ("the address of an argument, in register $%s",
2480 gdbarch_register_name
2481 (current_gdbarch
, SYMBOL_VALUE (sym
)));
2484 printf_filtered ("a typedef.\n");
2487 printf_filtered ("a label at address ");
2488 printf_filtered ("%s", paddress (SYMBOL_VALUE_ADDRESS (sym
)));
2491 printf_filtered ("a function at address ");
2492 printf_filtered ("%s", paddress (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2495 printf_filtered ("a variable at offset %ld from register $%s",
2497 gdbarch_register_name
2498 (current_gdbarch
, SYMBOL_BASEREG (sym
)));
2500 case LOC_BASEREG_ARG
:
2501 printf_filtered ("an argument at offset %ld from register $%s",
2503 gdbarch_register_name
2504 (current_gdbarch
, SYMBOL_BASEREG (sym
)));
2506 case LOC_UNRESOLVED
:
2507 msym
= lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (sym
),
2510 printf_filtered ("Unresolved Static");
2513 printf_filtered ("static storage at address ");
2514 printf_filtered ("%s", paddress (SYMBOL_VALUE_ADDRESS (msym
)));
2517 case LOC_OPTIMIZED_OUT
:
2518 printf_filtered ("optimized out.\n");
2520 case LOC_HP_THREAD_LOCAL_STATIC
:
2521 printf_filtered ("HP thread local static ");
2524 printf_filtered ("extern (local indirect) at address ");
2525 printf_filtered ("%s", paddress (SYMBOL_VALUE_ADDRESS (sym
)));
2528 case LOC_COMPUTED_ARG
:
2529 SYMBOL_OPS (sym
)->describe_location (sym
, gdb_stdout
);
2532 if (SYMBOL_TYPE (sym
))
2533 printf_filtered (", length %d.\n",
2534 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2536 if (BLOCK_FUNCTION (block
))
2539 block
= BLOCK_SUPERBLOCK (block
);
2542 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2546 /* worker function (cleanup) */
2548 replace_comma (void *data
)
2556 trace_dump_command (char *args
, int from_tty
)
2558 struct tracepoint
*t
;
2559 struct action_line
*action
;
2560 char *action_exp
, *next_comma
;
2561 struct cleanup
*old_cleanups
;
2562 int stepping_actions
= 0;
2563 int stepping_frame
= 0;
2565 if (!target_is_remote ())
2567 error (_("Trace can only be run on remote targets."));
2571 if (tracepoint_number
== -1)
2573 warning (_("No current trace frame."));
2578 if (t
->number
== tracepoint_number
)
2582 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2585 old_cleanups
= make_cleanup (null_cleanup
, NULL
);
2587 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2588 tracepoint_number
, traceframe_number
);
2590 /* The current frame is a trap frame if the frame PC is equal
2591 to the tracepoint PC. If not, then the current frame was
2592 collected during single-stepping. */
2594 stepping_frame
= (t
->address
!= (read_pc () - gdbarch_decr_pc_after_break
2595 (current_gdbarch
)));
2597 for (action
= t
->actions
; action
; action
= action
->next
)
2599 struct cmd_list_element
*cmd
;
2601 QUIT
; /* allow user to bail out with ^C */
2602 action_exp
= action
->action
;
2603 while (isspace ((int) *action_exp
))
2606 /* The collection actions to be done while stepping are
2607 bracketed by the commands "while-stepping" and "end". */
2609 if (*action_exp
== '#') /* comment line */
2612 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2614 error (_("Bad action list item: %s"), action_exp
);
2616 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2617 stepping_actions
= 1;
2618 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2619 stepping_actions
= 0;
2620 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2622 /* Display the collected data.
2623 For the trap frame, display only what was collected at
2624 the trap. Likewise for stepping frames, display only
2625 what was collected while stepping. This means that the
2626 two boolean variables, STEPPING_FRAME and
2627 STEPPING_ACTIONS should be equal. */
2628 if (stepping_frame
== stepping_actions
)
2631 { /* repeat over a comma-separated list */
2632 QUIT
; /* allow user to bail out with ^C */
2633 if (*action_exp
== ',')
2635 while (isspace ((int) *action_exp
))
2638 next_comma
= strchr (action_exp
, ',');
2640 if (0 == strncasecmp (action_exp
, "$reg", 4))
2641 registers_info (NULL
, from_tty
);
2642 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2643 locals_info (NULL
, from_tty
);
2644 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2645 args_info (NULL
, from_tty
);
2650 make_cleanup (replace_comma
, next_comma
);
2653 printf_filtered ("%s = ", action_exp
);
2654 output_command (action_exp
, from_tty
);
2655 printf_filtered ("\n");
2659 action_exp
= next_comma
;
2661 while (action_exp
&& *action_exp
== ',');
2665 discard_cleanups (old_cleanups
);
2668 /* Convert the memory pointed to by mem into hex, placing result in buf.
2669 * Return a pointer to the last char put in buf (null)
2670 * "stolen" from sparc-stub.c
2673 static const char hexchars
[] = "0123456789abcdef";
2676 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2684 *buf
++ = hexchars
[ch
>> 4];
2685 *buf
++ = hexchars
[ch
& 0xf];
2694 get_traceframe_number (void)
2696 return traceframe_number
;
2700 /* module initialization */
2702 _initialize_tracepoint (void)
2704 struct cmd_list_element
*c
;
2706 tracepoint_chain
= 0;
2707 tracepoint_count
= 0;
2708 traceframe_number
= -1;
2709 tracepoint_number
= -1;
2711 if (tracepoint_list
.list
== NULL
)
2713 tracepoint_list
.listsize
= 128;
2714 tracepoint_list
.list
= xmalloc
2715 (tracepoint_list
.listsize
* sizeof (struct memrange
));
2717 if (tracepoint_list
.aexpr_list
== NULL
)
2719 tracepoint_list
.aexpr_listsize
= 128;
2720 tracepoint_list
.aexpr_list
= xmalloc
2721 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
2724 if (stepping_list
.list
== NULL
)
2726 stepping_list
.listsize
= 128;
2727 stepping_list
.list
= xmalloc
2728 (stepping_list
.listsize
* sizeof (struct memrange
));
2731 if (stepping_list
.aexpr_list
== NULL
)
2733 stepping_list
.aexpr_listsize
= 128;
2734 stepping_list
.aexpr_list
= xmalloc
2735 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
2738 add_info ("scope", scope_info
,
2739 _("List the variables local to a scope"));
2741 add_cmd ("tracepoints", class_trace
, NULL
,
2742 _("Tracing of program execution without stopping the program."),
2745 add_info ("tracepoints", tracepoints_info
, _("\
2746 Status of tracepoints, or tracepoint number NUMBER.\n\
2747 Convenience variable \"$tpnum\" contains the number of the\n\
2748 last tracepoint set."));
2750 add_info_alias ("tp", "tracepoints", 1);
2752 c
= add_com ("save-tracepoints", class_trace
, tracepoint_save_command
, _("\
2753 Save current tracepoint definitions as a script.\n\
2754 Use the 'source' command in another debug session to restore them."));
2755 set_cmd_completer (c
, filename_completer
);
2757 add_com ("tdump", class_trace
, trace_dump_command
,
2758 _("Print everything collected at the current tracepoint."));
2760 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
2761 Select a trace frame;\n\
2762 No argument means forward by one frame; '-' means backward by one frame."),
2763 &tfindlist
, "tfind ", 1, &cmdlist
);
2765 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
2766 Select a trace frame whose PC is outside the given range.\n\
2767 Usage: tfind outside addr1, addr2"),
2770 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
2771 Select a trace frame whose PC is in the given range.\n\
2772 Usage: tfind range addr1,addr2"),
2775 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
2776 Select a trace frame by source line.\n\
2777 Argument can be a line number (with optional source file), \n\
2778 a function name, or '*' followed by an address.\n\
2779 Default argument is 'the next source line that was traced'."),
2782 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
2783 Select a trace frame by tracepoint number.\n\
2784 Default is the tracepoint for the current trace frame."),
2787 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
2788 Select a trace frame by PC.\n\
2789 Default is the current PC, or the PC of the current trace frame."),
2792 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
2793 Synonym for 'none'.\n\
2794 De-select any trace frame and resume 'live' debugging."),
2797 add_cmd ("none", class_trace
, trace_find_none_command
,
2798 _("De-select any trace frame and resume 'live' debugging."),
2801 add_cmd ("start", class_trace
, trace_find_start_command
,
2802 _("Select the first trace frame in the trace buffer."),
2805 add_com ("tstatus", class_trace
, trace_status_command
,
2806 _("Display the status of the current trace data collection."));
2808 add_com ("tstop", class_trace
, trace_stop_command
,
2809 _("Stop trace data collection."));
2811 add_com ("tstart", class_trace
, trace_start_command
,
2812 _("Start trace data collection."));
2814 add_com ("passcount", class_trace
, trace_pass_command
, _("\
2815 Set the passcount for a tracepoint.\n\
2816 The trace will end when the tracepoint has been passed 'count' times.\n\
2817 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
2818 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
2820 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
2821 Ends a list of commands or actions.\n\
2822 Several GDB commands allow you to enter a list of commands or actions.\n\
2823 Entering \"end\" on a line by itself is the normal way to terminate\n\
2825 Note: the \"end\" command cannot be used at the gdb prompt."));
2827 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
2828 Specify single-stepping behavior at a tracepoint.\n\
2829 Argument is number of instructions to trace in single-step mode\n\
2830 following the tracepoint. This command is normally followed by\n\
2831 one or more \"collect\" commands, to specify what to collect\n\
2832 while single-stepping.\n\n\
2833 Note: this command can only be used in a tracepoint \"actions\" list."));
2835 add_com_alias ("ws", "while-stepping", class_alias
, 0);
2836 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
2838 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
2839 Specify one or more data items to be collected at a tracepoint.\n\
2840 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
2841 collect all data (variables, registers) referenced by that expression.\n\
2842 Also accepts the following special arguments:\n\
2843 $regs -- all registers.\n\
2844 $args -- all function arguments.\n\
2845 $locals -- all variables local to the block/function scope.\n\
2846 Note: this command can only be used in a tracepoint \"actions\" list."));
2848 add_com ("actions", class_trace
, trace_actions_command
, _("\
2849 Specify the actions to be taken at a tracepoint.\n\
2850 Tracepoint actions may include collecting of specified data, \n\
2851 single-stepping, or enabling/disabling other tracepoints, \n\
2852 depending on target's capabilities."));
2854 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
2855 Delete specified tracepoints.\n\
2856 Arguments are tracepoint numbers, separated by spaces.\n\
2857 No argument means delete all tracepoints."),
2860 add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
2861 Disable specified tracepoints.\n\
2862 Arguments are tracepoint numbers, separated by spaces.\n\
2863 No argument means disable all tracepoints."),
2866 add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
2867 Enable specified tracepoints.\n\
2868 Arguments are tracepoint numbers, separated by spaces.\n\
2869 No argument means enable all tracepoints."),
2872 c
= add_com ("trace", class_trace
, trace_command
, _("\
2873 Set a tracepoint at a specified line or function or address.\n\
2874 Argument may be a line number, function name, or '*' plus an address.\n\
2875 For a line number or function, trace at the start of its code.\n\
2876 If an address is specified, trace at that exact address.\n\n\
2877 Do \"help tracepoints\" for info on other tracepoint commands."));
2878 set_cmd_completer (c
, location_completer
);
2880 add_com_alias ("tp", "trace", class_alias
, 0);
2881 add_com_alias ("tr", "trace", class_alias
, 1);
2882 add_com_alias ("tra", "trace", class_alias
, 1);
2883 add_com_alias ("trac", "trace", class_alias
, 1);
2885 target_buf_size
= 2048;
2886 target_buf
= xmalloc (target_buf_size
);