1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright 1997, 1998, 1999, 2000, 2001, 2002 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"
44 /* readline include files */
45 #include <readline/readline.h>
46 #include <readline/history.h>
48 /* readline defines this. */
55 /* maximum length of an agent aexpression.
56 this accounts for the fact that packets are limited to 400 bytes
57 (which includes everything -- including the checksum), and assumes
58 the worst case of maximum length for each of the pieces of a
61 NOTE: expressions get mem2hex'ed otherwise this would be twice as
62 large. (400 - 31)/2 == 184 */
63 #define MAX_AGENT_EXPR_LEN 184
66 extern void (*readline_begin_hook
) (char *, ...);
67 extern char *(*readline_hook
) (char *);
68 extern void (*readline_end_hook
) (void);
69 extern void x_command (char *, int);
70 extern int addressprint
; /* Print machine addresses? */
72 /* GDB commands implemented in other modules:
75 extern void output_command (char *, int);
76 extern void registers_info (char *, int);
77 extern void args_info (char *, int);
78 extern void locals_info (char *, int);
81 /* If this definition isn't overridden by the header files, assume
82 that isatty and fileno exist on this system. */
84 #define ISATTY(FP) (isatty (fileno (FP)))
90 This module defines the following debugger commands:
91 trace : set a tracepoint on a function, line, or address.
92 info trace : list all debugger-defined tracepoints.
93 delete trace : delete one or more tracepoints.
94 enable trace : enable one or more tracepoints.
95 disable trace : disable one or more tracepoints.
96 actions : specify actions to be taken at a tracepoint.
97 passcount : specify a pass count for a tracepoint.
98 tstart : start a trace experiment.
99 tstop : stop a trace experiment.
100 tstatus : query the status of a trace experiment.
101 tfind : find a trace frame in the trace buffer.
102 tdump : print everything collected at the current tracepoint.
103 save-tracepoints : write tracepoint setup into a file.
105 This module defines the following user-visible debugger variables:
106 $trace_frame : sequence number of trace frame currently being debugged.
107 $trace_line : source line of trace frame currently being debugged.
108 $trace_file : source file of trace frame currently being debugged.
109 $tracepoint : tracepoint number of trace frame currently being debugged.
113 /* ======= Important global variables: ======= */
115 /* Chain of all tracepoints defined. */
116 struct tracepoint
*tracepoint_chain
;
118 /* Number of last tracepoint made. */
119 static int tracepoint_count
;
121 /* Number of last traceframe collected. */
122 static int traceframe_number
;
124 /* Tracepoint for last traceframe collected. */
125 static int tracepoint_number
;
127 /* Symbol for function for last traceframe collected */
128 static struct symbol
*traceframe_fun
;
130 /* Symtab and line for last traceframe collected */
131 static struct symtab_and_line traceframe_sal
;
133 /* Tracing command lists */
134 static struct cmd_list_element
*tfindlist
;
136 /* ======= Important command functions: ======= */
137 static void trace_command (char *, int);
138 static void tracepoints_info (char *, int);
139 static void delete_trace_command (char *, int);
140 static void enable_trace_command (char *, int);
141 static void disable_trace_command (char *, int);
142 static void trace_pass_command (char *, int);
143 static void trace_actions_command (char *, int);
144 static void trace_start_command (char *, int);
145 static void trace_stop_command (char *, int);
146 static void trace_status_command (char *, int);
147 static void trace_find_command (char *, int);
148 static void trace_find_pc_command (char *, int);
149 static void trace_find_tracepoint_command (char *, int);
150 static void trace_find_line_command (char *, int);
151 static void trace_find_range_command (char *, int);
152 static void trace_find_outside_command (char *, int);
153 static void tracepoint_save_command (char *, int);
154 static void trace_dump_command (char *, int);
156 /* support routines */
157 static void trace_mention (struct tracepoint
*);
159 struct collection_list
;
160 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
161 static unsigned char *mem2hex (unsigned char *, unsigned char *, int);
162 static void add_register (struct collection_list
*collection
,
164 static struct cleanup
*make_cleanup_free_actions (struct tracepoint
*t
);
165 static void free_actions_list (char **actions_list
);
166 static void free_actions_list_cleanup_wrapper (void *);
168 extern void _initialize_tracepoint (void);
170 /* Utility: returns true if "target remote" */
172 target_is_remote (void)
174 if (current_target
.to_shortname
&&
175 strcmp (current_target
.to_shortname
, "remote") == 0)
181 /* Utility: generate error from an incoming stub packet. */
183 trace_error (char *buf
)
186 return; /* not an error msg */
189 case '1': /* malformed packet error */
190 if (*++buf
== '0') /* general case: */
191 error ("tracepoint.c: error in outgoing packet.");
193 error ("tracepoint.c: error in outgoing packet at field #%ld.",
194 strtol (buf
, NULL
, 16));
196 error ("trace API error 0x%s.", ++buf
);
198 error ("Target returns error code '%s'.", buf
);
202 /* Utility: wait for reply from stub, while accepting "O" packets */
204 remote_get_noisy_reply (char *buf
,
207 do /* loop on reply from remote stub */
209 QUIT
; /* allow user to bail out with ^C */
210 getpkt (buf
, sizeof_buf
, 0);
212 error ("Target does not support this command.");
213 else if (buf
[0] == 'E')
215 else if (buf
[0] == 'O' &&
217 remote_console_output (buf
+ 1); /* 'O' message from stub */
219 return buf
; /* here's the actual reply */
224 /* Set tracepoint count to NUM. */
226 set_tracepoint_count (int num
)
228 tracepoint_count
= num
;
229 set_internalvar (lookup_internalvar ("tpnum"),
230 value_from_longest (builtin_type_int
, (LONGEST
) num
));
233 /* Set traceframe number to NUM. */
235 set_traceframe_num (int num
)
237 traceframe_number
= num
;
238 set_internalvar (lookup_internalvar ("trace_frame"),
239 value_from_longest (builtin_type_int
, (LONGEST
) num
));
242 /* Set tracepoint number to NUM. */
244 set_tracepoint_num (int num
)
246 tracepoint_number
= num
;
247 set_internalvar (lookup_internalvar ("tracepoint"),
248 value_from_longest (builtin_type_int
, (LONGEST
) num
));
251 /* Set externally visible debug variables for querying/printing
252 the traceframe context (line, function, file) */
255 set_traceframe_context (CORE_ADDR trace_pc
)
257 static struct type
*func_string
, *file_string
;
258 static struct type
*func_range
, *file_range
;
259 struct value
*func_val
;
260 struct value
*file_val
;
261 static struct type
*charstar
;
264 if (charstar
== (struct type
*) NULL
)
265 charstar
= lookup_pointer_type (builtin_type_char
);
267 if (trace_pc
== -1) /* cease debugging any trace buffers */
270 traceframe_sal
.pc
= traceframe_sal
.line
= 0;
271 traceframe_sal
.symtab
= NULL
;
272 set_internalvar (lookup_internalvar ("trace_func"),
273 value_from_pointer (charstar
, (LONGEST
) 0));
274 set_internalvar (lookup_internalvar ("trace_file"),
275 value_from_pointer (charstar
, (LONGEST
) 0));
276 set_internalvar (lookup_internalvar ("trace_line"),
277 value_from_pointer (builtin_type_int
, (LONGEST
) - 1));
281 /* save as globals for internal use */
282 traceframe_sal
= find_pc_line (trace_pc
, 0);
283 traceframe_fun
= find_pc_function (trace_pc
);
285 /* save linenumber as "$trace_line", a debugger variable visible to users */
286 set_internalvar (lookup_internalvar ("trace_line"),
287 value_from_longest (builtin_type_int
,
288 (LONGEST
) traceframe_sal
.line
));
290 /* save func name as "$trace_func", a debugger variable visible to users */
291 if (traceframe_fun
== NULL
||
292 SYMBOL_NAME (traceframe_fun
) == NULL
)
293 set_internalvar (lookup_internalvar ("trace_func"),
294 value_from_pointer (charstar
, (LONGEST
) 0));
297 len
= strlen (SYMBOL_NAME (traceframe_fun
));
298 func_range
= create_range_type (func_range
,
299 builtin_type_int
, 0, len
- 1);
300 func_string
= create_array_type (func_string
,
301 builtin_type_char
, func_range
);
302 func_val
= allocate_value (func_string
);
303 VALUE_TYPE (func_val
) = func_string
;
304 memcpy (VALUE_CONTENTS_RAW (func_val
),
305 SYMBOL_NAME (traceframe_fun
),
307 func_val
->modifiable
= 0;
308 set_internalvar (lookup_internalvar ("trace_func"), func_val
);
311 /* save file name as "$trace_file", a debugger variable visible to users */
312 if (traceframe_sal
.symtab
== NULL
||
313 traceframe_sal
.symtab
->filename
== NULL
)
314 set_internalvar (lookup_internalvar ("trace_file"),
315 value_from_pointer (charstar
, (LONGEST
) 0));
318 len
= strlen (traceframe_sal
.symtab
->filename
);
319 file_range
= create_range_type (file_range
,
320 builtin_type_int
, 0, len
- 1);
321 file_string
= create_array_type (file_string
,
322 builtin_type_char
, file_range
);
323 file_val
= allocate_value (file_string
);
324 VALUE_TYPE (file_val
) = file_string
;
325 memcpy (VALUE_CONTENTS_RAW (file_val
),
326 traceframe_sal
.symtab
->filename
,
328 file_val
->modifiable
= 0;
329 set_internalvar (lookup_internalvar ("trace_file"), file_val
);
333 /* Low level routine to set a tracepoint.
334 Returns the tracepoint object so caller can set other things.
335 Does not set the tracepoint number!
336 Does not print anything.
338 ==> This routine should not be called if there is a chance of later
339 error(); otherwise it leaves a bogus tracepoint on the chain. Validate
340 your arguments BEFORE calling this routine! */
342 static struct tracepoint
*
343 set_raw_tracepoint (struct symtab_and_line sal
)
345 register struct tracepoint
*t
, *tc
;
346 struct cleanup
*old_chain
;
348 t
= (struct tracepoint
*) xmalloc (sizeof (struct tracepoint
));
349 old_chain
= make_cleanup (xfree
, t
);
350 memset (t
, 0, sizeof (*t
));
352 if (sal
.symtab
== NULL
)
353 t
->source_file
= NULL
;
355 t
->source_file
= savestring (sal
.symtab
->filename
,
356 strlen (sal
.symtab
->filename
));
358 t
->section
= sal
.section
;
359 t
->language
= current_language
->la_language
;
360 t
->input_radix
= input_radix
;
361 t
->line_number
= sal
.line
;
366 t
->addr_string
= NULL
;
368 /* Add this tracepoint to the end of the chain
369 so that a list of tracepoints will come out in order
370 of increasing numbers. */
372 tc
= tracepoint_chain
;
374 tracepoint_chain
= t
;
381 discard_cleanups (old_chain
);
385 /* Set a tracepoint according to ARG (function, linenum or *address) */
387 trace_command (char *arg
, int from_tty
)
389 char **canonical
= (char **) NULL
;
390 struct symtabs_and_lines sals
;
391 struct symtab_and_line sal
;
392 struct tracepoint
*t
;
393 char *addr_start
= 0, *addr_end
= 0;
397 error ("trace command requires an argument");
399 if (from_tty
&& info_verbose
)
400 printf_filtered ("TRACE %s\n", arg
);
403 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
, 0, &canonical
);
406 return; /* ??? Presumably decode_line_1 has already warned? */
408 /* Resolve all line numbers to PC's */
409 for (i
= 0; i
< sals
.nelts
; i
++)
410 resolve_sal_pc (&sals
.sals
[i
]);
412 /* Now set all the tracepoints. */
413 for (i
= 0; i
< sals
.nelts
; i
++)
417 t
= set_raw_tracepoint (sal
);
418 set_tracepoint_count (tracepoint_count
+ 1);
419 t
->number
= tracepoint_count
;
421 /* If a canonical line spec is needed use that instead of the
423 if (canonical
!= (char **) NULL
&& canonical
[i
] != NULL
)
424 t
->addr_string
= canonical
[i
];
426 t
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
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_p
? "y" : "n");
504 if (TARGET_ADDR_BIT
<= 32)
505 tmp
= local_hex_string_custom (t
->address
506 & (CORE_ADDR
) 0xffffffff,
509 tmp
= 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 */
575 tracepoint_modify_event (t
->number
);
579 tracepoint_modify_event (t
->number
);
582 if (tracepoint_chain
== t
)
583 tracepoint_chain
= t
->next
;
588 tracepoint_delete_event (t2
->number
);
594 xfree (t
->addr_string
);
596 xfree (t
->source_file
);
605 /* Utility: parse a tracepoint number and look it up in the list.
606 If MULTI_P is true, there might be a range of tracepoints in ARG.
607 if OPTIONAL_P is true, then if the argument is missing, the most
608 recent tracepoint (tracepoint_count) is returned. */
610 get_tracepoint_by_number (char **arg
, int multi_p
, int optional_p
)
612 struct tracepoint
*t
;
614 char *instring
= arg
== NULL
? NULL
: *arg
;
616 if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
619 tpnum
= tracepoint_count
;
621 error_no_arg ("tracepoint number");
624 tpnum
= multi_p
? get_number_or_range (arg
) : get_number (arg
);
628 if (instring
&& *instring
)
629 printf_filtered ("bad tracepoint number at or near '%s'\n", instring
);
631 printf_filtered ("Tracepoint argument missing and no previous tracepoint\n");
636 if (t
->number
== tpnum
)
641 /* FIXME: if we are in the middle of a range we don't want to give
642 a message. The current interface to get_number_or_range doesn't
643 allow us to discover this. */
644 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
648 /* Utility: parse a list of tracepoint numbers, and call a func for each. */
650 map_args_over_tracepoints (char *args
, int from_tty
,
651 enum tracepoint_opcode opcode
)
653 struct tracepoint
*t
, *tmp
;
655 if (args
== 0 || *args
== 0) /* do them all */
656 ALL_TRACEPOINTS_SAFE (t
, tmp
)
657 tracepoint_operation (t
, from_tty
, opcode
);
661 QUIT
; /* give user option to bail out with ^C */
662 t
= get_tracepoint_by_number (&args
, 1, 0);
663 tracepoint_operation (t
, from_tty
, opcode
);
664 while (*args
== ' ' || *args
== '\t')
669 /* The 'enable trace' command enables tracepoints. Not supported by all targets. */
671 enable_trace_command (char *args
, int from_tty
)
674 map_args_over_tracepoints (args
, from_tty
, enable_op
);
677 /* The 'disable trace' command enables tracepoints. Not supported by all targets. */
679 disable_trace_command (char *args
, int from_tty
)
682 map_args_over_tracepoints (args
, from_tty
, disable_op
);
685 /* Remove a tracepoint (or all if no argument) */
687 delete_trace_command (char *args
, int from_tty
)
690 if (!args
|| !*args
) /* No args implies all tracepoints; */
691 if (from_tty
) /* confirm only if from_tty... */
692 if (tracepoint_chain
) /* and if there are tracepoints to delete! */
693 if (!query ("Delete all tracepoints? "))
696 map_args_over_tracepoints (args
, from_tty
, delete_op
);
699 /* Set passcount for tracepoint.
701 First command argument is passcount, second is tracepoint number.
702 If tracepoint number omitted, apply to most recently defined.
703 Also accepts special argument "all". */
706 trace_pass_command (char *args
, int from_tty
)
708 struct tracepoint
*t1
= (struct tracepoint
*) -1, *t2
;
712 if (args
== 0 || *args
== 0)
713 error ("passcount command requires an argument (count + optional TP num)");
715 count
= strtoul (args
, &args
, 10); /* count comes first, then TP num */
717 while (*args
&& isspace ((int) *args
))
720 if (*args
&& strncasecmp (args
, "all", 3) == 0)
722 args
+= 3; /* skip special argument "all" */
725 error ("Junk at end of arguments.");
728 t1
= get_tracepoint_by_number (&args
, 1, 1);
735 if (t1
== (struct tracepoint
*) -1 || t1
== t2
)
737 t2
->pass_count
= count
;
738 tracepoint_modify_event (t2
->number
);
740 printf_filtered ("Setting tracepoint %d's passcount to %d\n",
744 t1
= get_tracepoint_by_number (&args
, 1, 0);
750 /* ACTIONS functions: */
752 /* Prototypes for action-parsing utility commands */
753 static void read_actions (struct tracepoint
*);
755 /* The three functions:
756 collect_pseudocommand,
757 while_stepping_pseudocommand, and
758 end_actions_pseudocommand
759 are placeholders for "commands" that are actually ONLY to be used
760 within a tracepoint action list. If the actual function is ever called,
761 it means that somebody issued the "command" at the top level,
762 which is always an error. */
765 end_actions_pseudocommand (char *args
, int from_tty
)
767 error ("This command cannot be used at the top level.");
771 while_stepping_pseudocommand (char *args
, int from_tty
)
773 error ("This command can only be used in a tracepoint actions list.");
777 collect_pseudocommand (char *args
, int from_tty
)
779 error ("This command can only be used in a tracepoint actions list.");
782 /* Enter a list of actions for a tracepoint. */
784 trace_actions_command (char *args
, int from_tty
)
786 struct tracepoint
*t
;
788 char *end_msg
= "End with a line saying just \"end\".";
790 t
= get_tracepoint_by_number (&args
, 0, 1);
793 sprintf (tmpbuf
, "Enter actions for tracepoint %d, one per line.",
798 if (readline_begin_hook
)
799 (*readline_begin_hook
) ("%s %s\n", tmpbuf
, end_msg
);
800 else if (input_from_terminal_p ())
801 printf_filtered ("%s\n%s\n", tmpbuf
, end_msg
);
805 t
->step_count
= 0; /* read_actions may set this */
808 if (readline_end_hook
)
809 (*readline_end_hook
) ();
810 /* tracepoints_changed () */
812 /* else just return */
815 /* worker function */
817 read_actions (struct tracepoint
*t
)
820 char *prompt1
= "> ", *prompt2
= " > ";
821 char *prompt
= prompt1
;
822 enum actionline_type linetype
;
823 extern FILE *instream
;
824 struct action_line
*next
= NULL
, *temp
;
825 struct cleanup
*old_chain
;
827 /* Control-C quits instantly if typed while in this loop
828 since it should not wait until the user types a newline. */
830 /* FIXME: kettenis/20010823: Something is wrong here. In this file
831 STOP_SIGNAL is never defined. So this code has been left out, at
832 least for quite a while now. Replacing STOP_SIGNAL with SIGTSTP
833 leads to compilation failures since the variable job_control
834 isn't declared. Leave this alone for now. */
839 signal (STOP_SIGNAL
, handle_stop_sig
);
841 signal (STOP_SIGNAL
, stop_sig
);
844 old_chain
= make_cleanup_free_actions (t
);
847 /* Make sure that all output has been output. Some machines may let
848 you get away with leaving out some of the gdb_flush, but not all. */
850 gdb_flush (gdb_stdout
);
851 gdb_flush (gdb_stderr
);
853 if (readline_hook
&& instream
== NULL
)
854 line
= (*readline_hook
) (prompt
);
855 else if (instream
== stdin
&& ISATTY (instream
))
857 line
= gdb_readline_wrapper (prompt
);
858 if (line
&& *line
) /* add it to command history */
862 line
= gdb_readline (0);
864 linetype
= validate_actionline (&line
, t
);
865 if (linetype
== BADLINE
)
866 continue; /* already warned -- collect another line */
868 temp
= xmalloc (sizeof (struct action_line
));
872 if (next
== NULL
) /* first action for this tracepoint? */
873 t
->actions
= next
= temp
;
880 if (linetype
== STEPPING
) /* begin "while-stepping" */
882 if (prompt
== prompt2
)
884 warning ("Already processing 'while-stepping'");
888 prompt
= prompt2
; /* change prompt for stepping actions */
890 else if (linetype
== END
)
892 if (prompt
== prompt2
)
894 prompt
= prompt1
; /* end of single-stepping actions */
897 { /* end of actions */
898 if (t
->actions
->next
== NULL
)
900 /* an "end" all by itself with no other actions means
901 this tracepoint has no actions. Discard empty list. */
910 signal (STOP_SIGNAL
, SIG_DFL
);
913 discard_cleanups (old_chain
);
916 /* worker function */
918 validate_actionline (char **line
, struct tracepoint
*t
)
920 struct cmd_list_element
*c
;
921 struct expression
*exp
= NULL
;
922 struct cleanup
*old_chain
= NULL
;
925 for (p
= *line
; isspace ((int) *p
);)
928 /* symbol lookup etc. */
929 if (*p
== '\0') /* empty line: just prompt for another line. */
932 if (*p
== '#') /* comment line */
935 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
938 warning ("'%s' is not an action that I know, or is ambiguous.", p
);
942 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
944 struct agent_expr
*aexpr
;
945 struct agent_reqs areqs
;
948 { /* repeat over a comma-separated list */
949 QUIT
; /* allow user to bail out with ^C */
950 while (isspace ((int) *p
))
953 if (*p
== '$') /* look for special pseudo-symbols */
955 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
956 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
957 (0 == strncasecmp ("loc", p
+ 1, 3)))
962 /* else fall thru, treat p as an expression and parse it! */
964 exp
= parse_exp_1 (&p
, block_for_pc (t
->address
), 1);
965 old_chain
= make_cleanup (free_current_contents
, &exp
);
967 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
969 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
971 warning ("constant %s (value %ld) will not be collected.",
972 SYMBOL_NAME (exp
->elts
[2].symbol
),
973 SYMBOL_VALUE (exp
->elts
[2].symbol
));
976 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
978 warning ("%s is optimized away and cannot be collected.",
979 SYMBOL_NAME (exp
->elts
[2].symbol
));
984 /* we have something to collect, make sure that the expr to
985 bytecode translator can handle it and that it's not too long */
986 aexpr
= gen_trace_for_expr (t
->address
, exp
);
987 make_cleanup_free_agent_expr (aexpr
);
989 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
990 error ("expression too complicated, try simplifying");
992 ax_reqs (aexpr
, &areqs
);
993 (void) make_cleanup (xfree
, areqs
.reg_mask
);
995 if (areqs
.flaw
!= agent_flaw_none
)
996 error ("malformed expression");
998 if (areqs
.min_height
< 0)
999 error ("gdb: Internal error: expression has min height < 0");
1001 if (areqs
.max_height
> 20)
1002 error ("expression too complicated, try simplifying");
1004 do_cleanups (old_chain
);
1006 while (p
&& *p
++ == ',');
1009 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
1011 char *steparg
; /* in case warning is necessary */
1013 while (isspace ((int) *p
))
1018 (t
->step_count
= strtol (p
, &p
, 0)) == 0)
1020 warning ("'%s': bad step-count; command ignored.", *line
);
1025 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
1029 warning ("'%s' is not a supported tracepoint action.", *line
);
1034 /* worker function */
1036 free_actions (struct tracepoint
*t
)
1038 struct action_line
*line
, *next
;
1040 for (line
= t
->actions
; line
; line
= next
)
1044 xfree (line
->action
);
1051 do_free_actions_cleanup (void *t
)
1056 static struct cleanup
*
1057 make_cleanup_free_actions (struct tracepoint
*t
)
1059 return make_cleanup (do_free_actions_cleanup
, t
);
1064 int type
; /* 0 for absolute memory range, else basereg number */
1065 bfd_signed_vma start
;
1069 struct collection_list
1071 unsigned char regs_mask
[8]; /* room for up to 256 regs */
1074 struct memrange
*list
;
1075 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
1076 long next_aexpr_elt
;
1077 struct agent_expr
**aexpr_list
;
1080 tracepoint_list
, stepping_list
;
1082 /* MEMRANGE functions: */
1084 static int memrange_cmp (const void *, const void *);
1086 /* compare memranges for qsort */
1088 memrange_cmp (const void *va
, const void *vb
)
1090 const struct memrange
*a
= va
, *b
= vb
;
1092 if (a
->type
< b
->type
)
1094 if (a
->type
> b
->type
)
1098 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
1100 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
1105 if (a
->start
< b
->start
)
1107 if (a
->start
> b
->start
)
1113 /* Sort the memrange list using qsort, and merge adjacent memranges */
1115 memrange_sortmerge (struct collection_list
*memranges
)
1119 qsort (memranges
->list
, memranges
->next_memrange
,
1120 sizeof (struct memrange
), memrange_cmp
);
1121 if (memranges
->next_memrange
> 0)
1123 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
1125 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
1126 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
1127 MAX_REGISTER_VIRTUAL_SIZE
)
1129 /* memrange b starts before memrange a ends; merge them. */
1130 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
1131 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
1132 continue; /* next b, same a */
1136 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
1137 sizeof (struct memrange
));
1139 memranges
->next_memrange
= a
+ 1;
1143 /* Add a register to a collection list */
1145 add_register (struct collection_list
*collection
, unsigned int regno
)
1148 printf_filtered ("collect register %d\n", regno
);
1149 if (regno
> (8 * sizeof (collection
->regs_mask
)))
1150 error ("Internal: register number %d too large for tracepoint",
1152 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
1155 /* Add a memrange to a collection list */
1157 add_memrange (struct collection_list
*memranges
, int type
, bfd_signed_vma base
,
1162 printf_filtered ("(%d,", type
);
1164 printf_filtered (",%ld)\n", len
);
1167 /* type: 0 == memory, n == basereg */
1168 memranges
->list
[memranges
->next_memrange
].type
= type
;
1169 /* base: addr if memory, offset if reg relative. */
1170 memranges
->list
[memranges
->next_memrange
].start
= base
;
1171 /* len: we actually save end (base + len) for convenience */
1172 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
1173 memranges
->next_memrange
++;
1174 if (memranges
->next_memrange
>= memranges
->listsize
)
1176 memranges
->listsize
*= 2;
1177 memranges
->list
= xrealloc (memranges
->list
,
1178 memranges
->listsize
);
1181 if (type
!= -1) /* better collect the base register! */
1182 add_register (memranges
, type
);
1185 /* Add a symbol to a collection list */
1187 collect_symbol (struct collection_list
*collect
, struct symbol
*sym
,
1188 long frame_regno
, long frame_offset
)
1192 bfd_signed_vma offset
;
1194 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
1195 switch (SYMBOL_CLASS (sym
))
1198 printf_filtered ("%s: don't know symbol class %d\n",
1199 SYMBOL_NAME (sym
), SYMBOL_CLASS (sym
));
1202 printf_filtered ("constant %s (value %ld) will not be collected.\n",
1203 SYMBOL_NAME (sym
), SYMBOL_VALUE (sym
));
1206 offset
= SYMBOL_VALUE_ADDRESS (sym
);
1211 sprintf_vma (tmp
, offset
);
1212 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1213 SYMBOL_NAME (sym
), len
, tmp
/* address */);
1215 add_memrange (collect
, -1, offset
, len
); /* 0 == memory */
1219 reg
= SYMBOL_VALUE (sym
);
1221 printf_filtered ("LOC_REG[parm] %s: ", SYMBOL_NAME (sym
));
1222 add_register (collect
, reg
);
1223 /* check for doubles stored in two registers */
1224 /* FIXME: how about larger types stored in 3 or more regs? */
1225 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1226 len
> REGISTER_RAW_SIZE (reg
))
1227 add_register (collect
, reg
+ 1);
1230 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1231 printf_filtered (" (will not collect %s)\n",
1236 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1239 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1240 SYMBOL_NAME (sym
), len
);
1241 printf_vma (offset
);
1242 printf_filtered (" from frame ptr reg %d\n", reg
);
1244 add_memrange (collect
, reg
, offset
, len
);
1246 case LOC_REGPARM_ADDR
:
1247 reg
= SYMBOL_VALUE (sym
);
1251 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1252 SYMBOL_NAME (sym
), len
);
1253 printf_vma (offset
);
1254 printf_filtered (" from reg %d\n", reg
);
1256 add_memrange (collect
, reg
, offset
, len
);
1261 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1264 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1265 SYMBOL_NAME (sym
), len
);
1266 printf_vma (offset
);
1267 printf_filtered (" from frame ptr reg %d\n", reg
);
1269 add_memrange (collect
, reg
, offset
, len
);
1272 case LOC_BASEREG_ARG
:
1273 reg
= SYMBOL_BASEREG (sym
);
1274 offset
= SYMBOL_VALUE (sym
);
1277 printf_filtered ("LOC_BASEREG %s: collect %ld bytes at offset ",
1278 SYMBOL_NAME (sym
), len
);
1279 printf_vma (offset
);
1280 printf_filtered (" from basereg %d\n", reg
);
1282 add_memrange (collect
, reg
, offset
, len
);
1284 case LOC_UNRESOLVED
:
1285 printf_filtered ("Don't know LOC_UNRESOLVED %s\n", SYMBOL_NAME (sym
));
1287 case LOC_OPTIMIZED_OUT
:
1288 printf_filtered ("%s has been optimized out of existence.\n",
1294 /* Add all locals (or args) symbols to collection list */
1296 add_local_symbols (struct collection_list
*collect
, CORE_ADDR pc
,
1297 long frame_regno
, long frame_offset
, int type
)
1300 struct block
*block
;
1303 block
= block_for_pc (pc
);
1306 QUIT
; /* allow user to bail out with ^C */
1307 ALL_BLOCK_SYMBOLS (block
, i
, sym
)
1309 switch (SYMBOL_CLASS (sym
))
1312 warning ("don't know how to trace local symbol %s",
1318 if (type
== 'L') /* collecting Locals */
1321 collect_symbol (collect
, sym
, frame_regno
, frame_offset
);
1328 case LOC_REGPARM_ADDR
:
1329 case LOC_BASEREG_ARG
:
1330 if (type
== 'A') /* collecting Arguments */
1333 collect_symbol (collect
, sym
, frame_regno
, frame_offset
);
1337 if (BLOCK_FUNCTION (block
))
1340 block
= BLOCK_SUPERBLOCK (block
);
1343 warning ("No %s found in scope.", type
== 'L' ? "locals" : "args");
1346 /* worker function */
1348 clear_collection_list (struct collection_list
*list
)
1352 list
->next_memrange
= 0;
1353 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1355 free_agent_expr (list
->aexpr_list
[ndx
]);
1356 list
->aexpr_list
[ndx
] = NULL
;
1358 list
->next_aexpr_elt
= 0;
1359 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1362 /* reduce a collection list to string form (for gdb protocol) */
1364 stringify_collection_list (struct collection_list
*list
, char *string
)
1366 char temp_buf
[2048];
1370 char *(*str_list
)[];
1374 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1375 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1377 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1378 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1380 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1383 printf_filtered ("\nCollecting registers (mask): 0x");
1388 QUIT
; /* allow user to bail out with ^C */
1390 printf_filtered ("%02X", list
->regs_mask
[i
]);
1391 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1394 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1398 printf_filtered ("\n");
1399 if (list
->next_memrange
> 0 && info_verbose
)
1400 printf_filtered ("Collecting memranges: \n");
1401 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1403 QUIT
; /* allow user to bail out with ^C */
1404 sprintf_vma (tmp2
, list
->list
[i
].start
);
1407 printf_filtered ("(%d, %s, %ld)\n",
1410 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1412 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1414 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1420 sprintf (end
, "M%X,%s,%lX",
1423 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1425 count
+= strlen (end
);
1429 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1431 QUIT
; /* allow user to bail out with ^C */
1432 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1434 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1439 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1440 end
+= 10; /* 'X' + 8 hex digits + ',' */
1443 end
= mem2hex (list
->aexpr_list
[i
]->buf
, end
, list
->aexpr_list
[i
]->len
);
1444 count
+= 2 * list
->aexpr_list
[i
]->len
;
1449 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1454 (*str_list
)[ndx
] = NULL
;
1463 free_actions_list_cleanup_wrapper (void *al
)
1465 free_actions_list (al
);
1469 free_actions_list (char **actions_list
)
1473 if (actions_list
== 0)
1476 for (ndx
= 0; actions_list
[ndx
]; ndx
++)
1477 xfree (actions_list
[ndx
]);
1479 xfree (actions_list
);
1482 /* render all actions into gdb protocol */
1484 encode_actions (struct tracepoint
*t
, char ***tdp_actions
,
1485 char ***stepping_actions
)
1487 static char tdp_buff
[2048], step_buff
[2048];
1489 struct expression
*exp
= NULL
;
1490 struct action_line
*action
;
1492 struct value
*tempval
;
1493 struct collection_list
*collect
;
1494 struct cmd_list_element
*cmd
;
1495 struct agent_expr
*aexpr
;
1497 LONGEST frame_offset
;
1500 clear_collection_list (&tracepoint_list
);
1501 clear_collection_list (&stepping_list
);
1502 collect
= &tracepoint_list
;
1504 *tdp_actions
= NULL
;
1505 *stepping_actions
= NULL
;
1507 TARGET_VIRTUAL_FRAME_POINTER (t
->address
, &frame_reg
, &frame_offset
);
1509 for (action
= t
->actions
; action
; action
= action
->next
)
1511 QUIT
; /* allow user to bail out with ^C */
1512 action_exp
= action
->action
;
1513 while (isspace ((int) *action_exp
))
1516 if (*action_exp
== '#') /* comment line */
1519 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1521 error ("Bad action list item: %s", action_exp
);
1523 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1526 { /* repeat over a comma-separated list */
1527 QUIT
; /* allow user to bail out with ^C */
1528 while (isspace ((int) *action_exp
))
1531 if (0 == strncasecmp ("$reg", action_exp
, 4))
1533 for (i
= 0; i
< NUM_REGS
; i
++)
1534 add_register (collect
, i
);
1535 action_exp
= strchr (action_exp
, ','); /* more? */
1537 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1539 add_local_symbols (collect
,
1544 action_exp
= strchr (action_exp
, ','); /* more? */
1546 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1548 add_local_symbols (collect
,
1553 action_exp
= strchr (action_exp
, ','); /* more? */
1557 unsigned long addr
, len
;
1558 struct cleanup
*old_chain
= NULL
;
1559 struct cleanup
*old_chain1
= NULL
;
1560 struct agent_reqs areqs
;
1562 exp
= parse_exp_1 (&action_exp
,
1563 block_for_pc (t
->address
), 1);
1564 old_chain
= make_cleanup (free_current_contents
, &exp
);
1566 switch (exp
->elts
[0].opcode
)
1569 i
= exp
->elts
[1].longconst
;
1571 printf_filtered ("OP_REGISTER: ");
1572 add_register (collect
, i
);
1576 /* safe because we know it's a simple expression */
1577 tempval
= evaluate_expression (exp
);
1578 addr
= VALUE_ADDRESS (tempval
) + VALUE_OFFSET (tempval
);
1579 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1580 add_memrange (collect
, -1, addr
, len
);
1584 collect_symbol (collect
,
1585 exp
->elts
[2].symbol
,
1590 default: /* full-fledged expression */
1591 aexpr
= gen_trace_for_expr (t
->address
, exp
);
1593 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1595 ax_reqs (aexpr
, &areqs
);
1596 if (areqs
.flaw
!= agent_flaw_none
)
1597 error ("malformed expression");
1599 if (areqs
.min_height
< 0)
1600 error ("gdb: Internal error: expression has min height < 0");
1601 if (areqs
.max_height
> 20)
1602 error ("expression too complicated, try simplifying");
1604 discard_cleanups (old_chain1
);
1605 add_aexpr (collect
, aexpr
);
1607 /* take care of the registers */
1608 if (areqs
.reg_mask_len
> 0)
1613 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1615 QUIT
; /* allow user to bail out with ^C */
1616 if (areqs
.reg_mask
[ndx1
] != 0)
1618 /* assume chars have 8 bits */
1619 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1620 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1621 /* it's used -- record it */
1622 add_register (collect
, ndx1
* 8 + ndx2
);
1628 do_cleanups (old_chain
);
1631 while (action_exp
&& *action_exp
++ == ',');
1633 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1635 collect
= &stepping_list
;
1637 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
1639 if (collect
== &stepping_list
) /* end stepping actions */
1640 collect
= &tracepoint_list
;
1642 break; /* end tracepoint actions */
1645 memrange_sortmerge (&tracepoint_list
);
1646 memrange_sortmerge (&stepping_list
);
1648 *tdp_actions
= stringify_collection_list (&tracepoint_list
, tdp_buff
);
1649 *stepping_actions
= stringify_collection_list (&stepping_list
, step_buff
);
1653 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1655 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1657 collect
->aexpr_list
=
1658 xrealloc (collect
->aexpr_list
,
1659 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1660 collect
->aexpr_listsize
*= 2;
1662 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1663 collect
->next_aexpr_elt
++;
1666 static char target_buf
[2048];
1668 /* Set "transparent" memory ranges
1670 Allow trace mechanism to treat text-like sections
1671 (and perhaps all read-only sections) transparently,
1672 i.e. don't reject memory requests from these address ranges
1673 just because they haven't been collected. */
1676 remote_set_transparent_ranges (void)
1678 extern bfd
*exec_bfd
;
1685 return; /* no information to give. */
1687 strcpy (target_buf
, "QTro");
1688 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
1690 char tmp1
[40], tmp2
[40];
1692 if ((s
->flags
& SEC_LOAD
) == 0 ||
1693 /* (s->flags & SEC_CODE) == 0 || */
1694 (s
->flags
& SEC_READONLY
) == 0)
1699 size
= bfd_get_section_size_before_reloc (s
);
1700 sprintf_vma (tmp1
, lma
);
1701 sprintf_vma (tmp2
, lma
+ size
);
1702 sprintf (target_buf
+ strlen (target_buf
),
1703 ":%s,%s", tmp1
, tmp2
);
1707 putpkt (target_buf
);
1708 getpkt (target_buf
, sizeof (target_buf
), 0);
1714 Tell target to clear any previous trace experiment.
1715 Walk the list of tracepoints, and send them (and their actions)
1716 to the target. If no errors,
1717 Tell target to start a new trace experiment. */
1720 trace_start_command (char *args
, int from_tty
)
1721 { /* STUB_COMM MOSTLY_IMPLEMENTED */
1722 struct tracepoint
*t
;
1725 char **stepping_actions
;
1727 struct cleanup
*old_chain
= NULL
;
1729 dont_repeat (); /* like "run", dangerous to repeat accidentally */
1731 if (target_is_remote ())
1734 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1735 if (strcmp (target_buf
, "OK"))
1736 error ("Target does not support this command.");
1742 sprintf_vma (tmp
, t
->address
);
1743 sprintf (buf
, "QTDP:%x:%s:%c:%lx:%x", t
->number
, tmp
, /* address */
1744 t
->enabled_p
? 'E' : 'D',
1745 t
->step_count
, t
->pass_count
);
1750 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1751 if (strcmp (target_buf
, "OK"))
1752 error ("Target does not support tracepoints.");
1756 encode_actions (t
, &tdp_actions
, &stepping_actions
);
1757 old_chain
= make_cleanup (free_actions_list_cleanup_wrapper
,
1759 (void) make_cleanup (free_actions_list_cleanup_wrapper
,
1762 /* do_single_steps (t); */
1765 for (ndx
= 0; tdp_actions
[ndx
]; ndx
++)
1767 QUIT
; /* allow user to bail out with ^C */
1768 sprintf (buf
, "QTDP:-%x:%s:%s%c",
1769 t
->number
, tmp
, /* address */
1771 ((tdp_actions
[ndx
+ 1] || stepping_actions
)
1774 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1775 if (strcmp (target_buf
, "OK"))
1776 error ("Error on target while setting tracepoints.");
1779 if (stepping_actions
)
1781 for (ndx
= 0; stepping_actions
[ndx
]; ndx
++)
1783 QUIT
; /* allow user to bail out with ^C */
1784 sprintf (buf
, "QTDP:-%x:%s:%s%s%s",
1785 t
->number
, tmp
, /* address */
1786 ((ndx
== 0) ? "S" : ""),
1787 stepping_actions
[ndx
],
1788 (stepping_actions
[ndx
+ 1] ? "-" : ""));
1790 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1791 if (strcmp (target_buf
, "OK"))
1792 error ("Error on target while setting tracepoints.");
1796 do_cleanups (old_chain
);
1799 /* Tell target to treat text-like sections as transparent */
1800 remote_set_transparent_ranges ();
1801 /* Now insert traps and begin collecting data */
1803 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1804 if (strcmp (target_buf
, "OK"))
1805 error ("Bogus reply from target: %s", target_buf
);
1806 set_traceframe_num (-1); /* all old traceframes invalidated */
1807 set_tracepoint_num (-1);
1808 set_traceframe_context (-1);
1809 trace_running_p
= 1;
1810 if (trace_start_stop_hook
)
1811 trace_start_stop_hook (1, from_tty
);
1815 error ("Trace can only be run on remote targets.");
1820 trace_stop_command (char *args
, int from_tty
)
1821 { /* STUB_COMM IS_IMPLEMENTED */
1822 if (target_is_remote ())
1825 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1826 if (strcmp (target_buf
, "OK"))
1827 error ("Bogus reply from target: %s", target_buf
);
1828 trace_running_p
= 0;
1829 if (trace_start_stop_hook
)
1830 trace_start_stop_hook (0, from_tty
);
1833 error ("Trace can only be run on remote targets.");
1836 unsigned long trace_running_p
;
1838 /* tstatus command */
1840 trace_status_command (char *args
, int from_tty
)
1841 { /* STUB_COMM IS_IMPLEMENTED */
1842 if (target_is_remote ())
1844 putpkt ("qTStatus");
1845 remote_get_noisy_reply (target_buf
, sizeof (target_buf
));
1847 if (target_buf
[0] != 'T' ||
1848 (target_buf
[1] != '0' && target_buf
[1] != '1'))
1849 error ("Bogus reply from target: %s", target_buf
);
1851 /* exported for use by the GUI */
1852 trace_running_p
= (target_buf
[1] == '1');
1855 error ("Trace can only be run on remote targets.");
1858 /* Worker function for the various flavors of the tfind command */
1860 finish_tfind_command (char *msg
,
1864 int target_frameno
= -1, target_tracept
= -1;
1865 CORE_ADDR old_frame_addr
;
1866 struct symbol
*old_func
;
1869 old_frame_addr
= FRAME_FP (get_current_frame ());
1870 old_func
= find_pc_function (read_pc ());
1873 reply
= remote_get_noisy_reply (msg
, sizeof_msg
);
1875 while (reply
&& *reply
)
1879 if ((target_frameno
= (int) strtol (++reply
, &reply
, 16)) == -1)
1881 /* A request for a non-existant trace frame has failed.
1882 Our response will be different, depending on FROM_TTY:
1884 If FROM_TTY is true, meaning that this command was
1885 typed interactively by the user, then give an error
1886 and DO NOT change the state of traceframe_number etc.
1888 However if FROM_TTY is false, meaning that we're either
1889 in a script, a loop, or a user-defined command, then
1890 DON'T give an error, but DO change the state of
1891 traceframe_number etc. to invalid.
1893 The rationalle is that if you typed the command, you
1894 might just have committed a typo or something, and you'd
1895 like to NOT lose your current debugging state. However
1896 if you're in a user-defined command or especially in a
1897 loop, then you need a way to detect that the command
1898 failed WITHOUT aborting. This allows you to write
1899 scripts that search thru the trace buffer until the end,
1900 and then continue on to do something else. */
1903 error ("Target failed to find requested trace frame.");
1907 printf_filtered ("End of trace buffer.\n");
1908 /* The following will not recurse, since it's special-cased */
1909 trace_find_command ("-1", from_tty
);
1910 reply
= NULL
; /* break out of loop,
1911 (avoid recursive nonsense) */
1916 if ((target_tracept
= (int) strtol (++reply
, &reply
, 16)) == -1)
1917 error ("Target failed to find requested trace frame.");
1919 case 'O': /* "OK"? */
1920 if (reply
[1] == 'K' && reply
[2] == '\0')
1923 error ("Bogus reply from target: %s", reply
);
1926 error ("Bogus reply from target: %s", reply
);
1929 flush_cached_frames ();
1930 registers_changed ();
1931 select_frame (get_current_frame ());
1932 set_traceframe_num (target_frameno
);
1933 set_tracepoint_num (target_tracept
);
1934 if (target_frameno
== -1)
1935 set_traceframe_context (-1);
1937 set_traceframe_context (read_pc ());
1943 /* NOTE: in immitation of the step command, try to determine
1944 whether we have made a transition from one function to another.
1945 If so, we'll print the "stack frame" (ie. the new function and
1946 it's arguments) -- otherwise we'll just show the new source line.
1948 This determination is made by checking (1) whether the current
1949 function has changed, and (2) whether the current FP has changed.
1950 Hack: if the FP wasn't collected, either at the current or the
1951 previous frame, assume that the FP has NOT changed. */
1953 if (old_func
== find_pc_function (read_pc ()) &&
1954 (old_frame_addr
== 0 ||
1955 FRAME_FP (get_current_frame ()) == 0 ||
1956 old_frame_addr
== FRAME_FP (get_current_frame ())))
1961 print_stack_frame (selected_frame
, frame_relative_level (selected_frame
),
1967 /* trace_find_command takes a trace frame number n,
1968 sends "QTFrame:<n>" to the target,
1969 and accepts a reply that may contain several optional pieces
1970 of information: a frame number, a tracepoint number, and an
1971 indication of whether this is a trap frame or a stepping frame.
1973 The minimal response is just "OK" (which indicates that the
1974 target does not give us a frame number or a tracepoint number).
1975 Instead of that, the target may send us a string containing
1977 F<hexnum> (gives the selected frame number)
1978 T<hexnum> (gives the selected tracepoint number)
1983 trace_find_command (char *args
, int from_tty
)
1984 { /* STUB_COMM PART_IMPLEMENTED */
1985 /* this should only be called with a numeric argument */
1988 if (target_is_remote ())
1990 if (trace_find_hook
)
1991 trace_find_hook (args
, from_tty
);
1993 if (args
== 0 || *args
== 0)
1994 { /* TFIND with no args means find NEXT trace frame. */
1995 if (traceframe_number
== -1)
1996 frameno
= 0; /* "next" is first one */
1998 frameno
= traceframe_number
+ 1;
2000 else if (0 == strcmp (args
, "-"))
2002 if (traceframe_number
== -1)
2003 error ("not debugging trace buffer");
2004 else if (from_tty
&& traceframe_number
== 0)
2005 error ("already at start of trace buffer");
2007 frameno
= traceframe_number
- 1;
2010 frameno
= parse_and_eval_long (args
);
2013 error ("invalid input (%d is less than zero)", frameno
);
2015 sprintf (target_buf
, "QTFrame:%x", frameno
);
2016 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2019 error ("Trace can only be run on remote targets.");
2024 trace_find_end_command (char *args
, int from_tty
)
2026 trace_find_command ("-1", from_tty
);
2031 trace_find_none_command (char *args
, int from_tty
)
2033 trace_find_command ("-1", from_tty
);
2038 trace_find_start_command (char *args
, int from_tty
)
2040 trace_find_command ("0", from_tty
);
2043 /* tfind pc command */
2045 trace_find_pc_command (char *args
, int from_tty
)
2046 { /* STUB_COMM PART_IMPLEMENTED */
2050 if (target_is_remote ())
2052 if (args
== 0 || *args
== 0)
2053 pc
= read_pc (); /* default is current pc */
2055 pc
= parse_and_eval_address (args
);
2057 sprintf_vma (tmp
, pc
);
2058 sprintf (target_buf
, "QTFrame:pc:%s", tmp
);
2059 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2062 error ("Trace can only be run on remote targets.");
2065 /* tfind tracepoint command */
2067 trace_find_tracepoint_command (char *args
, int from_tty
)
2068 { /* STUB_COMM PART_IMPLEMENTED */
2071 if (target_is_remote ())
2073 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 */
2081 tdp
= parse_and_eval_long (args
);
2083 sprintf (target_buf
, "QTFrame:tdp:%x", tdp
);
2084 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2087 error ("Trace can only be run on remote targets.");
2090 /* TFIND LINE command:
2092 This command will take a sourceline for argument, just like BREAK
2093 or TRACE (ie. anything that "decode_line_1" can handle).
2095 With no argument, this command will find the next trace frame
2096 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2099 trace_find_line_command (char *args
, int from_tty
)
2100 { /* STUB_COMM PART_IMPLEMENTED */
2101 static CORE_ADDR start_pc
, end_pc
;
2102 struct symtabs_and_lines sals
;
2103 struct symtab_and_line sal
;
2104 struct cleanup
*old_chain
;
2105 char startpc_str
[40], endpc_str
[40];
2107 if (target_is_remote ())
2109 if (args
== 0 || *args
== 0)
2111 sal
= find_pc_line ((get_current_frame ())->pc
, 0);
2113 sals
.sals
= (struct symtab_and_line
*)
2114 xmalloc (sizeof (struct symtab_and_line
));
2119 sals
= decode_line_spec (args
, 1);
2123 old_chain
= make_cleanup (xfree
, sals
.sals
);
2124 if (sal
.symtab
== 0)
2126 printf_filtered ("TFIND: No line number information available");
2129 /* This is useful for "info line *0x7f34". If we can't tell the
2130 user about a source line, at least let them have the symbolic
2132 printf_filtered (" for address ");
2134 print_address (sal
.pc
, gdb_stdout
);
2135 printf_filtered (";\n -- will attempt to find by PC. \n");
2139 printf_filtered (".\n");
2140 return; /* no line, no PC; what can we do? */
2143 else if (sal
.line
> 0
2144 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2146 if (start_pc
== end_pc
)
2148 printf_filtered ("Line %d of \"%s\"",
2149 sal
.line
, sal
.symtab
->filename
);
2151 printf_filtered (" is at address ");
2152 print_address (start_pc
, gdb_stdout
);
2154 printf_filtered (" but contains no code.\n");
2155 sal
= find_pc_line (start_pc
, 0);
2157 find_line_pc_range (sal
, &start_pc
, &end_pc
) &&
2159 printf_filtered ("Attempting to find line %d instead.\n",
2162 error ("Cannot find a good line.");
2166 /* Is there any case in which we get here, and have an address
2167 which the user would want to see? If we have debugging symbols
2168 and no line numbers? */
2169 error ("Line number %d is out of range for \"%s\".\n",
2170 sal
.line
, sal
.symtab
->filename
);
2172 sprintf_vma (startpc_str
, start_pc
);
2173 sprintf_vma (endpc_str
, end_pc
- 1);
2174 if (args
&& *args
) /* find within range of stated line */
2175 sprintf (target_buf
, "QTFrame:range:%s:%s", startpc_str
, endpc_str
);
2176 else /* find OUTSIDE OF range of CURRENT line */
2177 sprintf (target_buf
, "QTFrame:outside:%s:%s", startpc_str
, endpc_str
);
2178 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2179 do_cleanups (old_chain
);
2182 error ("Trace can only be run on remote targets.");
2185 /* tfind range command */
2187 trace_find_range_command (char *args
, int from_tty
)
2189 static CORE_ADDR start
, stop
;
2190 char start_str
[40], stop_str
[40];
2193 if (target_is_remote ())
2195 if (args
== 0 || *args
== 0)
2196 { /* XXX FIXME: what should default behavior be? */
2197 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2201 if (0 != (tmp
= strchr (args
, ',')))
2203 *tmp
++ = '\0'; /* terminate start address */
2204 while (isspace ((int) *tmp
))
2206 start
= parse_and_eval_address (args
);
2207 stop
= parse_and_eval_address (tmp
);
2210 { /* no explicit end address? */
2211 start
= parse_and_eval_address (args
);
2212 stop
= start
+ 1; /* ??? */
2215 sprintf_vma (start_str
, start
);
2216 sprintf_vma (stop_str
, stop
);
2217 sprintf (target_buf
, "QTFrame:range:%s:%s", start_str
, stop_str
);
2218 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2221 error ("Trace can only be run on remote targets.");
2224 /* tfind outside command */
2226 trace_find_outside_command (char *args
, int from_tty
)
2228 CORE_ADDR start
, stop
;
2229 char start_str
[40], stop_str
[40];
2232 if (target_is_remote ())
2234 if (args
== 0 || *args
== 0)
2235 { /* XXX FIXME: what should default behavior be? */
2236 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2240 if (0 != (tmp
= strchr (args
, ',')))
2242 *tmp
++ = '\0'; /* terminate start address */
2243 while (isspace ((int) *tmp
))
2245 start
= parse_and_eval_address (args
);
2246 stop
= parse_and_eval_address (tmp
);
2249 { /* no explicit end address? */
2250 start
= parse_and_eval_address (args
);
2251 stop
= start
+ 1; /* ??? */
2254 sprintf_vma (start_str
, start
);
2255 sprintf_vma (stop_str
, stop
);
2256 sprintf (target_buf
, "QTFrame:outside:%s:%s", start_str
, stop_str
);
2257 finish_tfind_command (target_buf
, sizeof (target_buf
), from_tty
);
2260 error ("Trace can only be run on remote targets.");
2263 /* save-tracepoints command */
2265 tracepoint_save_command (char *args
, int from_tty
)
2267 struct tracepoint
*tp
;
2268 struct action_line
*line
;
2270 char *i1
= " ", *i2
= " ";
2271 char *indent
, *actionline
, *pathname
;
2274 if (args
== 0 || *args
== 0)
2275 error ("Argument required (file name in which to save tracepoints");
2277 if (tracepoint_chain
== 0)
2279 warning ("save-tracepoints: no tracepoints to save.\n");
2283 pathname
= tilde_expand (args
);
2284 if (!(fp
= fopen (pathname
, "w")))
2285 error ("Unable to open file '%s' for saving tracepoints (%s)",
2286 args
, safe_strerror (errno
));
2289 ALL_TRACEPOINTS (tp
)
2291 if (tp
->addr_string
)
2292 fprintf (fp
, "trace %s\n", tp
->addr_string
);
2295 sprintf_vma (tmp
, tp
->address
);
2296 fprintf (fp
, "trace *0x%s\n", tmp
);
2300 fprintf (fp
, " passcount %d\n", tp
->pass_count
);
2304 fprintf (fp
, " actions\n");
2306 for (line
= tp
->actions
; line
; line
= line
->next
)
2308 struct cmd_list_element
*cmd
;
2310 QUIT
; /* allow user to bail out with ^C */
2311 actionline
= line
->action
;
2312 while (isspace ((int) *actionline
))
2315 fprintf (fp
, "%s%s\n", indent
, actionline
);
2316 if (*actionline
!= '#') /* skip for comment lines */
2318 cmd
= lookup_cmd (&actionline
, cmdlist
, "", -1, 1);
2320 error ("Bad action list item: %s", actionline
);
2321 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2323 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2331 printf_filtered ("Tracepoints saved to file '%s'.\n", args
);
2335 /* info scope command: list the locals for a scope. */
2337 scope_info (char *args
, int from_tty
)
2339 struct symtabs_and_lines sals
;
2341 struct minimal_symbol
*msym
;
2342 struct block
*block
;
2343 char **canonical
, *symname
, *save_args
= args
;
2344 int i
, j
, count
= 0;
2346 if (args
== 0 || *args
== 0)
2347 error ("requires an argument (function, line or *addr) to define a scope");
2349 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
);
2350 if (sals
.nelts
== 0)
2351 return; /* presumably decode_line_1 has already warned */
2353 /* Resolve line numbers to PC */
2354 resolve_sal_pc (&sals
.sals
[0]);
2355 block
= block_for_pc (sals
.sals
[0].pc
);
2359 QUIT
; /* allow user to bail out with ^C */
2360 ALL_BLOCK_SYMBOLS (block
, i
, sym
)
2362 QUIT
; /* allow user to bail out with ^C */
2364 printf_filtered ("Scope for %s:\n", save_args
);
2367 symname
= SYMBOL_NAME (sym
);
2368 if (symname
== NULL
|| *symname
== '\0')
2369 continue; /* probably botched, certainly useless */
2371 printf_filtered ("Symbol %s is ", symname
);
2372 switch (SYMBOL_CLASS (sym
))
2375 case LOC_UNDEF
: /* messed up symbol? */
2376 printf_filtered ("a bogus symbol, class %d.\n",
2377 SYMBOL_CLASS (sym
));
2378 count
--; /* don't count this one */
2381 printf_filtered ("a constant with value %ld (0x%lx)",
2382 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2384 case LOC_CONST_BYTES
:
2385 printf_filtered ("constant bytes: ");
2386 if (SYMBOL_TYPE (sym
))
2387 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2388 fprintf_filtered (gdb_stdout
, " %02x",
2389 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2392 printf_filtered ("in static storage at address ");
2393 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
), 1, gdb_stdout
);
2396 printf_filtered ("a local variable in register $%s",
2397 REGISTER_NAME (SYMBOL_VALUE (sym
)));
2401 printf_filtered ("an argument at stack/frame offset %ld",
2402 SYMBOL_VALUE (sym
));
2405 printf_filtered ("a local variable at frame offset %ld",
2406 SYMBOL_VALUE (sym
));
2409 printf_filtered ("a reference argument at offset %ld",
2410 SYMBOL_VALUE (sym
));
2413 printf_filtered ("an argument in register $%s",
2414 REGISTER_NAME (SYMBOL_VALUE (sym
)));
2416 case LOC_REGPARM_ADDR
:
2417 printf_filtered ("the address of an argument, in register $%s",
2418 REGISTER_NAME (SYMBOL_VALUE (sym
)));
2421 printf_filtered ("a typedef.\n");
2424 printf_filtered ("a label at address ");
2425 print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
), 1, gdb_stdout
);
2428 printf_filtered ("a function at address ");
2429 print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)), 1,
2433 printf_filtered ("a variable at offset %ld from register $%s",
2435 REGISTER_NAME (SYMBOL_BASEREG (sym
)));
2437 case LOC_BASEREG_ARG
:
2438 printf_filtered ("an argument at offset %ld from register $%s",
2440 REGISTER_NAME (SYMBOL_BASEREG (sym
)));
2442 case LOC_UNRESOLVED
:
2443 msym
= lookup_minimal_symbol (SYMBOL_NAME (sym
), NULL
, NULL
);
2445 printf_filtered ("Unresolved Static");
2448 printf_filtered ("static storage at address ");
2449 print_address_numeric (SYMBOL_VALUE_ADDRESS (msym
), 1,
2453 case LOC_OPTIMIZED_OUT
:
2454 printf_filtered ("optimized out.\n");
2457 if (SYMBOL_TYPE (sym
))
2458 printf_filtered (", length %d.\n",
2459 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2461 if (BLOCK_FUNCTION (block
))
2464 block
= BLOCK_SUPERBLOCK (block
);
2467 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2471 /* worker function (cleanup) */
2473 replace_comma (void *data
)
2481 trace_dump_command (char *args
, int from_tty
)
2483 struct tracepoint
*t
;
2484 struct action_line
*action
;
2485 char *action_exp
, *next_comma
;
2486 struct cleanup
*old_cleanups
;
2487 int stepping_actions
= 0;
2488 int stepping_frame
= 0;
2490 if (!target_is_remote ())
2492 error ("Trace can only be run on remote targets.");
2496 if (tracepoint_number
== -1)
2498 warning ("No current trace frame.");
2503 if (t
->number
== tracepoint_number
)
2507 error ("No known tracepoint matches 'current' tracepoint #%d.",
2510 old_cleanups
= make_cleanup (null_cleanup
, NULL
);
2512 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2513 tracepoint_number
, traceframe_number
);
2515 /* The current frame is a trap frame if the frame PC is equal
2516 to the tracepoint PC. If not, then the current frame was
2517 collected during single-stepping. */
2519 stepping_frame
= (t
->address
!= read_pc ());
2521 for (action
= t
->actions
; action
; action
= action
->next
)
2523 struct cmd_list_element
*cmd
;
2525 QUIT
; /* allow user to bail out with ^C */
2526 action_exp
= action
->action
;
2527 while (isspace ((int) *action_exp
))
2530 /* The collection actions to be done while stepping are
2531 bracketed by the commands "while-stepping" and "end". */
2533 if (*action_exp
== '#') /* comment line */
2536 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2538 error ("Bad action list item: %s", action_exp
);
2540 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2541 stepping_actions
= 1;
2542 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2543 stepping_actions
= 0;
2544 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2546 /* Display the collected data.
2547 For the trap frame, display only what was collected at the trap.
2548 Likewise for stepping frames, display only what was collected
2549 while stepping. This means that the two boolean variables,
2550 STEPPING_FRAME and STEPPING_ACTIONS should be equal. */
2551 if (stepping_frame
== stepping_actions
)
2554 { /* repeat over a comma-separated list */
2555 QUIT
; /* allow user to bail out with ^C */
2556 if (*action_exp
== ',')
2558 while (isspace ((int) *action_exp
))
2561 next_comma
= strchr (action_exp
, ',');
2563 if (0 == strncasecmp (action_exp
, "$reg", 4))
2564 registers_info (NULL
, from_tty
);
2565 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2566 locals_info (NULL
, from_tty
);
2567 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2568 args_info (NULL
, from_tty
);
2573 make_cleanup (replace_comma
, next_comma
);
2576 printf_filtered ("%s = ", action_exp
);
2577 output_command (action_exp
, from_tty
);
2578 printf_filtered ("\n");
2582 action_exp
= next_comma
;
2584 while (action_exp
&& *action_exp
== ',');
2588 discard_cleanups (old_cleanups
);
2591 /* Convert the memory pointed to by mem into hex, placing result in buf.
2592 * Return a pointer to the last char put in buf (null)
2593 * "stolen" from sparc-stub.c
2596 static const char hexchars
[] = "0123456789abcdef";
2598 static unsigned char *
2599 mem2hex (unsigned char *mem
, unsigned char *buf
, int count
)
2607 *buf
++ = hexchars
[ch
>> 4];
2608 *buf
++ = hexchars
[ch
& 0xf];
2617 get_traceframe_number (void)
2619 return traceframe_number
;
2623 /* module initialization */
2625 _initialize_tracepoint (void)
2627 struct cmd_list_element
*c
;
2629 tracepoint_chain
= 0;
2630 tracepoint_count
= 0;
2631 traceframe_number
= -1;
2632 tracepoint_number
= -1;
2634 set_internalvar (lookup_internalvar ("tpnum"),
2635 value_from_longest (builtin_type_int
, (LONGEST
) 0));
2636 set_internalvar (lookup_internalvar ("trace_frame"),
2637 value_from_longest (builtin_type_int
, (LONGEST
) - 1));
2639 if (tracepoint_list
.list
== NULL
)
2641 tracepoint_list
.listsize
= 128;
2642 tracepoint_list
.list
= xmalloc
2643 (tracepoint_list
.listsize
* sizeof (struct memrange
));
2645 if (tracepoint_list
.aexpr_list
== NULL
)
2647 tracepoint_list
.aexpr_listsize
= 128;
2648 tracepoint_list
.aexpr_list
= xmalloc
2649 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
2652 if (stepping_list
.list
== NULL
)
2654 stepping_list
.listsize
= 128;
2655 stepping_list
.list
= xmalloc
2656 (stepping_list
.listsize
* sizeof (struct memrange
));
2659 if (stepping_list
.aexpr_list
== NULL
)
2661 stepping_list
.aexpr_listsize
= 128;
2662 stepping_list
.aexpr_list
= xmalloc
2663 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
2666 add_info ("scope", scope_info
,
2667 "List the variables local to a scope");
2669 add_cmd ("tracepoints", class_trace
, NULL
,
2670 "Tracing of program execution without stopping the program.",
2673 add_info ("tracepoints", tracepoints_info
,
2674 "Status of tracepoints, or tracepoint number NUMBER.\n\
2675 Convenience variable \"$tpnum\" contains the number of the\n\
2676 last tracepoint set.");
2678 add_info_alias ("tp", "tracepoints", 1);
2680 c
= add_com ("save-tracepoints", class_trace
, tracepoint_save_command
,
2681 "Save current tracepoint definitions as a script.\n\
2682 Use the 'source' command in another debug session to restore them.");
2683 set_cmd_completer (c
, filename_completer
);
2685 add_com ("tdump", class_trace
, trace_dump_command
,
2686 "Print everything collected at the current tracepoint.");
2688 add_prefix_cmd ("tfind", class_trace
, trace_find_command
,
2689 "Select a trace frame;\n\
2690 No argument means forward by one frame; '-' meand backward by one frame.",
2691 &tfindlist
, "tfind ", 1, &cmdlist
);
2693 add_cmd ("outside", class_trace
, trace_find_outside_command
,
2694 "Select a trace frame whose PC is outside the given \
2695 range.\nUsage: tfind outside addr1, addr2",
2698 add_cmd ("range", class_trace
, trace_find_range_command
,
2699 "Select a trace frame whose PC is in the given range.\n\
2700 Usage: tfind range addr1,addr2",
2703 add_cmd ("line", class_trace
, trace_find_line_command
,
2704 "Select a trace frame by source line.\n\
2705 Argument can be a line number (with optional source file), \n\
2706 a function name, or '*' followed by an address.\n\
2707 Default argument is 'the next source line that was traced'.",
2710 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
,
2711 "Select a trace frame by tracepoint number.\n\
2712 Default is the tracepoint for the current trace frame.",
2715 add_cmd ("pc", class_trace
, trace_find_pc_command
,
2716 "Select a trace frame by PC.\n\
2717 Default is the current PC, or the PC of the current trace frame.",
2720 add_cmd ("end", class_trace
, trace_find_end_command
,
2721 "Synonym for 'none'.\n\
2722 De-select any trace frame and resume 'live' debugging.",
2725 add_cmd ("none", class_trace
, trace_find_none_command
,
2726 "De-select any trace frame and resume 'live' debugging.",
2729 add_cmd ("start", class_trace
, trace_find_start_command
,
2730 "Select the first trace frame in the trace buffer.",
2733 add_com ("tstatus", class_trace
, trace_status_command
,
2734 "Display the status of the current trace data collection.");
2736 add_com ("tstop", class_trace
, trace_stop_command
,
2737 "Stop trace data collection.");
2739 add_com ("tstart", class_trace
, trace_start_command
,
2740 "Start trace data collection.");
2742 add_com ("passcount", class_trace
, trace_pass_command
,
2743 "Set the passcount for a tracepoint.\n\
2744 The trace will end when the tracepoint has been passed 'count' times.\n\
2745 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
2746 if TPNUM is omitted, passcount refers to the last tracepoint defined.");
2748 add_com ("end", class_trace
, end_actions_pseudocommand
,
2749 "Ends a list of commands or actions.\n\
2750 Several GDB commands allow you to enter a list of commands or actions.\n\
2751 Entering \"end\" on a line by itself is the normal way to terminate\n\
2753 Note: the \"end\" command cannot be used at the gdb prompt.");
2755 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
,
2756 "Specify single-stepping behavior at a tracepoint.\n\
2757 Argument is number of instructions to trace in single-step mode\n\
2758 following the tracepoint. This command is normally followed by\n\
2759 one or more \"collect\" commands, to specify what to collect\n\
2760 while single-stepping.\n\n\
2761 Note: this command can only be used in a tracepoint \"actions\" list.");
2763 add_com_alias ("ws", "while-stepping", class_alias
, 0);
2764 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
2766 add_com ("collect", class_trace
, collect_pseudocommand
,
2767 "Specify one or more data items to be collected at a tracepoint.\n\
2768 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
2769 collect all data (variables, registers) referenced by that expression.\n\
2770 Also accepts the following special arguments:\n\
2771 $regs -- all registers.\n\
2772 $args -- all function arguments.\n\
2773 $locals -- all variables local to the block/function scope.\n\
2774 Note: this command can only be used in a tracepoint \"actions\" list.");
2776 add_com ("actions", class_trace
, trace_actions_command
,
2777 "Specify the actions to be taken at a tracepoint.\n\
2778 Tracepoint actions may include collecting of specified data, \n\
2779 single-stepping, or enabling/disabling other tracepoints, \n\
2780 depending on target's capabilities.");
2782 add_cmd ("tracepoints", class_trace
, delete_trace_command
,
2783 "Delete specified tracepoints.\n\
2784 Arguments are tracepoint numbers, separated by spaces.\n\
2785 No argument means delete all tracepoints.",
2788 add_cmd ("tracepoints", class_trace
, disable_trace_command
,
2789 "Disable specified tracepoints.\n\
2790 Arguments are tracepoint numbers, separated by spaces.\n\
2791 No argument means disable all tracepoints.",
2794 add_cmd ("tracepoints", class_trace
, enable_trace_command
,
2795 "Enable specified tracepoints.\n\
2796 Arguments are tracepoint numbers, separated by spaces.\n\
2797 No argument means enable all tracepoints.",
2800 c
= add_com ("trace", class_trace
, trace_command
,
2801 "Set a tracepoint at a specified line or function or address.\n\
2802 Argument may be a line number, function name, or '*' plus an address.\n\
2803 For a line number or function, trace at the start of its code.\n\
2804 If an address is specified, trace at that exact address.\n\n\
2805 Do \"help tracepoints\" for info on other tracepoint commands.");
2806 set_cmd_completer (c
, location_completer
);
2808 add_com_alias ("tp", "trace", class_alias
, 0);
2809 add_com_alias ("tr", "trace", class_alias
, 1);
2810 add_com_alias ("tra", "trace", class_alias
, 1);
2811 add_com_alias ("trac", "trace", class_alias
, 1);