1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software
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"
45 /* readline include files */
46 #include <readline/readline.h>
47 #include <readline/history.h>
49 /* readline defines this. */
56 /* maximum length of an agent aexpression.
57 this accounts for the fact that packets are limited to 400 bytes
58 (which includes everything -- including the checksum), and assumes
59 the worst case of maximum length for each of the pieces of a
62 NOTE: expressions get mem2hex'ed otherwise this would be twice as
63 large. (400 - 31)/2 == 184 */
64 #define MAX_AGENT_EXPR_LEN 184
67 extern void (*readline_begin_hook
) (char *, ...);
68 extern char *(*readline_hook
) (char *);
69 extern void (*readline_end_hook
) (void);
70 extern void x_command (char *, int);
71 extern int addressprint
; /* Print machine addresses? */
73 /* GDB commands implemented in other modules:
76 extern void output_command (char *, int);
81 This module defines the following debugger commands:
82 trace : set a tracepoint on a function, line, or address.
83 info trace : list all debugger-defined tracepoints.
84 delete trace : delete one or more tracepoints.
85 enable trace : enable one or more tracepoints.
86 disable trace : disable one or more tracepoints.
87 actions : specify actions to be taken at a tracepoint.
88 passcount : specify a pass count for a tracepoint.
89 tstart : start a trace experiment.
90 tstop : stop a trace experiment.
91 tstatus : query the status of a trace experiment.
92 tfind : find a trace frame in the trace buffer.
93 tdump : print everything collected at the current tracepoint.
94 save-tracepoints : write tracepoint setup into a file.
96 This module defines the following user-visible debugger variables:
97 $trace_frame : sequence number of trace frame currently being debugged.
98 $trace_line : source line of trace frame currently being debugged.
99 $trace_file : source file of trace frame currently being debugged.
100 $tracepoint : tracepoint number of trace frame currently being debugged.
104 /* ======= Important global variables: ======= */
106 /* Chain of all tracepoints defined. */
107 struct tracepoint
*tracepoint_chain
;
109 /* Number of last tracepoint made. */
110 static int tracepoint_count
;
112 /* Number of last traceframe collected. */
113 static int traceframe_number
;
115 /* Tracepoint for last traceframe collected. */
116 static int tracepoint_number
;
118 /* Symbol for function for last traceframe collected */
119 static struct symbol
*traceframe_fun
;
121 /* Symtab and line for last traceframe collected */
122 static struct symtab_and_line traceframe_sal
;
124 /* Tracing command lists */
125 static struct cmd_list_element
*tfindlist
;
127 /* ======= Important command functions: ======= */
128 static void trace_command (char *, int);
129 static void tracepoints_info (char *, int);
130 static void delete_trace_command (char *, int);
131 static void enable_trace_command (char *, int);
132 static void disable_trace_command (char *, int);
133 static void trace_pass_command (char *, int);
134 static void trace_actions_command (char *, int);
135 static void trace_start_command (char *, int);
136 static void trace_stop_command (char *, int);
137 static void trace_status_command (char *, int);
138 static void trace_find_command (char *, int);
139 static void trace_find_pc_command (char *, int);
140 static void trace_find_tracepoint_command (char *, int);
141 static void trace_find_line_command (char *, int);
142 static void trace_find_range_command (char *, int);
143 static void trace_find_outside_command (char *, int);
144 static void tracepoint_save_command (char *, int);
145 static void trace_dump_command (char *, int);
147 /* support routines */
148 static void trace_mention (struct tracepoint
*);
150 struct collection_list
;
151 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
152 static unsigned char *mem2hex (unsigned char *, unsigned char *, int);
153 static void add_register (struct collection_list
*collection
,
155 static struct cleanup
*make_cleanup_free_actions (struct tracepoint
*t
);
156 static void free_actions_list (char **actions_list
);
157 static void free_actions_list_cleanup_wrapper (void *);
159 extern void _initialize_tracepoint (void);
161 /* Utility: returns true if "target remote" */
163 target_is_remote (void)
165 if (current_target
.to_shortname
&&
166 strcmp (current_target
.to_shortname
, "remote") == 0)
172 /* Utility: generate error from an incoming stub packet. */
174 trace_error (char *buf
)
177 return; /* not an error msg */
180 case '1': /* malformed packet error */
181 if (*++buf
== '0') /* general case: */
182 error ("tracepoint.c: error in outgoing packet.");
184 error ("tracepoint.c: error in outgoing packet at field #%ld.",
185 strtol (buf
, NULL
, 16));
187 error ("trace API error 0x%s.", ++buf
);
189 error ("Target returns error code '%s'.", buf
);
193 /* Utility: wait for reply from stub, while accepting "O" packets */
195 remote_get_noisy_reply (char *buf
,
198 do /* loop on reply from remote stub */
200 QUIT
; /* allow user to bail out with ^C */
201 getpkt (buf
, sizeof_buf
, 0);
203 error ("Target does not support this command.");
204 else if (buf
[0] == 'E')
206 else if (buf
[0] == 'O' &&
208 remote_console_output (buf
+ 1); /* 'O' message from stub */
210 return buf
; /* here's the actual reply */
215 /* Set tracepoint count to NUM. */
217 set_tracepoint_count (int num
)
219 tracepoint_count
= num
;
220 set_internalvar (lookup_internalvar ("tpnum"),
221 value_from_longest (builtin_type_int
, (LONGEST
) num
));
224 /* Set traceframe number to NUM. */
226 set_traceframe_num (int num
)
228 traceframe_number
= num
;
229 set_internalvar (lookup_internalvar ("trace_frame"),
230 value_from_longest (builtin_type_int
, (LONGEST
) num
));
233 /* Set tracepoint number to NUM. */
235 set_tracepoint_num (int num
)
237 tracepoint_number
= num
;
238 set_internalvar (lookup_internalvar ("tracepoint"),
239 value_from_longest (builtin_type_int
, (LONGEST
) num
));
242 /* Set externally visible debug variables for querying/printing
243 the traceframe context (line, function, file) */
246 set_traceframe_context (CORE_ADDR trace_pc
)
248 static struct type
*func_string
, *file_string
;
249 static struct type
*func_range
, *file_range
;
250 struct value
*func_val
;
251 struct value
*file_val
;
252 static struct type
*charstar
;
255 if (charstar
== (struct type
*) NULL
)
256 charstar
= lookup_pointer_type (builtin_type_char
);
258 if (trace_pc
== -1) /* cease debugging any trace buffers */
261 traceframe_sal
.pc
= traceframe_sal
.line
= 0;
262 traceframe_sal
.symtab
= NULL
;
263 set_internalvar (lookup_internalvar ("trace_func"),
264 value_from_pointer (charstar
, (LONGEST
) 0));
265 set_internalvar (lookup_internalvar ("trace_file"),
266 value_from_pointer (charstar
, (LONGEST
) 0));
267 set_internalvar (lookup_internalvar ("trace_line"),
268 value_from_pointer (builtin_type_int
, (LONGEST
) - 1));
272 /* save as globals for internal use */
273 traceframe_sal
= find_pc_line (trace_pc
, 0);
274 traceframe_fun
= find_pc_function (trace_pc
);
276 /* save linenumber as "$trace_line", a debugger variable visible to users */
277 set_internalvar (lookup_internalvar ("trace_line"),
278 value_from_longest (builtin_type_int
,
279 (LONGEST
) traceframe_sal
.line
));
281 /* save func name as "$trace_func", a debugger variable visible to users */
282 if (traceframe_fun
== NULL
||
283 SYMBOL_NAME (traceframe_fun
) == NULL
)
284 set_internalvar (lookup_internalvar ("trace_func"),
285 value_from_pointer (charstar
, (LONGEST
) 0));
288 len
= strlen (SYMBOL_NAME (traceframe_fun
));
289 func_range
= create_range_type (func_range
,
290 builtin_type_int
, 0, len
- 1);
291 func_string
= create_array_type (func_string
,
292 builtin_type_char
, func_range
);
293 func_val
= allocate_value (func_string
);
294 VALUE_TYPE (func_val
) = func_string
;
295 memcpy (VALUE_CONTENTS_RAW (func_val
),
296 SYMBOL_NAME (traceframe_fun
),
298 func_val
->modifiable
= 0;
299 set_internalvar (lookup_internalvar ("trace_func"), func_val
);
302 /* save file name as "$trace_file", a debugger variable visible to users */
303 if (traceframe_sal
.symtab
== NULL
||
304 traceframe_sal
.symtab
->filename
== NULL
)
305 set_internalvar (lookup_internalvar ("trace_file"),
306 value_from_pointer (charstar
, (LONGEST
) 0));
309 len
= strlen (traceframe_sal
.symtab
->filename
);
310 file_range
= create_range_type (file_range
,
311 builtin_type_int
, 0, len
- 1);
312 file_string
= create_array_type (file_string
,
313 builtin_type_char
, file_range
);
314 file_val
= allocate_value (file_string
);
315 VALUE_TYPE (file_val
) = file_string
;
316 memcpy (VALUE_CONTENTS_RAW (file_val
),
317 traceframe_sal
.symtab
->filename
,
319 file_val
->modifiable
= 0;
320 set_internalvar (lookup_internalvar ("trace_file"), file_val
);
324 /* Low level routine to set a tracepoint.
325 Returns the tracepoint object so caller can set other things.
326 Does not set the tracepoint number!
327 Does not print anything.
329 ==> This routine should not be called if there is a chance of later
330 error(); otherwise it leaves a bogus tracepoint on the chain. Validate
331 your arguments BEFORE calling this routine! */
333 static struct tracepoint
*
334 set_raw_tracepoint (struct symtab_and_line sal
)
336 register struct tracepoint
*t
, *tc
;
337 struct cleanup
*old_chain
;
339 t
= (struct tracepoint
*) xmalloc (sizeof (struct tracepoint
));
340 old_chain
= make_cleanup (xfree
, t
);
341 memset (t
, 0, sizeof (*t
));
343 if (sal
.symtab
== NULL
)
344 t
->source_file
= NULL
;
346 t
->source_file
= savestring (sal
.symtab
->filename
,
347 strlen (sal
.symtab
->filename
));
349 t
->section
= sal
.section
;
350 t
->language
= current_language
->la_language
;
351 t
->input_radix
= input_radix
;
352 t
->line_number
= sal
.line
;
357 t
->addr_string
= NULL
;
359 /* Add this tracepoint to the end of the chain
360 so that a list of tracepoints will come out in order
361 of increasing numbers. */
363 tc
= tracepoint_chain
;
365 tracepoint_chain
= t
;
372 discard_cleanups (old_chain
);
376 /* Set a tracepoint according to ARG (function, linenum or *address) */
378 trace_command (char *arg
, int from_tty
)
380 char **canonical
= (char **) NULL
;
381 struct symtabs_and_lines sals
;
382 struct symtab_and_line sal
;
383 struct tracepoint
*t
;
384 char *addr_start
= 0, *addr_end
= 0;
388 error ("trace command requires an argument");
390 if (from_tty
&& info_verbose
)
391 printf_filtered ("TRACE %s\n", arg
);
394 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
, 0, &canonical
);
397 return; /* ??? Presumably decode_line_1 has already warned? */
399 /* Resolve all line numbers to PC's */
400 for (i
= 0; i
< sals
.nelts
; i
++)
401 resolve_sal_pc (&sals
.sals
[i
]);
403 /* Now set all the tracepoints. */
404 for (i
= 0; i
< sals
.nelts
; i
++)
408 t
= set_raw_tracepoint (sal
);
409 set_tracepoint_count (tracepoint_count
+ 1);
410 t
->number
= tracepoint_count
;
412 /* If a canonical line spec is needed use that instead of the
414 if (canonical
!= (char **) NULL
&& canonical
[i
] != NULL
)
415 t
->addr_string
= canonical
[i
];
417 t
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
424 printf_filtered ("Multiple tracepoints were set.\n");
425 printf_filtered ("Use 'delete trace' to delete unwanted tracepoints.\n");
429 /* Tell the user we have just set a tracepoint TP. */
432 trace_mention (struct tracepoint
*tp
)
434 printf_filtered ("Tracepoint %d", tp
->number
);
436 if (addressprint
|| (tp
->source_file
== NULL
))
438 printf_filtered (" at ");
439 print_address_numeric (tp
->address
, 1, gdb_stdout
);
442 printf_filtered (": file %s, line %d.",
443 tp
->source_file
, tp
->line_number
);
445 printf_filtered ("\n");
448 /* Print information on tracepoint number TPNUM_EXP, or all if omitted. */
451 tracepoints_info (char *tpnum_exp
, int from_tty
)
453 struct tracepoint
*t
;
454 struct action_line
*action
;
455 int found_a_tracepoint
= 0;
456 char wrap_indent
[80];
461 tpnum
= parse_and_eval_long (tpnum_exp
);
464 if (tpnum
== -1 || tpnum
== t
->number
)
466 extern int addressprint
; /* print machine addresses? */
468 if (!found_a_tracepoint
++)
470 printf_filtered ("Num Enb ");
473 if (TARGET_ADDR_BIT
<= 32)
474 printf_filtered ("Address ");
476 printf_filtered ("Address ");
478 printf_filtered ("PassC StepC What\n");
480 strcpy (wrap_indent
, " ");
483 if (TARGET_ADDR_BIT
<= 32)
484 strcat (wrap_indent
, " ");
486 strcat (wrap_indent
, " ");
489 printf_filtered ("%-3d %-3s ", t
->number
,
490 t
->enabled_p
? "y" : "n");
495 if (TARGET_ADDR_BIT
<= 32)
496 tmp
= local_hex_string_custom (t
->address
497 & (CORE_ADDR
) 0xffffffff,
500 tmp
= local_hex_string_custom (t
->address
, "016l");
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 (readline_begin_hook
)
790 (*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 (readline_end_hook
)
800 (*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 (readline_hook
&& instream
== NULL
)
845 line
= (*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 for (p
= *line
; isspace ((int) *p
);)
919 /* symbol lookup etc. */
920 if (*p
== '\0') /* empty line: just prompt for another line. */
923 if (*p
== '#') /* comment line */
926 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
929 warning ("'%s' is not an action that I know, or is ambiguous.", p
);
933 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
935 struct agent_expr
*aexpr
;
936 struct agent_reqs areqs
;
939 { /* repeat over a comma-separated list */
940 QUIT
; /* allow user to bail out with ^C */
941 while (isspace ((int) *p
))
944 if (*p
== '$') /* look for special pseudo-symbols */
946 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
947 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
948 (0 == strncasecmp ("loc", p
+ 1, 3)))
953 /* else fall thru, treat p as an expression and parse it! */
955 exp
= parse_exp_1 (&p
, block_for_pc (t
->address
), 1);
956 old_chain
= make_cleanup (free_current_contents
, &exp
);
958 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
960 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
962 warning ("constant %s (value %ld) will not be collected.",
963 SYMBOL_NAME (exp
->elts
[2].symbol
),
964 SYMBOL_VALUE (exp
->elts
[2].symbol
));
967 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
969 warning ("%s is optimized away and cannot be collected.",
970 SYMBOL_NAME (exp
->elts
[2].symbol
));
975 /* we have something to collect, make sure that the expr to
976 bytecode translator can handle it and that it's not too long */
977 aexpr
= gen_trace_for_expr (t
->address
, exp
);
978 make_cleanup_free_agent_expr (aexpr
);
980 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
981 error ("expression too complicated, try simplifying");
983 ax_reqs (aexpr
, &areqs
);
984 (void) make_cleanup (xfree
, areqs
.reg_mask
);
986 if (areqs
.flaw
!= agent_flaw_none
)
987 error ("malformed expression");
989 if (areqs
.min_height
< 0)
990 error ("gdb: Internal error: expression has min height < 0");
992 if (areqs
.max_height
> 20)
993 error ("expression too complicated, try simplifying");
995 do_cleanups (old_chain
);
997 while (p
&& *p
++ == ',');
1000 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
1002 char *steparg
; /* in case warning is necessary */
1004 while (isspace ((int) *p
))
1009 (t
->step_count
= strtol (p
, &p
, 0)) == 0)
1011 warning ("'%s': bad step-count; command ignored.", *line
);
1016 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
1020 warning ("'%s' is not a supported tracepoint action.", *line
);
1025 /* worker function */
1027 free_actions (struct tracepoint
*t
)
1029 struct action_line
*line
, *next
;
1031 for (line
= t
->actions
; line
; line
= next
)
1035 xfree (line
->action
);
1042 do_free_actions_cleanup (void *t
)
1047 static struct cleanup
*
1048 make_cleanup_free_actions (struct tracepoint
*t
)
1050 return make_cleanup (do_free_actions_cleanup
, t
);
1055 int type
; /* 0 for absolute memory range, else basereg number */
1056 bfd_signed_vma start
;
1060 struct collection_list
1062 unsigned char regs_mask
[8]; /* room for up to 256 regs */
1065 struct memrange
*list
;
1066 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
1067 long next_aexpr_elt
;
1068 struct agent_expr
**aexpr_list
;
1071 tracepoint_list
, stepping_list
;
1073 /* MEMRANGE functions: */
1075 static int memrange_cmp (const void *, const void *);
1077 /* compare memranges for qsort */
1079 memrange_cmp (const void *va
, const void *vb
)
1081 const struct memrange
*a
= va
, *b
= vb
;
1083 if (a
->type
< b
->type
)
1085 if (a
->type
> b
->type
)
1089 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
1091 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
1096 if (a
->start
< b
->start
)
1098 if (a
->start
> b
->start
)
1104 /* Sort the memrange list using qsort, and merge adjacent memranges */
1106 memrange_sortmerge (struct collection_list
*memranges
)
1110 qsort (memranges
->list
, memranges
->next_memrange
,
1111 sizeof (struct memrange
), memrange_cmp
);
1112 if (memranges
->next_memrange
> 0)
1114 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
1116 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
1117 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
1118 MAX_REGISTER_VIRTUAL_SIZE
)
1120 /* memrange b starts before memrange a ends; merge them. */
1121 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
1122 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
1123 continue; /* next b, same a */
1127 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
1128 sizeof (struct memrange
));
1130 memranges
->next_memrange
= a
+ 1;
1134 /* Add a register to a collection list */
1136 add_register (struct collection_list
*collection
, unsigned int regno
)
1139 printf_filtered ("collect register %d\n", regno
);
1140 if (regno
> (8 * sizeof (collection
->regs_mask
)))
1141 error ("Internal: register number %d too large for tracepoint",
1143 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
1146 /* Add a memrange to a collection list */
1148 add_memrange (struct collection_list
*memranges
, int type
, bfd_signed_vma base
,
1153 printf_filtered ("(%d,", type
);
1155 printf_filtered (",%ld)\n", len
);
1158 /* type: 0 == memory, n == basereg */
1159 memranges
->list
[memranges
->next_memrange
].type
= type
;
1160 /* base: addr if memory, offset if reg relative. */
1161 memranges
->list
[memranges
->next_memrange
].start
= base
;
1162 /* len: we actually save end (base + len) for convenience */
1163 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
1164 memranges
->next_memrange
++;
1165 if (memranges
->next_memrange
>= memranges
->listsize
)
1167 memranges
->listsize
*= 2;
1168 memranges
->list
= xrealloc (memranges
->list
,
1169 memranges
->listsize
);
1172 if (type
!= -1) /* better collect the base register! */
1173 add_register (memranges
, type
);
1176 /* Add a symbol to a collection list */
1178 collect_symbol (struct collection_list
*collect
, struct symbol
*sym
,
1179 long frame_regno
, long frame_offset
)
1183 bfd_signed_vma offset
;
1185 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
1186 switch (SYMBOL_CLASS (sym
))
1189 printf_filtered ("%s: don't know symbol class %d\n",
1190 SYMBOL_NAME (sym
), SYMBOL_CLASS (sym
));
1193 printf_filtered ("constant %s (value %ld) will not be collected.\n",
1194 SYMBOL_NAME (sym
), SYMBOL_VALUE (sym
));
1197 offset
= SYMBOL_VALUE_ADDRESS (sym
);
1202 sprintf_vma (tmp
, offset
);
1203 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1204 SYMBOL_NAME (sym
), len
, tmp
/* address */);
1206 add_memrange (collect
, -1, offset
, len
); /* 0 == memory */
1210 reg
= SYMBOL_VALUE (sym
);
1212 printf_filtered ("LOC_REG[parm] %s: ", SYMBOL_NAME (sym
));
1213 add_register (collect
, reg
);
1214 /* check for doubles stored in two registers */
1215 /* FIXME: how about larger types stored in 3 or more regs? */
1216 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1217 len
> REGISTER_RAW_SIZE (reg
))
1218 add_register (collect
, reg
+ 1);
1221 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1222 printf_filtered (" (will not collect %s)\n",
1227 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1230 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1231 SYMBOL_NAME (sym
), len
);
1232 printf_vma (offset
);
1233 printf_filtered (" from frame ptr reg %d\n", reg
);
1235 add_memrange (collect
, reg
, offset
, len
);
1237 case LOC_REGPARM_ADDR
:
1238 reg
= SYMBOL_VALUE (sym
);
1242 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1243 SYMBOL_NAME (sym
), len
);
1244 printf_vma (offset
);
1245 printf_filtered (" from reg %d\n", reg
);
1247 add_memrange (collect
, reg
, offset
, len
);
1252 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1255 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1256 SYMBOL_NAME (sym
), len
);
1257 printf_vma (offset
);
1258 printf_filtered (" from frame ptr reg %d\n", reg
);
1260 add_memrange (collect
, reg
, offset
, len
);
1263 case LOC_BASEREG_ARG
:
1264 reg
= SYMBOL_BASEREG (sym
);
1265 offset
= SYMBOL_VALUE (sym
);
1268 printf_filtered ("LOC_BASEREG %s: collect %ld bytes at offset ",
1269 SYMBOL_NAME (sym
), len
);
1270 printf_vma (offset
);
1271 printf_filtered (" from basereg %d\n", reg
);
1273 add_memrange (collect
, reg
, offset
, len
);
1275 case LOC_UNRESOLVED
:
1276 printf_filtered ("Don't know LOC_UNRESOLVED %s\n", SYMBOL_NAME (sym
));
1278 case LOC_OPTIMIZED_OUT
:
1279 printf_filtered ("%s has been optimized out of existence.\n",
1285 /* Add all locals (or args) symbols to collection list */
1287 add_local_symbols (struct collection_list
*collect
, CORE_ADDR pc
,
1288 long frame_regno
, long frame_offset
, int type
)
1291 struct block
*block
;
1294 block
= block_for_pc (pc
);
1297 QUIT
; /* allow user to bail out with ^C */
1298 ALL_BLOCK_SYMBOLS (block
, i
, sym
)
1300 switch (SYMBOL_CLASS (sym
))
1303 warning ("don't know how to trace local symbol %s",
1309 if (type
== 'L') /* collecting Locals */
1312 collect_symbol (collect
, sym
, frame_regno
, frame_offset
);
1319 case LOC_REGPARM_ADDR
:
1320 case LOC_BASEREG_ARG
:
1321 if (type
== 'A') /* collecting Arguments */
1324 collect_symbol (collect
, sym
, frame_regno
, frame_offset
);
1328 if (BLOCK_FUNCTION (block
))
1331 block
= BLOCK_SUPERBLOCK (block
);
1334 warning ("No %s found in scope.", type
== 'L' ? "locals" : "args");
1337 /* worker function */
1339 clear_collection_list (struct collection_list
*list
)
1343 list
->next_memrange
= 0;
1344 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1346 free_agent_expr (list
->aexpr_list
[ndx
]);
1347 list
->aexpr_list
[ndx
] = NULL
;
1349 list
->next_aexpr_elt
= 0;
1350 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1353 /* reduce a collection list to string form (for gdb protocol) */
1355 stringify_collection_list (struct collection_list
*list
, char *string
)
1357 char temp_buf
[2048];
1361 char *(*str_list
)[];
1365 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1366 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1368 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1369 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1371 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1374 printf_filtered ("\nCollecting registers (mask): 0x");
1379 QUIT
; /* allow user to bail out with ^C */
1381 printf_filtered ("%02X", list
->regs_mask
[i
]);
1382 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1385 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1389 printf_filtered ("\n");
1390 if (list
->next_memrange
> 0 && info_verbose
)
1391 printf_filtered ("Collecting memranges: \n");
1392 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1394 QUIT
; /* allow user to bail out with ^C */
1395 sprintf_vma (tmp2
, list
->list
[i
].start
);
1398 printf_filtered ("(%d, %s, %ld)\n",
1401 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1403 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1405 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1411 sprintf (end
, "M%X,%s,%lX",
1414 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1416 count
+= strlen (end
);
1420 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1422 QUIT
; /* allow user to bail out with ^C */
1423 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1425 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1430 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1431 end
+= 10; /* 'X' + 8 hex digits + ',' */
1434 end
= mem2hex (list
->aexpr_list
[i
]->buf
, end
, list
->aexpr_list
[i
]->len
);
1435 count
+= 2 * list
->aexpr_list
[i
]->len
;
1440 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1445 (*str_list
)[ndx
] = NULL
;
1454 free_actions_list_cleanup_wrapper (void *al
)
1456 free_actions_list (al
);
1460 free_actions_list (char **actions_list
)
1464 if (actions_list
== 0)
1467 for (ndx
= 0; actions_list
[ndx
]; ndx
++)
1468 xfree (actions_list
[ndx
]);
1470 xfree (actions_list
);
1473 /* render all actions into gdb protocol */
1475 encode_actions (struct tracepoint
*t
, char ***tdp_actions
,
1476 char ***stepping_actions
)
1478 static char tdp_buff
[2048], step_buff
[2048];
1480 struct expression
*exp
= NULL
;
1481 struct action_line
*action
;
1483 struct value
*tempval
;
1484 struct collection_list
*collect
;
1485 struct cmd_list_element
*cmd
;
1486 struct agent_expr
*aexpr
;
1488 LONGEST frame_offset
;
1491 clear_collection_list (&tracepoint_list
);
1492 clear_collection_list (&stepping_list
);
1493 collect
= &tracepoint_list
;
1495 *tdp_actions
= NULL
;
1496 *stepping_actions
= NULL
;
1498 TARGET_VIRTUAL_FRAME_POINTER (t
->address
, &frame_reg
, &frame_offset
);
1500 for (action
= t
->actions
; action
; action
= action
->next
)
1502 QUIT
; /* allow user to bail out with ^C */
1503 action_exp
= action
->action
;
1504 while (isspace ((int) *action_exp
))
1507 if (*action_exp
== '#') /* comment line */
1510 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1512 error ("Bad action list item: %s", action_exp
);
1514 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1517 { /* repeat over a comma-separated list */
1518 QUIT
; /* allow user to bail out with ^C */
1519 while (isspace ((int) *action_exp
))
1522 if (0 == strncasecmp ("$reg", action_exp
, 4))
1524 for (i
= 0; i
< NUM_REGS
; i
++)
1525 add_register (collect
, i
);
1526 action_exp
= strchr (action_exp
, ','); /* more? */
1528 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1530 add_local_symbols (collect
,
1535 action_exp
= strchr (action_exp
, ','); /* more? */
1537 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1539 add_local_symbols (collect
,
1544 action_exp
= strchr (action_exp
, ','); /* more? */
1548 unsigned long addr
, len
;
1549 struct cleanup
*old_chain
= NULL
;
1550 struct cleanup
*old_chain1
= NULL
;
1551 struct agent_reqs areqs
;
1553 exp
= parse_exp_1 (&action_exp
,
1554 block_for_pc (t
->address
), 1);
1555 old_chain
= make_cleanup (free_current_contents
, &exp
);
1557 switch (exp
->elts
[0].opcode
)
1560 i
= exp
->elts
[1].longconst
;
1562 printf_filtered ("OP_REGISTER: ");
1563 add_register (collect
, i
);
1567 /* safe because we know it's a simple expression */
1568 tempval
= evaluate_expression (exp
);
1569 addr
= VALUE_ADDRESS (tempval
) + VALUE_OFFSET (tempval
);
1570 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1571 add_memrange (collect
, -1, addr
, len
);
1575 collect_symbol (collect
,
1576 exp
->elts
[2].symbol
,
1581 default: /* full-fledged expression */
1582 aexpr
= gen_trace_for_expr (t
->address
, exp
);
1584 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1586 ax_reqs (aexpr
, &areqs
);
1587 if (areqs
.flaw
!= agent_flaw_none
)
1588 error ("malformed expression");
1590 if (areqs
.min_height
< 0)
1591 error ("gdb: Internal error: expression has min height < 0");
1592 if (areqs
.max_height
> 20)
1593 error ("expression too complicated, try simplifying");
1595 discard_cleanups (old_chain1
);
1596 add_aexpr (collect
, aexpr
);
1598 /* take care of the registers */
1599 if (areqs
.reg_mask_len
> 0)
1604 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1606 QUIT
; /* allow user to bail out with ^C */
1607 if (areqs
.reg_mask
[ndx1
] != 0)
1609 /* assume chars have 8 bits */
1610 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1611 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1612 /* it's used -- record it */
1613 add_register (collect
, ndx1
* 8 + ndx2
);
1619 do_cleanups (old_chain
);
1622 while (action_exp
&& *action_exp
++ == ',');
1624 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1626 collect
= &stepping_list
;
1628 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
1630 if (collect
== &stepping_list
) /* end stepping actions */
1631 collect
= &tracepoint_list
;
1633 break; /* end tracepoint actions */
1636 memrange_sortmerge (&tracepoint_list
);
1637 memrange_sortmerge (&stepping_list
);
1639 *tdp_actions
= stringify_collection_list (&tracepoint_list
, tdp_buff
);
1640 *stepping_actions
= stringify_collection_list (&stepping_list
, step_buff
);
1644 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1646 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1648 collect
->aexpr_list
=
1649 xrealloc (collect
->aexpr_list
,
1650 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1651 collect
->aexpr_listsize
*= 2;
1653 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1654 collect
->next_aexpr_elt
++;
1657 static char target_buf
[2048];
1659 /* Set "transparent" memory ranges
1661 Allow trace mechanism to treat text-like sections
1662 (and perhaps all read-only sections) transparently,
1663 i.e. don't reject memory requests from these address ranges
1664 just because they haven't been collected. */
1667 remote_set_transparent_ranges (void)
1669 extern bfd
*exec_bfd
;
1676 return; /* no information to give. */
1678 strcpy (target_buf
, "QTro");
1679 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
1681 char tmp1
[40], tmp2
[40];
1683 if ((s
->flags
& SEC_LOAD
) == 0 ||
1684 /* (s->flags & SEC_CODE) == 0 || */
1685 (s
->flags
& SEC_READONLY
) == 0)
1690 size
= bfd_get_section_size_before_reloc (s
);
1691 sprintf_vma (tmp1
, lma
);
1692 sprintf_vma (tmp2
, lma
+ size
);
1693 sprintf (target_buf
+ strlen (target_buf
),
1694 ":%s,%s", tmp1
, tmp2
);
1698 putpkt (target_buf
);
1699 getpkt (target_buf
, sizeof (target_buf
), 0);
1705 Tell target to clear any previous trace experiment.
1706 Walk the list of tracepoints, and send them (and their actions)
1707 to the target. If no errors,
1708 Tell target to start a new trace experiment. */
1711 trace_start_command (char *args
, int from_tty
)
1712 { /* STUB_COMM MOSTLY_IMPLEMENTED */
1713 struct tracepoint
*t
;
1716 char **stepping_actions
;
1718 struct cleanup
*old_chain
= NULL
;
1720 dont_repeat (); /* like "run", dangerous to repeat accidentally */
1722 if (target_is_remote ())
1725 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1726 if (strcmp (target_buf
, "OK"))
1727 error ("Target does not support this command.");
1733 sprintf_vma (tmp
, t
->address
);
1734 sprintf (buf
, "QTDP:%x:%s:%c:%lx:%x", t
->number
, tmp
, /* address */
1735 t
->enabled_p
? 'E' : 'D',
1736 t
->step_count
, t
->pass_count
);
1741 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1742 if (strcmp (target_buf
, "OK"))
1743 error ("Target does not support tracepoints.");
1747 encode_actions (t
, &tdp_actions
, &stepping_actions
);
1748 old_chain
= make_cleanup (free_actions_list_cleanup_wrapper
,
1750 (void) make_cleanup (free_actions_list_cleanup_wrapper
,
1753 /* do_single_steps (t); */
1756 for (ndx
= 0; tdp_actions
[ndx
]; ndx
++)
1758 QUIT
; /* allow user to bail out with ^C */
1759 sprintf (buf
, "QTDP:-%x:%s:%s%c",
1760 t
->number
, tmp
, /* address */
1762 ((tdp_actions
[ndx
+ 1] || stepping_actions
)
1765 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1766 if (strcmp (target_buf
, "OK"))
1767 error ("Error on target while setting tracepoints.");
1770 if (stepping_actions
)
1772 for (ndx
= 0; stepping_actions
[ndx
]; ndx
++)
1774 QUIT
; /* allow user to bail out with ^C */
1775 sprintf (buf
, "QTDP:-%x:%s:%s%s%s",
1776 t
->number
, tmp
, /* address */
1777 ((ndx
== 0) ? "S" : ""),
1778 stepping_actions
[ndx
],
1779 (stepping_actions
[ndx
+ 1] ? "-" : ""));
1781 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1782 if (strcmp (target_buf
, "OK"))
1783 error ("Error on target while setting tracepoints.");
1787 do_cleanups (old_chain
);
1790 /* Tell target to treat text-like sections as transparent */
1791 remote_set_transparent_ranges ();
1792 /* Now insert traps and begin collecting data */
1794 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1795 if (strcmp (target_buf
, "OK"))
1796 error ("Bogus reply from target: %s", target_buf
);
1797 set_traceframe_num (-1); /* all old traceframes invalidated */
1798 set_tracepoint_num (-1);
1799 set_traceframe_context (-1);
1800 trace_running_p
= 1;
1801 if (trace_start_stop_hook
)
1802 trace_start_stop_hook (1, from_tty
);
1806 error ("Trace can only be run on remote targets.");
1811 trace_stop_command (char *args
, int from_tty
)
1812 { /* STUB_COMM IS_IMPLEMENTED */
1813 if (target_is_remote ())
1816 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1817 if (strcmp (target_buf
, "OK"))
1818 error ("Bogus reply from target: %s", target_buf
);
1819 trace_running_p
= 0;
1820 if (trace_start_stop_hook
)
1821 trace_start_stop_hook (0, from_tty
);
1824 error ("Trace can only be run on remote targets.");
1827 unsigned long trace_running_p
;
1829 /* tstatus command */
1831 trace_status_command (char *args
, int from_tty
)
1832 { /* STUB_COMM IS_IMPLEMENTED */
1833 if (target_is_remote ())
1835 putpkt ("qTStatus");
1836 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1838 if (target_buf
[0] != 'T' ||
1839 (target_buf
[1] != '0' && target_buf
[1] != '1'))
1840 error ("Bogus reply from target: %s", target_buf
);
1842 /* exported for use by the GUI */
1843 trace_running_p
= (target_buf
[1] == '1');
1846 error ("Trace can only be run on remote targets.");
1849 /* Worker function for the various flavors of the tfind command */
1851 finish_tfind_command (char *msg
,
1855 int target_frameno
= -1, target_tracept
= -1;
1856 CORE_ADDR old_frame_addr
;
1857 struct symbol
*old_func
;
1860 old_frame_addr
= get_frame_base (get_current_frame ());
1861 old_func
= find_pc_function (read_pc ());
1864 reply
= remote_get_noisy_reply (msg
, sizeof_msg
);
1866 while (reply
&& *reply
)
1870 if ((target_frameno
= (int) strtol (++reply
, &reply
, 16)) == -1)
1872 /* A request for a non-existant trace frame has failed.
1873 Our response will be different, depending on FROM_TTY:
1875 If FROM_TTY is true, meaning that this command was
1876 typed interactively by the user, then give an error
1877 and DO NOT change the state of traceframe_number etc.
1879 However if FROM_TTY is false, meaning that we're either
1880 in a script, a loop, or a user-defined command, then
1881 DON'T give an error, but DO change the state of
1882 traceframe_number etc. to invalid.
1884 The rationalle is that if you typed the command, you
1885 might just have committed a typo or something, and you'd
1886 like to NOT lose your current debugging state. However
1887 if you're in a user-defined command or especially in a
1888 loop, then you need a way to detect that the command
1889 failed WITHOUT aborting. This allows you to write
1890 scripts that search thru the trace buffer until the end,
1891 and then continue on to do something else. */
1894 error ("Target failed to find requested trace frame.");
1898 printf_filtered ("End of trace buffer.\n");
1899 /* The following will not recurse, since it's special-cased */
1900 trace_find_command ("-1", from_tty
);
1901 reply
= NULL
; /* break out of loop,
1902 (avoid recursive nonsense) */
1907 if ((target_tracept
= (int) strtol (++reply
, &reply
, 16)) == -1)
1908 error ("Target failed to find requested trace frame.");
1910 case 'O': /* "OK"? */
1911 if (reply
[1] == 'K' && reply
[2] == '\0')
1914 error ("Bogus reply from target: %s", reply
);
1917 error ("Bogus reply from target: %s", reply
);
1920 flush_cached_frames ();
1921 registers_changed ();
1922 select_frame (get_current_frame ());
1923 set_traceframe_num (target_frameno
);
1924 set_tracepoint_num (target_tracept
);
1925 if (target_frameno
== -1)
1926 set_traceframe_context (-1);
1928 set_traceframe_context (read_pc ());
1934 /* NOTE: in immitation of the step command, try to determine
1935 whether we have made a transition from one function to another.
1936 If so, we'll print the "stack frame" (ie. the new function and
1937 it's arguments) -- otherwise we'll just show the new source line.
1939 This determination is made by checking (1) whether the current
1940 function has changed, and (2) whether the current FP has changed.
1941 Hack: if the FP wasn't collected, either at the current or the
1942 previous frame, assume that the FP has NOT changed. */
1944 if (old_func
== find_pc_function (read_pc ()) &&
1945 (old_frame_addr
== 0 ||
1946 get_frame_base (get_current_frame ()) == 0 ||
1947 old_frame_addr
== get_frame_base (get_current_frame ())))
1952 print_stack_frame (deprecated_selected_frame
,
1953 frame_relative_level (deprecated_selected_frame
),
1959 /* trace_find_command takes a trace frame number n,
1960 sends "QTFrame:<n>" to the target,
1961 and accepts a reply that may contain several optional pieces
1962 of information: a frame number, a tracepoint number, and an
1963 indication of whether this is a trap frame or a stepping frame.
1965 The minimal response is just "OK" (which indicates that the
1966 target does not give us a frame number or a tracepoint number).
1967 Instead of that, the target may send us a string containing
1969 F<hexnum> (gives the selected frame number)
1970 T<hexnum> (gives the selected tracepoint number)
1975 trace_find_command (char *args
, int from_tty
)
1976 { /* STUB_COMM PART_IMPLEMENTED */
1977 /* this should only be called with a numeric argument */
1980 if (target_is_remote ())
1982 if (trace_find_hook
)
1983 trace_find_hook (args
, from_tty
);
1985 if (args
== 0 || *args
== 0)
1986 { /* TFIND with no args means find NEXT trace frame. */
1987 if (traceframe_number
== -1)
1988 frameno
= 0; /* "next" is first one */
1990 frameno
= traceframe_number
+ 1;
1992 else if (0 == strcmp (args
, "-"))
1994 if (traceframe_number
== -1)
1995 error ("not debugging trace buffer");
1996 else if (from_tty
&& traceframe_number
== 0)
1997 error ("already at start of trace buffer");
1999 frameno
= traceframe_number
- 1;
2002 frameno
= parse_and_eval_long (args
);
2005 error ("invalid input (%d is less than zero)", frameno
);
2007 sprintf (target_buf
, "QTFrame:%x", frameno
);
2008 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2011 error ("Trace can only be run on remote targets.");
2016 trace_find_end_command (char *args
, int from_tty
)
2018 trace_find_command ("-1", from_tty
);
2023 trace_find_none_command (char *args
, int from_tty
)
2025 trace_find_command ("-1", from_tty
);
2030 trace_find_start_command (char *args
, int from_tty
)
2032 trace_find_command ("0", from_tty
);
2035 /* tfind pc command */
2037 trace_find_pc_command (char *args
, int from_tty
)
2038 { /* STUB_COMM PART_IMPLEMENTED */
2042 if (target_is_remote ())
2044 if (args
== 0 || *args
== 0)
2045 pc
= read_pc (); /* default is current pc */
2047 pc
= parse_and_eval_address (args
);
2049 sprintf_vma (tmp
, pc
);
2050 sprintf (target_buf
, "QTFrame:pc:%s", tmp
);
2051 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2054 error ("Trace can only be run on remote targets.");
2057 /* tfind tracepoint command */
2059 trace_find_tracepoint_command (char *args
, int from_tty
)
2060 { /* STUB_COMM PART_IMPLEMENTED */
2063 if (target_is_remote ())
2065 if (args
== 0 || *args
== 0)
2067 if (tracepoint_number
== -1)
2068 error ("No current tracepoint -- please supply an argument.");
2070 tdp
= tracepoint_number
; /* default is current TDP */
2073 tdp
= parse_and_eval_long (args
);
2075 sprintf (target_buf
, "QTFrame:tdp:%x", tdp
);
2076 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2079 error ("Trace can only be run on remote targets.");
2082 /* TFIND LINE command:
2084 This command will take a sourceline for argument, just like BREAK
2085 or TRACE (ie. anything that "decode_line_1" can handle).
2087 With no argument, this command will find the next trace frame
2088 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2091 trace_find_line_command (char *args
, int from_tty
)
2092 { /* STUB_COMM PART_IMPLEMENTED */
2093 static CORE_ADDR start_pc
, end_pc
;
2094 struct symtabs_and_lines sals
;
2095 struct symtab_and_line sal
;
2096 struct cleanup
*old_chain
;
2097 char startpc_str
[40], endpc_str
[40];
2099 if (target_is_remote ())
2101 if (args
== 0 || *args
== 0)
2103 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2105 sals
.sals
= (struct symtab_and_line
*)
2106 xmalloc (sizeof (struct symtab_and_line
));
2111 sals
= decode_line_spec (args
, 1);
2115 old_chain
= make_cleanup (xfree
, sals
.sals
);
2116 if (sal
.symtab
== 0)
2118 printf_filtered ("TFIND: No line number information available");
2121 /* This is useful for "info line *0x7f34". If we can't tell the
2122 user about a source line, at least let them have the symbolic
2124 printf_filtered (" for address ");
2126 print_address (sal
.pc
, gdb_stdout
);
2127 printf_filtered (";\n -- will attempt to find by PC. \n");
2131 printf_filtered (".\n");
2132 return; /* no line, no PC; what can we do? */
2135 else if (sal
.line
> 0
2136 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2138 if (start_pc
== end_pc
)
2140 printf_filtered ("Line %d of \"%s\"",
2141 sal
.line
, sal
.symtab
->filename
);
2143 printf_filtered (" is at address ");
2144 print_address (start_pc
, gdb_stdout
);
2146 printf_filtered (" but contains no code.\n");
2147 sal
= find_pc_line (start_pc
, 0);
2149 find_line_pc_range (sal
, &start_pc
, &end_pc
) &&
2151 printf_filtered ("Attempting to find line %d instead.\n",
2154 error ("Cannot find a good line.");
2158 /* Is there any case in which we get here, and have an address
2159 which the user would want to see? If we have debugging symbols
2160 and no line numbers? */
2161 error ("Line number %d is out of range for \"%s\".\n",
2162 sal
.line
, sal
.symtab
->filename
);
2164 sprintf_vma (startpc_str
, start_pc
);
2165 sprintf_vma (endpc_str
, end_pc
- 1);
2166 if (args
&& *args
) /* find within range of stated line */
2167 sprintf (target_buf
, "QTFrame:range:%s:%s", startpc_str
, endpc_str
);
2168 else /* find OUTSIDE OF range of CURRENT line */
2169 sprintf (target_buf
, "QTFrame:outside:%s:%s", startpc_str
, endpc_str
);
2170 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2171 do_cleanups (old_chain
);
2174 error ("Trace can only be run on remote targets.");
2177 /* tfind range command */
2179 trace_find_range_command (char *args
, int from_tty
)
2181 static CORE_ADDR start
, stop
;
2182 char start_str
[40], stop_str
[40];
2185 if (target_is_remote ())
2187 if (args
== 0 || *args
== 0)
2188 { /* XXX FIXME: what should default behavior be? */
2189 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2193 if (0 != (tmp
= strchr (args
, ',')))
2195 *tmp
++ = '\0'; /* terminate start address */
2196 while (isspace ((int) *tmp
))
2198 start
= parse_and_eval_address (args
);
2199 stop
= parse_and_eval_address (tmp
);
2202 { /* no explicit end address? */
2203 start
= parse_and_eval_address (args
);
2204 stop
= start
+ 1; /* ??? */
2207 sprintf_vma (start_str
, start
);
2208 sprintf_vma (stop_str
, stop
);
2209 sprintf (target_buf
, "QTFrame:range:%s:%s", start_str
, stop_str
);
2210 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2213 error ("Trace can only be run on remote targets.");
2216 /* tfind outside command */
2218 trace_find_outside_command (char *args
, int from_tty
)
2220 CORE_ADDR start
, stop
;
2221 char start_str
[40], stop_str
[40];
2224 if (target_is_remote ())
2226 if (args
== 0 || *args
== 0)
2227 { /* XXX FIXME: what should default behavior be? */
2228 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2232 if (0 != (tmp
= strchr (args
, ',')))
2234 *tmp
++ = '\0'; /* terminate start address */
2235 while (isspace ((int) *tmp
))
2237 start
= parse_and_eval_address (args
);
2238 stop
= parse_and_eval_address (tmp
);
2241 { /* no explicit end address? */
2242 start
= parse_and_eval_address (args
);
2243 stop
= start
+ 1; /* ??? */
2246 sprintf_vma (start_str
, start
);
2247 sprintf_vma (stop_str
, stop
);
2248 sprintf (target_buf
, "QTFrame:outside:%s:%s", start_str
, stop_str
);
2249 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2252 error ("Trace can only be run on remote targets.");
2255 /* save-tracepoints command */
2257 tracepoint_save_command (char *args
, int from_tty
)
2259 struct tracepoint
*tp
;
2260 struct action_line
*line
;
2262 char *i1
= " ", *i2
= " ";
2263 char *indent
, *actionline
, *pathname
;
2266 if (args
== 0 || *args
== 0)
2267 error ("Argument required (file name in which to save tracepoints");
2269 if (tracepoint_chain
== 0)
2271 warning ("save-tracepoints: no tracepoints to save.\n");
2275 pathname
= tilde_expand (args
);
2276 if (!(fp
= fopen (pathname
, "w")))
2277 error ("Unable to open file '%s' for saving tracepoints (%s)",
2278 args
, safe_strerror (errno
));
2281 ALL_TRACEPOINTS (tp
)
2283 if (tp
->addr_string
)
2284 fprintf (fp
, "trace %s\n", tp
->addr_string
);
2287 sprintf_vma (tmp
, tp
->address
);
2288 fprintf (fp
, "trace *0x%s\n", tmp
);
2292 fprintf (fp
, " passcount %d\n", tp
->pass_count
);
2296 fprintf (fp
, " actions\n");
2298 for (line
= tp
->actions
; line
; line
= line
->next
)
2300 struct cmd_list_element
*cmd
;
2302 QUIT
; /* allow user to bail out with ^C */
2303 actionline
= line
->action
;
2304 while (isspace ((int) *actionline
))
2307 fprintf (fp
, "%s%s\n", indent
, actionline
);
2308 if (*actionline
!= '#') /* skip for comment lines */
2310 cmd
= lookup_cmd (&actionline
, cmdlist
, "", -1, 1);
2312 error ("Bad action list item: %s", actionline
);
2313 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2315 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2323 printf_filtered ("Tracepoints saved to file '%s'.\n", args
);
2327 /* info scope command: list the locals for a scope. */
2329 scope_info (char *args
, int from_tty
)
2331 struct symtabs_and_lines sals
;
2333 struct minimal_symbol
*msym
;
2334 struct block
*block
;
2335 char **canonical
, *symname
, *save_args
= args
;
2336 int i
, j
, count
= 0;
2338 if (args
== 0 || *args
== 0)
2339 error ("requires an argument (function, line or *addr) to define a scope");
2341 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
);
2342 if (sals
.nelts
== 0)
2343 return; /* presumably decode_line_1 has already warned */
2345 /* Resolve line numbers to PC */
2346 resolve_sal_pc (&sals
.sals
[0]);
2347 block
= block_for_pc (sals
.sals
[0].pc
);
2351 QUIT
; /* allow user to bail out with ^C */
2352 ALL_BLOCK_SYMBOLS (block
, i
, sym
)
2354 QUIT
; /* allow user to bail out with ^C */
2356 printf_filtered ("Scope for %s:\n", save_args
);
2359 symname
= SYMBOL_NAME (sym
);
2360 if (symname
== NULL
|| *symname
== '\0')
2361 continue; /* probably botched, certainly useless */
2363 printf_filtered ("Symbol %s is ", symname
);
2364 switch (SYMBOL_CLASS (sym
))
2367 case LOC_UNDEF
: /* messed up symbol? */
2368 printf_filtered ("a bogus symbol, class %d.\n",
2369 SYMBOL_CLASS (sym
));
2370 count
--; /* don't count this one */
2373 printf_filtered ("a constant with value %ld (0x%lx)",
2374 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2376 case LOC_CONST_BYTES
:
2377 printf_filtered ("constant bytes: ");
2378 if (SYMBOL_TYPE (sym
))
2379 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2380 fprintf_filtered (gdb_stdout
, " %02x",
2381 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2384 printf_filtered ("in static storage at address ");
2385 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
), 1, gdb_stdout
);
2388 printf_filtered ("a local variable in register $%s",
2389 REGISTER_NAME (SYMBOL_VALUE (sym
)));
2393 printf_filtered ("an argument at stack/frame offset %ld",
2394 SYMBOL_VALUE (sym
));
2397 printf_filtered ("a local variable at frame offset %ld",
2398 SYMBOL_VALUE (sym
));
2401 printf_filtered ("a reference argument at offset %ld",
2402 SYMBOL_VALUE (sym
));
2405 printf_filtered ("an argument in register $%s",
2406 REGISTER_NAME (SYMBOL_VALUE (sym
)));
2408 case LOC_REGPARM_ADDR
:
2409 printf_filtered ("the address of an argument, in register $%s",
2410 REGISTER_NAME (SYMBOL_VALUE (sym
)));
2413 printf_filtered ("a typedef.\n");
2416 printf_filtered ("a label at address ");
2417 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
), 1, gdb_stdout
);
2420 printf_filtered ("a function at address ");
2421 print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)), 1,
2425 printf_filtered ("a variable at offset %ld from register $%s",
2427 REGISTER_NAME (SYMBOL_BASEREG (sym
)));
2429 case LOC_BASEREG_ARG
:
2430 printf_filtered ("an argument at offset %ld from register $%s",
2432 REGISTER_NAME (SYMBOL_BASEREG (sym
)));
2434 case LOC_UNRESOLVED
:
2435 msym
= lookup_minimal_symbol (SYMBOL_NAME (sym
), NULL
, NULL
);
2437 printf_filtered ("Unresolved Static");
2440 printf_filtered ("static storage at address ");
2441 print_address_numeric (SYMBOL_VALUE_ADDRESS (msym
), 1,
2445 case LOC_OPTIMIZED_OUT
:
2446 printf_filtered ("optimized out.\n");
2449 if (SYMBOL_TYPE (sym
))
2450 printf_filtered (", length %d.\n",
2451 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2453 if (BLOCK_FUNCTION (block
))
2456 block
= BLOCK_SUPERBLOCK (block
);
2459 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2463 /* worker function (cleanup) */
2465 replace_comma (void *data
)
2473 trace_dump_command (char *args
, int from_tty
)
2475 struct tracepoint
*t
;
2476 struct action_line
*action
;
2477 char *action_exp
, *next_comma
;
2478 struct cleanup
*old_cleanups
;
2479 int stepping_actions
= 0;
2480 int stepping_frame
= 0;
2482 if (!target_is_remote ())
2484 error ("Trace can only be run on remote targets.");
2488 if (tracepoint_number
== -1)
2490 warning ("No current trace frame.");
2495 if (t
->number
== tracepoint_number
)
2499 error ("No known tracepoint matches 'current' tracepoint #%d.",
2502 old_cleanups
= make_cleanup (null_cleanup
, NULL
);
2504 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2505 tracepoint_number
, traceframe_number
);
2507 /* The current frame is a trap frame if the frame PC is equal
2508 to the tracepoint PC. If not, then the current frame was
2509 collected during single-stepping. */
2511 stepping_frame
= (t
->address
!= read_pc ());
2513 for (action
= t
->actions
; action
; action
= action
->next
)
2515 struct cmd_list_element
*cmd
;
2517 QUIT
; /* allow user to bail out with ^C */
2518 action_exp
= action
->action
;
2519 while (isspace ((int) *action_exp
))
2522 /* The collection actions to be done while stepping are
2523 bracketed by the commands "while-stepping" and "end". */
2525 if (*action_exp
== '#') /* comment line */
2528 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2530 error ("Bad action list item: %s", action_exp
);
2532 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2533 stepping_actions
= 1;
2534 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2535 stepping_actions
= 0;
2536 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2538 /* Display the collected data.
2539 For the trap frame, display only what was collected at the trap.
2540 Likewise for stepping frames, display only what was collected
2541 while stepping. This means that the two boolean variables,
2542 STEPPING_FRAME and STEPPING_ACTIONS should be equal. */
2543 if (stepping_frame
== stepping_actions
)
2546 { /* repeat over a comma-separated list */
2547 QUIT
; /* allow user to bail out with ^C */
2548 if (*action_exp
== ',')
2550 while (isspace ((int) *action_exp
))
2553 next_comma
= strchr (action_exp
, ',');
2555 if (0 == strncasecmp (action_exp
, "$reg", 4))
2556 registers_info (NULL
, from_tty
);
2557 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2558 locals_info (NULL
, from_tty
);
2559 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2560 args_info (NULL
, from_tty
);
2565 make_cleanup (replace_comma
, next_comma
);
2568 printf_filtered ("%s = ", action_exp
);
2569 output_command (action_exp
, from_tty
);
2570 printf_filtered ("\n");
2574 action_exp
= next_comma
;
2576 while (action_exp
&& *action_exp
== ',');
2580 discard_cleanups (old_cleanups
);
2583 /* Convert the memory pointed to by mem into hex, placing result in buf.
2584 * Return a pointer to the last char put in buf (null)
2585 * "stolen" from sparc-stub.c
2588 static const char hexchars
[] = "0123456789abcdef";
2590 static unsigned char *
2591 mem2hex (unsigned char *mem
, unsigned char *buf
, int count
)
2599 *buf
++ = hexchars
[ch
>> 4];
2600 *buf
++ = hexchars
[ch
& 0xf];
2609 get_traceframe_number (void)
2611 return traceframe_number
;
2615 /* module initialization */
2617 _initialize_tracepoint (void)
2619 struct cmd_list_element
*c
;
2621 tracepoint_chain
= 0;
2622 tracepoint_count
= 0;
2623 traceframe_number
= -1;
2624 tracepoint_number
= -1;
2626 set_internalvar (lookup_internalvar ("tpnum"),
2627 value_from_longest (builtin_type_int
, (LONGEST
) 0));
2628 set_internalvar (lookup_internalvar ("trace_frame"),
2629 value_from_longest (builtin_type_int
, (LONGEST
) - 1));
2631 if (tracepoint_list
.list
== NULL
)
2633 tracepoint_list
.listsize
= 128;
2634 tracepoint_list
.list
= xmalloc
2635 (tracepoint_list
.listsize
* sizeof (struct memrange
));
2637 if (tracepoint_list
.aexpr_list
== NULL
)
2639 tracepoint_list
.aexpr_listsize
= 128;
2640 tracepoint_list
.aexpr_list
= xmalloc
2641 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
2644 if (stepping_list
.list
== NULL
)
2646 stepping_list
.listsize
= 128;
2647 stepping_list
.list
= xmalloc
2648 (stepping_list
.listsize
* sizeof (struct memrange
));
2651 if (stepping_list
.aexpr_list
== NULL
)
2653 stepping_list
.aexpr_listsize
= 128;
2654 stepping_list
.aexpr_list
= xmalloc
2655 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
2658 add_info ("scope", scope_info
,
2659 "List the variables local to a scope");
2661 add_cmd ("tracepoints", class_trace
, NULL
,
2662 "Tracing of program execution without stopping the program.",
2665 add_info ("tracepoints", tracepoints_info
,
2666 "Status of tracepoints, or tracepoint number NUMBER.\n\
2667 Convenience variable \"$tpnum\" contains the number of the\n\
2668 last tracepoint set.");
2670 add_info_alias ("tp", "tracepoints", 1);
2672 c
= add_com ("save-tracepoints", class_trace
, tracepoint_save_command
,
2673 "Save current tracepoint definitions as a script.\n\
2674 Use the 'source' command in another debug session to restore them.");
2675 set_cmd_completer (c
, filename_completer
);
2677 add_com ("tdump", class_trace
, trace_dump_command
,
2678 "Print everything collected at the current tracepoint.");
2680 add_prefix_cmd ("tfind", class_trace
, trace_find_command
,
2681 "Select a trace frame;\n\
2682 No argument means forward by one frame; '-' meand backward by one frame.",
2683 &tfindlist
, "tfind ", 1, &cmdlist
);
2685 add_cmd ("outside", class_trace
, trace_find_outside_command
,
2686 "Select a trace frame whose PC is outside the given \
2687 range.\nUsage: tfind outside addr1, addr2",
2690 add_cmd ("range", class_trace
, trace_find_range_command
,
2691 "Select a trace frame whose PC is in the given range.\n\
2692 Usage: tfind range addr1,addr2",
2695 add_cmd ("line", class_trace
, trace_find_line_command
,
2696 "Select a trace frame by source line.\n\
2697 Argument can be a line number (with optional source file), \n\
2698 a function name, or '*' followed by an address.\n\
2699 Default argument is 'the next source line that was traced'.",
2702 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
,
2703 "Select a trace frame by tracepoint number.\n\
2704 Default is the tracepoint for the current trace frame.",
2707 add_cmd ("pc", class_trace
, trace_find_pc_command
,
2708 "Select a trace frame by PC.\n\
2709 Default is the current PC, or the PC of the current trace frame.",
2712 add_cmd ("end", class_trace
, trace_find_end_command
,
2713 "Synonym for 'none'.\n\
2714 De-select any trace frame and resume 'live' debugging.",
2717 add_cmd ("none", class_trace
, trace_find_none_command
,
2718 "De-select any trace frame and resume 'live' debugging.",
2721 add_cmd ("start", class_trace
, trace_find_start_command
,
2722 "Select the first trace frame in the trace buffer.",
2725 add_com ("tstatus", class_trace
, trace_status_command
,
2726 "Display the status of the current trace data collection.");
2728 add_com ("tstop", class_trace
, trace_stop_command
,
2729 "Stop trace data collection.");
2731 add_com ("tstart", class_trace
, trace_start_command
,
2732 "Start trace data collection.");
2734 add_com ("passcount", class_trace
, trace_pass_command
,
2735 "Set the passcount for a tracepoint.\n\
2736 The trace will end when the tracepoint has been passed 'count' times.\n\
2737 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
2738 if TPNUM is omitted, passcount refers to the last tracepoint defined.");
2740 add_com ("end", class_trace
, end_actions_pseudocommand
,
2741 "Ends a list of commands or actions.\n\
2742 Several GDB commands allow you to enter a list of commands or actions.\n\
2743 Entering \"end\" on a line by itself is the normal way to terminate\n\
2745 Note: the \"end\" command cannot be used at the gdb prompt.");
2747 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
,
2748 "Specify single-stepping behavior at a tracepoint.\n\
2749 Argument is number of instructions to trace in single-step mode\n\
2750 following the tracepoint. This command is normally followed by\n\
2751 one or more \"collect\" commands, to specify what to collect\n\
2752 while single-stepping.\n\n\
2753 Note: this command can only be used in a tracepoint \"actions\" list.");
2755 add_com_alias ("ws", "while-stepping", class_alias
, 0);
2756 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
2758 add_com ("collect", class_trace
, collect_pseudocommand
,
2759 "Specify one or more data items to be collected at a tracepoint.\n\
2760 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
2761 collect all data (variables, registers) referenced by that expression.\n\
2762 Also accepts the following special arguments:\n\
2763 $regs -- all registers.\n\
2764 $args -- all function arguments.\n\
2765 $locals -- all variables local to the block/function scope.\n\
2766 Note: this command can only be used in a tracepoint \"actions\" list.");
2768 add_com ("actions", class_trace
, trace_actions_command
,
2769 "Specify the actions to be taken at a tracepoint.\n\
2770 Tracepoint actions may include collecting of specified data, \n\
2771 single-stepping, or enabling/disabling other tracepoints, \n\
2772 depending on target's capabilities.");
2774 add_cmd ("tracepoints", class_trace
, delete_trace_command
,
2775 "Delete specified tracepoints.\n\
2776 Arguments are tracepoint numbers, separated by spaces.\n\
2777 No argument means delete all tracepoints.",
2780 add_cmd ("tracepoints", class_trace
, disable_trace_command
,
2781 "Disable specified tracepoints.\n\
2782 Arguments are tracepoint numbers, separated by spaces.\n\
2783 No argument means disable all tracepoints.",
2786 add_cmd ("tracepoints", class_trace
, enable_trace_command
,
2787 "Enable specified tracepoints.\n\
2788 Arguments are tracepoint numbers, separated by spaces.\n\
2789 No argument means enable all tracepoints.",
2792 c
= add_com ("trace", class_trace
, trace_command
,
2793 "Set a tracepoint at a specified line or function or address.\n\
2794 Argument may be a line number, function name, or '*' plus an address.\n\
2795 For a line number or function, trace at the start of its code.\n\
2796 If an address is specified, trace at that exact address.\n\n\
2797 Do \"help tracepoints\" for info on other tracepoint commands.");
2798 set_cmd_completer (c
, location_completer
);
2800 add_com_alias ("tp", "trace", class_alias
, 0);
2801 add_com_alias ("tr", "trace", class_alias
, 1);
2802 add_com_alias ("tra", "trace", class_alias
, 1);
2803 add_com_alias ("trac", "trace", class_alias
, 1);