1 /* Tracing functionality for remote targets in custom GDB protocol
2 Copyright 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
25 #include "expression.h"
30 #include "gdb_string.h"
32 #include "tracepoint.h"
40 /* readline include files */
41 #include <readline/readline.h>
42 #include <readline/history.h>
44 /* readline defines this. */
51 /* maximum length of an agent aexpression.
52 this accounts for the fact that packets are limited to 400 bytes
53 (which includes everything -- including the checksum), and assumes
54 the worst case of maximum length for each of the pieces of a
57 NOTE: expressions get mem2hex'ed otherwise this would be twice as
58 large. (400 - 31)/2 == 184 */
59 #define MAX_AGENT_EXPR_LEN 184
62 extern int info_verbose
;
63 extern void (*readline_begin_hook
) (char *, ...);
64 extern char *(*readline_hook
) (char *);
65 extern void (*readline_end_hook
) (void);
66 extern void x_command (char *, int);
67 extern int addressprint
; /* Print machine addresses? */
69 /* GDB commands implemented in other modules:
72 extern void output_command (char *, int);
73 extern void registers_info (char *, int);
74 extern void args_info (char *, int);
75 extern void locals_info (char *, int);
78 /* If this definition isn't overridden by the header files, assume
79 that isatty and fileno exist on this system. */
81 #define ISATTY(FP) (isatty (fileno (FP)))
87 This module defines the following debugger commands:
88 trace : set a tracepoint on a function, line, or address.
89 info trace : list all debugger-defined tracepoints.
90 delete trace : delete one or more tracepoints.
91 enable trace : enable one or more tracepoints.
92 disable trace : disable one or more tracepoints.
93 actions : specify actions to be taken at a tracepoint.
94 passcount : specify a pass count for a tracepoint.
95 tstart : start a trace experiment.
96 tstop : stop a trace experiment.
97 tstatus : query the status of a trace experiment.
98 tfind : find a trace frame in the trace buffer.
99 tdump : print everything collected at the current tracepoint.
100 save-tracepoints : write tracepoint setup into a file.
102 This module defines the following user-visible debugger variables:
103 $trace_frame : sequence number of trace frame currently being debugged.
104 $trace_line : source line of trace frame currently being debugged.
105 $trace_file : source file of trace frame currently being debugged.
106 $tracepoint : tracepoint number of trace frame currently being debugged.
110 /* ======= Important global variables: ======= */
112 /* Chain of all tracepoints defined. */
113 struct tracepoint
*tracepoint_chain
;
115 /* Number of last tracepoint made. */
116 static int tracepoint_count
;
118 /* Number of last traceframe collected. */
119 static int traceframe_number
;
121 /* Tracepoint for last traceframe collected. */
122 static int tracepoint_number
;
124 /* Symbol for function for last traceframe collected */
125 static struct symbol
*traceframe_fun
;
127 /* Symtab and line for last traceframe collected */
128 static struct symtab_and_line traceframe_sal
;
130 /* Tracing command lists */
131 static struct cmd_list_element
*tfindlist
;
133 /* ======= Important command functions: ======= */
134 static void trace_command (char *, int);
135 static void tracepoints_info (char *, int);
136 static void delete_trace_command (char *, int);
137 static void enable_trace_command (char *, int);
138 static void disable_trace_command (char *, int);
139 static void trace_pass_command (char *, int);
140 static void trace_actions_command (char *, int);
141 static void trace_start_command (char *, int);
142 static void trace_stop_command (char *, int);
143 static void trace_status_command (char *, int);
144 static void trace_find_command (char *, int);
145 static void trace_find_pc_command (char *, int);
146 static void trace_find_tracepoint_command (char *, int);
147 static void trace_find_line_command (char *, int);
148 static void trace_find_range_command (char *, int);
149 static void trace_find_outside_command (char *, int);
150 static void tracepoint_save_command (char *, int);
151 static void trace_dump_command (char *, int);
153 /* support routines */
154 static void trace_mention (struct tracepoint
*);
156 struct collection_list
;
157 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
158 static unsigned char *mem2hex (unsigned char *, unsigned char *, int);
159 static void add_register (struct collection_list
*collection
,
161 static struct cleanup
*make_cleanup_free_actions (struct tracepoint
*t
);
162 static void free_actions_list (char **actions_list
);
163 static void free_actions_list_cleanup_wrapper (void *);
165 extern void _initialize_tracepoint (void);
167 /* Utility: returns true if "target remote" */
169 target_is_remote (void)
171 if (current_target
.to_shortname
&&
172 strcmp (current_target
.to_shortname
, "remote") == 0)
178 /* Utility: generate error from an incoming stub packet. */
180 trace_error (char *buf
)
183 return; /* not an error msg */
186 case '1': /* malformed packet error */
187 if (*++buf
== '0') /* general case: */
188 error ("tracepoint.c: error in outgoing packet.");
190 error ("tracepoint.c: error in outgoing packet at field #%d.",
191 strtol (buf
, NULL
, 16));
193 error ("trace API error 0x%s.", ++buf
);
195 error ("Target returns error code '%s'.", buf
);
199 /* Utility: wait for reply from stub, while accepting "O" packets */
201 remote_get_noisy_reply (char *buf
,
204 do /* loop on reply from remote stub */
206 QUIT
; /* allow user to bail out with ^C */
207 getpkt (buf
, sizeof_buf
, 0);
209 error ("Target does not support this command.");
210 else if (buf
[0] == 'E')
212 else if (buf
[0] == 'O' &&
214 remote_console_output (buf
+ 1); /* 'O' message from stub */
216 return buf
; /* here's the actual reply */
221 /* Set tracepoint count to NUM. */
223 set_tracepoint_count (int num
)
225 tracepoint_count
= num
;
226 set_internalvar (lookup_internalvar ("tpnum"),
227 value_from_longest (builtin_type_int
, (LONGEST
) num
));
230 /* Set traceframe number to NUM. */
232 set_traceframe_num (int num
)
234 traceframe_number
= num
;
235 set_internalvar (lookup_internalvar ("trace_frame"),
236 value_from_longest (builtin_type_int
, (LONGEST
) num
));
239 /* Set tracepoint number to NUM. */
241 set_tracepoint_num (int num
)
243 tracepoint_number
= num
;
244 set_internalvar (lookup_internalvar ("tracepoint"),
245 value_from_longest (builtin_type_int
, (LONGEST
) num
));
248 /* Set externally visible debug variables for querying/printing
249 the traceframe context (line, function, file) */
252 set_traceframe_context (CORE_ADDR trace_pc
)
254 static struct type
*func_string
, *file_string
;
255 static struct type
*func_range
, *file_range
;
256 static value_ptr func_val
, file_val
;
257 static struct type
*charstar
;
260 if (charstar
== (struct type
*) NULL
)
261 charstar
= lookup_pointer_type (builtin_type_char
);
263 if (trace_pc
== -1) /* cease debugging any trace buffers */
266 traceframe_sal
.pc
= traceframe_sal
.line
= 0;
267 traceframe_sal
.symtab
= NULL
;
268 set_internalvar (lookup_internalvar ("trace_func"),
269 value_from_pointer (charstar
, (LONGEST
) 0));
270 set_internalvar (lookup_internalvar ("trace_file"),
271 value_from_pointer (charstar
, (LONGEST
) 0));
272 set_internalvar (lookup_internalvar ("trace_line"),
273 value_from_pointer (builtin_type_int
, (LONGEST
) - 1));
277 /* save as globals for internal use */
278 traceframe_sal
= find_pc_line (trace_pc
, 0);
279 traceframe_fun
= find_pc_function (trace_pc
);
281 /* save linenumber as "$trace_line", a debugger variable visible to users */
282 set_internalvar (lookup_internalvar ("trace_line"),
283 value_from_longest (builtin_type_int
,
284 (LONGEST
) traceframe_sal
.line
));
286 /* save func name as "$trace_func", a debugger variable visible to users */
287 if (traceframe_fun
== NULL
||
288 SYMBOL_NAME (traceframe_fun
) == NULL
)
289 set_internalvar (lookup_internalvar ("trace_func"),
290 value_from_pointer (charstar
, (LONGEST
) 0));
293 len
= strlen (SYMBOL_NAME (traceframe_fun
));
294 func_range
= create_range_type (func_range
,
295 builtin_type_int
, 0, len
- 1);
296 func_string
= create_array_type (func_string
,
297 builtin_type_char
, func_range
);
298 func_val
= allocate_value (func_string
);
299 VALUE_TYPE (func_val
) = func_string
;
300 memcpy (VALUE_CONTENTS_RAW (func_val
),
301 SYMBOL_NAME (traceframe_fun
),
303 func_val
->modifiable
= 0;
304 set_internalvar (lookup_internalvar ("trace_func"), func_val
);
307 /* save file name as "$trace_file", a debugger variable visible to users */
308 if (traceframe_sal
.symtab
== NULL
||
309 traceframe_sal
.symtab
->filename
== NULL
)
310 set_internalvar (lookup_internalvar ("trace_file"),
311 value_from_pointer (charstar
, (LONGEST
) 0));
314 len
= strlen (traceframe_sal
.symtab
->filename
);
315 file_range
= create_range_type (file_range
,
316 builtin_type_int
, 0, len
- 1);
317 file_string
= create_array_type (file_string
,
318 builtin_type_char
, file_range
);
319 file_val
= allocate_value (file_string
);
320 VALUE_TYPE (file_val
) = file_string
;
321 memcpy (VALUE_CONTENTS_RAW (file_val
),
322 traceframe_sal
.symtab
->filename
,
324 file_val
->modifiable
= 0;
325 set_internalvar (lookup_internalvar ("trace_file"), file_val
);
329 /* Low level routine to set a tracepoint.
330 Returns the tracepoint object so caller can set other things.
331 Does not set the tracepoint number!
332 Does not print anything.
334 ==> This routine should not be called if there is a chance of later
335 error(); otherwise it leaves a bogus tracepoint on the chain. Validate
336 your arguments BEFORE calling this routine! */
338 static struct tracepoint
*
339 set_raw_tracepoint (struct symtab_and_line sal
)
341 register struct tracepoint
*t
, *tc
;
342 struct cleanup
*old_chain
;
344 t
= (struct tracepoint
*) xmalloc (sizeof (struct tracepoint
));
345 old_chain
= make_cleanup (xfree
, t
);
346 memset (t
, 0, sizeof (*t
));
348 if (sal
.symtab
== NULL
)
349 t
->source_file
= NULL
;
351 t
->source_file
= savestring (sal
.symtab
->filename
,
352 strlen (sal
.symtab
->filename
));
354 t
->section
= sal
.section
;
355 t
->language
= current_language
->la_language
;
356 t
->input_radix
= input_radix
;
357 t
->line_number
= sal
.line
;
358 t
->enabled
= enabled
;
362 t
->addr_string
= NULL
;
364 /* Add this tracepoint to the end of the chain
365 so that a list of tracepoints will come out in order
366 of increasing numbers. */
368 tc
= tracepoint_chain
;
370 tracepoint_chain
= t
;
377 discard_cleanups (old_chain
);
381 /* Set a tracepoint according to ARG (function, linenum or *address) */
383 trace_command (char *arg
, int from_tty
)
385 char **canonical
= (char **) NULL
;
386 struct symtabs_and_lines sals
;
387 struct symtab_and_line sal
;
388 struct tracepoint
*t
;
389 char *addr_start
= 0, *addr_end
= 0;
393 error ("trace command requires an argument");
395 if (from_tty
&& info_verbose
)
396 printf_filtered ("TRACE %s\n", arg
);
399 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
, 0, &canonical
);
402 return; /* ??? Presumably decode_line_1 has already warned? */
404 /* Resolve all line numbers to PC's */
405 for (i
= 0; i
< sals
.nelts
; i
++)
406 resolve_sal_pc (&sals
.sals
[i
]);
408 /* Now set all the tracepoints. */
409 for (i
= 0; i
< sals
.nelts
; i
++)
413 t
= set_raw_tracepoint (sal
);
414 set_tracepoint_count (tracepoint_count
+ 1);
415 t
->number
= tracepoint_count
;
417 /* If a canonical line spec is needed use that instead of the
419 if (canonical
!= (char **) NULL
&& canonical
[i
] != NULL
)
420 t
->addr_string
= canonical
[i
];
422 t
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
426 /* Let the UI know of any additions */
427 if (create_tracepoint_hook
)
428 create_tracepoint_hook (t
);
433 printf_filtered ("Multiple tracepoints were set.\n");
434 printf_filtered ("Use 'delete trace' to delete unwanted tracepoints.\n");
438 /* Tell the user we have just set a tracepoint TP. */
441 trace_mention (struct tracepoint
*tp
)
443 printf_filtered ("Tracepoint %d", tp
->number
);
445 if (addressprint
|| (tp
->source_file
== NULL
))
447 printf_filtered (" at ");
448 print_address_numeric (tp
->address
, 1, gdb_stdout
);
451 printf_filtered (": file %s, line %d.",
452 tp
->source_file
, tp
->line_number
);
454 printf_filtered ("\n");
457 /* Print information on tracepoint number TPNUM_EXP, or all if omitted. */
460 tracepoints_info (char *tpnum_exp
, int from_tty
)
462 struct tracepoint
*t
;
463 struct action_line
*action
;
464 int found_a_tracepoint
= 0;
465 char wrap_indent
[80];
470 tpnum
= parse_and_eval_long (tpnum_exp
);
473 if (tpnum
== -1 || tpnum
== t
->number
)
475 extern int addressprint
; /* print machine addresses? */
477 if (!found_a_tracepoint
++)
479 printf_filtered ("Num Enb ");
482 if (TARGET_ADDR_BIT
<= 32)
483 printf_filtered ("Address ");
485 printf_filtered ("Address ");
487 printf_filtered ("PassC StepC What\n");
489 strcpy (wrap_indent
, " ");
492 if (TARGET_ADDR_BIT
<= 32)
493 strcat (wrap_indent
, " ");
495 strcat (wrap_indent
, " ");
498 printf_filtered ("%-3d %-3s ", t
->number
,
499 t
->enabled
== enabled
? "y" : "n");
504 if (TARGET_ADDR_BIT
<= 32)
505 tmp
= longest_local_hex_string_custom (t
->address
506 & (CORE_ADDR
) 0xffffffff,
509 tmp
= longest_local_hex_string_custom (t
->address
, "016l");
511 printf_filtered ("%s ", tmp
);
513 printf_filtered ("%-5d %-5ld ", t
->pass_count
, t
->step_count
);
517 sym
= find_pc_sect_function (t
->address
, t
->section
);
520 fputs_filtered ("in ", gdb_stdout
);
521 fputs_filtered (SYMBOL_SOURCE_NAME (sym
), gdb_stdout
);
522 wrap_here (wrap_indent
);
523 fputs_filtered (" at ", gdb_stdout
);
525 fputs_filtered (t
->source_file
, gdb_stdout
);
526 printf_filtered (":%d", t
->line_number
);
529 print_address_symbolic (t
->address
, gdb_stdout
, demangle
, " ");
531 printf_filtered ("\n");
534 printf_filtered (" Actions for tracepoint %d: \n", t
->number
);
535 for (action
= t
->actions
; action
; action
= action
->next
)
537 printf_filtered ("\t%s\n", action
->action
);
541 if (!found_a_tracepoint
)
544 printf_filtered ("No tracepoints.\n");
546 printf_filtered ("No tracepoint number %d.\n", tpnum
);
550 /* Optimization: the code to parse an enable, disable, or delete TP command
551 is virtually identical except for whether it performs an enable, disable,
552 or delete. Therefore I've combined them into one function with an opcode.
554 enum tracepoint_opcode
561 /* This function implements enable, disable and delete commands. */
563 tracepoint_operation (struct tracepoint
*t
, int from_tty
,
564 enum tracepoint_opcode opcode
)
566 struct tracepoint
*t2
;
568 if (t
== NULL
) /* no tracepoint operand */
574 t
->enabled
= enabled
;
575 if (modify_tracepoint_hook
)
576 modify_tracepoint_hook (t
);
579 t
->enabled
= disabled
;
580 if (modify_tracepoint_hook
)
581 modify_tracepoint_hook (t
);
584 if (tracepoint_chain
== t
)
585 tracepoint_chain
= t
->next
;
594 /* Let the UI know of any deletions */
595 if (delete_tracepoint_hook
)
596 delete_tracepoint_hook (t
);
599 xfree (t
->addr_string
);
601 xfree (t
->source_file
);
610 /* Utility: parse a tracepoint number and look it up in the list.
611 If MULTI_P is true, there might be a range of tracepoints in ARG.
612 if OPTIONAL_P is true, then if the argument is missing, the most
613 recent tracepoint (tracepoint_count) is returned. */
615 get_tracepoint_by_number (char **arg
, int multi_p
, int optional_p
)
617 struct tracepoint
*t
;
619 char *instring
= arg
== NULL
? NULL
: *arg
;
621 if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
624 tpnum
= tracepoint_count
;
626 error_no_arg ("tracepoint number");
629 tpnum
= multi_p
? get_number_or_range (arg
) : get_number (arg
);
633 if (instring
&& *instring
)
634 printf_filtered ("bad tracepoint number at or near '%s'\n", instring
);
636 printf_filtered ("Tracepoint argument missing and no previous tracepoint\n");
641 if (t
->number
== tpnum
)
646 /* FIXME: if we are in the middle of a range we don't want to give
647 a message. The current interface to get_number_or_range doesn't
648 allow us to discover this. */
649 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
653 /* Utility: parse a list of tracepoint numbers, and call a func for each. */
655 map_args_over_tracepoints (char *args
, int from_tty
,
656 enum tracepoint_opcode opcode
)
658 struct tracepoint
*t
, *tmp
;
660 if (args
== 0 || *args
== 0) /* do them all */
661 ALL_TRACEPOINTS_SAFE (t
, tmp
)
662 tracepoint_operation (t
, from_tty
, opcode
);
666 QUIT
; /* give user option to bail out with ^C */
667 t
= get_tracepoint_by_number (&args
, 1, 0);
668 tracepoint_operation (t
, from_tty
, opcode
);
669 while (*args
== ' ' || *args
== '\t')
674 /* The 'enable trace' command enables tracepoints. Not supported by all targets. */
676 enable_trace_command (char *args
, int from_tty
)
679 map_args_over_tracepoints (args
, from_tty
, enable_op
);
682 /* The 'disable trace' command enables tracepoints. Not supported by all targets. */
684 disable_trace_command (char *args
, int from_tty
)
687 map_args_over_tracepoints (args
, from_tty
, disable_op
);
690 /* Remove a tracepoint (or all if no argument) */
692 delete_trace_command (char *args
, int from_tty
)
695 if (!args
|| !*args
) /* No args implies all tracepoints; */
696 if (from_tty
) /* confirm only if from_tty... */
697 if (tracepoint_chain
) /* and if there are tracepoints to delete! */
698 if (!query ("Delete all tracepoints? "))
701 map_args_over_tracepoints (args
, from_tty
, delete_op
);
704 /* Set passcount for tracepoint.
706 First command argument is passcount, second is tracepoint number.
707 If tracepoint number omitted, apply to most recently defined.
708 Also accepts special argument "all". */
711 trace_pass_command (char *args
, int from_tty
)
713 struct tracepoint
*t1
= (struct tracepoint
*) -1, *t2
;
717 if (args
== 0 || *args
== 0)
718 error ("passcount command requires an argument (count + optional TP num)");
720 count
= strtoul (args
, &args
, 10); /* count comes first, then TP num */
722 while (*args
&& isspace ((int) *args
))
725 if (*args
&& strncasecmp (args
, "all", 3) == 0)
727 args
+= 3; /* skip special argument "all" */
730 error ("Junk at end of arguments.");
733 t1
= get_tracepoint_by_number (&args
, 1, 1);
740 if (t1
== (struct tracepoint
*) -1 || t1
== t2
)
742 t2
->pass_count
= count
;
743 if (modify_tracepoint_hook
)
744 modify_tracepoint_hook (t2
);
746 printf_filtered ("Setting tracepoint %d's passcount to %d\n",
750 t1
= get_tracepoint_by_number (&args
, 1, 0);
756 /* ACTIONS functions: */
758 /* Prototypes for action-parsing utility commands */
759 static void read_actions (struct tracepoint
*);
761 /* The three functions:
762 collect_pseudocommand,
763 while_stepping_pseudocommand, and
764 end_actions_pseudocommand
765 are placeholders for "commands" that are actually ONLY to be used
766 within a tracepoint action list. If the actual function is ever called,
767 it means that somebody issued the "command" at the top level,
768 which is always an error. */
771 end_actions_pseudocommand (char *args
, int from_tty
)
773 error ("This command cannot be used at the top level.");
777 while_stepping_pseudocommand (char *args
, int from_tty
)
779 error ("This command can only be used in a tracepoint actions list.");
783 collect_pseudocommand (char *args
, int from_tty
)
785 error ("This command can only be used in a tracepoint actions list.");
788 /* Enter a list of actions for a tracepoint. */
790 trace_actions_command (char *args
, int from_tty
)
792 struct tracepoint
*t
;
794 char *end_msg
= "End with a line saying just \"end\".";
796 t
= get_tracepoint_by_number (&args
, 0, 1);
799 sprintf (tmpbuf
, "Enter actions for tracepoint %d, one per line.",
804 if (readline_begin_hook
)
805 (*readline_begin_hook
) ("%s %s\n", tmpbuf
, end_msg
);
806 else if (input_from_terminal_p ())
807 printf_filtered ("%s\n%s\n", tmpbuf
, end_msg
);
811 t
->step_count
= 0; /* read_actions may set this */
814 if (readline_end_hook
)
815 (*readline_end_hook
) ();
816 /* tracepoints_changed () */
818 /* else just return */
821 /* worker function */
823 read_actions (struct tracepoint
*t
)
826 char *prompt1
= "> ", *prompt2
= " > ";
827 char *prompt
= prompt1
;
828 enum actionline_type linetype
;
829 extern FILE *instream
;
830 struct action_line
*next
= NULL
, *temp
;
831 struct cleanup
*old_chain
;
833 /* Control-C quits instantly if typed while in this loop
834 since it should not wait until the user types a newline. */
840 signal (STOP_SIGNAL
, handle_stop_sig
);
842 signal (STOP_SIGNAL
, stop_sig
);
845 old_chain
= make_cleanup_free_actions (t
);
848 /* Make sure that all output has been output. Some machines may let
849 you get away with leaving out some of the gdb_flush, but not all. */
851 gdb_flush (gdb_stdout
);
852 gdb_flush (gdb_stderr
);
854 if (readline_hook
&& instream
== NULL
)
855 line
= (*readline_hook
) (prompt
);
856 else if (instream
== stdin
&& ISATTY (instream
))
858 line
= readline (prompt
);
859 if (line
&& *line
) /* add it to command history */
863 line
= gdb_readline (0);
865 linetype
= validate_actionline (&line
, t
);
866 if (linetype
== BADLINE
)
867 continue; /* already warned -- collect another line */
869 temp
= xmalloc (sizeof (struct action_line
));
873 if (next
== NULL
) /* first action for this tracepoint? */
874 t
->actions
= next
= temp
;
881 if (linetype
== STEPPING
) /* begin "while-stepping" */
883 if (prompt
== prompt2
)
885 warning ("Already processing 'while-stepping'");
889 prompt
= prompt2
; /* change prompt for stepping actions */
891 else if (linetype
== END
)
893 if (prompt
== prompt2
)
895 prompt
= prompt1
; /* end of single-stepping actions */
898 { /* end of actions */
899 if (t
->actions
->next
== NULL
)
901 /* an "end" all by itself with no other actions means
902 this tracepoint has no actions. Discard empty list. */
911 signal (STOP_SIGNAL
, SIG_DFL
);
914 discard_cleanups (old_chain
);
917 /* worker function */
919 validate_actionline (char **line
, struct tracepoint
*t
)
921 struct cmd_list_element
*c
;
922 struct expression
*exp
= NULL
;
923 struct cleanup
*old_chain
= NULL
;
926 for (p
= *line
; isspace ((int) *p
);)
929 /* symbol lookup etc. */
930 if (*p
== '\0') /* empty line: just prompt for another line. */
933 if (*p
== '#') /* comment line */
936 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
939 warning ("'%s' is not an action that I know, or is ambiguous.", p
);
943 if (c
->function
.cfunc
== collect_pseudocommand
)
945 struct agent_expr
*aexpr
;
946 struct agent_reqs areqs
;
949 { /* repeat over a comma-separated list */
950 QUIT
; /* allow user to bail out with ^C */
951 while (isspace ((int) *p
))
954 if (*p
== '$') /* look for special pseudo-symbols */
956 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
957 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
958 (0 == strncasecmp ("loc", p
+ 1, 3)))
963 /* else fall thru, treat p as an expression and parse it! */
965 exp
= parse_exp_1 (&p
, block_for_pc (t
->address
), 1);
966 old_chain
= make_cleanup (free_current_contents
, &exp
);
968 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
970 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
972 warning ("constant %s (value %ld) will not be collected.",
973 SYMBOL_NAME (exp
->elts
[2].symbol
),
974 SYMBOL_VALUE (exp
->elts
[2].symbol
));
977 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
979 warning ("%s is optimized away and cannot be collected.",
980 SYMBOL_NAME (exp
->elts
[2].symbol
));
985 /* we have something to collect, make sure that the expr to
986 bytecode translator can handle it and that it's not too long */
987 aexpr
= gen_trace_for_expr (t
->address
, exp
);
988 make_cleanup_free_agent_expr (aexpr
);
990 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
991 error ("expression too complicated, try simplifying");
993 ax_reqs (aexpr
, &areqs
);
994 (void) make_cleanup (xfree
, areqs
.reg_mask
);
996 if (areqs
.flaw
!= agent_flaw_none
)
997 error ("malformed expression");
999 if (areqs
.min_height
< 0)
1000 error ("gdb: Internal error: expression has min height < 0");
1002 if (areqs
.max_height
> 20)
1003 error ("expression too complicated, try simplifying");
1005 do_cleanups (old_chain
);
1007 while (p
&& *p
++ == ',');
1010 else if (c
->function
.cfunc
== while_stepping_pseudocommand
)
1012 char *steparg
; /* in case warning is necessary */
1014 while (isspace ((int) *p
))
1019 (t
->step_count
= strtol (p
, &p
, 0)) == 0)
1021 warning ("'%s': bad step-count; command ignored.", *line
);
1026 else if (c
->function
.cfunc
== end_actions_pseudocommand
)
1030 warning ("'%s' is not a supported tracepoint action.", *line
);
1035 /* worker function */
1037 free_actions (struct tracepoint
*t
)
1039 struct action_line
*line
, *next
;
1041 for (line
= t
->actions
; line
; line
= next
)
1045 xfree (line
->action
);
1052 do_free_actions_cleanup (void *t
)
1057 static struct cleanup
*
1058 make_cleanup_free_actions (struct tracepoint
*t
)
1060 return make_cleanup (do_free_actions_cleanup
, t
);
1065 int type
; /* 0 for absolute memory range, else basereg number */
1066 bfd_signed_vma start
;
1070 struct collection_list
1072 unsigned char regs_mask
[8]; /* room for up to 256 regs */
1075 struct memrange
*list
;
1076 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
1077 long next_aexpr_elt
;
1078 struct agent_expr
**aexpr_list
;
1081 tracepoint_list
, stepping_list
;
1083 /* MEMRANGE functions: */
1085 static int memrange_cmp (const void *, const void *);
1087 /* compare memranges for qsort */
1089 memrange_cmp (const void *va
, const void *vb
)
1091 const struct memrange
*a
= va
, *b
= vb
;
1093 if (a
->type
< b
->type
)
1095 if (a
->type
> b
->type
)
1099 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
1101 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
1106 if (a
->start
< b
->start
)
1108 if (a
->start
> b
->start
)
1114 /* Sort the memrange list using qsort, and merge adjacent memranges */
1116 memrange_sortmerge (struct collection_list
*memranges
)
1120 qsort (memranges
->list
, memranges
->next_memrange
,
1121 sizeof (struct memrange
), memrange_cmp
);
1122 if (memranges
->next_memrange
> 0)
1124 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
1126 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
1127 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
1128 MAX_REGISTER_VIRTUAL_SIZE
)
1130 /* memrange b starts before memrange a ends; merge them. */
1131 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
1132 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
1133 continue; /* next b, same a */
1137 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
1138 sizeof (struct memrange
));
1140 memranges
->next_memrange
= a
+ 1;
1144 /* Add a register to a collection list */
1146 add_register (struct collection_list
*collection
, unsigned int regno
)
1149 printf_filtered ("collect register %d\n", regno
);
1150 if (regno
> (8 * sizeof (collection
->regs_mask
)))
1151 error ("Internal: register number %d too large for tracepoint",
1153 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
1156 /* Add a memrange to a collection list */
1158 add_memrange (struct collection_list
*memranges
, int type
, bfd_signed_vma base
,
1163 printf_filtered ("(%d,", type
);
1165 printf_filtered (",%ld)\n", len
);
1168 /* type: 0 == memory, n == basereg */
1169 memranges
->list
[memranges
->next_memrange
].type
= type
;
1170 /* base: addr if memory, offset if reg relative. */
1171 memranges
->list
[memranges
->next_memrange
].start
= base
;
1172 /* len: we actually save end (base + len) for convenience */
1173 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
1174 memranges
->next_memrange
++;
1175 if (memranges
->next_memrange
>= memranges
->listsize
)
1177 memranges
->listsize
*= 2;
1178 memranges
->list
= xrealloc (memranges
->list
,
1179 memranges
->listsize
);
1182 if (type
!= -1) /* better collect the base register! */
1183 add_register (memranges
, type
);
1186 /* Add a symbol to a collection list */
1188 collect_symbol (struct collection_list
*collect
, struct symbol
*sym
,
1189 long frame_regno
, long frame_offset
)
1193 bfd_signed_vma offset
;
1195 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
1196 switch (SYMBOL_CLASS (sym
))
1199 printf_filtered ("%s: don't know symbol class %d\n",
1200 SYMBOL_NAME (sym
), SYMBOL_CLASS (sym
));
1203 printf_filtered ("constant %s (value %ld) will not be collected.\n",
1204 SYMBOL_NAME (sym
), SYMBOL_VALUE (sym
));
1207 offset
= SYMBOL_VALUE_ADDRESS (sym
);
1212 sprintf_vma (tmp
, offset
);
1213 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1214 SYMBOL_NAME (sym
), len
, tmp
/* address */);
1216 add_memrange (collect
, -1, offset
, len
); /* 0 == memory */
1220 reg
= SYMBOL_VALUE (sym
);
1222 printf_filtered ("LOC_REG[parm] %s: ", SYMBOL_NAME (sym
));
1223 add_register (collect
, reg
);
1224 /* check for doubles stored in two registers */
1225 /* FIXME: how about larger types stored in 3 or more regs? */
1226 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1227 len
> REGISTER_RAW_SIZE (reg
))
1228 add_register (collect
, reg
+ 1);
1231 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1232 printf_filtered (" (will not collect %s)\n",
1237 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1240 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1241 SYMBOL_NAME (sym
), len
);
1242 printf_vma (offset
);
1243 printf_filtered (" from frame ptr reg %d\n", reg
);
1245 add_memrange (collect
, reg
, offset
, len
);
1247 case LOC_REGPARM_ADDR
:
1248 reg
= SYMBOL_VALUE (sym
);
1252 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1253 SYMBOL_NAME (sym
), len
);
1254 printf_vma (offset
);
1255 printf_filtered (" from reg %d\n", reg
);
1257 add_memrange (collect
, reg
, offset
, len
);
1262 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1265 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1266 SYMBOL_NAME (sym
), len
);
1267 printf_vma (offset
);
1268 printf_filtered (" from frame ptr reg %d\n", reg
);
1270 add_memrange (collect
, reg
, offset
, len
);
1273 case LOC_BASEREG_ARG
:
1274 reg
= SYMBOL_BASEREG (sym
);
1275 offset
= SYMBOL_VALUE (sym
);
1278 printf_filtered ("LOC_BASEREG %s: collect %ld bytes at offset ",
1279 SYMBOL_NAME (sym
), len
);
1280 printf_vma (offset
);
1281 printf_filtered (" from basereg %d\n", reg
);
1283 add_memrange (collect
, reg
, offset
, len
);
1285 case LOC_UNRESOLVED
:
1286 printf_filtered ("Don't know LOC_UNRESOLVED %s\n", SYMBOL_NAME (sym
));
1288 case LOC_OPTIMIZED_OUT
:
1289 printf_filtered ("%s has been optimized out of existence.\n",
1295 /* Add all locals (or args) symbols to collection list */
1297 add_local_symbols (struct collection_list
*collect
, CORE_ADDR pc
,
1298 long frame_regno
, long frame_offset
, int type
)
1301 struct block
*block
;
1302 int i
, nsyms
, count
= 0;
1304 block
= block_for_pc (pc
);
1307 QUIT
; /* allow user to bail out with ^C */
1308 nsyms
= BLOCK_NSYMS (block
);
1309 for (i
= 0; i
< nsyms
; i
++)
1311 sym
= BLOCK_SYM (block
, i
);
1312 switch (SYMBOL_CLASS (sym
))
1315 warning ("don't know how to trace local symbol %s",
1321 if (type
== 'L') /* collecting Locals */
1324 collect_symbol (collect
, sym
, frame_regno
, frame_offset
);
1331 case LOC_REGPARM_ADDR
:
1332 case LOC_BASEREG_ARG
:
1333 if (type
== 'A') /* collecting Arguments */
1336 collect_symbol (collect
, sym
, frame_regno
, frame_offset
);
1340 if (BLOCK_FUNCTION (block
))
1343 block
= BLOCK_SUPERBLOCK (block
);
1346 warning ("No %s found in scope.", type
== 'L' ? "locals" : "args");
1349 /* worker function */
1351 clear_collection_list (struct collection_list
*list
)
1355 list
->next_memrange
= 0;
1356 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1358 free_agent_expr (list
->aexpr_list
[ndx
]);
1359 list
->aexpr_list
[ndx
] = NULL
;
1361 list
->next_aexpr_elt
= 0;
1362 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1365 /* reduce a collection list to string form (for gdb protocol) */
1367 stringify_collection_list (struct collection_list
*list
, char *string
)
1369 char temp_buf
[2048];
1373 char *(*str_list
)[];
1377 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1378 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1380 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1381 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1383 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1386 printf_filtered ("\nCollecting registers (mask): 0x");
1391 QUIT
; /* allow user to bail out with ^C */
1393 printf_filtered ("%02X", list
->regs_mask
[i
]);
1394 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1397 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1401 printf_filtered ("\n");
1402 if (list
->next_memrange
> 0 && info_verbose
)
1403 printf_filtered ("Collecting memranges: \n");
1404 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1406 QUIT
; /* allow user to bail out with ^C */
1407 sprintf_vma (tmp2
, list
->list
[i
].start
);
1410 printf_filtered ("(%d, %s, %ld)\n",
1413 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1415 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1417 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1423 sprintf (end
, "M%X,%s,%lX",
1426 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1428 count
+= strlen (end
);
1432 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1434 QUIT
; /* allow user to bail out with ^C */
1435 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1437 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1442 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1443 end
+= 10; /* 'X' + 8 hex digits + ',' */
1446 end
= mem2hex (list
->aexpr_list
[i
]->buf
, end
, list
->aexpr_list
[i
]->len
);
1447 count
+= 2 * list
->aexpr_list
[i
]->len
;
1452 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1457 (*str_list
)[ndx
] = NULL
;
1466 free_actions_list_cleanup_wrapper (void *al
)
1468 free_actions_list (al
);
1472 free_actions_list (char **actions_list
)
1476 if (actions_list
== 0)
1479 for (ndx
= 0; actions_list
[ndx
]; ndx
++)
1480 xfree (actions_list
[ndx
]);
1482 xfree (actions_list
);
1485 /* render all actions into gdb protocol */
1487 encode_actions (struct tracepoint
*t
, char ***tdp_actions
,
1488 char ***stepping_actions
)
1490 static char tdp_buff
[2048], step_buff
[2048];
1492 struct expression
*exp
= NULL
;
1493 struct action_line
*action
;
1496 struct collection_list
*collect
;
1497 struct cmd_list_element
*cmd
;
1498 struct agent_expr
*aexpr
;
1499 long frame_reg
, frame_offset
;
1502 clear_collection_list (&tracepoint_list
);
1503 clear_collection_list (&stepping_list
);
1504 collect
= &tracepoint_list
;
1506 *tdp_actions
= NULL
;
1507 *stepping_actions
= NULL
;
1509 TARGET_VIRTUAL_FRAME_POINTER (t
->address
, &frame_reg
, &frame_offset
);
1511 for (action
= t
->actions
; action
; action
= action
->next
)
1513 QUIT
; /* allow user to bail out with ^C */
1514 action_exp
= action
->action
;
1515 while (isspace ((int) *action_exp
))
1518 if (*action_exp
== '#') /* comment line */
1521 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1523 error ("Bad action list item: %s", action_exp
);
1525 if (cmd
->function
.cfunc
== collect_pseudocommand
)
1528 { /* repeat over a comma-separated list */
1529 QUIT
; /* allow user to bail out with ^C */
1530 while (isspace ((int) *action_exp
))
1533 if (0 == strncasecmp ("$reg", action_exp
, 4))
1535 for (i
= 0; i
< NUM_REGS
; i
++)
1536 add_register (collect
, i
);
1537 action_exp
= strchr (action_exp
, ','); /* more? */
1539 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1541 add_local_symbols (collect
,
1546 action_exp
= strchr (action_exp
, ','); /* more? */
1548 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1550 add_local_symbols (collect
,
1555 action_exp
= strchr (action_exp
, ','); /* more? */
1559 unsigned long addr
, len
;
1560 struct cleanup
*old_chain
= NULL
;
1561 struct cleanup
*old_chain1
= NULL
;
1562 struct agent_reqs areqs
;
1564 exp
= parse_exp_1 (&action_exp
,
1565 block_for_pc (t
->address
), 1);
1566 old_chain
= make_cleanup (free_current_contents
, &exp
);
1568 switch (exp
->elts
[0].opcode
)
1571 i
= exp
->elts
[1].longconst
;
1573 printf_filtered ("OP_REGISTER: ");
1574 add_register (collect
, i
);
1578 /* safe because we know it's a simple expression */
1579 tempval
= evaluate_expression (exp
);
1580 addr
= VALUE_ADDRESS (tempval
) + VALUE_OFFSET (tempval
);
1581 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1582 add_memrange (collect
, -1, addr
, len
);
1586 collect_symbol (collect
,
1587 exp
->elts
[2].symbol
,
1592 default: /* full-fledged expression */
1593 aexpr
= gen_trace_for_expr (t
->address
, exp
);
1595 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1597 ax_reqs (aexpr
, &areqs
);
1598 if (areqs
.flaw
!= agent_flaw_none
)
1599 error ("malformed expression");
1601 if (areqs
.min_height
< 0)
1602 error ("gdb: Internal error: expression has min height < 0");
1603 if (areqs
.max_height
> 20)
1604 error ("expression too complicated, try simplifying");
1606 discard_cleanups (old_chain1
);
1607 add_aexpr (collect
, aexpr
);
1609 /* take care of the registers */
1610 if (areqs
.reg_mask_len
> 0)
1615 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1617 QUIT
; /* allow user to bail out with ^C */
1618 if (areqs
.reg_mask
[ndx1
] != 0)
1620 /* assume chars have 8 bits */
1621 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1622 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1623 /* it's used -- record it */
1624 add_register (collect
, ndx1
* 8 + ndx2
);
1630 do_cleanups (old_chain
);
1633 while (action_exp
&& *action_exp
++ == ',');
1635 else if (cmd
->function
.cfunc
== while_stepping_pseudocommand
)
1637 collect
= &stepping_list
;
1639 else if (cmd
->function
.cfunc
== end_actions_pseudocommand
)
1641 if (collect
== &stepping_list
) /* end stepping actions */
1642 collect
= &tracepoint_list
;
1644 break; /* end tracepoint actions */
1647 memrange_sortmerge (&tracepoint_list
);
1648 memrange_sortmerge (&stepping_list
);
1650 *tdp_actions
= stringify_collection_list (&tracepoint_list
, tdp_buff
);
1651 *stepping_actions
= stringify_collection_list (&stepping_list
, step_buff
);
1655 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1657 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1659 collect
->aexpr_list
=
1660 xrealloc (collect
->aexpr_list
,
1661 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1662 collect
->aexpr_listsize
*= 2;
1664 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1665 collect
->next_aexpr_elt
++;
1668 static char target_buf
[2048];
1670 /* Set "transparent" memory ranges
1672 Allow trace mechanism to treat text-like sections
1673 (and perhaps all read-only sections) transparently,
1674 i.e. don't reject memory requests from these address ranges
1675 just because they haven't been collected. */
1678 remote_set_transparent_ranges (void)
1680 extern bfd
*exec_bfd
;
1687 return; /* no information to give. */
1689 strcpy (target_buf
, "QTro");
1690 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
1692 char tmp1
[40], tmp2
[40];
1694 if ((s
->flags
& SEC_LOAD
) == 0 ||
1695 /* (s->flags & SEC_CODE) == 0 || */
1696 (s
->flags
& SEC_READONLY
) == 0)
1701 size
= bfd_get_section_size_before_reloc (s
);
1702 sprintf_vma (tmp1
, lma
);
1703 sprintf_vma (tmp2
, lma
+ size
);
1704 sprintf (target_buf
+ strlen (target_buf
),
1705 ":%s,%s", tmp1
, tmp2
);
1709 putpkt (target_buf
);
1710 getpkt (target_buf
, sizeof (target_buf
), 0);
1716 Tell target to clear any previous trace experiment.
1717 Walk the list of tracepoints, and send them (and their actions)
1718 to the target. If no errors,
1719 Tell target to start a new trace experiment. */
1722 trace_start_command (char *args
, int from_tty
)
1723 { /* STUB_COMM MOSTLY_IMPLEMENTED */
1724 struct tracepoint
*t
;
1727 char **stepping_actions
;
1729 struct cleanup
*old_chain
= NULL
;
1731 dont_repeat (); /* like "run", dangerous to repeat accidentally */
1733 if (target_is_remote ())
1736 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1737 if (strcmp (target_buf
, "OK"))
1738 error ("Target does not support this command.");
1744 sprintf_vma (tmp
, t
->address
);
1745 sprintf (buf
, "QTDP:%x:%s:%c:%lx:%x", t
->number
, tmp
, /* address */
1746 t
->enabled
== enabled
? 'E' : 'D',
1747 t
->step_count
, t
->pass_count
);
1752 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1753 if (strcmp (target_buf
, "OK"))
1754 error ("Target does not support tracepoints.");
1758 encode_actions (t
, &tdp_actions
, &stepping_actions
);
1759 old_chain
= make_cleanup (free_actions_list_cleanup_wrapper
,
1761 (void) make_cleanup (free_actions_list_cleanup_wrapper
,
1764 /* do_single_steps (t); */
1767 for (ndx
= 0; tdp_actions
[ndx
]; ndx
++)
1769 QUIT
; /* allow user to bail out with ^C */
1770 sprintf (buf
, "QTDP:-%x:%s:%s%c",
1771 t
->number
, tmp
, /* address */
1773 ((tdp_actions
[ndx
+ 1] || stepping_actions
)
1776 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1777 if (strcmp (target_buf
, "OK"))
1778 error ("Error on target while setting tracepoints.");
1781 if (stepping_actions
)
1783 for (ndx
= 0; stepping_actions
[ndx
]; ndx
++)
1785 QUIT
; /* allow user to bail out with ^C */
1786 sprintf (buf
, "QTDP:-%x:%s:%s%s%s",
1787 t
->number
, tmp
, /* address */
1788 ((ndx
== 0) ? "S" : ""),
1789 stepping_actions
[ndx
],
1790 (stepping_actions
[ndx
+ 1] ? "-" : ""));
1792 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1793 if (strcmp (target_buf
, "OK"))
1794 error ("Error on target while setting tracepoints.");
1798 do_cleanups (old_chain
);
1801 /* Tell target to treat text-like sections as transparent */
1802 remote_set_transparent_ranges ();
1803 /* Now insert traps and begin collecting data */
1805 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1806 if (strcmp (target_buf
, "OK"))
1807 error ("Bogus reply from target: %s", target_buf
);
1808 set_traceframe_num (-1); /* all old traceframes invalidated */
1809 set_tracepoint_num (-1);
1810 set_traceframe_context (-1);
1811 trace_running_p
= 1;
1812 if (trace_start_stop_hook
)
1813 trace_start_stop_hook (1, from_tty
);
1817 error ("Trace can only be run on remote targets.");
1822 trace_stop_command (char *args
, int from_tty
)
1823 { /* STUB_COMM IS_IMPLEMENTED */
1824 if (target_is_remote ())
1827 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1828 if (strcmp (target_buf
, "OK"))
1829 error ("Bogus reply from target: %s", target_buf
);
1830 trace_running_p
= 0;
1831 if (trace_start_stop_hook
)
1832 trace_start_stop_hook (0, from_tty
);
1835 error ("Trace can only be run on remote targets.");
1838 unsigned long trace_running_p
;
1840 /* tstatus command */
1842 trace_status_command (char *args
, int from_tty
)
1843 { /* STUB_COMM IS_IMPLEMENTED */
1844 if (target_is_remote ())
1846 putpkt ("qTStatus");
1847 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1849 if (target_buf
[0] != 'T' ||
1850 (target_buf
[1] != '0' && target_buf
[1] != '1'))
1851 error ("Bogus reply from target: %s", target_buf
);
1853 /* exported for use by the GUI */
1854 trace_running_p
= (target_buf
[1] == '1');
1857 error ("Trace can only be run on remote targets.");
1860 /* Worker function for the various flavors of the tfind command */
1862 finish_tfind_command (char *msg
,
1866 int target_frameno
= -1, target_tracept
= -1;
1867 CORE_ADDR old_frame_addr
;
1868 struct symbol
*old_func
;
1871 old_frame_addr
= FRAME_FP (get_current_frame ());
1872 old_func
= find_pc_function (read_pc ());
1875 reply
= remote_get_noisy_reply (msg
, sizeof_msg
);
1877 while (reply
&& *reply
)
1881 if ((target_frameno
= (int) strtol (++reply
, &reply
, 16)) == -1)
1883 /* A request for a non-existant trace frame has failed.
1884 Our response will be different, depending on FROM_TTY:
1886 If FROM_TTY is true, meaning that this command was
1887 typed interactively by the user, then give an error
1888 and DO NOT change the state of traceframe_number etc.
1890 However if FROM_TTY is false, meaning that we're either
1891 in a script, a loop, or a user-defined command, then
1892 DON'T give an error, but DO change the state of
1893 traceframe_number etc. to invalid.
1895 The rationalle is that if you typed the command, you
1896 might just have committed a typo or something, and you'd
1897 like to NOT lose your current debugging state. However
1898 if you're in a user-defined command or especially in a
1899 loop, then you need a way to detect that the command
1900 failed WITHOUT aborting. This allows you to write
1901 scripts that search thru the trace buffer until the end,
1902 and then continue on to do something else. */
1905 error ("Target failed to find requested trace frame.");
1909 printf_filtered ("End of trace buffer.\n");
1910 /* The following will not recurse, since it's special-cased */
1911 trace_find_command ("-1", from_tty
);
1912 reply
= NULL
; /* break out of loop,
1913 (avoid recursive nonsense) */
1918 if ((target_tracept
= (int) strtol (++reply
, &reply
, 16)) == -1)
1919 error ("Target failed to find requested trace frame.");
1921 case 'O': /* "OK"? */
1922 if (reply
[1] == 'K' && reply
[2] == '\0')
1925 error ("Bogus reply from target: %s", reply
);
1928 error ("Bogus reply from target: %s", reply
);
1931 flush_cached_frames ();
1932 registers_changed ();
1933 select_frame (get_current_frame (), 0);
1934 set_traceframe_num (target_frameno
);
1935 set_tracepoint_num (target_tracept
);
1936 if (target_frameno
== -1)
1937 set_traceframe_context (-1);
1939 set_traceframe_context (read_pc ());
1945 /* NOTE: in immitation of the step command, try to determine
1946 whether we have made a transition from one function to another.
1947 If so, we'll print the "stack frame" (ie. the new function and
1948 it's arguments) -- otherwise we'll just show the new source line.
1950 This determination is made by checking (1) whether the current
1951 function has changed, and (2) whether the current FP has changed.
1952 Hack: if the FP wasn't collected, either at the current or the
1953 previous frame, assume that the FP has NOT changed. */
1955 if (old_func
== find_pc_function (read_pc ()) &&
1956 (old_frame_addr
== 0 ||
1957 FRAME_FP (get_current_frame ()) == 0 ||
1958 old_frame_addr
== FRAME_FP (get_current_frame ())))
1963 print_stack_frame (selected_frame
, selected_frame_level
, source_only
);
1968 /* trace_find_command takes a trace frame number n,
1969 sends "QTFrame:<n>" to the target,
1970 and accepts a reply that may contain several optional pieces
1971 of information: a frame number, a tracepoint number, and an
1972 indication of whether this is a trap frame or a stepping frame.
1974 The minimal response is just "OK" (which indicates that the
1975 target does not give us a frame number or a tracepoint number).
1976 Instead of that, the target may send us a string containing
1978 F<hexnum> (gives the selected frame number)
1979 T<hexnum> (gives the selected tracepoint number)
1984 trace_find_command (char *args
, int from_tty
)
1985 { /* STUB_COMM PART_IMPLEMENTED */
1986 /* this should only be called with a numeric argument */
1989 if (target_is_remote ())
1991 if (trace_find_hook
)
1992 trace_find_hook (args
, from_tty
);
1994 if (args
== 0 || *args
== 0)
1995 { /* TFIND with no args means find NEXT trace frame. */
1996 if (traceframe_number
== -1)
1997 frameno
= 0; /* "next" is first one */
1999 frameno
= traceframe_number
+ 1;
2001 else if (0 == strcmp (args
, "-"))
2003 if (traceframe_number
== -1)
2004 error ("not debugging trace buffer");
2005 else if (from_tty
&& traceframe_number
== 0)
2006 error ("already at start of trace buffer");
2008 frameno
= traceframe_number
- 1;
2011 frameno
= parse_and_eval_long (args
);
2014 error ("invalid input (%d is less than zero)", frameno
);
2016 sprintf (target_buf
, "QTFrame:%x", frameno
);
2017 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2020 error ("Trace can only be run on remote targets.");
2025 trace_find_end_command (char *args
, int from_tty
)
2027 trace_find_command ("-1", from_tty
);
2032 trace_find_none_command (char *args
, int from_tty
)
2034 trace_find_command ("-1", from_tty
);
2039 trace_find_start_command (char *args
, int from_tty
)
2041 trace_find_command ("0", from_tty
);
2044 /* tfind pc command */
2046 trace_find_pc_command (char *args
, int from_tty
)
2047 { /* STUB_COMM PART_IMPLEMENTED */
2051 if (target_is_remote ())
2053 if (args
== 0 || *args
== 0)
2054 pc
= read_pc (); /* default is current pc */
2056 pc
= parse_and_eval_address (args
);
2058 sprintf_vma (tmp
, pc
);
2059 sprintf (target_buf
, "QTFrame:pc:%s", tmp
);
2060 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2063 error ("Trace can only be run on remote targets.");
2066 /* tfind tracepoint command */
2068 trace_find_tracepoint_command (char *args
, int from_tty
)
2069 { /* STUB_COMM PART_IMPLEMENTED */
2072 if (target_is_remote ())
2074 if (args
== 0 || *args
== 0)
2075 if (tracepoint_number
== -1)
2076 error ("No current tracepoint -- please supply an argument.");
2078 tdp
= tracepoint_number
; /* default is current TDP */
2080 tdp
= parse_and_eval_long (args
);
2082 sprintf (target_buf
, "QTFrame:tdp:%x", tdp
);
2083 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2086 error ("Trace can only be run on remote targets.");
2089 /* TFIND LINE command:
2091 This command will take a sourceline for argument, just like BREAK
2092 or TRACE (ie. anything that "decode_line_1" can handle).
2094 With no argument, this command will find the next trace frame
2095 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2098 trace_find_line_command (char *args
, int from_tty
)
2099 { /* STUB_COMM PART_IMPLEMENTED */
2100 static CORE_ADDR start_pc
, end_pc
;
2101 struct symtabs_and_lines sals
;
2102 struct symtab_and_line sal
;
2103 struct cleanup
*old_chain
;
2104 char startpc_str
[40], endpc_str
[40];
2106 if (target_is_remote ())
2108 if (args
== 0 || *args
== 0)
2110 sal
= find_pc_line ((get_current_frame ())->pc
, 0);
2112 sals
.sals
= (struct symtab_and_line
*)
2113 xmalloc (sizeof (struct symtab_and_line
));
2118 sals
= decode_line_spec (args
, 1);
2122 old_chain
= make_cleanup (xfree
, sals
.sals
);
2123 if (sal
.symtab
== 0)
2125 printf_filtered ("TFIND: No line number information available");
2128 /* This is useful for "info line *0x7f34". If we can't tell the
2129 user about a source line, at least let them have the symbolic
2131 printf_filtered (" for address ");
2133 print_address (sal
.pc
, gdb_stdout
);
2134 printf_filtered (";\n -- will attempt to find by PC. \n");
2138 printf_filtered (".\n");
2139 return; /* no line, no PC; what can we do? */
2142 else if (sal
.line
> 0
2143 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2145 if (start_pc
== end_pc
)
2147 printf_filtered ("Line %d of \"%s\"",
2148 sal
.line
, sal
.symtab
->filename
);
2150 printf_filtered (" is at address ");
2151 print_address (start_pc
, gdb_stdout
);
2153 printf_filtered (" but contains no code.\n");
2154 sal
= find_pc_line (start_pc
, 0);
2156 find_line_pc_range (sal
, &start_pc
, &end_pc
) &&
2158 printf_filtered ("Attempting to find line %d instead.\n",
2161 error ("Cannot find a good line.");
2165 /* Is there any case in which we get here, and have an address
2166 which the user would want to see? If we have debugging symbols
2167 and no line numbers? */
2168 error ("Line number %d is out of range for \"%s\".\n",
2169 sal
.line
, sal
.symtab
->filename
);
2171 sprintf_vma (startpc_str
, start_pc
);
2172 sprintf_vma (endpc_str
, end_pc
- 1);
2173 if (args
&& *args
) /* find within range of stated line */
2174 sprintf (target_buf
, "QTFrame:range:%s:%s", startpc_str
, endpc_str
);
2175 else /* find OUTSIDE OF range of CURRENT line */
2176 sprintf (target_buf
, "QTFrame:outside:%s:%s", startpc_str
, endpc_str
);
2177 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2178 do_cleanups (old_chain
);
2181 error ("Trace can only be run on remote targets.");
2184 /* tfind range command */
2186 trace_find_range_command (char *args
, int from_tty
)
2188 static CORE_ADDR start
, stop
;
2189 char start_str
[40], stop_str
[40];
2192 if (target_is_remote ())
2194 if (args
== 0 || *args
== 0)
2195 { /* XXX FIXME: what should default behavior be? */
2196 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2200 if (0 != (tmp
= strchr (args
, ',')))
2202 *tmp
++ = '\0'; /* terminate start address */
2203 while (isspace ((int) *tmp
))
2205 start
= parse_and_eval_address (args
);
2206 stop
= parse_and_eval_address (tmp
);
2209 { /* no explicit end address? */
2210 start
= parse_and_eval_address (args
);
2211 stop
= start
+ 1; /* ??? */
2214 sprintf_vma (start_str
, start
);
2215 sprintf_vma (stop_str
, stop
);
2216 sprintf (target_buf
, "QTFrame:range:%s:%s", start_str
, stop_str
);
2217 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2220 error ("Trace can only be run on remote targets.");
2223 /* tfind outside command */
2225 trace_find_outside_command (char *args
, int from_tty
)
2227 CORE_ADDR start
, stop
;
2228 char start_str
[40], stop_str
[40];
2231 if (target_is_remote ())
2233 if (args
== 0 || *args
== 0)
2234 { /* XXX FIXME: what should default behavior be? */
2235 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2239 if (0 != (tmp
= strchr (args
, ',')))
2241 *tmp
++ = '\0'; /* terminate start address */
2242 while (isspace ((int) *tmp
))
2244 start
= parse_and_eval_address (args
);
2245 stop
= parse_and_eval_address (tmp
);
2248 { /* no explicit end address? */
2249 start
= parse_and_eval_address (args
);
2250 stop
= start
+ 1; /* ??? */
2253 sprintf_vma (start_str
, start
);
2254 sprintf_vma (stop_str
, stop
);
2255 sprintf (target_buf
, "QTFrame:outside:%s:%s", start_str
, stop_str
);
2256 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2259 error ("Trace can only be run on remote targets.");
2262 /* save-tracepoints command */
2264 tracepoint_save_command (char *args
, int from_tty
)
2266 struct tracepoint
*tp
;
2267 struct action_line
*line
;
2269 char *i1
= " ", *i2
= " ";
2270 char *indent
, *actionline
;
2273 if (args
== 0 || *args
== 0)
2274 error ("Argument required (file name in which to save tracepoints");
2276 if (tracepoint_chain
== 0)
2278 warning ("save-tracepoints: no tracepoints to save.\n");
2282 if (!(fp
= fopen (args
, "w")))
2283 error ("Unable to open file '%s' for saving tracepoints");
2285 ALL_TRACEPOINTS (tp
)
2287 if (tp
->addr_string
)
2288 fprintf (fp
, "trace %s\n", tp
->addr_string
);
2291 sprintf_vma (tmp
, tp
->address
);
2292 fprintf (fp
, "trace *0x%s\n", tmp
);
2296 fprintf (fp
, " passcount %d\n", tp
->pass_count
);
2300 fprintf (fp
, " actions\n");
2302 for (line
= tp
->actions
; line
; line
= line
->next
)
2304 struct cmd_list_element
*cmd
;
2306 QUIT
; /* allow user to bail out with ^C */
2307 actionline
= line
->action
;
2308 while (isspace ((int) *actionline
))
2311 fprintf (fp
, "%s%s\n", indent
, actionline
);
2312 if (*actionline
!= '#') /* skip for comment lines */
2314 cmd
= lookup_cmd (&actionline
, cmdlist
, "", -1, 1);
2316 error ("Bad action list item: %s", actionline
);
2317 if (cmd
->function
.cfunc
== while_stepping_pseudocommand
)
2319 else if (cmd
->function
.cfunc
== end_actions_pseudocommand
)
2327 printf_filtered ("Tracepoints saved to file '%s'.\n", args
);
2331 /* info scope command: list the locals for a scope. */
2333 scope_info (char *args
, int from_tty
)
2335 struct symtabs_and_lines sals
;
2337 struct minimal_symbol
*msym
;
2338 struct block
*block
;
2339 char **canonical
, *symname
, *save_args
= args
;
2340 int i
, j
, nsyms
, count
= 0;
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
);
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 nsyms
= BLOCK_NSYMS (block
);
2357 for (i
= 0; i
< nsyms
; i
++)
2359 QUIT
; /* allow user to bail out with ^C */
2361 printf_filtered ("Scope for %s:\n", save_args
);
2363 sym
= BLOCK_SYM (block
, i
);
2364 symname
= SYMBOL_NAME (sym
);
2365 if (symname
== NULL
|| *symname
== '\0')
2366 continue; /* probably botched, certainly useless */
2368 printf_filtered ("Symbol %s is ", symname
);
2369 switch (SYMBOL_CLASS (sym
))
2372 case LOC_UNDEF
: /* messed up symbol? */
2373 printf_filtered ("a bogus symbol, class %d.\n",
2374 SYMBOL_CLASS (sym
));
2375 count
--; /* don't count this one */
2378 printf_filtered ("a constant with value %ld (0x%lx)",
2379 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2381 case LOC_CONST_BYTES
:
2382 printf_filtered ("constant bytes: ");
2383 if (SYMBOL_TYPE (sym
))
2384 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2385 fprintf_filtered (gdb_stdout
, " %02x",
2386 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2389 printf_filtered ("in static storage at address ");
2390 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
), 1, gdb_stdout
);
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
), 1, gdb_stdout
);
2425 printf_filtered ("a function at address ");
2426 print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)), 1,
2430 printf_filtered ("a variable at offset %ld from register $%s",
2432 REGISTER_NAME (SYMBOL_BASEREG (sym
)));
2434 case LOC_BASEREG_ARG
:
2435 printf_filtered ("an argument at offset %ld from register $%s",
2437 REGISTER_NAME (SYMBOL_BASEREG (sym
)));
2439 case LOC_UNRESOLVED
:
2440 msym
= lookup_minimal_symbol (SYMBOL_NAME (sym
), NULL
, NULL
);
2442 printf_filtered ("Unresolved Static");
2445 printf_filtered ("static storage at address ");
2446 print_address_numeric (SYMBOL_VALUE_ADDRESS (msym
), 1,
2450 case LOC_OPTIMIZED_OUT
:
2451 printf_filtered ("optimized out.\n");
2454 if (SYMBOL_TYPE (sym
))
2455 printf_filtered (", length %d.\n",
2456 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2458 if (BLOCK_FUNCTION (block
))
2461 block
= BLOCK_SUPERBLOCK (block
);
2464 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2468 /* worker function (cleanup) */
2470 replace_comma (void *data
)
2478 trace_dump_command (char *args
, int from_tty
)
2480 struct tracepoint
*t
;
2481 struct action_line
*action
;
2482 char *action_exp
, *next_comma
;
2483 struct cleanup
*old_cleanups
;
2484 int stepping_actions
= 0;
2485 int stepping_frame
= 0;
2487 if (!target_is_remote ())
2489 error ("Trace can only be run on remote targets.");
2493 if (tracepoint_number
== -1)
2495 warning ("No current trace frame.");
2500 if (t
->number
== tracepoint_number
)
2504 error ("No known tracepoint matches 'current' tracepoint #%d.",
2507 old_cleanups
= make_cleanup (null_cleanup
, NULL
);
2509 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2510 tracepoint_number
, traceframe_number
);
2512 /* The current frame is a trap frame if the frame PC is equal
2513 to the tracepoint PC. If not, then the current frame was
2514 collected during single-stepping. */
2516 stepping_frame
= (t
->address
!= read_pc ());
2518 for (action
= t
->actions
; action
; action
= action
->next
)
2520 struct cmd_list_element
*cmd
;
2522 QUIT
; /* allow user to bail out with ^C */
2523 action_exp
= action
->action
;
2524 while (isspace ((int) *action_exp
))
2527 /* The collection actions to be done while stepping are
2528 bracketed by the commands "while-stepping" and "end". */
2530 if (*action_exp
== '#') /* comment line */
2533 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2535 error ("Bad action list item: %s", action_exp
);
2537 if (cmd
->function
.cfunc
== while_stepping_pseudocommand
)
2538 stepping_actions
= 1;
2539 else if (cmd
->function
.cfunc
== end_actions_pseudocommand
)
2540 stepping_actions
= 0;
2541 else if (cmd
->function
.cfunc
== collect_pseudocommand
)
2543 /* Display the collected data.
2544 For the trap frame, display only what was collected at the trap.
2545 Likewise for stepping frames, display only what was collected
2546 while stepping. This means that the two boolean variables,
2547 STEPPING_FRAME and STEPPING_ACTIONS should be equal. */
2548 if (stepping_frame
== stepping_actions
)
2551 { /* repeat over a comma-separated list */
2552 QUIT
; /* allow user to bail out with ^C */
2553 if (*action_exp
== ',')
2555 while (isspace ((int) *action_exp
))
2558 next_comma
= strchr (action_exp
, ',');
2560 if (0 == strncasecmp (action_exp
, "$reg", 4))
2561 registers_info (NULL
, from_tty
);
2562 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2563 locals_info (NULL
, from_tty
);
2564 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2565 args_info (NULL
, from_tty
);
2570 make_cleanup (replace_comma
, next_comma
);
2573 printf_filtered ("%s = ", action_exp
);
2574 output_command (action_exp
, from_tty
);
2575 printf_filtered ("\n");
2579 action_exp
= next_comma
;
2581 while (action_exp
&& *action_exp
== ',');
2585 discard_cleanups (old_cleanups
);
2588 /* Convert the memory pointed to by mem into hex, placing result in buf.
2589 * Return a pointer to the last char put in buf (null)
2590 * "stolen" from sparc-stub.c
2593 static const char hexchars
[] = "0123456789abcdef";
2595 static unsigned char *
2596 mem2hex (unsigned char *mem
, unsigned char *buf
, int count
)
2604 *buf
++ = hexchars
[ch
>> 4];
2605 *buf
++ = hexchars
[ch
& 0xf];
2614 get_traceframe_number (void)
2616 return traceframe_number
;
2620 /* module initialization */
2622 _initialize_tracepoint (void)
2624 struct cmd_list_element
*c
;
2626 tracepoint_chain
= 0;
2627 tracepoint_count
= 0;
2628 traceframe_number
= -1;
2629 tracepoint_number
= -1;
2631 set_internalvar (lookup_internalvar ("tpnum"),
2632 value_from_longest (builtin_type_int
, (LONGEST
) 0));
2633 set_internalvar (lookup_internalvar ("trace_frame"),
2634 value_from_longest (builtin_type_int
, (LONGEST
) - 1));
2636 if (tracepoint_list
.list
== NULL
)
2638 tracepoint_list
.listsize
= 128;
2639 tracepoint_list
.list
= xmalloc
2640 (tracepoint_list
.listsize
* sizeof (struct memrange
));
2642 if (tracepoint_list
.aexpr_list
== NULL
)
2644 tracepoint_list
.aexpr_listsize
= 128;
2645 tracepoint_list
.aexpr_list
= xmalloc
2646 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
2649 if (stepping_list
.list
== NULL
)
2651 stepping_list
.listsize
= 128;
2652 stepping_list
.list
= xmalloc
2653 (stepping_list
.listsize
* sizeof (struct memrange
));
2656 if (stepping_list
.aexpr_list
== NULL
)
2658 stepping_list
.aexpr_listsize
= 128;
2659 stepping_list
.aexpr_list
= xmalloc
2660 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
2663 add_info ("scope", scope_info
,
2664 "List the variables local to a scope");
2666 add_cmd ("tracepoints", class_trace
, NO_FUNCTION
,
2667 "Tracing of program execution without stopping the program.",
2670 add_info ("tracepoints", tracepoints_info
,
2671 "Status of tracepoints, or tracepoint number NUMBER.\n\
2672 Convenience variable \"$tpnum\" contains the number of the\n\
2673 last tracepoint set.");
2675 add_info_alias ("tp", "tracepoints", 1);
2677 c
= add_com ("save-tracepoints", class_trace
, tracepoint_save_command
,
2678 "Save current tracepoint definitions as a script.\n\
2679 Use the 'source' command in another debug session to restore them.");
2680 c
->completer
= filename_completer
;
2682 add_com ("tdump", class_trace
, trace_dump_command
,
2683 "Print everything collected at the current tracepoint.");
2685 add_prefix_cmd ("tfind", class_trace
, trace_find_command
,
2686 "Select a trace frame;\n\
2687 No argument means forward by one frame; '-' meand backward by one frame.",
2688 &tfindlist
, "tfind ", 1, &cmdlist
);
2690 add_cmd ("outside", class_trace
, trace_find_outside_command
,
2691 "Select a trace frame whose PC is outside the given \
2692 range.\nUsage: tfind outside addr1, addr2",
2695 add_cmd ("range", class_trace
, trace_find_range_command
,
2696 "Select a trace frame whose PC is in the given range.\n\
2697 Usage: tfind range addr1,addr2",
2700 add_cmd ("line", class_trace
, trace_find_line_command
,
2701 "Select a trace frame by source line.\n\
2702 Argument can be a line number (with optional source file), \n\
2703 a function name, or '*' followed by an address.\n\
2704 Default argument is 'the next source line that was traced'.",
2707 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
,
2708 "Select a trace frame by tracepoint number.\n\
2709 Default is the tracepoint for the current trace frame.",
2712 add_cmd ("pc", class_trace
, trace_find_pc_command
,
2713 "Select a trace frame by PC.\n\
2714 Default is the current PC, or the PC of the current trace frame.",
2717 add_cmd ("end", class_trace
, trace_find_end_command
,
2718 "Synonym for 'none'.\n\
2719 De-select any trace frame and resume 'live' debugging.",
2722 add_cmd ("none", class_trace
, trace_find_none_command
,
2723 "De-select any trace frame and resume 'live' debugging.",
2726 add_cmd ("start", class_trace
, trace_find_start_command
,
2727 "Select the first trace frame in the trace buffer.",
2730 add_com ("tstatus", class_trace
, trace_status_command
,
2731 "Display the status of the current trace data collection.");
2733 add_com ("tstop", class_trace
, trace_stop_command
,
2734 "Stop trace data collection.");
2736 add_com ("tstart", class_trace
, trace_start_command
,
2737 "Start trace data collection.");
2739 add_com ("passcount", class_trace
, trace_pass_command
,
2740 "Set the passcount for a tracepoint.\n\
2741 The trace will end when the tracepoint has been passed 'count' times.\n\
2742 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
2743 if TPNUM is omitted, passcount refers to the last tracepoint defined.");
2745 add_com ("end", class_trace
, end_actions_pseudocommand
,
2746 "Ends a list of commands or actions.\n\
2747 Several GDB commands allow you to enter a list of commands or actions.\n\
2748 Entering \"end\" on a line by itself is the normal way to terminate\n\
2750 Note: the \"end\" command cannot be used at the gdb prompt.");
2752 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
,
2753 "Specify single-stepping behavior at a tracepoint.\n\
2754 Argument is number of instructions to trace in single-step mode\n\
2755 following the tracepoint. This command is normally followed by\n\
2756 one or more \"collect\" commands, to specify what to collect\n\
2757 while single-stepping.\n\n\
2758 Note: this command can only be used in a tracepoint \"actions\" list.");
2760 add_com_alias ("ws", "while-stepping", class_alias
, 0);
2761 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
2763 add_com ("collect", class_trace
, collect_pseudocommand
,
2764 "Specify one or more data items to be collected at a tracepoint.\n\
2765 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
2766 collect all data (variables, registers) referenced by that expression.\n\
2767 Also accepts the following special arguments:\n\
2768 $regs -- all registers.\n\
2769 $args -- all function arguments.\n\
2770 $locals -- all variables local to the block/function scope.\n\
2771 Note: this command can only be used in a tracepoint \"actions\" list.");
2773 add_com ("actions", class_trace
, trace_actions_command
,
2774 "Specify the actions to be taken at a tracepoint.\n\
2775 Tracepoint actions may include collecting of specified data, \n\
2776 single-stepping, or enabling/disabling other tracepoints, \n\
2777 depending on target's capabilities.");
2779 add_cmd ("tracepoints", class_trace
, delete_trace_command
,
2780 "Delete specified tracepoints.\n\
2781 Arguments are tracepoint numbers, separated by spaces.\n\
2782 No argument means delete all tracepoints.",
2785 add_cmd ("tracepoints", class_trace
, disable_trace_command
,
2786 "Disable specified tracepoints.\n\
2787 Arguments are tracepoint numbers, separated by spaces.\n\
2788 No argument means disable all tracepoints.",
2791 add_cmd ("tracepoints", class_trace
, enable_trace_command
,
2792 "Enable specified tracepoints.\n\
2793 Arguments are tracepoint numbers, separated by spaces.\n\
2794 No argument means enable all tracepoints.",
2797 add_com ("trace", class_trace
, trace_command
,
2798 "Set a tracepoint at a specified line or function or address.\n\
2799 Argument may be a line number, function name, or '*' plus an address.\n\
2800 For a line number or function, trace at the start of its code.\n\
2801 If an address is specified, trace at that exact address.\n\n\
2802 Do \"help tracepoints\" for info on other tracepoint commands.");
2804 add_com_alias ("tp", "trace", class_alias
, 0);
2805 add_com_alias ("tr", "trace", class_alias
, 1);
2806 add_com_alias ("tra", "trace", class_alias
, 1);
2807 add_com_alias ("trac", "trace", class_alias
, 1);