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);
866 line
= xstrdup ("end");
867 printf_filtered ("end\n");
870 linetype
= validate_actionline (&line
, t
);
871 if (linetype
== BADLINE
)
872 continue; /* already warned -- collect another line */
874 temp
= xmalloc (sizeof (struct action_line
));
878 if (next
== NULL
) /* first action for this tracepoint? */
879 t
->actions
= next
= temp
;
886 if (linetype
== STEPPING
) /* begin "while-stepping" */
888 if (prompt
== prompt2
)
890 warning (_("Already processing 'while-stepping'"));
894 prompt
= prompt2
; /* change prompt for stepping actions */
896 else if (linetype
== END
)
898 if (prompt
== prompt2
)
900 prompt
= prompt1
; /* end of single-stepping actions */
903 { /* end of actions */
904 if (t
->actions
->next
== NULL
)
906 /* An "end" all by itself with no other actions
907 means this tracepoint has no actions.
908 Discard empty list. */
917 signal (STOP_SIGNAL
, SIG_DFL
);
920 discard_cleanups (old_chain
);
923 /* worker function */
925 validate_actionline (char **line
, struct tracepoint
*t
)
927 struct cmd_list_element
*c
;
928 struct expression
*exp
= NULL
;
929 struct cleanup
*old_chain
= NULL
;
932 /* if EOF is typed, *line is NULL */
936 for (p
= *line
; isspace ((int) *p
);)
939 /* Symbol lookup etc. */
940 if (*p
== '\0') /* empty line: just prompt for another line. */
943 if (*p
== '#') /* comment line */
946 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
949 warning (_("'%s' is not an action that I know, or is ambiguous."),
954 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
956 struct agent_expr
*aexpr
;
957 struct agent_reqs areqs
;
960 { /* repeat over a comma-separated list */
961 QUIT
; /* allow user to bail out with ^C */
962 while (isspace ((int) *p
))
965 if (*p
== '$') /* look for special pseudo-symbols */
967 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
968 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
969 (0 == strncasecmp ("loc", p
+ 1, 3)))
974 /* else fall thru, treat p as an expression and parse it! */
976 exp
= parse_exp_1 (&p
, block_for_pc (t
->address
), 1);
977 old_chain
= make_cleanup (free_current_contents
, &exp
);
979 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
981 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
983 warning (_("constant %s (value %ld) will not be collected."),
984 DEPRECATED_SYMBOL_NAME (exp
->elts
[2].symbol
),
985 SYMBOL_VALUE (exp
->elts
[2].symbol
));
988 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
990 warning (_("%s is optimized away and cannot be collected."),
991 DEPRECATED_SYMBOL_NAME (exp
->elts
[2].symbol
));
996 /* We have something to collect, make sure that the expr to
997 bytecode translator can handle it and that it's not too
999 aexpr
= gen_trace_for_expr (t
->address
, exp
);
1000 make_cleanup_free_agent_expr (aexpr
);
1002 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
1003 error (_("expression too complicated, try simplifying"));
1005 ax_reqs (aexpr
, &areqs
);
1006 (void) make_cleanup (xfree
, areqs
.reg_mask
);
1008 if (areqs
.flaw
!= agent_flaw_none
)
1009 error (_("malformed expression"));
1011 if (areqs
.min_height
< 0)
1012 error (_("gdb: Internal error: expression has min height < 0"));
1014 if (areqs
.max_height
> 20)
1015 error (_("expression too complicated, try simplifying"));
1017 do_cleanups (old_chain
);
1019 while (p
&& *p
++ == ',');
1022 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
1024 char *steparg
; /* in case warning is necessary */
1026 while (isspace ((int) *p
))
1031 (t
->step_count
= strtol (p
, &p
, 0)) == 0)
1033 warning (_("'%s': bad step-count; command ignored."), *line
);
1038 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
1042 warning (_("'%s' is not a supported tracepoint action."), *line
);
1047 /* worker function */
1049 free_actions (struct tracepoint
*t
)
1051 struct action_line
*line
, *next
;
1053 for (line
= t
->actions
; line
; line
= next
)
1057 xfree (line
->action
);
1064 do_free_actions_cleanup (void *t
)
1069 static struct cleanup
*
1070 make_cleanup_free_actions (struct tracepoint
*t
)
1072 return make_cleanup (do_free_actions_cleanup
, t
);
1076 memrange_absolute
= -1
1081 int type
; /* memrange_absolute for absolute memory range,
1082 else basereg number */
1083 bfd_signed_vma start
;
1087 struct collection_list
1089 unsigned char regs_mask
[32]; /* room for up to 256 regs */
1092 struct memrange
*list
;
1093 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
1094 long next_aexpr_elt
;
1095 struct agent_expr
**aexpr_list
;
1098 tracepoint_list
, stepping_list
;
1100 /* MEMRANGE functions: */
1102 static int memrange_cmp (const void *, const void *);
1104 /* compare memranges for qsort */
1106 memrange_cmp (const void *va
, const void *vb
)
1108 const struct memrange
*a
= va
, *b
= vb
;
1110 if (a
->type
< b
->type
)
1112 if (a
->type
> b
->type
)
1114 if (a
->type
== memrange_absolute
)
1116 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
1118 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
1123 if (a
->start
< b
->start
)
1125 if (a
->start
> b
->start
)
1131 /* Sort the memrange list using qsort, and merge adjacent memranges. */
1133 memrange_sortmerge (struct collection_list
*memranges
)
1137 qsort (memranges
->list
, memranges
->next_memrange
,
1138 sizeof (struct memrange
), memrange_cmp
);
1139 if (memranges
->next_memrange
> 0)
1141 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
1143 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
1144 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
1147 /* memrange b starts before memrange a ends; merge them. */
1148 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
1149 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
1150 continue; /* next b, same a */
1154 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
1155 sizeof (struct memrange
));
1157 memranges
->next_memrange
= a
+ 1;
1161 /* Add a register to a collection list. */
1163 add_register (struct collection_list
*collection
, unsigned int regno
)
1166 printf_filtered ("collect register %d\n", regno
);
1167 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
1168 error (_("Internal: register number %d too large for tracepoint"),
1170 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
1173 /* Add a memrange to a collection list */
1175 add_memrange (struct collection_list
*memranges
,
1176 int type
, bfd_signed_vma base
,
1181 printf_filtered ("(%d,", type
);
1183 printf_filtered (",%ld)\n", len
);
1186 /* type: memrange_absolute == memory, other n == basereg */
1187 memranges
->list
[memranges
->next_memrange
].type
= type
;
1188 /* base: addr if memory, offset if reg relative. */
1189 memranges
->list
[memranges
->next_memrange
].start
= base
;
1190 /* len: we actually save end (base + len) for convenience */
1191 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
1192 memranges
->next_memrange
++;
1193 if (memranges
->next_memrange
>= memranges
->listsize
)
1195 memranges
->listsize
*= 2;
1196 memranges
->list
= xrealloc (memranges
->list
,
1197 memranges
->listsize
);
1200 if (type
!= memrange_absolute
) /* Better collect the base register! */
1201 add_register (memranges
, type
);
1204 /* Add a symbol to a collection list. */
1206 collect_symbol (struct collection_list
*collect
,
1208 long frame_regno
, long frame_offset
)
1212 bfd_signed_vma offset
;
1214 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
1215 switch (SYMBOL_CLASS (sym
))
1218 printf_filtered ("%s: don't know symbol class %d\n",
1219 DEPRECATED_SYMBOL_NAME (sym
),
1220 SYMBOL_CLASS (sym
));
1223 printf_filtered ("constant %s (value %ld) will not be collected.\n",
1224 DEPRECATED_SYMBOL_NAME (sym
), SYMBOL_VALUE (sym
));
1227 offset
= SYMBOL_VALUE_ADDRESS (sym
);
1232 sprintf_vma (tmp
, offset
);
1233 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1234 DEPRECATED_SYMBOL_NAME (sym
), len
,
1237 add_memrange (collect
, memrange_absolute
, offset
, len
);
1241 reg
= SYMBOL_VALUE (sym
);
1243 printf_filtered ("LOC_REG[parm] %s: ",
1244 DEPRECATED_SYMBOL_NAME (sym
));
1245 add_register (collect
, reg
);
1246 /* Check for doubles stored in two registers. */
1247 /* FIXME: how about larger types stored in 3 or more regs? */
1248 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1249 len
> register_size (current_gdbarch
, reg
))
1250 add_register (collect
, reg
+ 1);
1253 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1254 printf_filtered (" (will not collect %s)\n",
1255 DEPRECATED_SYMBOL_NAME (sym
));
1259 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1262 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1263 DEPRECATED_SYMBOL_NAME (sym
), len
);
1264 printf_vma (offset
);
1265 printf_filtered (" from frame ptr reg %d\n", reg
);
1267 add_memrange (collect
, reg
, offset
, len
);
1269 case LOC_REGPARM_ADDR
:
1270 reg
= SYMBOL_VALUE (sym
);
1274 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1275 DEPRECATED_SYMBOL_NAME (sym
), len
);
1276 printf_vma (offset
);
1277 printf_filtered (" from reg %d\n", reg
);
1279 add_memrange (collect
, reg
, offset
, len
);
1283 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1286 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1287 DEPRECATED_SYMBOL_NAME (sym
), len
);
1288 printf_vma (offset
);
1289 printf_filtered (" from frame ptr reg %d\n", reg
);
1291 add_memrange (collect
, reg
, offset
, len
);
1293 case LOC_UNRESOLVED
:
1294 printf_filtered ("Don't know LOC_UNRESOLVED %s\n",
1295 DEPRECATED_SYMBOL_NAME (sym
));
1297 case LOC_OPTIMIZED_OUT
:
1298 printf_filtered ("%s has been optimized out of existence.\n",
1299 DEPRECATED_SYMBOL_NAME (sym
));
1304 /* Add all locals (or args) symbols to collection list */
1306 add_local_symbols (struct collection_list
*collect
, CORE_ADDR pc
,
1307 long frame_regno
, long frame_offset
, int type
)
1310 struct block
*block
;
1311 struct dict_iterator iter
;
1314 block
= block_for_pc (pc
);
1317 QUIT
; /* allow user to bail out with ^C */
1318 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
1320 switch (SYMBOL_CLASS (sym
))
1323 warning (_("don't know how to trace local symbol %s"),
1324 DEPRECATED_SYMBOL_NAME (sym
));
1328 if (type
== 'L') /* collecting Locals */
1331 collect_symbol (collect
, sym
, frame_regno
,
1338 case LOC_REGPARM_ADDR
:
1339 if (type
== 'A') /* collecting Arguments */
1342 collect_symbol (collect
, sym
, frame_regno
,
1347 if (BLOCK_FUNCTION (block
))
1350 block
= BLOCK_SUPERBLOCK (block
);
1353 warning (_("No %s found in scope."),
1354 type
== 'L' ? "locals" : "args");
1357 /* worker function */
1359 clear_collection_list (struct collection_list
*list
)
1363 list
->next_memrange
= 0;
1364 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1366 free_agent_expr (list
->aexpr_list
[ndx
]);
1367 list
->aexpr_list
[ndx
] = NULL
;
1369 list
->next_aexpr_elt
= 0;
1370 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1373 /* reduce a collection list to string form (for gdb protocol) */
1375 stringify_collection_list (struct collection_list
*list
, char *string
)
1377 char temp_buf
[2048];
1381 char *(*str_list
)[];
1385 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1386 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1388 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1389 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1391 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1394 printf_filtered ("\nCollecting registers (mask): 0x");
1399 QUIT
; /* allow user to bail out with ^C */
1401 printf_filtered ("%02X", list
->regs_mask
[i
]);
1402 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1405 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1409 printf_filtered ("\n");
1410 if (list
->next_memrange
> 0 && info_verbose
)
1411 printf_filtered ("Collecting memranges: \n");
1412 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1414 QUIT
; /* allow user to bail out with ^C */
1415 sprintf_vma (tmp2
, list
->list
[i
].start
);
1418 printf_filtered ("(%d, %s, %ld)\n",
1421 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1423 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1425 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1432 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1434 /* The "%X" conversion specifier expects an unsigned argument,
1435 so passing -1 (memrange_absolute) to it directly gives you
1436 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1438 if (list
->list
[i
].type
== memrange_absolute
)
1439 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1441 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1444 count
+= strlen (end
);
1445 end
= temp_buf
+ count
;
1448 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1450 QUIT
; /* allow user to bail out with ^C */
1451 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1453 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1458 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1459 end
+= 10; /* 'X' + 8 hex digits + ',' */
1462 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1463 end
, list
->aexpr_list
[i
]->len
);
1464 count
+= 2 * list
->aexpr_list
[i
]->len
;
1469 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1474 (*str_list
)[ndx
] = NULL
;
1486 free_actions_list_cleanup_wrapper (void *al
)
1488 free_actions_list (al
);
1492 free_actions_list (char **actions_list
)
1496 if (actions_list
== 0)
1499 for (ndx
= 0; actions_list
[ndx
]; ndx
++)
1500 xfree (actions_list
[ndx
]);
1502 xfree (actions_list
);
1505 /* Render all actions into gdb protocol. */
1507 encode_actions (struct tracepoint
*t
, char ***tdp_actions
,
1508 char ***stepping_actions
)
1510 static char tdp_buff
[2048], step_buff
[2048];
1512 struct expression
*exp
= NULL
;
1513 struct action_line
*action
;
1515 struct value
*tempval
;
1516 struct collection_list
*collect
;
1517 struct cmd_list_element
*cmd
;
1518 struct agent_expr
*aexpr
;
1520 LONGEST frame_offset
;
1523 clear_collection_list (&tracepoint_list
);
1524 clear_collection_list (&stepping_list
);
1525 collect
= &tracepoint_list
;
1527 *tdp_actions
= NULL
;
1528 *stepping_actions
= NULL
;
1530 gdbarch_virtual_frame_pointer (current_gdbarch
,
1531 t
->address
, &frame_reg
, &frame_offset
);
1533 for (action
= t
->actions
; action
; action
= action
->next
)
1535 QUIT
; /* allow user to bail out with ^C */
1536 action_exp
= action
->action
;
1537 while (isspace ((int) *action_exp
))
1540 if (*action_exp
== '#') /* comment line */
1543 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1545 error (_("Bad action list item: %s"), action_exp
);
1547 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1550 { /* repeat over a comma-separated list */
1551 QUIT
; /* allow user to bail out with ^C */
1552 while (isspace ((int) *action_exp
))
1555 if (0 == strncasecmp ("$reg", action_exp
, 4))
1557 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
1558 add_register (collect
, i
);
1559 action_exp
= strchr (action_exp
, ','); /* more? */
1561 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1563 add_local_symbols (collect
,
1568 action_exp
= strchr (action_exp
, ','); /* more? */
1570 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1572 add_local_symbols (collect
,
1577 action_exp
= strchr (action_exp
, ','); /* more? */
1581 unsigned long addr
, len
;
1582 struct cleanup
*old_chain
= NULL
;
1583 struct cleanup
*old_chain1
= NULL
;
1584 struct agent_reqs areqs
;
1586 exp
= parse_exp_1 (&action_exp
,
1587 block_for_pc (t
->address
), 1);
1588 old_chain
= make_cleanup (free_current_contents
, &exp
);
1590 switch (exp
->elts
[0].opcode
)
1594 const char *name
= &exp
->elts
[2].string
;
1596 i
= frame_map_name_to_regnum (deprecated_safe_get_selected_frame (),
1597 name
, strlen (name
));
1599 internal_error (__FILE__
, __LINE__
,
1600 _("Register $%s not available"),
1603 printf_filtered ("OP_REGISTER: ");
1604 add_register (collect
, i
);
1609 /* safe because we know it's a simple expression */
1610 tempval
= evaluate_expression (exp
);
1611 addr
= VALUE_ADDRESS (tempval
) + value_offset (tempval
);
1612 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1613 add_memrange (collect
, memrange_absolute
, addr
, len
);
1617 collect_symbol (collect
,
1618 exp
->elts
[2].symbol
,
1623 default: /* full-fledged expression */
1624 aexpr
= gen_trace_for_expr (t
->address
, exp
);
1626 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1628 ax_reqs (aexpr
, &areqs
);
1629 if (areqs
.flaw
!= agent_flaw_none
)
1630 error (_("malformed expression"));
1632 if (areqs
.min_height
< 0)
1633 error (_("gdb: Internal error: expression has min height < 0"));
1634 if (areqs
.max_height
> 20)
1635 error (_("expression too complicated, try simplifying"));
1637 discard_cleanups (old_chain1
);
1638 add_aexpr (collect
, aexpr
);
1640 /* take care of the registers */
1641 if (areqs
.reg_mask_len
> 0)
1646 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1648 QUIT
; /* allow user to bail out with ^C */
1649 if (areqs
.reg_mask
[ndx1
] != 0)
1651 /* assume chars have 8 bits */
1652 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1653 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1654 /* it's used -- record it */
1655 add_register (collect
,
1662 do_cleanups (old_chain
);
1665 while (action_exp
&& *action_exp
++ == ',');
1667 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1669 collect
= &stepping_list
;
1671 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
1673 if (collect
== &stepping_list
) /* end stepping actions */
1674 collect
= &tracepoint_list
;
1676 break; /* end tracepoint actions */
1679 memrange_sortmerge (&tracepoint_list
);
1680 memrange_sortmerge (&stepping_list
);
1682 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1684 *stepping_actions
= stringify_collection_list (&stepping_list
,
1689 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1691 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1693 collect
->aexpr_list
=
1694 xrealloc (collect
->aexpr_list
,
1695 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1696 collect
->aexpr_listsize
*= 2;
1698 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1699 collect
->next_aexpr_elt
++;
1702 static char *target_buf
;
1703 static long target_buf_size
;
1705 /* Set "transparent" memory ranges
1707 Allow trace mechanism to treat text-like sections
1708 (and perhaps all read-only sections) transparently,
1709 i.e. don't reject memory requests from these address ranges
1710 just because they haven't been collected. */
1713 remote_set_transparent_ranges (void)
1715 extern bfd
*exec_bfd
;
1722 return; /* No information to give. */
1724 strcpy (target_buf
, "QTro");
1725 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
1727 char tmp1
[40], tmp2
[40];
1729 if ((s
->flags
& SEC_LOAD
) == 0 ||
1730 /* (s->flags & SEC_CODE) == 0 || */
1731 (s
->flags
& SEC_READONLY
) == 0)
1736 size
= bfd_get_section_size (s
);
1737 sprintf_vma (tmp1
, lma
);
1738 sprintf_vma (tmp2
, lma
+ size
);
1739 sprintf (target_buf
+ strlen (target_buf
),
1740 ":%s,%s", tmp1
, tmp2
);
1744 putpkt (target_buf
);
1745 getpkt (&target_buf
, &target_buf_size
, 0);
1751 Tell target to clear any previous trace experiment.
1752 Walk the list of tracepoints, and send them (and their actions)
1753 to the target. If no errors,
1754 Tell target to start a new trace experiment. */
1757 trace_start_command (char *args
, int from_tty
)
1759 struct tracepoint
*t
;
1762 char **stepping_actions
;
1764 struct cleanup
*old_chain
= NULL
;
1766 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1768 if (target_is_remote ())
1771 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1772 if (strcmp (target_buf
, "OK"))
1773 error (_("Target does not support this command."));
1779 sprintf_vma (tmp
, t
->address
);
1780 sprintf (buf
, "QTDP:%x:%s:%c:%lx:%x", t
->number
,
1782 t
->enabled_p
? 'E' : 'D',
1783 t
->step_count
, t
->pass_count
);
1788 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1789 if (strcmp (target_buf
, "OK"))
1790 error (_("Target does not support tracepoints."));
1794 encode_actions (t
, &tdp_actions
, &stepping_actions
);
1795 old_chain
= make_cleanup (free_actions_list_cleanup_wrapper
,
1797 (void) make_cleanup (free_actions_list_cleanup_wrapper
,
1800 /* do_single_steps (t); */
1803 for (ndx
= 0; tdp_actions
[ndx
]; ndx
++)
1805 QUIT
; /* allow user to bail out with ^C */
1806 sprintf (buf
, "QTDP:-%x:%s:%s%c",
1807 t
->number
, tmp
, /* address */
1809 ((tdp_actions
[ndx
+ 1] || stepping_actions
)
1812 remote_get_noisy_reply (&target_buf
,
1814 if (strcmp (target_buf
, "OK"))
1815 error (_("Error on target while setting tracepoints."));
1818 if (stepping_actions
)
1820 for (ndx
= 0; stepping_actions
[ndx
]; ndx
++)
1822 QUIT
; /* allow user to bail out with ^C */
1823 sprintf (buf
, "QTDP:-%x:%s:%s%s%s",
1824 t
->number
, tmp
, /* address */
1825 ((ndx
== 0) ? "S" : ""),
1826 stepping_actions
[ndx
],
1827 (stepping_actions
[ndx
+ 1] ? "-" : ""));
1829 remote_get_noisy_reply (&target_buf
,
1831 if (strcmp (target_buf
, "OK"))
1832 error (_("Error on target while setting tracepoints."));
1836 do_cleanups (old_chain
);
1839 /* Tell target to treat text-like sections as transparent. */
1840 remote_set_transparent_ranges ();
1841 /* Now insert traps and begin collecting data. */
1843 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1844 if (strcmp (target_buf
, "OK"))
1845 error (_("Bogus reply from target: %s"), target_buf
);
1846 set_traceframe_num (-1); /* All old traceframes invalidated. */
1847 set_tracepoint_num (-1);
1848 set_traceframe_context (-1);
1849 trace_running_p
= 1;
1850 if (deprecated_trace_start_stop_hook
)
1851 deprecated_trace_start_stop_hook (1, from_tty
);
1855 error (_("Trace can only be run on remote targets."));
1860 trace_stop_command (char *args
, int from_tty
)
1862 if (target_is_remote ())
1865 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1866 if (strcmp (target_buf
, "OK"))
1867 error (_("Bogus reply from target: %s"), target_buf
);
1868 trace_running_p
= 0;
1869 if (deprecated_trace_start_stop_hook
)
1870 deprecated_trace_start_stop_hook (0, from_tty
);
1873 error (_("Trace can only be run on remote targets."));
1876 unsigned long trace_running_p
;
1878 /* tstatus command */
1880 trace_status_command (char *args
, int from_tty
)
1882 if (target_is_remote ())
1884 putpkt ("qTStatus");
1885 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1887 if (target_buf
[0] != 'T' ||
1888 (target_buf
[1] != '0' && target_buf
[1] != '1'))
1889 error (_("Bogus reply from target: %s"), target_buf
);
1891 /* exported for use by the GUI */
1892 trace_running_p
= (target_buf
[1] == '1');
1895 error (_("Trace can only be run on remote targets."));
1898 /* Worker function for the various flavors of the tfind command. */
1900 finish_tfind_command (char **msg
,
1904 int target_frameno
= -1, target_tracept
= -1;
1905 CORE_ADDR old_frame_addr
;
1906 struct symbol
*old_func
;
1909 old_frame_addr
= get_frame_base (get_current_frame ());
1910 old_func
= find_pc_function (read_pc ());
1913 reply
= remote_get_noisy_reply (msg
, sizeof_msg
);
1915 while (reply
&& *reply
)
1919 if ((target_frameno
= (int) strtol (++reply
, &reply
, 16)) == -1)
1921 /* A request for a non-existant trace frame has failed.
1922 Our response will be different, depending on FROM_TTY:
1924 If FROM_TTY is true, meaning that this command was
1925 typed interactively by the user, then give an error
1926 and DO NOT change the state of traceframe_number etc.
1928 However if FROM_TTY is false, meaning that we're either
1929 in a script, a loop, or a user-defined command, then
1930 DON'T give an error, but DO change the state of
1931 traceframe_number etc. to invalid.
1933 The rationalle is that if you typed the command, you
1934 might just have committed a typo or something, and you'd
1935 like to NOT lose your current debugging state. However
1936 if you're in a user-defined command or especially in a
1937 loop, then you need a way to detect that the command
1938 failed WITHOUT aborting. This allows you to write
1939 scripts that search thru the trace buffer until the end,
1940 and then continue on to do something else. */
1943 error (_("Target failed to find requested trace frame."));
1947 printf_filtered ("End of trace buffer.\n");
1948 /* The following will not recurse, since it's
1950 trace_find_command ("-1", from_tty
);
1951 reply
= NULL
; /* Break out of loop
1952 (avoid recursive nonsense). */
1957 if ((target_tracept
= (int) strtol (++reply
, &reply
, 16)) == -1)
1958 error (_("Target failed to find requested trace frame."));
1960 case 'O': /* "OK"? */
1961 if (reply
[1] == 'K' && reply
[2] == '\0')
1964 error (_("Bogus reply from target: %s"), reply
);
1967 error (_("Bogus reply from target: %s"), reply
);
1970 reinit_frame_cache ();
1971 registers_changed ();
1972 set_traceframe_num (target_frameno
);
1973 set_tracepoint_num (target_tracept
);
1974 if (target_frameno
== -1)
1975 set_traceframe_context (-1);
1977 set_traceframe_context (read_pc ());
1981 enum print_what print_what
;
1983 /* NOTE: in immitation of the step command, try to determine
1984 whether we have made a transition from one function to
1985 another. If so, we'll print the "stack frame" (ie. the new
1986 function and it's arguments) -- otherwise we'll just show the
1989 This determination is made by checking (1) whether the
1990 current function has changed, and (2) whether the current FP
1991 has changed. Hack: if the FP wasn't collected, either at the
1992 current or the previous frame, assume that the FP has NOT
1995 if (old_func
== find_pc_function (read_pc ()) &&
1996 (old_frame_addr
== 0 ||
1997 get_frame_base (get_current_frame ()) == 0 ||
1998 old_frame_addr
== get_frame_base (get_current_frame ())))
1999 print_what
= SRC_LINE
;
2001 print_what
= SRC_AND_LOC
;
2003 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2008 /* trace_find_command takes a trace frame number n,
2009 sends "QTFrame:<n>" to the target,
2010 and accepts a reply that may contain several optional pieces
2011 of information: a frame number, a tracepoint number, and an
2012 indication of whether this is a trap frame or a stepping frame.
2014 The minimal response is just "OK" (which indicates that the
2015 target does not give us a frame number or a tracepoint number).
2016 Instead of that, the target may send us a string containing
2018 F<hexnum> (gives the selected frame number)
2019 T<hexnum> (gives the selected tracepoint number)
2024 trace_find_command (char *args
, int from_tty
)
2025 { /* this should only be called with a numeric argument */
2028 if (target_is_remote ())
2030 if (deprecated_trace_find_hook
)
2031 deprecated_trace_find_hook (args
, from_tty
);
2033 if (args
== 0 || *args
== 0)
2034 { /* TFIND with no args means find NEXT trace frame. */
2035 if (traceframe_number
== -1)
2036 frameno
= 0; /* "next" is first one */
2038 frameno
= traceframe_number
+ 1;
2040 else if (0 == strcmp (args
, "-"))
2042 if (traceframe_number
== -1)
2043 error (_("not debugging trace buffer"));
2044 else if (from_tty
&& traceframe_number
== 0)
2045 error (_("already at start of trace buffer"));
2047 frameno
= traceframe_number
- 1;
2050 frameno
= parse_and_eval_long (args
);
2053 error (_("invalid input (%d is less than zero)"), frameno
);
2055 sprintf (target_buf
, "QTFrame:%x", frameno
);
2056 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2059 error (_("Trace can only be run on remote targets."));
2064 trace_find_end_command (char *args
, int from_tty
)
2066 trace_find_command ("-1", from_tty
);
2071 trace_find_none_command (char *args
, int from_tty
)
2073 trace_find_command ("-1", from_tty
);
2078 trace_find_start_command (char *args
, int from_tty
)
2080 trace_find_command ("0", from_tty
);
2083 /* tfind pc command */
2085 trace_find_pc_command (char *args
, int from_tty
)
2090 if (target_is_remote ())
2092 if (args
== 0 || *args
== 0)
2093 pc
= read_pc (); /* default is current pc */
2095 pc
= parse_and_eval_address (args
);
2097 sprintf_vma (tmp
, pc
);
2098 sprintf (target_buf
, "QTFrame:pc:%s", tmp
);
2099 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2102 error (_("Trace can only be run on remote targets."));
2105 /* tfind tracepoint command */
2107 trace_find_tracepoint_command (char *args
, int from_tty
)
2111 if (target_is_remote ())
2113 if (args
== 0 || *args
== 0)
2115 if (tracepoint_number
== -1)
2116 error (_("No current tracepoint -- please supply an argument."));
2118 tdp
= tracepoint_number
; /* default is current TDP */
2121 tdp
= parse_and_eval_long (args
);
2123 sprintf (target_buf
, "QTFrame:tdp:%x", tdp
);
2124 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2127 error (_("Trace can only be run on remote targets."));
2130 /* TFIND LINE command:
2132 This command will take a sourceline for argument, just like BREAK
2133 or TRACE (ie. anything that "decode_line_1" can handle).
2135 With no argument, this command will find the next trace frame
2136 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2139 trace_find_line_command (char *args
, int from_tty
)
2141 static CORE_ADDR start_pc
, end_pc
;
2142 struct symtabs_and_lines sals
;
2143 struct symtab_and_line sal
;
2144 struct cleanup
*old_chain
;
2145 char startpc_str
[40], endpc_str
[40];
2147 if (target_is_remote ())
2149 if (args
== 0 || *args
== 0)
2151 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2153 sals
.sals
= (struct symtab_and_line
*)
2154 xmalloc (sizeof (struct symtab_and_line
));
2159 sals
= decode_line_spec (args
, 1);
2163 old_chain
= make_cleanup (xfree
, sals
.sals
);
2164 if (sal
.symtab
== 0)
2166 printf_filtered ("TFIND: No line number information available");
2169 /* This is useful for "info line *0x7f34". If we can't
2170 tell the user about a source line, at least let them
2171 have the symbolic address. */
2172 printf_filtered (" for address ");
2174 print_address (sal
.pc
, gdb_stdout
);
2175 printf_filtered (";\n -- will attempt to find by PC. \n");
2179 printf_filtered (".\n");
2180 return; /* No line, no PC; what can we do? */
2183 else if (sal
.line
> 0
2184 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2186 if (start_pc
== end_pc
)
2188 printf_filtered ("Line %d of \"%s\"",
2189 sal
.line
, sal
.symtab
->filename
);
2191 printf_filtered (" is at address ");
2192 print_address (start_pc
, gdb_stdout
);
2194 printf_filtered (" but contains no code.\n");
2195 sal
= find_pc_line (start_pc
, 0);
2197 find_line_pc_range (sal
, &start_pc
, &end_pc
) &&
2199 printf_filtered ("Attempting to find line %d instead.\n",
2202 error (_("Cannot find a good line."));
2206 /* Is there any case in which we get here, and have an address
2207 which the user would want to see? If we have debugging
2208 symbols and no line numbers? */
2209 error (_("Line number %d is out of range for \"%s\"."),
2210 sal
.line
, sal
.symtab
->filename
);
2212 sprintf_vma (startpc_str
, start_pc
);
2213 sprintf_vma (endpc_str
, end_pc
- 1);
2214 /* Find within range of stated line. */
2216 sprintf (target_buf
, "QTFrame:range:%s:%s",
2217 startpc_str
, endpc_str
);
2218 /* Find OUTSIDE OF range of CURRENT line. */
2220 sprintf (target_buf
, "QTFrame:outside:%s:%s",
2221 startpc_str
, endpc_str
);
2222 finish_tfind_command (&target_buf
, &target_buf_size
,
2224 do_cleanups (old_chain
);
2227 error (_("Trace can only be run on remote targets."));
2230 /* tfind range command */
2232 trace_find_range_command (char *args
, int from_tty
)
2234 static CORE_ADDR start
, stop
;
2235 char start_str
[40], stop_str
[40];
2238 if (target_is_remote ())
2240 if (args
== 0 || *args
== 0)
2241 { /* XXX FIXME: what should default behavior be? */
2242 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2246 if (0 != (tmp
= strchr (args
, ',')))
2248 *tmp
++ = '\0'; /* terminate start address */
2249 while (isspace ((int) *tmp
))
2251 start
= parse_and_eval_address (args
);
2252 stop
= parse_and_eval_address (tmp
);
2255 { /* no explicit end address? */
2256 start
= parse_and_eval_address (args
);
2257 stop
= start
+ 1; /* ??? */
2260 sprintf_vma (start_str
, start
);
2261 sprintf_vma (stop_str
, stop
);
2262 sprintf (target_buf
, "QTFrame:range:%s:%s", start_str
, stop_str
);
2263 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2266 error (_("Trace can only be run on remote targets."));
2269 /* tfind outside command */
2271 trace_find_outside_command (char *args
, int from_tty
)
2273 CORE_ADDR start
, stop
;
2274 char start_str
[40], stop_str
[40];
2277 if (target_is_remote ())
2279 if (args
== 0 || *args
== 0)
2280 { /* XXX FIXME: what should default behavior be? */
2281 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2285 if (0 != (tmp
= strchr (args
, ',')))
2287 *tmp
++ = '\0'; /* terminate start address */
2288 while (isspace ((int) *tmp
))
2290 start
= parse_and_eval_address (args
);
2291 stop
= parse_and_eval_address (tmp
);
2294 { /* no explicit end address? */
2295 start
= parse_and_eval_address (args
);
2296 stop
= start
+ 1; /* ??? */
2299 sprintf_vma (start_str
, start
);
2300 sprintf_vma (stop_str
, stop
);
2301 sprintf (target_buf
, "QTFrame:outside:%s:%s", start_str
, stop_str
);
2302 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2305 error (_("Trace can only be run on remote targets."));
2308 /* save-tracepoints command */
2310 tracepoint_save_command (char *args
, int from_tty
)
2312 struct tracepoint
*tp
;
2313 struct action_line
*line
;
2315 char *i1
= " ", *i2
= " ";
2316 char *indent
, *actionline
, *pathname
;
2319 if (args
== 0 || *args
== 0)
2320 error (_("Argument required (file name in which to save tracepoints)"));
2322 if (tracepoint_chain
== 0)
2324 warning (_("save-tracepoints: no tracepoints to save."));
2328 pathname
= tilde_expand (args
);
2329 if (!(fp
= fopen (pathname
, "w")))
2330 error (_("Unable to open file '%s' for saving tracepoints (%s)"),
2331 args
, safe_strerror (errno
));
2334 ALL_TRACEPOINTS (tp
)
2336 if (tp
->addr_string
)
2337 fprintf (fp
, "trace %s\n", tp
->addr_string
);
2340 sprintf_vma (tmp
, tp
->address
);
2341 fprintf (fp
, "trace *0x%s\n", tmp
);
2345 fprintf (fp
, " passcount %d\n", tp
->pass_count
);
2349 fprintf (fp
, " actions\n");
2351 for (line
= tp
->actions
; line
; line
= line
->next
)
2353 struct cmd_list_element
*cmd
;
2355 QUIT
; /* allow user to bail out with ^C */
2356 actionline
= line
->action
;
2357 while (isspace ((int) *actionline
))
2360 fprintf (fp
, "%s%s\n", indent
, actionline
);
2361 if (*actionline
!= '#') /* skip for comment lines */
2363 cmd
= lookup_cmd (&actionline
, cmdlist
, "", -1, 1);
2365 error (_("Bad action list item: %s"), actionline
);
2366 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2368 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2376 printf_filtered ("Tracepoints saved to file '%s'.\n", args
);
2380 /* info scope command: list the locals for a scope. */
2382 scope_info (char *args
, int from_tty
)
2384 struct symtabs_and_lines sals
;
2386 struct minimal_symbol
*msym
;
2387 struct block
*block
;
2388 char **canonical
, *symname
, *save_args
= args
;
2389 struct dict_iterator iter
;
2392 if (args
== 0 || *args
== 0)
2393 error (_("requires an argument (function, line or *addr) to define a scope"));
2395 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2396 if (sals
.nelts
== 0)
2397 return; /* presumably decode_line_1 has already warned */
2399 /* Resolve line numbers to PC */
2400 resolve_sal_pc (&sals
.sals
[0]);
2401 block
= block_for_pc (sals
.sals
[0].pc
);
2405 QUIT
; /* allow user to bail out with ^C */
2406 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2408 QUIT
; /* allow user to bail out with ^C */
2410 printf_filtered ("Scope for %s:\n", save_args
);
2413 symname
= DEPRECATED_SYMBOL_NAME (sym
);
2414 if (symname
== NULL
|| *symname
== '\0')
2415 continue; /* probably botched, certainly useless */
2417 printf_filtered ("Symbol %s is ", symname
);
2418 switch (SYMBOL_CLASS (sym
))
2421 case LOC_UNDEF
: /* messed up symbol? */
2422 printf_filtered ("a bogus symbol, class %d.\n",
2423 SYMBOL_CLASS (sym
));
2424 count
--; /* don't count this one */
2427 printf_filtered ("a constant with value %ld (0x%lx)",
2428 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2430 case LOC_CONST_BYTES
:
2431 printf_filtered ("constant bytes: ");
2432 if (SYMBOL_TYPE (sym
))
2433 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2434 fprintf_filtered (gdb_stdout
, " %02x",
2435 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2438 printf_filtered ("in static storage at address ");
2439 printf_filtered ("%s", paddress (SYMBOL_VALUE_ADDRESS (sym
)));
2442 printf_filtered ("a local variable in register $%s",
2443 gdbarch_register_name
2444 (current_gdbarch
, SYMBOL_VALUE (sym
)));
2447 printf_filtered ("an argument at stack/frame offset %ld",
2448 SYMBOL_VALUE (sym
));
2451 printf_filtered ("a local variable at frame offset %ld",
2452 SYMBOL_VALUE (sym
));
2455 printf_filtered ("a reference argument at offset %ld",
2456 SYMBOL_VALUE (sym
));
2459 printf_filtered ("an argument in register $%s",
2460 gdbarch_register_name
2461 (current_gdbarch
, SYMBOL_VALUE (sym
)));
2463 case LOC_REGPARM_ADDR
:
2464 printf_filtered ("the address of an argument, in register $%s",
2465 gdbarch_register_name
2466 (current_gdbarch
, SYMBOL_VALUE (sym
)));
2469 printf_filtered ("a typedef.\n");
2472 printf_filtered ("a label at address ");
2473 printf_filtered ("%s", paddress (SYMBOL_VALUE_ADDRESS (sym
)));
2476 printf_filtered ("a function at address ");
2477 printf_filtered ("%s", paddress (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
))));
2479 case LOC_UNRESOLVED
:
2480 msym
= lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (sym
),
2483 printf_filtered ("Unresolved Static");
2486 printf_filtered ("static storage at address ");
2487 printf_filtered ("%s", paddress (SYMBOL_VALUE_ADDRESS (msym
)));
2490 case LOC_OPTIMIZED_OUT
:
2491 printf_filtered ("optimized out.\n");
2494 case LOC_COMPUTED_ARG
:
2495 SYMBOL_OPS (sym
)->describe_location (sym
, gdb_stdout
);
2498 if (SYMBOL_TYPE (sym
))
2499 printf_filtered (", length %d.\n",
2500 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2502 if (BLOCK_FUNCTION (block
))
2505 block
= BLOCK_SUPERBLOCK (block
);
2508 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2512 /* worker function (cleanup) */
2514 replace_comma (void *data
)
2522 trace_dump_command (char *args
, int from_tty
)
2524 struct regcache
*regcache
;
2525 struct gdbarch
*gdbarch
;
2526 struct tracepoint
*t
;
2527 struct action_line
*action
;
2528 char *action_exp
, *next_comma
;
2529 struct cleanup
*old_cleanups
;
2530 int stepping_actions
= 0;
2531 int stepping_frame
= 0;
2533 if (!target_is_remote ())
2535 error (_("Trace can only be run on remote targets."));
2539 if (tracepoint_number
== -1)
2541 warning (_("No current trace frame."));
2546 if (t
->number
== tracepoint_number
)
2550 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2553 old_cleanups
= make_cleanup (null_cleanup
, NULL
);
2555 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2556 tracepoint_number
, traceframe_number
);
2558 /* The current frame is a trap frame if the frame PC is equal
2559 to the tracepoint PC. If not, then the current frame was
2560 collected during single-stepping. */
2562 regcache
= get_current_regcache ();
2563 gdbarch
= get_regcache_arch (regcache
);
2565 stepping_frame
= (t
->address
!= (regcache_read_pc (regcache
)
2566 - gdbarch_decr_pc_after_break (gdbarch
)));
2568 for (action
= t
->actions
; action
; action
= action
->next
)
2570 struct cmd_list_element
*cmd
;
2572 QUIT
; /* allow user to bail out with ^C */
2573 action_exp
= action
->action
;
2574 while (isspace ((int) *action_exp
))
2577 /* The collection actions to be done while stepping are
2578 bracketed by the commands "while-stepping" and "end". */
2580 if (*action_exp
== '#') /* comment line */
2583 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2585 error (_("Bad action list item: %s"), action_exp
);
2587 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2588 stepping_actions
= 1;
2589 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2590 stepping_actions
= 0;
2591 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2593 /* Display the collected data.
2594 For the trap frame, display only what was collected at
2595 the trap. Likewise for stepping frames, display only
2596 what was collected while stepping. This means that the
2597 two boolean variables, STEPPING_FRAME and
2598 STEPPING_ACTIONS should be equal. */
2599 if (stepping_frame
== stepping_actions
)
2602 { /* repeat over a comma-separated list */
2603 QUIT
; /* allow user to bail out with ^C */
2604 if (*action_exp
== ',')
2606 while (isspace ((int) *action_exp
))
2609 next_comma
= strchr (action_exp
, ',');
2611 if (0 == strncasecmp (action_exp
, "$reg", 4))
2612 registers_info (NULL
, from_tty
);
2613 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2614 locals_info (NULL
, from_tty
);
2615 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2616 args_info (NULL
, from_tty
);
2621 make_cleanup (replace_comma
, next_comma
);
2624 printf_filtered ("%s = ", action_exp
);
2625 output_command (action_exp
, from_tty
);
2626 printf_filtered ("\n");
2630 action_exp
= next_comma
;
2632 while (action_exp
&& *action_exp
== ',');
2636 discard_cleanups (old_cleanups
);
2639 /* Convert the memory pointed to by mem into hex, placing result in buf.
2640 * Return a pointer to the last char put in buf (null)
2641 * "stolen" from sparc-stub.c
2644 static const char hexchars
[] = "0123456789abcdef";
2647 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2655 *buf
++ = hexchars
[ch
>> 4];
2656 *buf
++ = hexchars
[ch
& 0xf];
2665 get_traceframe_number (void)
2667 return traceframe_number
;
2671 /* module initialization */
2673 _initialize_tracepoint (void)
2675 struct cmd_list_element
*c
;
2677 tracepoint_chain
= 0;
2678 tracepoint_count
= 0;
2679 traceframe_number
= -1;
2680 tracepoint_number
= -1;
2682 if (tracepoint_list
.list
== NULL
)
2684 tracepoint_list
.listsize
= 128;
2685 tracepoint_list
.list
= xmalloc
2686 (tracepoint_list
.listsize
* sizeof (struct memrange
));
2688 if (tracepoint_list
.aexpr_list
== NULL
)
2690 tracepoint_list
.aexpr_listsize
= 128;
2691 tracepoint_list
.aexpr_list
= xmalloc
2692 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
2695 if (stepping_list
.list
== NULL
)
2697 stepping_list
.listsize
= 128;
2698 stepping_list
.list
= xmalloc
2699 (stepping_list
.listsize
* sizeof (struct memrange
));
2702 if (stepping_list
.aexpr_list
== NULL
)
2704 stepping_list
.aexpr_listsize
= 128;
2705 stepping_list
.aexpr_list
= xmalloc
2706 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
2709 add_info ("scope", scope_info
,
2710 _("List the variables local to a scope"));
2712 add_cmd ("tracepoints", class_trace
, NULL
,
2713 _("Tracing of program execution without stopping the program."),
2716 add_info ("tracepoints", tracepoints_info
, _("\
2717 Status of tracepoints, or tracepoint number NUMBER.\n\
2718 Convenience variable \"$tpnum\" contains the number of the\n\
2719 last tracepoint set."));
2721 add_info_alias ("tp", "tracepoints", 1);
2723 c
= add_com ("save-tracepoints", class_trace
, tracepoint_save_command
, _("\
2724 Save current tracepoint definitions as a script.\n\
2725 Use the 'source' command in another debug session to restore them."));
2726 set_cmd_completer (c
, filename_completer
);
2728 add_com ("tdump", class_trace
, trace_dump_command
,
2729 _("Print everything collected at the current tracepoint."));
2731 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
2732 Select a trace frame;\n\
2733 No argument means forward by one frame; '-' means backward by one frame."),
2734 &tfindlist
, "tfind ", 1, &cmdlist
);
2736 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
2737 Select a trace frame whose PC is outside the given range.\n\
2738 Usage: tfind outside addr1, addr2"),
2741 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
2742 Select a trace frame whose PC is in the given range.\n\
2743 Usage: tfind range addr1,addr2"),
2746 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
2747 Select a trace frame by source line.\n\
2748 Argument can be a line number (with optional source file), \n\
2749 a function name, or '*' followed by an address.\n\
2750 Default argument is 'the next source line that was traced'."),
2753 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
2754 Select a trace frame by tracepoint number.\n\
2755 Default is the tracepoint for the current trace frame."),
2758 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
2759 Select a trace frame by PC.\n\
2760 Default is the current PC, or the PC of the current trace frame."),
2763 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
2764 Synonym for 'none'.\n\
2765 De-select any trace frame and resume 'live' debugging."),
2768 add_cmd ("none", class_trace
, trace_find_none_command
,
2769 _("De-select any trace frame and resume 'live' debugging."),
2772 add_cmd ("start", class_trace
, trace_find_start_command
,
2773 _("Select the first trace frame in the trace buffer."),
2776 add_com ("tstatus", class_trace
, trace_status_command
,
2777 _("Display the status of the current trace data collection."));
2779 add_com ("tstop", class_trace
, trace_stop_command
,
2780 _("Stop trace data collection."));
2782 add_com ("tstart", class_trace
, trace_start_command
,
2783 _("Start trace data collection."));
2785 add_com ("passcount", class_trace
, trace_pass_command
, _("\
2786 Set the passcount for a tracepoint.\n\
2787 The trace will end when the tracepoint has been passed 'count' times.\n\
2788 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
2789 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
2791 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
2792 Ends a list of commands or actions.\n\
2793 Several GDB commands allow you to enter a list of commands or actions.\n\
2794 Entering \"end\" on a line by itself is the normal way to terminate\n\
2796 Note: the \"end\" command cannot be used at the gdb prompt."));
2798 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
2799 Specify single-stepping behavior at a tracepoint.\n\
2800 Argument is number of instructions to trace in single-step mode\n\
2801 following the tracepoint. This command is normally followed by\n\
2802 one or more \"collect\" commands, to specify what to collect\n\
2803 while single-stepping.\n\n\
2804 Note: this command can only be used in a tracepoint \"actions\" list."));
2806 add_com_alias ("ws", "while-stepping", class_alias
, 0);
2807 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
2809 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
2810 Specify one or more data items to be collected at a tracepoint.\n\
2811 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
2812 collect all data (variables, registers) referenced by that expression.\n\
2813 Also accepts the following special arguments:\n\
2814 $regs -- all registers.\n\
2815 $args -- all function arguments.\n\
2816 $locals -- all variables local to the block/function scope.\n\
2817 Note: this command can only be used in a tracepoint \"actions\" list."));
2819 add_com ("actions", class_trace
, trace_actions_command
, _("\
2820 Specify the actions to be taken at a tracepoint.\n\
2821 Tracepoint actions may include collecting of specified data, \n\
2822 single-stepping, or enabling/disabling other tracepoints, \n\
2823 depending on target's capabilities."));
2825 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
2826 Delete specified tracepoints.\n\
2827 Arguments are tracepoint numbers, separated by spaces.\n\
2828 No argument means delete all tracepoints."),
2831 add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
2832 Disable specified tracepoints.\n\
2833 Arguments are tracepoint numbers, separated by spaces.\n\
2834 No argument means disable all tracepoints."),
2837 add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
2838 Enable specified tracepoints.\n\
2839 Arguments are tracepoint numbers, separated by spaces.\n\
2840 No argument means enable all tracepoints."),
2843 c
= add_com ("trace", class_trace
, trace_command
, _("\
2844 Set a tracepoint at a specified line or function or address.\n\
2845 Argument may be a line number, function name, or '*' plus an address.\n\
2846 For a line number or function, trace at the start of its code.\n\
2847 If an address is specified, trace at that exact address.\n\n\
2848 Do \"help tracepoints\" for info on other tracepoint commands."));
2849 set_cmd_completer (c
, location_completer
);
2851 add_com_alias ("tp", "trace", class_alias
, 0);
2852 add_com_alias ("tr", "trace", class_alias
, 1);
2853 add_com_alias ("tra", "trace", class_alias
, 1);
2854 add_com_alias ("trac", "trace", class_alias
, 1);
2856 target_buf_size
= 2048;
2857 target_buf
= xmalloc (target_buf_size
);