1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
27 #include "expression.h"
32 #include "gdb_string.h"
34 #include "tracepoint.h"
38 #include "completer.h"
39 #include "gdb-events.h"
41 #include "dictionary.h"
46 /* readline include files */
47 #include "readline/readline.h"
48 #include "readline/history.h"
50 /* readline defines this. */
57 /* maximum length of an agent aexpression.
58 this accounts for the fact that packets are limited to 400 bytes
59 (which includes everything -- including the checksum), and assumes
60 the worst case of maximum length for each of the pieces of a
63 NOTE: expressions get mem2hex'ed otherwise this would be twice as
64 large. (400 - 31)/2 == 184 */
65 #define MAX_AGENT_EXPR_LEN 184
68 extern void (*deprecated_readline_begin_hook
) (char *, ...);
69 extern char *(*deprecated_readline_hook
) (char *);
70 extern void (*deprecated_readline_end_hook
) (void);
71 extern void x_command (char *, int);
72 extern int addressprint
; /* Print machine addresses? */
74 /* GDB commands implemented in other modules:
77 extern void output_command (char *, int);
82 This module defines the following debugger commands:
83 trace : set a tracepoint on a function, line, or address.
84 info trace : list all debugger-defined tracepoints.
85 delete trace : delete one or more tracepoints.
86 enable trace : enable one or more tracepoints.
87 disable trace : disable one or more tracepoints.
88 actions : specify actions to be taken at a tracepoint.
89 passcount : specify a pass count for a tracepoint.
90 tstart : start a trace experiment.
91 tstop : stop a trace experiment.
92 tstatus : query the status of a trace experiment.
93 tfind : find a trace frame in the trace buffer.
94 tdump : print everything collected at the current tracepoint.
95 save-tracepoints : write tracepoint setup into a file.
97 This module defines the following user-visible debugger variables:
98 $trace_frame : sequence number of trace frame currently being debugged.
99 $trace_line : source line of trace frame currently being debugged.
100 $trace_file : source file of trace frame currently being debugged.
101 $tracepoint : tracepoint number of trace frame currently being debugged.
105 /* ======= Important global variables: ======= */
107 /* Chain of all tracepoints defined. */
108 struct tracepoint
*tracepoint_chain
;
110 /* Number of last tracepoint made. */
111 static int tracepoint_count
;
113 /* Number of last traceframe collected. */
114 static int traceframe_number
;
116 /* Tracepoint for last traceframe collected. */
117 static int tracepoint_number
;
119 /* Symbol for function for last traceframe collected */
120 static struct symbol
*traceframe_fun
;
122 /* Symtab and line for last traceframe collected */
123 static struct symtab_and_line traceframe_sal
;
125 /* Tracing command lists */
126 static struct cmd_list_element
*tfindlist
;
128 /* ======= Important command functions: ======= */
129 static void trace_command (char *, int);
130 static void tracepoints_info (char *, int);
131 static void delete_trace_command (char *, int);
132 static void enable_trace_command (char *, int);
133 static void disable_trace_command (char *, int);
134 static void trace_pass_command (char *, int);
135 static void trace_actions_command (char *, int);
136 static void trace_start_command (char *, int);
137 static void trace_stop_command (char *, int);
138 static void trace_status_command (char *, int);
139 static void trace_find_command (char *, int);
140 static void trace_find_pc_command (char *, int);
141 static void trace_find_tracepoint_command (char *, int);
142 static void trace_find_line_command (char *, int);
143 static void trace_find_range_command (char *, int);
144 static void trace_find_outside_command (char *, int);
145 static void tracepoint_save_command (char *, int);
146 static void trace_dump_command (char *, int);
148 /* support routines */
149 static void trace_mention (struct tracepoint
*);
151 struct collection_list
;
152 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
153 static unsigned char *mem2hex (unsigned char *, unsigned char *, int);
154 static void add_register (struct collection_list
*collection
,
156 static struct cleanup
*make_cleanup_free_actions (struct tracepoint
*t
);
157 static void free_actions_list (char **actions_list
);
158 static void free_actions_list_cleanup_wrapper (void *);
160 extern void _initialize_tracepoint (void);
162 /* Utility: returns true if "target remote" */
164 target_is_remote (void)
166 if (current_target
.to_shortname
&&
167 strcmp (current_target
.to_shortname
, "remote") == 0)
173 /* Utility: generate error from an incoming stub packet. */
175 trace_error (char *buf
)
178 return; /* not an error msg */
181 case '1': /* malformed packet error */
182 if (*++buf
== '0') /* general case: */
183 error ("tracepoint.c: error in outgoing packet.");
185 error ("tracepoint.c: error in outgoing packet at field #%ld.",
186 strtol (buf
, NULL
, 16));
188 error ("trace API error 0x%s.", ++buf
);
190 error ("Target returns error code '%s'.", buf
);
194 /* Utility: wait for reply from stub, while accepting "O" packets */
196 remote_get_noisy_reply (char *buf
,
199 do /* loop on reply from remote stub */
201 QUIT
; /* allow user to bail out with ^C */
202 getpkt (buf
, 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
, (LONGEST
) num
));
243 /* Set externally visible debug variables for querying/printing
244 the traceframe context (line, function, file) */
247 set_traceframe_context (CORE_ADDR trace_pc
)
249 static struct type
*func_string
, *file_string
;
250 static struct type
*func_range
, *file_range
;
251 struct value
*func_val
;
252 struct value
*file_val
;
253 static struct type
*charstar
;
256 if (charstar
== (struct type
*) NULL
)
257 charstar
= lookup_pointer_type (builtin_type_char
);
259 if (trace_pc
== -1) /* cease debugging any trace buffers */
262 traceframe_sal
.pc
= traceframe_sal
.line
= 0;
263 traceframe_sal
.symtab
= NULL
;
264 set_internalvar (lookup_internalvar ("trace_func"),
265 value_from_pointer (charstar
, (LONGEST
) 0));
266 set_internalvar (lookup_internalvar ("trace_file"),
267 value_from_pointer (charstar
, (LONGEST
) 0));
268 set_internalvar (lookup_internalvar ("trace_line"),
269 value_from_longest (builtin_type_int
, (LONGEST
) - 1));
273 /* save as globals for internal use */
274 traceframe_sal
= find_pc_line (trace_pc
, 0);
275 traceframe_fun
= find_pc_function (trace_pc
);
277 /* save linenumber as "$trace_line", a debugger variable visible to users */
278 set_internalvar (lookup_internalvar ("trace_line"),
279 value_from_longest (builtin_type_int
,
280 (LONGEST
) traceframe_sal
.line
));
282 /* save func name as "$trace_func", a debugger variable visible to users */
283 if (traceframe_fun
== NULL
||
284 DEPRECATED_SYMBOL_NAME (traceframe_fun
) == NULL
)
285 set_internalvar (lookup_internalvar ("trace_func"),
286 value_from_pointer (charstar
, (LONGEST
) 0));
289 len
= strlen (DEPRECATED_SYMBOL_NAME (traceframe_fun
));
290 func_range
= create_range_type (func_range
,
291 builtin_type_int
, 0, len
- 1);
292 func_string
= create_array_type (func_string
,
293 builtin_type_char
, func_range
);
294 func_val
= allocate_value (func_string
);
295 VALUE_TYPE (func_val
) = func_string
;
296 memcpy (VALUE_CONTENTS_RAW (func_val
),
297 DEPRECATED_SYMBOL_NAME (traceframe_fun
),
299 func_val
->modifiable
= 0;
300 set_internalvar (lookup_internalvar ("trace_func"), func_val
);
303 /* save file name as "$trace_file", a debugger variable visible to users */
304 if (traceframe_sal
.symtab
== NULL
||
305 traceframe_sal
.symtab
->filename
== NULL
)
306 set_internalvar (lookup_internalvar ("trace_file"),
307 value_from_pointer (charstar
, (LONGEST
) 0));
310 len
= strlen (traceframe_sal
.symtab
->filename
);
311 file_range
= create_range_type (file_range
,
312 builtin_type_int
, 0, len
- 1);
313 file_string
= create_array_type (file_string
,
314 builtin_type_char
, file_range
);
315 file_val
= allocate_value (file_string
);
316 VALUE_TYPE (file_val
) = file_string
;
317 memcpy (VALUE_CONTENTS_RAW (file_val
),
318 traceframe_sal
.symtab
->filename
,
320 file_val
->modifiable
= 0;
321 set_internalvar (lookup_internalvar ("trace_file"), file_val
);
325 /* Low level routine to set a tracepoint.
326 Returns the tracepoint object so caller can set other things.
327 Does not set the tracepoint number!
328 Does not print anything.
330 ==> This routine should not be called if there is a chance of later
331 error(); otherwise it leaves a bogus tracepoint on the chain. Validate
332 your arguments BEFORE calling this routine! */
334 static struct tracepoint
*
335 set_raw_tracepoint (struct symtab_and_line sal
)
337 struct tracepoint
*t
, *tc
;
338 struct cleanup
*old_chain
;
340 t
= (struct tracepoint
*) xmalloc (sizeof (struct tracepoint
));
341 old_chain
= make_cleanup (xfree
, t
);
342 memset (t
, 0, sizeof (*t
));
344 if (sal
.symtab
== NULL
)
345 t
->source_file
= NULL
;
347 t
->source_file
= savestring (sal
.symtab
->filename
,
348 strlen (sal
.symtab
->filename
));
350 t
->section
= sal
.section
;
351 t
->language
= current_language
->la_language
;
352 t
->input_radix
= input_radix
;
353 t
->line_number
= sal
.line
;
358 t
->addr_string
= NULL
;
360 /* Add this tracepoint to the end of the chain
361 so that a list of tracepoints will come out in order
362 of increasing numbers. */
364 tc
= tracepoint_chain
;
366 tracepoint_chain
= t
;
373 discard_cleanups (old_chain
);
377 /* Set a tracepoint according to ARG (function, linenum or *address) */
379 trace_command (char *arg
, int from_tty
)
381 char **canonical
= (char **) NULL
;
382 struct symtabs_and_lines sals
;
383 struct symtab_and_line sal
;
384 struct tracepoint
*t
;
385 char *addr_start
= 0, *addr_end
= 0;
389 error ("trace command requires an argument");
391 if (from_tty
&& info_verbose
)
392 printf_filtered ("TRACE %s\n", arg
);
395 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
, 0, &canonical
, NULL
);
398 return; /* ??? Presumably decode_line_1 has already warned? */
400 /* Resolve all line numbers to PC's */
401 for (i
= 0; i
< sals
.nelts
; i
++)
402 resolve_sal_pc (&sals
.sals
[i
]);
404 /* Now set all the tracepoints. */
405 for (i
= 0; i
< sals
.nelts
; i
++)
409 t
= set_raw_tracepoint (sal
);
410 set_tracepoint_count (tracepoint_count
+ 1);
411 t
->number
= tracepoint_count
;
413 /* If a canonical line spec is needed use that instead of the
415 if (canonical
!= (char **) NULL
&& canonical
[i
] != NULL
)
416 t
->addr_string
= canonical
[i
];
418 t
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
425 printf_filtered ("Multiple tracepoints were set.\n");
426 printf_filtered ("Use 'delete trace' to delete unwanted tracepoints.\n");
430 /* Tell the user we have just set a tracepoint TP. */
433 trace_mention (struct tracepoint
*tp
)
435 printf_filtered ("Tracepoint %d", tp
->number
);
437 if (addressprint
|| (tp
->source_file
== NULL
))
439 printf_filtered (" at ");
440 print_address_numeric (tp
->address
, 1, gdb_stdout
);
443 printf_filtered (": file %s, line %d.",
444 tp
->source_file
, tp
->line_number
);
446 printf_filtered ("\n");
449 /* Print information on tracepoint number TPNUM_EXP, or all if omitted. */
452 tracepoints_info (char *tpnum_exp
, int from_tty
)
454 struct tracepoint
*t
;
455 struct action_line
*action
;
456 int found_a_tracepoint
= 0;
457 char wrap_indent
[80];
462 tpnum
= parse_and_eval_long (tpnum_exp
);
465 if (tpnum
== -1 || tpnum
== t
->number
)
467 extern int addressprint
; /* print machine addresses? */
469 if (!found_a_tracepoint
++)
471 printf_filtered ("Num Enb ");
474 if (TARGET_ADDR_BIT
<= 32)
475 printf_filtered ("Address ");
477 printf_filtered ("Address ");
479 printf_filtered ("PassC StepC What\n");
481 strcpy (wrap_indent
, " ");
484 if (TARGET_ADDR_BIT
<= 32)
485 strcat (wrap_indent
, " ");
487 strcat (wrap_indent
, " ");
490 printf_filtered ("%-3d %-3s ", t
->number
,
491 t
->enabled_p
? "y" : "n");
496 if (TARGET_ADDR_BIT
<= 32)
497 tmp
= hex_string_custom (t
->address
& (CORE_ADDR
) 0xffffffff,
500 tmp
= hex_string_custom (t
->address
, 16);
502 printf_filtered ("%s ", tmp
);
504 printf_filtered ("%-5d %-5ld ", t
->pass_count
, t
->step_count
);
508 sym
= find_pc_sect_function (t
->address
, t
->section
);
511 fputs_filtered ("in ", gdb_stdout
);
512 fputs_filtered (SYMBOL_PRINT_NAME (sym
), gdb_stdout
);
513 wrap_here (wrap_indent
);
514 fputs_filtered (" at ", gdb_stdout
);
516 fputs_filtered (t
->source_file
, gdb_stdout
);
517 printf_filtered (":%d", t
->line_number
);
520 print_address_symbolic (t
->address
, gdb_stdout
, demangle
, " ");
522 printf_filtered ("\n");
525 printf_filtered (" Actions for tracepoint %d: \n", t
->number
);
526 for (action
= t
->actions
; action
; action
= action
->next
)
528 printf_filtered ("\t%s\n", action
->action
);
532 if (!found_a_tracepoint
)
535 printf_filtered ("No tracepoints.\n");
537 printf_filtered ("No tracepoint number %d.\n", tpnum
);
541 /* Optimization: the code to parse an enable, disable, or delete TP command
542 is virtually identical except for whether it performs an enable, disable,
543 or delete. Therefore I've combined them into one function with an opcode.
545 enum tracepoint_opcode
552 /* This function implements enable, disable and delete commands. */
554 tracepoint_operation (struct tracepoint
*t
, int from_tty
,
555 enum tracepoint_opcode opcode
)
557 struct tracepoint
*t2
;
559 if (t
== NULL
) /* no tracepoint operand */
566 tracepoint_modify_event (t
->number
);
570 tracepoint_modify_event (t
->number
);
573 if (tracepoint_chain
== t
)
574 tracepoint_chain
= t
->next
;
579 tracepoint_delete_event (t2
->number
);
585 xfree (t
->addr_string
);
587 xfree (t
->source_file
);
596 /* Utility: parse a tracepoint number and look it up in the list.
597 If MULTI_P is true, there might be a range of tracepoints in ARG.
598 if OPTIONAL_P is true, then if the argument is missing, the most
599 recent tracepoint (tracepoint_count) is returned. */
601 get_tracepoint_by_number (char **arg
, int multi_p
, int optional_p
)
603 struct tracepoint
*t
;
605 char *instring
= arg
== NULL
? NULL
: *arg
;
607 if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
610 tpnum
= tracepoint_count
;
612 error_no_arg ("tracepoint number");
615 tpnum
= multi_p
? get_number_or_range (arg
) : get_number (arg
);
619 if (instring
&& *instring
)
620 printf_filtered ("bad tracepoint number at or near '%s'\n", instring
);
622 printf_filtered ("Tracepoint argument missing and no previous tracepoint\n");
627 if (t
->number
== tpnum
)
632 /* FIXME: if we are in the middle of a range we don't want to give
633 a message. The current interface to get_number_or_range doesn't
634 allow us to discover this. */
635 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
639 /* Utility: parse a list of tracepoint numbers, and call a func for each. */
641 map_args_over_tracepoints (char *args
, int from_tty
,
642 enum tracepoint_opcode opcode
)
644 struct tracepoint
*t
, *tmp
;
646 if (args
== 0 || *args
== 0) /* do them all */
647 ALL_TRACEPOINTS_SAFE (t
, tmp
)
648 tracepoint_operation (t
, from_tty
, opcode
);
652 QUIT
; /* give user option to bail out with ^C */
653 t
= get_tracepoint_by_number (&args
, 1, 0);
654 tracepoint_operation (t
, from_tty
, opcode
);
655 while (*args
== ' ' || *args
== '\t')
660 /* The 'enable trace' command enables tracepoints. Not supported by all targets. */
662 enable_trace_command (char *args
, int from_tty
)
665 map_args_over_tracepoints (args
, from_tty
, enable_op
);
668 /* The 'disable trace' command enables tracepoints. Not supported by all targets. */
670 disable_trace_command (char *args
, int from_tty
)
673 map_args_over_tracepoints (args
, from_tty
, disable_op
);
676 /* Remove a tracepoint (or all if no argument) */
678 delete_trace_command (char *args
, int from_tty
)
681 if (!args
|| !*args
) /* No args implies all tracepoints; */
682 if (from_tty
) /* confirm only if from_tty... */
683 if (tracepoint_chain
) /* and if there are tracepoints to delete! */
684 if (!query ("Delete all tracepoints? "))
687 map_args_over_tracepoints (args
, from_tty
, delete_op
);
690 /* Set passcount for tracepoint.
692 First command argument is passcount, second is tracepoint number.
693 If tracepoint number omitted, apply to most recently defined.
694 Also accepts special argument "all". */
697 trace_pass_command (char *args
, int from_tty
)
699 struct tracepoint
*t1
= (struct tracepoint
*) -1, *t2
;
703 if (args
== 0 || *args
== 0)
704 error ("passcount command requires an argument (count + optional TP num)");
706 count
= strtoul (args
, &args
, 10); /* count comes first, then TP num */
708 while (*args
&& isspace ((int) *args
))
711 if (*args
&& strncasecmp (args
, "all", 3) == 0)
713 args
+= 3; /* skip special argument "all" */
716 error ("Junk at end of arguments.");
719 t1
= get_tracepoint_by_number (&args
, 1, 1);
726 if (t1
== (struct tracepoint
*) -1 || t1
== t2
)
728 t2
->pass_count
= count
;
729 tracepoint_modify_event (t2
->number
);
731 printf_filtered ("Setting tracepoint %d's passcount to %d\n",
735 t1
= get_tracepoint_by_number (&args
, 1, 0);
741 /* ACTIONS functions: */
743 /* Prototypes for action-parsing utility commands */
744 static void read_actions (struct tracepoint
*);
746 /* The three functions:
747 collect_pseudocommand,
748 while_stepping_pseudocommand, and
749 end_actions_pseudocommand
750 are placeholders for "commands" that are actually ONLY to be used
751 within a tracepoint action list. If the actual function is ever called,
752 it means that somebody issued the "command" at the top level,
753 which is always an error. */
756 end_actions_pseudocommand (char *args
, int from_tty
)
758 error ("This command cannot be used at the top level.");
762 while_stepping_pseudocommand (char *args
, int from_tty
)
764 error ("This command can only be used in a tracepoint actions list.");
768 collect_pseudocommand (char *args
, int from_tty
)
770 error ("This command can only be used in a tracepoint actions list.");
773 /* Enter a list of actions for a tracepoint. */
775 trace_actions_command (char *args
, int from_tty
)
777 struct tracepoint
*t
;
779 char *end_msg
= "End with a line saying just \"end\".";
781 t
= get_tracepoint_by_number (&args
, 0, 1);
784 sprintf (tmpbuf
, "Enter actions for tracepoint %d, one per line.",
789 if (deprecated_readline_begin_hook
)
790 (*deprecated_readline_begin_hook
) ("%s %s\n", tmpbuf
, end_msg
);
791 else if (input_from_terminal_p ())
792 printf_filtered ("%s\n%s\n", tmpbuf
, end_msg
);
796 t
->step_count
= 0; /* read_actions may set this */
799 if (deprecated_readline_end_hook
)
800 (*deprecated_readline_end_hook
) ();
801 /* tracepoints_changed () */
803 /* else just return */
806 /* worker function */
808 read_actions (struct tracepoint
*t
)
811 char *prompt1
= "> ", *prompt2
= " > ";
812 char *prompt
= prompt1
;
813 enum actionline_type linetype
;
814 extern FILE *instream
;
815 struct action_line
*next
= NULL
, *temp
;
816 struct cleanup
*old_chain
;
818 /* Control-C quits instantly if typed while in this loop
819 since it should not wait until the user types a newline. */
821 /* FIXME: kettenis/20010823: Something is wrong here. In this file
822 STOP_SIGNAL is never defined. So this code has been left out, at
823 least for quite a while now. Replacing STOP_SIGNAL with SIGTSTP
824 leads to compilation failures since the variable job_control
825 isn't declared. Leave this alone for now. */
830 signal (STOP_SIGNAL
, handle_stop_sig
);
832 signal (STOP_SIGNAL
, stop_sig
);
835 old_chain
= make_cleanup_free_actions (t
);
838 /* Make sure that all output has been output. Some machines may let
839 you get away with leaving out some of the gdb_flush, but not all. */
841 gdb_flush (gdb_stdout
);
842 gdb_flush (gdb_stderr
);
844 if (deprecated_readline_hook
&& instream
== NULL
)
845 line
= (*deprecated_readline_hook
) (prompt
);
846 else if (instream
== stdin
&& ISATTY (instream
))
848 line
= gdb_readline_wrapper (prompt
);
849 if (line
&& *line
) /* add it to command history */
853 line
= gdb_readline (0);
855 linetype
= validate_actionline (&line
, t
);
856 if (linetype
== BADLINE
)
857 continue; /* already warned -- collect another line */
859 temp
= xmalloc (sizeof (struct action_line
));
863 if (next
== NULL
) /* first action for this tracepoint? */
864 t
->actions
= next
= temp
;
871 if (linetype
== STEPPING
) /* begin "while-stepping" */
873 if (prompt
== prompt2
)
875 warning ("Already processing 'while-stepping'");
879 prompt
= prompt2
; /* change prompt for stepping actions */
881 else if (linetype
== END
)
883 if (prompt
== prompt2
)
885 prompt
= prompt1
; /* end of single-stepping actions */
888 { /* end of actions */
889 if (t
->actions
->next
== NULL
)
891 /* an "end" all by itself with no other actions means
892 this tracepoint has no actions. Discard empty list. */
901 signal (STOP_SIGNAL
, SIG_DFL
);
904 discard_cleanups (old_chain
);
907 /* worker function */
909 validate_actionline (char **line
, struct tracepoint
*t
)
911 struct cmd_list_element
*c
;
912 struct expression
*exp
= NULL
;
913 struct cleanup
*old_chain
= NULL
;
916 /* if EOF is typed, *line is NULL */
920 for (p
= *line
; isspace ((int) *p
);)
923 /* symbol lookup etc. */
924 if (*p
== '\0') /* empty line: just prompt for another line. */
927 if (*p
== '#') /* comment line */
930 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
933 warning ("'%s' is not an action that I know, or is ambiguous.", p
);
937 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
939 struct agent_expr
*aexpr
;
940 struct agent_reqs areqs
;
943 { /* repeat over a comma-separated list */
944 QUIT
; /* allow user to bail out with ^C */
945 while (isspace ((int) *p
))
948 if (*p
== '$') /* look for special pseudo-symbols */
950 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
951 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
952 (0 == strncasecmp ("loc", p
+ 1, 3)))
957 /* else fall thru, treat p as an expression and parse it! */
959 exp
= parse_exp_1 (&p
, block_for_pc (t
->address
), 1);
960 old_chain
= make_cleanup (free_current_contents
, &exp
);
962 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
964 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
966 warning ("constant %s (value %ld) will not be collected.",
967 DEPRECATED_SYMBOL_NAME (exp
->elts
[2].symbol
),
968 SYMBOL_VALUE (exp
->elts
[2].symbol
));
971 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
973 warning ("%s is optimized away and cannot be collected.",
974 DEPRECATED_SYMBOL_NAME (exp
->elts
[2].symbol
));
979 /* we have something to collect, make sure that the expr to
980 bytecode translator can handle it and that it's not too long */
981 aexpr
= gen_trace_for_expr (t
->address
, exp
);
982 make_cleanup_free_agent_expr (aexpr
);
984 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
985 error ("expression too complicated, try simplifying");
987 ax_reqs (aexpr
, &areqs
);
988 (void) make_cleanup (xfree
, areqs
.reg_mask
);
990 if (areqs
.flaw
!= agent_flaw_none
)
991 error ("malformed expression");
993 if (areqs
.min_height
< 0)
994 error ("gdb: Internal error: expression has min height < 0");
996 if (areqs
.max_height
> 20)
997 error ("expression too complicated, try simplifying");
999 do_cleanups (old_chain
);
1001 while (p
&& *p
++ == ',');
1004 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
1006 char *steparg
; /* in case warning is necessary */
1008 while (isspace ((int) *p
))
1013 (t
->step_count
= strtol (p
, &p
, 0)) == 0)
1015 warning ("'%s': bad step-count; command ignored.", *line
);
1020 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
1024 warning ("'%s' is not a supported tracepoint action.", *line
);
1029 /* worker function */
1031 free_actions (struct tracepoint
*t
)
1033 struct action_line
*line
, *next
;
1035 for (line
= t
->actions
; line
; line
= next
)
1039 xfree (line
->action
);
1046 do_free_actions_cleanup (void *t
)
1051 static struct cleanup
*
1052 make_cleanup_free_actions (struct tracepoint
*t
)
1054 return make_cleanup (do_free_actions_cleanup
, t
);
1059 int type
; /* 0 for absolute memory range, else basereg number */
1060 bfd_signed_vma start
;
1064 struct collection_list
1066 unsigned char regs_mask
[8]; /* room for up to 256 regs */
1069 struct memrange
*list
;
1070 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
1071 long next_aexpr_elt
;
1072 struct agent_expr
**aexpr_list
;
1075 tracepoint_list
, stepping_list
;
1077 /* MEMRANGE functions: */
1079 static int memrange_cmp (const void *, const void *);
1081 /* compare memranges for qsort */
1083 memrange_cmp (const void *va
, const void *vb
)
1085 const struct memrange
*a
= va
, *b
= vb
;
1087 if (a
->type
< b
->type
)
1089 if (a
->type
> b
->type
)
1093 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
1095 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
1100 if (a
->start
< b
->start
)
1102 if (a
->start
> b
->start
)
1108 /* Sort the memrange list using qsort, and merge adjacent memranges */
1110 memrange_sortmerge (struct collection_list
*memranges
)
1114 qsort (memranges
->list
, memranges
->next_memrange
,
1115 sizeof (struct memrange
), memrange_cmp
);
1116 if (memranges
->next_memrange
> 0)
1118 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
1120 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
1121 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
1124 /* memrange b starts before memrange a ends; merge them. */
1125 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
1126 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
1127 continue; /* next b, same a */
1131 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
1132 sizeof (struct memrange
));
1134 memranges
->next_memrange
= a
+ 1;
1138 /* Add a register to a collection list */
1140 add_register (struct collection_list
*collection
, unsigned int regno
)
1143 printf_filtered ("collect register %d\n", regno
);
1144 if (regno
> (8 * sizeof (collection
->regs_mask
)))
1145 error ("Internal: register number %d too large for tracepoint",
1147 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
1150 /* Add a memrange to a collection list */
1152 add_memrange (struct collection_list
*memranges
, int type
, bfd_signed_vma base
,
1157 printf_filtered ("(%d,", type
);
1159 printf_filtered (",%ld)\n", len
);
1162 /* type: 0 == memory, n == basereg */
1163 memranges
->list
[memranges
->next_memrange
].type
= type
;
1164 /* base: addr if memory, offset if reg relative. */
1165 memranges
->list
[memranges
->next_memrange
].start
= base
;
1166 /* len: we actually save end (base + len) for convenience */
1167 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
1168 memranges
->next_memrange
++;
1169 if (memranges
->next_memrange
>= memranges
->listsize
)
1171 memranges
->listsize
*= 2;
1172 memranges
->list
= xrealloc (memranges
->list
,
1173 memranges
->listsize
);
1176 if (type
!= -1) /* better collect the base register! */
1177 add_register (memranges
, type
);
1180 /* Add a symbol to a collection list */
1182 collect_symbol (struct collection_list
*collect
, struct symbol
*sym
,
1183 long frame_regno
, long frame_offset
)
1187 bfd_signed_vma offset
;
1189 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
1190 switch (SYMBOL_CLASS (sym
))
1193 printf_filtered ("%s: don't know symbol class %d\n",
1194 DEPRECATED_SYMBOL_NAME (sym
), SYMBOL_CLASS (sym
));
1197 printf_filtered ("constant %s (value %ld) will not be collected.\n",
1198 DEPRECATED_SYMBOL_NAME (sym
), SYMBOL_VALUE (sym
));
1201 offset
= SYMBOL_VALUE_ADDRESS (sym
);
1206 sprintf_vma (tmp
, offset
);
1207 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1208 DEPRECATED_SYMBOL_NAME (sym
), len
, tmp
/* address */);
1210 add_memrange (collect
, -1, offset
, len
); /* 0 == memory */
1214 reg
= SYMBOL_VALUE (sym
);
1216 printf_filtered ("LOC_REG[parm] %s: ", DEPRECATED_SYMBOL_NAME (sym
));
1217 add_register (collect
, reg
);
1218 /* check for doubles stored in two registers */
1219 /* FIXME: how about larger types stored in 3 or more regs? */
1220 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1221 len
> register_size (current_gdbarch
, reg
))
1222 add_register (collect
, reg
+ 1);
1225 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1226 printf_filtered (" (will not collect %s)\n",
1227 DEPRECATED_SYMBOL_NAME (sym
));
1231 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1234 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1235 DEPRECATED_SYMBOL_NAME (sym
), len
);
1236 printf_vma (offset
);
1237 printf_filtered (" from frame ptr reg %d\n", reg
);
1239 add_memrange (collect
, reg
, offset
, len
);
1241 case LOC_REGPARM_ADDR
:
1242 reg
= SYMBOL_VALUE (sym
);
1246 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1247 DEPRECATED_SYMBOL_NAME (sym
), len
);
1248 printf_vma (offset
);
1249 printf_filtered (" from reg %d\n", reg
);
1251 add_memrange (collect
, reg
, offset
, len
);
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
);
1267 case LOC_BASEREG_ARG
:
1268 reg
= SYMBOL_BASEREG (sym
);
1269 offset
= SYMBOL_VALUE (sym
);
1272 printf_filtered ("LOC_BASEREG %s: collect %ld bytes at offset ",
1273 DEPRECATED_SYMBOL_NAME (sym
), len
);
1274 printf_vma (offset
);
1275 printf_filtered (" from basereg %d\n", reg
);
1277 add_memrange (collect
, reg
, offset
, len
);
1279 case LOC_UNRESOLVED
:
1280 printf_filtered ("Don't know LOC_UNRESOLVED %s\n", DEPRECATED_SYMBOL_NAME (sym
));
1282 case LOC_OPTIMIZED_OUT
:
1283 printf_filtered ("%s has been optimized out of existence.\n",
1284 DEPRECATED_SYMBOL_NAME (sym
));
1289 /* Add all locals (or args) symbols to collection list */
1291 add_local_symbols (struct collection_list
*collect
, CORE_ADDR pc
,
1292 long frame_regno
, long frame_offset
, int type
)
1295 struct block
*block
;
1296 struct dict_iterator iter
;
1299 block
= block_for_pc (pc
);
1302 QUIT
; /* allow user to bail out with ^C */
1303 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
1305 switch (SYMBOL_CLASS (sym
))
1308 warning ("don't know how to trace local symbol %s",
1309 DEPRECATED_SYMBOL_NAME (sym
));
1314 if (type
== 'L') /* collecting Locals */
1317 collect_symbol (collect
, sym
, frame_regno
, frame_offset
);
1324 case LOC_REGPARM_ADDR
:
1325 case LOC_BASEREG_ARG
:
1326 if (type
== 'A') /* collecting Arguments */
1329 collect_symbol (collect
, sym
, frame_regno
, frame_offset
);
1333 if (BLOCK_FUNCTION (block
))
1336 block
= BLOCK_SUPERBLOCK (block
);
1339 warning ("No %s found in scope.", type
== 'L' ? "locals" : "args");
1342 /* worker function */
1344 clear_collection_list (struct collection_list
*list
)
1348 list
->next_memrange
= 0;
1349 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1351 free_agent_expr (list
->aexpr_list
[ndx
]);
1352 list
->aexpr_list
[ndx
] = NULL
;
1354 list
->next_aexpr_elt
= 0;
1355 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1358 /* reduce a collection list to string form (for gdb protocol) */
1360 stringify_collection_list (struct collection_list
*list
, char *string
)
1362 char temp_buf
[2048];
1366 char *(*str_list
)[];
1370 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1371 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1373 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1374 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1376 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1379 printf_filtered ("\nCollecting registers (mask): 0x");
1384 QUIT
; /* allow user to bail out with ^C */
1386 printf_filtered ("%02X", list
->regs_mask
[i
]);
1387 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1390 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1394 printf_filtered ("\n");
1395 if (list
->next_memrange
> 0 && info_verbose
)
1396 printf_filtered ("Collecting memranges: \n");
1397 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1399 QUIT
; /* allow user to bail out with ^C */
1400 sprintf_vma (tmp2
, list
->list
[i
].start
);
1403 printf_filtered ("(%d, %s, %ld)\n",
1406 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1408 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1410 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1416 sprintf (end
, "M%X,%s,%lX",
1419 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1421 count
+= strlen (end
);
1425 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1427 QUIT
; /* allow user to bail out with ^C */
1428 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1430 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1435 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1436 end
+= 10; /* 'X' + 8 hex digits + ',' */
1439 end
= mem2hex (list
->aexpr_list
[i
]->buf
, end
, list
->aexpr_list
[i
]->len
);
1440 count
+= 2 * list
->aexpr_list
[i
]->len
;
1445 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1450 (*str_list
)[ndx
] = NULL
;
1459 free_actions_list_cleanup_wrapper (void *al
)
1461 free_actions_list (al
);
1465 free_actions_list (char **actions_list
)
1469 if (actions_list
== 0)
1472 for (ndx
= 0; actions_list
[ndx
]; ndx
++)
1473 xfree (actions_list
[ndx
]);
1475 xfree (actions_list
);
1478 /* render all actions into gdb protocol */
1480 encode_actions (struct tracepoint
*t
, char ***tdp_actions
,
1481 char ***stepping_actions
)
1483 static char tdp_buff
[2048], step_buff
[2048];
1485 struct expression
*exp
= NULL
;
1486 struct action_line
*action
;
1488 struct value
*tempval
;
1489 struct collection_list
*collect
;
1490 struct cmd_list_element
*cmd
;
1491 struct agent_expr
*aexpr
;
1493 LONGEST frame_offset
;
1496 clear_collection_list (&tracepoint_list
);
1497 clear_collection_list (&stepping_list
);
1498 collect
= &tracepoint_list
;
1500 *tdp_actions
= NULL
;
1501 *stepping_actions
= NULL
;
1503 TARGET_VIRTUAL_FRAME_POINTER (t
->address
, &frame_reg
, &frame_offset
);
1505 for (action
= t
->actions
; action
; action
= action
->next
)
1507 QUIT
; /* allow user to bail out with ^C */
1508 action_exp
= action
->action
;
1509 while (isspace ((int) *action_exp
))
1512 if (*action_exp
== '#') /* comment line */
1515 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1517 error ("Bad action list item: %s", action_exp
);
1519 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1522 { /* repeat over a comma-separated list */
1523 QUIT
; /* allow user to bail out with ^C */
1524 while (isspace ((int) *action_exp
))
1527 if (0 == strncasecmp ("$reg", action_exp
, 4))
1529 for (i
= 0; i
< NUM_REGS
; i
++)
1530 add_register (collect
, i
);
1531 action_exp
= strchr (action_exp
, ','); /* more? */
1533 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1535 add_local_symbols (collect
,
1540 action_exp
= strchr (action_exp
, ','); /* more? */
1542 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1544 add_local_symbols (collect
,
1549 action_exp
= strchr (action_exp
, ','); /* more? */
1553 unsigned long addr
, len
;
1554 struct cleanup
*old_chain
= NULL
;
1555 struct cleanup
*old_chain1
= NULL
;
1556 struct agent_reqs areqs
;
1558 exp
= parse_exp_1 (&action_exp
,
1559 block_for_pc (t
->address
), 1);
1560 old_chain
= make_cleanup (free_current_contents
, &exp
);
1562 switch (exp
->elts
[0].opcode
)
1565 i
= exp
->elts
[1].longconst
;
1567 printf_filtered ("OP_REGISTER: ");
1568 add_register (collect
, i
);
1572 /* safe because we know it's a simple expression */
1573 tempval
= evaluate_expression (exp
);
1574 addr
= VALUE_ADDRESS (tempval
) + VALUE_OFFSET (tempval
);
1575 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1576 add_memrange (collect
, -1, addr
, len
);
1580 collect_symbol (collect
,
1581 exp
->elts
[2].symbol
,
1586 default: /* full-fledged expression */
1587 aexpr
= gen_trace_for_expr (t
->address
, exp
);
1589 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1591 ax_reqs (aexpr
, &areqs
);
1592 if (areqs
.flaw
!= agent_flaw_none
)
1593 error ("malformed expression");
1595 if (areqs
.min_height
< 0)
1596 error ("gdb: Internal error: expression has min height < 0");
1597 if (areqs
.max_height
> 20)
1598 error ("expression too complicated, try simplifying");
1600 discard_cleanups (old_chain1
);
1601 add_aexpr (collect
, aexpr
);
1603 /* take care of the registers */
1604 if (areqs
.reg_mask_len
> 0)
1609 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1611 QUIT
; /* allow user to bail out with ^C */
1612 if (areqs
.reg_mask
[ndx1
] != 0)
1614 /* assume chars have 8 bits */
1615 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1616 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1617 /* it's used -- record it */
1618 add_register (collect
, ndx1
* 8 + ndx2
);
1624 do_cleanups (old_chain
);
1627 while (action_exp
&& *action_exp
++ == ',');
1629 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1631 collect
= &stepping_list
;
1633 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
1635 if (collect
== &stepping_list
) /* end stepping actions */
1636 collect
= &tracepoint_list
;
1638 break; /* end tracepoint actions */
1641 memrange_sortmerge (&tracepoint_list
);
1642 memrange_sortmerge (&stepping_list
);
1644 *tdp_actions
= stringify_collection_list (&tracepoint_list
, tdp_buff
);
1645 *stepping_actions
= stringify_collection_list (&stepping_list
, step_buff
);
1649 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1651 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1653 collect
->aexpr_list
=
1654 xrealloc (collect
->aexpr_list
,
1655 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1656 collect
->aexpr_listsize
*= 2;
1658 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1659 collect
->next_aexpr_elt
++;
1662 static char target_buf
[2048];
1664 /* Set "transparent" memory ranges
1666 Allow trace mechanism to treat text-like sections
1667 (and perhaps all read-only sections) transparently,
1668 i.e. don't reject memory requests from these address ranges
1669 just because they haven't been collected. */
1672 remote_set_transparent_ranges (void)
1674 extern bfd
*exec_bfd
;
1681 return; /* no information to give. */
1683 strcpy (target_buf
, "QTro");
1684 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
1686 char tmp1
[40], tmp2
[40];
1688 if ((s
->flags
& SEC_LOAD
) == 0 ||
1689 /* (s->flags & SEC_CODE) == 0 || */
1690 (s
->flags
& SEC_READONLY
) == 0)
1695 size
= bfd_get_section_size (s
);
1696 sprintf_vma (tmp1
, lma
);
1697 sprintf_vma (tmp2
, lma
+ size
);
1698 sprintf (target_buf
+ strlen (target_buf
),
1699 ":%s,%s", tmp1
, tmp2
);
1703 putpkt (target_buf
);
1704 getpkt (target_buf
, sizeof (target_buf
), 0);
1710 Tell target to clear any previous trace experiment.
1711 Walk the list of tracepoints, and send them (and their actions)
1712 to the target. If no errors,
1713 Tell target to start a new trace experiment. */
1716 trace_start_command (char *args
, int from_tty
)
1717 { /* STUB_COMM MOSTLY_IMPLEMENTED */
1718 struct tracepoint
*t
;
1721 char **stepping_actions
;
1723 struct cleanup
*old_chain
= NULL
;
1725 dont_repeat (); /* like "run", dangerous to repeat accidentally */
1727 if (target_is_remote ())
1730 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1731 if (strcmp (target_buf
, "OK"))
1732 error ("Target does not support this command.");
1738 sprintf_vma (tmp
, t
->address
);
1739 sprintf (buf
, "QTDP:%x:%s:%c:%lx:%x", t
->number
, tmp
, /* address */
1740 t
->enabled_p
? 'E' : 'D',
1741 t
->step_count
, t
->pass_count
);
1746 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1747 if (strcmp (target_buf
, "OK"))
1748 error ("Target does not support tracepoints.");
1752 encode_actions (t
, &tdp_actions
, &stepping_actions
);
1753 old_chain
= make_cleanup (free_actions_list_cleanup_wrapper
,
1755 (void) make_cleanup (free_actions_list_cleanup_wrapper
,
1758 /* do_single_steps (t); */
1761 for (ndx
= 0; tdp_actions
[ndx
]; ndx
++)
1763 QUIT
; /* allow user to bail out with ^C */
1764 sprintf (buf
, "QTDP:-%x:%s:%s%c",
1765 t
->number
, tmp
, /* address */
1767 ((tdp_actions
[ndx
+ 1] || stepping_actions
)
1770 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1771 if (strcmp (target_buf
, "OK"))
1772 error ("Error on target while setting tracepoints.");
1775 if (stepping_actions
)
1777 for (ndx
= 0; stepping_actions
[ndx
]; ndx
++)
1779 QUIT
; /* allow user to bail out with ^C */
1780 sprintf (buf
, "QTDP:-%x:%s:%s%s%s",
1781 t
->number
, tmp
, /* address */
1782 ((ndx
== 0) ? "S" : ""),
1783 stepping_actions
[ndx
],
1784 (stepping_actions
[ndx
+ 1] ? "-" : ""));
1786 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1787 if (strcmp (target_buf
, "OK"))
1788 error ("Error on target while setting tracepoints.");
1792 do_cleanups (old_chain
);
1795 /* Tell target to treat text-like sections as transparent */
1796 remote_set_transparent_ranges ();
1797 /* Now insert traps and begin collecting data */
1799 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1800 if (strcmp (target_buf
, "OK"))
1801 error ("Bogus reply from target: %s", target_buf
);
1802 set_traceframe_num (-1); /* all old traceframes invalidated */
1803 set_tracepoint_num (-1);
1804 set_traceframe_context (-1);
1805 trace_running_p
= 1;
1806 if (deprecated_trace_start_stop_hook
)
1807 deprecated_trace_start_stop_hook (1, from_tty
);
1811 error ("Trace can only be run on remote targets.");
1816 trace_stop_command (char *args
, int from_tty
)
1817 { /* STUB_COMM IS_IMPLEMENTED */
1818 if (target_is_remote ())
1821 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1822 if (strcmp (target_buf
, "OK"))
1823 error ("Bogus reply from target: %s", target_buf
);
1824 trace_running_p
= 0;
1825 if (deprecated_trace_start_stop_hook
)
1826 deprecated_trace_start_stop_hook (0, from_tty
);
1829 error ("Trace can only be run on remote targets.");
1832 unsigned long trace_running_p
;
1834 /* tstatus command */
1836 trace_status_command (char *args
, int from_tty
)
1837 { /* STUB_COMM IS_IMPLEMENTED */
1838 if (target_is_remote ())
1840 putpkt ("qTStatus");
1841 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1843 if (target_buf
[0] != 'T' ||
1844 (target_buf
[1] != '0' && target_buf
[1] != '1'))
1845 error ("Bogus reply from target: %s", target_buf
);
1847 /* exported for use by the GUI */
1848 trace_running_p
= (target_buf
[1] == '1');
1851 error ("Trace can only be run on remote targets.");
1854 /* Worker function for the various flavors of the tfind command */
1856 finish_tfind_command (char *msg
,
1860 int target_frameno
= -1, target_tracept
= -1;
1861 CORE_ADDR old_frame_addr
;
1862 struct symbol
*old_func
;
1865 old_frame_addr
= get_frame_base (get_current_frame ());
1866 old_func
= find_pc_function (read_pc ());
1869 reply
= remote_get_noisy_reply (msg
, sizeof_msg
);
1871 while (reply
&& *reply
)
1875 if ((target_frameno
= (int) strtol (++reply
, &reply
, 16)) == -1)
1877 /* A request for a non-existant trace frame has failed.
1878 Our response will be different, depending on FROM_TTY:
1880 If FROM_TTY is true, meaning that this command was
1881 typed interactively by the user, then give an error
1882 and DO NOT change the state of traceframe_number etc.
1884 However if FROM_TTY is false, meaning that we're either
1885 in a script, a loop, or a user-defined command, then
1886 DON'T give an error, but DO change the state of
1887 traceframe_number etc. to invalid.
1889 The rationalle is that if you typed the command, you
1890 might just have committed a typo or something, and you'd
1891 like to NOT lose your current debugging state. However
1892 if you're in a user-defined command or especially in a
1893 loop, then you need a way to detect that the command
1894 failed WITHOUT aborting. This allows you to write
1895 scripts that search thru the trace buffer until the end,
1896 and then continue on to do something else. */
1899 error ("Target failed to find requested trace frame.");
1903 printf_filtered ("End of trace buffer.\n");
1904 /* The following will not recurse, since it's special-cased */
1905 trace_find_command ("-1", from_tty
);
1906 reply
= NULL
; /* break out of loop,
1907 (avoid recursive nonsense) */
1912 if ((target_tracept
= (int) strtol (++reply
, &reply
, 16)) == -1)
1913 error ("Target failed to find requested trace frame.");
1915 case 'O': /* "OK"? */
1916 if (reply
[1] == 'K' && reply
[2] == '\0')
1919 error ("Bogus reply from target: %s", reply
);
1922 error ("Bogus reply from target: %s", reply
);
1925 flush_cached_frames ();
1926 registers_changed ();
1927 select_frame (get_current_frame ());
1928 set_traceframe_num (target_frameno
);
1929 set_tracepoint_num (target_tracept
);
1930 if (target_frameno
== -1)
1931 set_traceframe_context (-1);
1933 set_traceframe_context (read_pc ());
1937 enum print_what print_what
;
1939 /* NOTE: in immitation of the step command, try to determine
1940 whether we have made a transition from one function to another.
1941 If so, we'll print the "stack frame" (ie. the new function and
1942 it's arguments) -- otherwise we'll just show the new source line.
1944 This determination is made by checking (1) whether the current
1945 function has changed, and (2) whether the current FP has changed.
1946 Hack: if the FP wasn't collected, either at the current or the
1947 previous frame, assume that the FP has NOT changed. */
1949 if (old_func
== find_pc_function (read_pc ()) &&
1950 (old_frame_addr
== 0 ||
1951 get_frame_base (get_current_frame ()) == 0 ||
1952 old_frame_addr
== get_frame_base (get_current_frame ())))
1953 print_what
= SRC_LINE
;
1955 print_what
= SRC_AND_LOC
;
1957 print_stack_frame (get_selected_frame (), 1, print_what
);
1962 /* trace_find_command takes a trace frame number n,
1963 sends "QTFrame:<n>" to the target,
1964 and accepts a reply that may contain several optional pieces
1965 of information: a frame number, a tracepoint number, and an
1966 indication of whether this is a trap frame or a stepping frame.
1968 The minimal response is just "OK" (which indicates that the
1969 target does not give us a frame number or a tracepoint number).
1970 Instead of that, the target may send us a string containing
1972 F<hexnum> (gives the selected frame number)
1973 T<hexnum> (gives the selected tracepoint number)
1978 trace_find_command (char *args
, int from_tty
)
1979 { /* STUB_COMM PART_IMPLEMENTED */
1980 /* this should only be called with a numeric argument */
1983 if (target_is_remote ())
1985 if (deprecated_trace_find_hook
)
1986 deprecated_trace_find_hook (args
, from_tty
);
1988 if (args
== 0 || *args
== 0)
1989 { /* TFIND with no args means find NEXT trace frame. */
1990 if (traceframe_number
== -1)
1991 frameno
= 0; /* "next" is first one */
1993 frameno
= traceframe_number
+ 1;
1995 else if (0 == strcmp (args
, "-"))
1997 if (traceframe_number
== -1)
1998 error ("not debugging trace buffer");
1999 else if (from_tty
&& traceframe_number
== 0)
2000 error ("already at start of trace buffer");
2002 frameno
= traceframe_number
- 1;
2005 frameno
= parse_and_eval_long (args
);
2008 error ("invalid input (%d is less than zero)", frameno
);
2010 sprintf (target_buf
, "QTFrame:%x", frameno
);
2011 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2014 error ("Trace can only be run on remote targets.");
2019 trace_find_end_command (char *args
, int from_tty
)
2021 trace_find_command ("-1", from_tty
);
2026 trace_find_none_command (char *args
, int from_tty
)
2028 trace_find_command ("-1", from_tty
);
2033 trace_find_start_command (char *args
, int from_tty
)
2035 trace_find_command ("0", from_tty
);
2038 /* tfind pc command */
2040 trace_find_pc_command (char *args
, int from_tty
)
2041 { /* STUB_COMM PART_IMPLEMENTED */
2045 if (target_is_remote ())
2047 if (args
== 0 || *args
== 0)
2048 pc
= read_pc (); /* default is current pc */
2050 pc
= parse_and_eval_address (args
);
2052 sprintf_vma (tmp
, pc
);
2053 sprintf (target_buf
, "QTFrame:pc:%s", tmp
);
2054 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2057 error ("Trace can only be run on remote targets.");
2060 /* tfind tracepoint command */
2062 trace_find_tracepoint_command (char *args
, int from_tty
)
2063 { /* STUB_COMM PART_IMPLEMENTED */
2066 if (target_is_remote ())
2068 if (args
== 0 || *args
== 0)
2070 if (tracepoint_number
== -1)
2071 error ("No current tracepoint -- please supply an argument.");
2073 tdp
= tracepoint_number
; /* default is current TDP */
2076 tdp
= parse_and_eval_long (args
);
2078 sprintf (target_buf
, "QTFrame:tdp:%x", tdp
);
2079 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2082 error ("Trace can only be run on remote targets.");
2085 /* TFIND LINE command:
2087 This command will take a sourceline for argument, just like BREAK
2088 or TRACE (ie. anything that "decode_line_1" can handle).
2090 With no argument, this command will find the next trace frame
2091 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2094 trace_find_line_command (char *args
, int from_tty
)
2095 { /* STUB_COMM PART_IMPLEMENTED */
2096 static CORE_ADDR start_pc
, end_pc
;
2097 struct symtabs_and_lines sals
;
2098 struct symtab_and_line sal
;
2099 struct cleanup
*old_chain
;
2100 char startpc_str
[40], endpc_str
[40];
2102 if (target_is_remote ())
2104 if (args
== 0 || *args
== 0)
2106 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2108 sals
.sals
= (struct symtab_and_line
*)
2109 xmalloc (sizeof (struct symtab_and_line
));
2114 sals
= decode_line_spec (args
, 1);
2118 old_chain
= make_cleanup (xfree
, sals
.sals
);
2119 if (sal
.symtab
== 0)
2121 printf_filtered ("TFIND: No line number information available");
2124 /* This is useful for "info line *0x7f34". If we can't tell the
2125 user about a source line, at least let them have the symbolic
2127 printf_filtered (" for address ");
2129 print_address (sal
.pc
, gdb_stdout
);
2130 printf_filtered (";\n -- will attempt to find by PC. \n");
2134 printf_filtered (".\n");
2135 return; /* no line, no PC; what can we do? */
2138 else if (sal
.line
> 0
2139 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2141 if (start_pc
== end_pc
)
2143 printf_filtered ("Line %d of \"%s\"",
2144 sal
.line
, sal
.symtab
->filename
);
2146 printf_filtered (" is at address ");
2147 print_address (start_pc
, gdb_stdout
);
2149 printf_filtered (" but contains no code.\n");
2150 sal
= find_pc_line (start_pc
, 0);
2152 find_line_pc_range (sal
, &start_pc
, &end_pc
) &&
2154 printf_filtered ("Attempting to find line %d instead.\n",
2157 error ("Cannot find a good line.");
2161 /* Is there any case in which we get here, and have an address
2162 which the user would want to see? If we have debugging symbols
2163 and no line numbers? */
2164 error ("Line number %d is out of range for \"%s\".\n",
2165 sal
.line
, sal
.symtab
->filename
);
2167 sprintf_vma (startpc_str
, start_pc
);
2168 sprintf_vma (endpc_str
, end_pc
- 1);
2169 if (args
&& *args
) /* find within range of stated line */
2170 sprintf (target_buf
, "QTFrame:range:%s:%s", startpc_str
, endpc_str
);
2171 else /* find OUTSIDE OF range of CURRENT line */
2172 sprintf (target_buf
, "QTFrame:outside:%s:%s", startpc_str
, endpc_str
);
2173 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2174 do_cleanups (old_chain
);
2177 error ("Trace can only be run on remote targets.");
2180 /* tfind range command */
2182 trace_find_range_command (char *args
, int from_tty
)
2184 static CORE_ADDR start
, stop
;
2185 char start_str
[40], stop_str
[40];
2188 if (target_is_remote ())
2190 if (args
== 0 || *args
== 0)
2191 { /* XXX FIXME: what should default behavior be? */
2192 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2196 if (0 != (tmp
= strchr (args
, ',')))
2198 *tmp
++ = '\0'; /* terminate start address */
2199 while (isspace ((int) *tmp
))
2201 start
= parse_and_eval_address (args
);
2202 stop
= parse_and_eval_address (tmp
);
2205 { /* no explicit end address? */
2206 start
= parse_and_eval_address (args
);
2207 stop
= start
+ 1; /* ??? */
2210 sprintf_vma (start_str
, start
);
2211 sprintf_vma (stop_str
, stop
);
2212 sprintf (target_buf
, "QTFrame:range:%s:%s", start_str
, stop_str
);
2213 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2216 error ("Trace can only be run on remote targets.");
2219 /* tfind outside command */
2221 trace_find_outside_command (char *args
, int from_tty
)
2223 CORE_ADDR start
, stop
;
2224 char start_str
[40], stop_str
[40];
2227 if (target_is_remote ())
2229 if (args
== 0 || *args
== 0)
2230 { /* XXX FIXME: what should default behavior be? */
2231 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2235 if (0 != (tmp
= strchr (args
, ',')))
2237 *tmp
++ = '\0'; /* terminate start address */
2238 while (isspace ((int) *tmp
))
2240 start
= parse_and_eval_address (args
);
2241 stop
= parse_and_eval_address (tmp
);
2244 { /* no explicit end address? */
2245 start
= parse_and_eval_address (args
);
2246 stop
= start
+ 1; /* ??? */
2249 sprintf_vma (start_str
, start
);
2250 sprintf_vma (stop_str
, stop
);
2251 sprintf (target_buf
, "QTFrame:outside:%s:%s", start_str
, stop_str
);
2252 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2255 error ("Trace can only be run on remote targets.");
2258 /* save-tracepoints command */
2260 tracepoint_save_command (char *args
, int from_tty
)
2262 struct tracepoint
*tp
;
2263 struct action_line
*line
;
2265 char *i1
= " ", *i2
= " ";
2266 char *indent
, *actionline
, *pathname
;
2269 if (args
== 0 || *args
== 0)
2270 error ("Argument required (file name in which to save tracepoints");
2272 if (tracepoint_chain
== 0)
2274 warning ("save-tracepoints: no tracepoints to save.\n");
2278 pathname
= tilde_expand (args
);
2279 if (!(fp
= fopen (pathname
, "w")))
2280 error ("Unable to open file '%s' for saving tracepoints (%s)",
2281 args
, safe_strerror (errno
));
2284 ALL_TRACEPOINTS (tp
)
2286 if (tp
->addr_string
)
2287 fprintf (fp
, "trace %s\n", tp
->addr_string
);
2290 sprintf_vma (tmp
, tp
->address
);
2291 fprintf (fp
, "trace *0x%s\n", tmp
);
2295 fprintf (fp
, " passcount %d\n", tp
->pass_count
);
2299 fprintf (fp
, " actions\n");
2301 for (line
= tp
->actions
; line
; line
= line
->next
)
2303 struct cmd_list_element
*cmd
;
2305 QUIT
; /* allow user to bail out with ^C */
2306 actionline
= line
->action
;
2307 while (isspace ((int) *actionline
))
2310 fprintf (fp
, "%s%s\n", indent
, actionline
);
2311 if (*actionline
!= '#') /* skip for comment lines */
2313 cmd
= lookup_cmd (&actionline
, cmdlist
, "", -1, 1);
2315 error ("Bad action list item: %s", actionline
);
2316 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2318 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2326 printf_filtered ("Tracepoints saved to file '%s'.\n", args
);
2330 /* info scope command: list the locals for a scope. */
2332 scope_info (char *args
, int from_tty
)
2334 struct symtabs_and_lines sals
;
2336 struct minimal_symbol
*msym
;
2337 struct block
*block
;
2338 char **canonical
, *symname
, *save_args
= args
;
2339 struct dict_iterator iter
;
2342 if (args
== 0 || *args
== 0)
2343 error ("requires an argument (function, line or *addr) to define a scope");
2345 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2346 if (sals
.nelts
== 0)
2347 return; /* presumably decode_line_1 has already warned */
2349 /* Resolve line numbers to PC */
2350 resolve_sal_pc (&sals
.sals
[0]);
2351 block
= block_for_pc (sals
.sals
[0].pc
);
2355 QUIT
; /* allow user to bail out with ^C */
2356 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2358 QUIT
; /* allow user to bail out with ^C */
2360 printf_filtered ("Scope for %s:\n", save_args
);
2363 symname
= DEPRECATED_SYMBOL_NAME (sym
);
2364 if (symname
== NULL
|| *symname
== '\0')
2365 continue; /* probably botched, certainly useless */
2367 printf_filtered ("Symbol %s is ", symname
);
2368 switch (SYMBOL_CLASS (sym
))
2371 case LOC_UNDEF
: /* messed up symbol? */
2372 printf_filtered ("a bogus symbol, class %d.\n",
2373 SYMBOL_CLASS (sym
));
2374 count
--; /* don't count this one */
2377 printf_filtered ("a constant with value %ld (0x%lx)",
2378 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2380 case LOC_CONST_BYTES
:
2381 printf_filtered ("constant bytes: ");
2382 if (SYMBOL_TYPE (sym
))
2383 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2384 fprintf_filtered (gdb_stdout
, " %02x",
2385 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2388 printf_filtered ("in static storage at address ");
2389 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
),
2393 printf_filtered ("a local variable in register $%s",
2394 REGISTER_NAME (SYMBOL_VALUE (sym
)));
2398 printf_filtered ("an argument at stack/frame offset %ld",
2399 SYMBOL_VALUE (sym
));
2402 printf_filtered ("a local variable at frame offset %ld",
2403 SYMBOL_VALUE (sym
));
2406 printf_filtered ("a reference argument at offset %ld",
2407 SYMBOL_VALUE (sym
));
2410 printf_filtered ("an argument in register $%s",
2411 REGISTER_NAME (SYMBOL_VALUE (sym
)));
2413 case LOC_REGPARM_ADDR
:
2414 printf_filtered ("the address of an argument, in register $%s",
2415 REGISTER_NAME (SYMBOL_VALUE (sym
)));
2418 printf_filtered ("a typedef.\n");
2421 printf_filtered ("a label at address ");
2422 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
),
2426 printf_filtered ("a function at address ");
2427 print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)),
2431 printf_filtered ("a variable at offset %ld from register $%s",
2433 REGISTER_NAME (SYMBOL_BASEREG (sym
)));
2435 case LOC_BASEREG_ARG
:
2436 printf_filtered ("an argument at offset %ld from register $%s",
2438 REGISTER_NAME (SYMBOL_BASEREG (sym
)));
2440 case LOC_UNRESOLVED
:
2441 msym
= lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (sym
),
2444 printf_filtered ("Unresolved Static");
2447 printf_filtered ("static storage at address ");
2448 print_address_numeric (SYMBOL_VALUE_ADDRESS (msym
), 1,
2452 case LOC_OPTIMIZED_OUT
:
2453 printf_filtered ("optimized out.\n");
2455 case LOC_HP_THREAD_LOCAL_STATIC
:
2456 printf_filtered ("HP thread local static ");
2459 printf_filtered ("extern (local indirect) at address ");
2460 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
),
2464 case LOC_COMPUTED_ARG
:
2465 SYMBOL_OPS (sym
)->describe_location (sym
, gdb_stdout
);
2468 if (SYMBOL_TYPE (sym
))
2469 printf_filtered (", length %d.\n",
2470 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2472 if (BLOCK_FUNCTION (block
))
2475 block
= BLOCK_SUPERBLOCK (block
);
2478 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2482 /* worker function (cleanup) */
2484 replace_comma (void *data
)
2492 trace_dump_command (char *args
, int from_tty
)
2494 struct tracepoint
*t
;
2495 struct action_line
*action
;
2496 char *action_exp
, *next_comma
;
2497 struct cleanup
*old_cleanups
;
2498 int stepping_actions
= 0;
2499 int stepping_frame
= 0;
2501 if (!target_is_remote ())
2503 error ("Trace can only be run on remote targets.");
2507 if (tracepoint_number
== -1)
2509 warning ("No current trace frame.");
2514 if (t
->number
== tracepoint_number
)
2518 error ("No known tracepoint matches 'current' tracepoint #%d.",
2521 old_cleanups
= make_cleanup (null_cleanup
, NULL
);
2523 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2524 tracepoint_number
, traceframe_number
);
2526 /* The current frame is a trap frame if the frame PC is equal
2527 to the tracepoint PC. If not, then the current frame was
2528 collected during single-stepping. */
2530 stepping_frame
= (t
->address
!= (read_pc () - DECR_PC_AFTER_BREAK
));
2532 for (action
= t
->actions
; action
; action
= action
->next
)
2534 struct cmd_list_element
*cmd
;
2536 QUIT
; /* allow user to bail out with ^C */
2537 action_exp
= action
->action
;
2538 while (isspace ((int) *action_exp
))
2541 /* The collection actions to be done while stepping are
2542 bracketed by the commands "while-stepping" and "end". */
2544 if (*action_exp
== '#') /* comment line */
2547 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2549 error ("Bad action list item: %s", action_exp
);
2551 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2552 stepping_actions
= 1;
2553 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2554 stepping_actions
= 0;
2555 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2557 /* Display the collected data.
2558 For the trap frame, display only what was collected at the trap.
2559 Likewise for stepping frames, display only what was collected
2560 while stepping. This means that the two boolean variables,
2561 STEPPING_FRAME and STEPPING_ACTIONS should be equal. */
2562 if (stepping_frame
== stepping_actions
)
2565 { /* repeat over a comma-separated list */
2566 QUIT
; /* allow user to bail out with ^C */
2567 if (*action_exp
== ',')
2569 while (isspace ((int) *action_exp
))
2572 next_comma
= strchr (action_exp
, ',');
2574 if (0 == strncasecmp (action_exp
, "$reg", 4))
2575 registers_info (NULL
, from_tty
);
2576 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2577 locals_info (NULL
, from_tty
);
2578 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2579 args_info (NULL
, from_tty
);
2584 make_cleanup (replace_comma
, next_comma
);
2587 printf_filtered ("%s = ", action_exp
);
2588 output_command (action_exp
, from_tty
);
2589 printf_filtered ("\n");
2593 action_exp
= next_comma
;
2595 while (action_exp
&& *action_exp
== ',');
2599 discard_cleanups (old_cleanups
);
2602 /* Convert the memory pointed to by mem into hex, placing result in buf.
2603 * Return a pointer to the last char put in buf (null)
2604 * "stolen" from sparc-stub.c
2607 static const char hexchars
[] = "0123456789abcdef";
2609 static unsigned char *
2610 mem2hex (unsigned char *mem
, unsigned char *buf
, int count
)
2618 *buf
++ = hexchars
[ch
>> 4];
2619 *buf
++ = hexchars
[ch
& 0xf];
2628 get_traceframe_number (void)
2630 return traceframe_number
;
2634 /* module initialization */
2636 _initialize_tracepoint (void)
2638 struct cmd_list_element
*c
;
2640 tracepoint_chain
= 0;
2641 tracepoint_count
= 0;
2642 traceframe_number
= -1;
2643 tracepoint_number
= -1;
2645 set_internalvar (lookup_internalvar ("tpnum"),
2646 value_from_longest (builtin_type_int
, (LONGEST
) 0));
2647 set_internalvar (lookup_internalvar ("trace_frame"),
2648 value_from_longest (builtin_type_int
, (LONGEST
) - 1));
2650 if (tracepoint_list
.list
== NULL
)
2652 tracepoint_list
.listsize
= 128;
2653 tracepoint_list
.list
= xmalloc
2654 (tracepoint_list
.listsize
* sizeof (struct memrange
));
2656 if (tracepoint_list
.aexpr_list
== NULL
)
2658 tracepoint_list
.aexpr_listsize
= 128;
2659 tracepoint_list
.aexpr_list
= xmalloc
2660 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
2663 if (stepping_list
.list
== NULL
)
2665 stepping_list
.listsize
= 128;
2666 stepping_list
.list
= xmalloc
2667 (stepping_list
.listsize
* sizeof (struct memrange
));
2670 if (stepping_list
.aexpr_list
== NULL
)
2672 stepping_list
.aexpr_listsize
= 128;
2673 stepping_list
.aexpr_list
= xmalloc
2674 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
2677 add_info ("scope", scope_info
,
2678 "List the variables local to a scope");
2680 add_cmd ("tracepoints", class_trace
, NULL
,
2681 "Tracing of program execution without stopping the program.",
2684 add_info ("tracepoints", tracepoints_info
,
2685 "Status of tracepoints, or tracepoint number NUMBER.\n\
2686 Convenience variable \"$tpnum\" contains the number of the\n\
2687 last tracepoint set.");
2689 add_info_alias ("tp", "tracepoints", 1);
2691 c
= add_com ("save-tracepoints", class_trace
, tracepoint_save_command
,
2692 "Save current tracepoint definitions as a script.\n\
2693 Use the 'source' command in another debug session to restore them.");
2694 set_cmd_completer (c
, filename_completer
);
2696 add_com ("tdump", class_trace
, trace_dump_command
,
2697 "Print everything collected at the current tracepoint.");
2699 add_prefix_cmd ("tfind", class_trace
, trace_find_command
,
2700 "Select a trace frame;\n\
2701 No argument means forward by one frame; '-' meand backward by one frame.",
2702 &tfindlist
, "tfind ", 1, &cmdlist
);
2704 add_cmd ("outside", class_trace
, trace_find_outside_command
,
2705 "Select a trace frame whose PC is outside the given \
2706 range.\nUsage: tfind outside addr1, addr2",
2709 add_cmd ("range", class_trace
, trace_find_range_command
,
2710 "Select a trace frame whose PC is in the given range.\n\
2711 Usage: tfind range addr1,addr2",
2714 add_cmd ("line", class_trace
, trace_find_line_command
,
2715 "Select a trace frame by source line.\n\
2716 Argument can be a line number (with optional source file), \n\
2717 a function name, or '*' followed by an address.\n\
2718 Default argument is 'the next source line that was traced'.",
2721 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
,
2722 "Select a trace frame by tracepoint number.\n\
2723 Default is the tracepoint for the current trace frame.",
2726 add_cmd ("pc", class_trace
, trace_find_pc_command
,
2727 "Select a trace frame by PC.\n\
2728 Default is the current PC, or the PC of the current trace frame.",
2731 add_cmd ("end", class_trace
, trace_find_end_command
,
2732 "Synonym for 'none'.\n\
2733 De-select any trace frame and resume 'live' debugging.",
2736 add_cmd ("none", class_trace
, trace_find_none_command
,
2737 "De-select any trace frame and resume 'live' debugging.",
2740 add_cmd ("start", class_trace
, trace_find_start_command
,
2741 "Select the first trace frame in the trace buffer.",
2744 add_com ("tstatus", class_trace
, trace_status_command
,
2745 "Display the status of the current trace data collection.");
2747 add_com ("tstop", class_trace
, trace_stop_command
,
2748 "Stop trace data collection.");
2750 add_com ("tstart", class_trace
, trace_start_command
,
2751 "Start trace data collection.");
2753 add_com ("passcount", class_trace
, trace_pass_command
,
2754 "Set the passcount for a tracepoint.\n\
2755 The trace will end when the tracepoint has been passed 'count' times.\n\
2756 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
2757 if TPNUM is omitted, passcount refers to the last tracepoint defined.");
2759 add_com ("end", class_trace
, end_actions_pseudocommand
,
2760 "Ends a list of commands or actions.\n\
2761 Several GDB commands allow you to enter a list of commands or actions.\n\
2762 Entering \"end\" on a line by itself is the normal way to terminate\n\
2764 Note: the \"end\" command cannot be used at the gdb prompt.");
2766 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
,
2767 "Specify single-stepping behavior at a tracepoint.\n\
2768 Argument is number of instructions to trace in single-step mode\n\
2769 following the tracepoint. This command is normally followed by\n\
2770 one or more \"collect\" commands, to specify what to collect\n\
2771 while single-stepping.\n\n\
2772 Note: this command can only be used in a tracepoint \"actions\" list.");
2774 add_com_alias ("ws", "while-stepping", class_alias
, 0);
2775 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
2777 add_com ("collect", class_trace
, collect_pseudocommand
,
2778 "Specify one or more data items to be collected at a tracepoint.\n\
2779 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
2780 collect all data (variables, registers) referenced by that expression.\n\
2781 Also accepts the following special arguments:\n\
2782 $regs -- all registers.\n\
2783 $args -- all function arguments.\n\
2784 $locals -- all variables local to the block/function scope.\n\
2785 Note: this command can only be used in a tracepoint \"actions\" list.");
2787 add_com ("actions", class_trace
, trace_actions_command
,
2788 "Specify the actions to be taken at a tracepoint.\n\
2789 Tracepoint actions may include collecting of specified data, \n\
2790 single-stepping, or enabling/disabling other tracepoints, \n\
2791 depending on target's capabilities.");
2793 add_cmd ("tracepoints", class_trace
, delete_trace_command
,
2794 "Delete specified tracepoints.\n\
2795 Arguments are tracepoint numbers, separated by spaces.\n\
2796 No argument means delete all tracepoints.",
2799 add_cmd ("tracepoints", class_trace
, disable_trace_command
,
2800 "Disable specified tracepoints.\n\
2801 Arguments are tracepoint numbers, separated by spaces.\n\
2802 No argument means disable all tracepoints.",
2805 add_cmd ("tracepoints", class_trace
, enable_trace_command
,
2806 "Enable specified tracepoints.\n\
2807 Arguments are tracepoint numbers, separated by spaces.\n\
2808 No argument means enable all tracepoints.",
2811 c
= add_com ("trace", class_trace
, trace_command
,
2812 "Set a tracepoint at a specified line or function or address.\n\
2813 Argument may be a line number, function name, or '*' plus an address.\n\
2814 For a line number or function, trace at the start of its code.\n\
2815 If an address is specified, trace at that exact address.\n\n\
2816 Do \"help tracepoints\" for info on other tracepoint commands.");
2817 set_cmd_completer (c
, location_completer
);
2819 add_com_alias ("tp", "trace", class_alias
, 0);
2820 add_com_alias ("tr", "trace", class_alias
, 1);
2821 add_com_alias ("tra", "trace", class_alias
, 1);
2822 add_com_alias ("trac", "trace", class_alias
, 1);