1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
4 2007 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
25 #include "expression.h"
30 #include "gdb_string.h"
32 #include "tracepoint.h"
36 #include "completer.h"
37 #include "gdb-events.h"
39 #include "dictionary.h"
44 /* readline include files */
45 #include "readline/readline.h"
46 #include "readline/history.h"
48 /* readline defines this. */
55 /* Maximum length of an agent aexpression.
56 This accounts for the fact that packets are limited to 400 bytes
57 (which includes everything -- including the checksum), and assumes
58 the worst case of maximum length for each of the pieces of a
61 NOTE: expressions get mem2hex'ed otherwise this would be twice as
62 large. (400 - 31)/2 == 184 */
63 #define MAX_AGENT_EXPR_LEN 184
66 extern void (*deprecated_readline_begin_hook
) (char *, ...);
67 extern char *(*deprecated_readline_hook
) (char *);
68 extern void (*deprecated_readline_end_hook
) (void);
69 extern int addressprint
; /* Print machine addresses? */
71 /* GDB commands implemented in other modules:
74 extern void output_command (char *, int);
79 This module defines the following debugger commands:
80 trace : set a tracepoint on a function, line, or address.
81 info trace : list all debugger-defined tracepoints.
82 delete trace : delete one or more tracepoints.
83 enable trace : enable one or more tracepoints.
84 disable trace : disable one or more tracepoints.
85 actions : specify actions to be taken at a tracepoint.
86 passcount : specify a pass count for a tracepoint.
87 tstart : start a trace experiment.
88 tstop : stop a trace experiment.
89 tstatus : query the status of a trace experiment.
90 tfind : find a trace frame in the trace buffer.
91 tdump : print everything collected at the current tracepoint.
92 save-tracepoints : write tracepoint setup into a file.
94 This module defines the following user-visible debugger variables:
95 $trace_frame : sequence number of trace frame currently being debugged.
96 $trace_line : source line of trace frame currently being debugged.
97 $trace_file : source file of trace frame currently being debugged.
98 $tracepoint : tracepoint number of trace frame currently being debugged.
102 /* ======= Important global variables: ======= */
104 /* Chain of all tracepoints defined. */
105 struct tracepoint
*tracepoint_chain
;
107 /* Number of last tracepoint made. */
108 static int tracepoint_count
;
110 /* Number of last traceframe collected. */
111 static int traceframe_number
;
113 /* Tracepoint for last traceframe collected. */
114 static int tracepoint_number
;
116 /* Symbol for function for last traceframe collected */
117 static struct symbol
*traceframe_fun
;
119 /* Symtab and line for last traceframe collected */
120 static struct symtab_and_line traceframe_sal
;
122 /* Tracing command lists */
123 static struct cmd_list_element
*tfindlist
;
125 /* ======= Important command functions: ======= */
126 static void trace_command (char *, int);
127 static void tracepoints_info (char *, int);
128 static void delete_trace_command (char *, int);
129 static void enable_trace_command (char *, int);
130 static void disable_trace_command (char *, int);
131 static void trace_pass_command (char *, int);
132 static void trace_actions_command (char *, int);
133 static void trace_start_command (char *, int);
134 static void trace_stop_command (char *, int);
135 static void trace_status_command (char *, int);
136 static void trace_find_command (char *, int);
137 static void trace_find_pc_command (char *, int);
138 static void trace_find_tracepoint_command (char *, int);
139 static void trace_find_line_command (char *, int);
140 static void trace_find_range_command (char *, int);
141 static void trace_find_outside_command (char *, int);
142 static void tracepoint_save_command (char *, int);
143 static void trace_dump_command (char *, int);
145 /* support routines */
146 static void trace_mention (struct tracepoint
*);
148 struct collection_list
;
149 static void add_aexpr (struct collection_list
*, struct agent_expr
*);
150 static char *mem2hex (gdb_byte
*, char *, int);
151 static void add_register (struct collection_list
*collection
,
153 static struct cleanup
*make_cleanup_free_actions (struct tracepoint
*t
);
154 static void free_actions_list (char **actions_list
);
155 static void free_actions_list_cleanup_wrapper (void *);
157 extern void _initialize_tracepoint (void);
159 /* Utility: returns true if "target remote" */
161 target_is_remote (void)
163 if (current_target
.to_shortname
&&
164 (strcmp (current_target
.to_shortname
, "remote") == 0
165 || strcmp (current_target
.to_shortname
, "extended-remote") == 0))
171 /* Utility: generate error from an incoming stub packet. */
173 trace_error (char *buf
)
176 return; /* not an error msg */
179 case '1': /* malformed packet error */
180 if (*++buf
== '0') /* general case: */
181 error (_("tracepoint.c: error in outgoing packet."));
183 error (_("tracepoint.c: error in outgoing packet at field #%ld."),
184 strtol (buf
, NULL
, 16));
186 error (_("trace API error 0x%s."), ++buf
);
188 error (_("Target returns error code '%s'."), buf
);
192 /* Utility: wait for reply from stub, while accepting "O" packets. */
194 remote_get_noisy_reply (char **buf_p
,
197 do /* Loop on reply from remote stub. */
200 QUIT
; /* allow user to bail out with ^C */
201 getpkt (buf_p
, sizeof_buf
, 0);
204 error (_("Target does not support this command."));
205 else if (buf
[0] == 'E')
207 else if (buf
[0] == 'O' &&
209 remote_console_output (buf
+ 1); /* 'O' message from stub */
211 return buf
; /* here's the actual reply */
216 /* Set tracepoint count to NUM. */
218 set_tracepoint_count (int num
)
220 tracepoint_count
= num
;
221 set_internalvar (lookup_internalvar ("tpnum"),
222 value_from_longest (builtin_type_int
, (LONGEST
) num
));
225 /* Set traceframe number to NUM. */
227 set_traceframe_num (int num
)
229 traceframe_number
= num
;
230 set_internalvar (lookup_internalvar ("trace_frame"),
231 value_from_longest (builtin_type_int
, (LONGEST
) num
));
234 /* Set tracepoint number to NUM. */
236 set_tracepoint_num (int num
)
238 tracepoint_number
= num
;
239 set_internalvar (lookup_internalvar ("tracepoint"),
240 value_from_longest (builtin_type_int
,
244 /* Set externally visible debug variables for querying/printing
245 the traceframe context (line, function, file) */
248 set_traceframe_context (CORE_ADDR trace_pc
)
250 static struct type
*func_string
, *file_string
;
251 static struct type
*func_range
, *file_range
;
252 struct value
*func_val
;
253 struct value
*file_val
;
254 static struct type
*charstar
;
257 if (charstar
== (struct type
*) NULL
)
258 charstar
= lookup_pointer_type (builtin_type_char
);
260 if (trace_pc
== -1) /* Cease debugging any trace buffers. */
263 traceframe_sal
.pc
= traceframe_sal
.line
= 0;
264 traceframe_sal
.symtab
= NULL
;
265 set_internalvar (lookup_internalvar ("trace_func"),
266 value_from_pointer (charstar
, (LONGEST
) 0));
267 set_internalvar (lookup_internalvar ("trace_file"),
268 value_from_pointer (charstar
, (LONGEST
) 0));
269 set_internalvar (lookup_internalvar ("trace_line"),
270 value_from_longest (builtin_type_int
,
275 /* Save as globals for internal use. */
276 traceframe_sal
= find_pc_line (trace_pc
, 0);
277 traceframe_fun
= find_pc_function (trace_pc
);
279 /* Save linenumber as "$trace_line", a debugger variable visible to
281 set_internalvar (lookup_internalvar ("trace_line"),
282 value_from_longest (builtin_type_int
,
283 (LONGEST
) traceframe_sal
.line
));
285 /* Save func name as "$trace_func", a debugger variable visible to
287 if (traceframe_fun
== NULL
||
288 DEPRECATED_SYMBOL_NAME (traceframe_fun
) == NULL
)
289 set_internalvar (lookup_internalvar ("trace_func"),
290 value_from_pointer (charstar
, (LONGEST
) 0));
293 len
= strlen (DEPRECATED_SYMBOL_NAME (traceframe_fun
));
294 func_range
= create_range_type (func_range
,
295 builtin_type_int
, 0, len
- 1);
296 func_string
= create_array_type (func_string
,
297 builtin_type_char
, func_range
);
298 func_val
= allocate_value (func_string
);
299 deprecated_set_value_type (func_val
, func_string
);
300 memcpy (value_contents_raw (func_val
),
301 DEPRECATED_SYMBOL_NAME (traceframe_fun
),
303 deprecated_set_value_modifiable (func_val
, 0);
304 set_internalvar (lookup_internalvar ("trace_func"), func_val
);
307 /* Save file name as "$trace_file", a debugger variable visible to
309 if (traceframe_sal
.symtab
== NULL
||
310 traceframe_sal
.symtab
->filename
== NULL
)
311 set_internalvar (lookup_internalvar ("trace_file"),
312 value_from_pointer (charstar
, (LONGEST
) 0));
315 len
= strlen (traceframe_sal
.symtab
->filename
);
316 file_range
= create_range_type (file_range
,
317 builtin_type_int
, 0, len
- 1);
318 file_string
= create_array_type (file_string
,
319 builtin_type_char
, file_range
);
320 file_val
= allocate_value (file_string
);
321 deprecated_set_value_type (file_val
, file_string
);
322 memcpy (value_contents_raw (file_val
),
323 traceframe_sal
.symtab
->filename
,
325 deprecated_set_value_modifiable (file_val
, 0);
326 set_internalvar (lookup_internalvar ("trace_file"), file_val
);
330 /* Low level routine to set a tracepoint.
331 Returns the tracepoint object so caller can set other things.
332 Does not set the tracepoint number!
333 Does not print anything.
335 ==> This routine should not be called if there is a chance of later
336 error(); otherwise it leaves a bogus tracepoint on the chain.
337 Validate your arguments BEFORE calling this routine! */
339 static struct tracepoint
*
340 set_raw_tracepoint (struct symtab_and_line sal
)
342 struct tracepoint
*t
, *tc
;
343 struct cleanup
*old_chain
;
345 t
= (struct tracepoint
*) xmalloc (sizeof (struct tracepoint
));
346 old_chain
= make_cleanup (xfree
, t
);
347 memset (t
, 0, sizeof (*t
));
349 if (sal
.symtab
== NULL
)
350 t
->source_file
= NULL
;
352 t
->source_file
= savestring (sal
.symtab
->filename
,
353 strlen (sal
.symtab
->filename
));
355 t
->section
= sal
.section
;
356 t
->language
= current_language
->la_language
;
357 t
->input_radix
= input_radix
;
358 t
->line_number
= sal
.line
;
363 t
->addr_string
= NULL
;
365 /* Add this tracepoint to the end of the chain
366 so that a list of tracepoints will come out in order
367 of increasing numbers. */
369 tc
= tracepoint_chain
;
371 tracepoint_chain
= t
;
378 discard_cleanups (old_chain
);
382 /* Set a tracepoint according to ARG (function, linenum or *address). */
384 trace_command (char *arg
, int from_tty
)
386 char **canonical
= (char **) NULL
;
387 struct symtabs_and_lines sals
;
388 struct symtab_and_line sal
;
389 struct tracepoint
*t
;
390 char *addr_start
= 0, *addr_end
= 0;
394 error (_("trace command requires an argument"));
396 if (from_tty
&& info_verbose
)
397 printf_filtered ("TRACE %s\n", arg
);
400 sals
= decode_line_1 (&arg
, 1, (struct symtab
*) NULL
,
401 0, &canonical
, NULL
);
404 return; /* ??? Presumably decode_line_1 has already warned? */
406 /* Resolve all line numbers to PC's */
407 for (i
= 0; i
< sals
.nelts
; i
++)
408 resolve_sal_pc (&sals
.sals
[i
]);
410 /* Now set all the tracepoints. */
411 for (i
= 0; i
< sals
.nelts
; i
++)
415 t
= set_raw_tracepoint (sal
);
416 set_tracepoint_count (tracepoint_count
+ 1);
417 t
->number
= tracepoint_count
;
419 /* If a canonical line spec is needed use that instead of the
421 if (canonical
!= (char **) NULL
&& canonical
[i
] != NULL
)
422 t
->addr_string
= canonical
[i
];
424 t
->addr_string
= savestring (addr_start
, addr_end
- addr_start
);
431 printf_filtered ("Multiple tracepoints were set.\n");
432 printf_filtered ("Use 'delete trace' to delete unwanted tracepoints.\n");
436 /* Tell the user we have just set a tracepoint TP. */
439 trace_mention (struct tracepoint
*tp
)
441 printf_filtered ("Tracepoint %d", tp
->number
);
443 if (addressprint
|| (tp
->source_file
== NULL
))
445 printf_filtered (" at ");
446 deprecated_print_address_numeric (tp
->address
, 1, gdb_stdout
);
449 printf_filtered (": file %s, line %d.",
450 tp
->source_file
, tp
->line_number
);
452 printf_filtered ("\n");
455 /* Print information on tracepoint number TPNUM_EXP, or all if
459 tracepoints_info (char *tpnum_exp
, int from_tty
)
461 struct tracepoint
*t
;
462 struct action_line
*action
;
463 int found_a_tracepoint
= 0;
464 char wrap_indent
[80];
469 tpnum
= parse_and_eval_long (tpnum_exp
);
472 if (tpnum
== -1 || tpnum
== t
->number
)
474 extern int addressprint
; /* Print machine addresses? */
476 if (!found_a_tracepoint
++)
478 printf_filtered ("Num Enb ");
481 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
482 printf_filtered ("Address ");
484 printf_filtered ("Address ");
486 printf_filtered ("PassC StepC What\n");
488 strcpy (wrap_indent
, " ");
491 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
492 strcat (wrap_indent
, " ");
494 strcat (wrap_indent
, " ");
497 printf_filtered ("%-3d %-3s ", t
->number
,
498 t
->enabled_p
? "y" : "n");
503 if (gdbarch_addr_bit (current_gdbarch
) <= 32)
504 tmp
= hex_string_custom (t
->address
& (CORE_ADDR
) 0xffffffff,
507 tmp
= hex_string_custom (t
->address
, 16);
509 printf_filtered ("%s ", tmp
);
511 printf_filtered ("%-5d %-5ld ", t
->pass_count
, t
->step_count
);
515 sym
= find_pc_sect_function (t
->address
, t
->section
);
518 fputs_filtered ("in ", gdb_stdout
);
519 fputs_filtered (SYMBOL_PRINT_NAME (sym
), gdb_stdout
);
520 wrap_here (wrap_indent
);
521 fputs_filtered (" at ", gdb_stdout
);
523 fputs_filtered (t
->source_file
, gdb_stdout
);
524 printf_filtered (":%d", t
->line_number
);
527 print_address_symbolic (t
->address
, gdb_stdout
, demangle
, " ");
529 printf_filtered ("\n");
532 printf_filtered (" Actions for tracepoint %d: \n", t
->number
);
533 for (action
= t
->actions
; action
; action
= action
->next
)
535 printf_filtered ("\t%s\n", action
->action
);
539 if (!found_a_tracepoint
)
542 printf_filtered ("No tracepoints.\n");
544 printf_filtered ("No tracepoint number %d.\n", tpnum
);
548 /* Optimization: the code to parse an enable, disable, or delete TP
549 command is virtually identical except for whether it performs an
550 enable, disable, or delete. Therefore I've combined them into one
551 function with an opcode. */
552 enum tracepoint_opcode
559 /* This function implements enable, disable and delete commands. */
561 tracepoint_operation (struct tracepoint
*t
, int from_tty
,
562 enum tracepoint_opcode opcode
)
564 struct tracepoint
*t2
;
566 if (t
== NULL
) /* no tracepoint operand */
573 tracepoint_modify_event (t
->number
);
577 tracepoint_modify_event (t
->number
);
580 if (tracepoint_chain
== t
)
581 tracepoint_chain
= t
->next
;
586 tracepoint_delete_event (t2
->number
);
592 xfree (t
->addr_string
);
594 xfree (t
->source_file
);
603 /* Utility: parse a tracepoint number and look it up in the list.
604 If MULTI_P is true, there might be a range of tracepoints in ARG.
605 if OPTIONAL_P is true, then if the argument is missing, the most
606 recent tracepoint (tracepoint_count) is returned. */
608 get_tracepoint_by_number (char **arg
, int multi_p
, int optional_p
)
610 struct tracepoint
*t
;
612 char *instring
= arg
== NULL
? NULL
: *arg
;
614 if (arg
== NULL
|| *arg
== NULL
|| ! **arg
)
617 tpnum
= tracepoint_count
;
619 error_no_arg (_("tracepoint number"));
622 tpnum
= multi_p
? get_number_or_range (arg
) : get_number (arg
);
626 if (instring
&& *instring
)
627 printf_filtered ("bad tracepoint number at or near '%s'\n",
630 printf_filtered ("Tracepoint argument missing and no previous tracepoint\n");
635 if (t
->number
== tpnum
)
640 /* FIXME: if we are in the middle of a range we don't want to give
641 a message. The current interface to get_number_or_range doesn't
642 allow us to discover this. */
643 printf_unfiltered ("No tracepoint number %d.\n", tpnum
);
648 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.
670 Not supported by all targets. */
672 enable_trace_command (char *args
, int from_tty
)
675 map_args_over_tracepoints (args
, from_tty
, enable_op
);
678 /* The 'disable trace' command disables tracepoints.
679 Not supported by all targets. */
681 disable_trace_command (char *args
, int from_tty
)
684 map_args_over_tracepoints (args
, from_tty
, disable_op
);
687 /* Remove a tracepoint (or all if no argument) */
689 delete_trace_command (char *args
, int from_tty
)
692 if (!args
|| !*args
) /* No args implies all tracepoints; */
693 if (from_tty
) /* confirm only if from_tty... */
694 if (tracepoint_chain
) /* and if there are tracepoints to
696 if (!query ("Delete all tracepoints? "))
699 map_args_over_tracepoints (args
, from_tty
, delete_op
);
702 /* Set passcount for tracepoint.
704 First command argument is passcount, second is tracepoint number.
705 If tracepoint number omitted, apply to most recently defined.
706 Also accepts special argument "all". */
709 trace_pass_command (char *args
, int from_tty
)
711 struct tracepoint
*t1
= (struct tracepoint
*) -1, *t2
;
715 if (args
== 0 || *args
== 0)
716 error (_("passcount command requires an argument (count + optional TP num)"));
718 count
= strtoul (args
, &args
, 10); /* Count comes first, then TP num. */
720 while (*args
&& isspace ((int) *args
))
723 if (*args
&& strncasecmp (args
, "all", 3) == 0)
725 args
+= 3; /* Skip special argument "all". */
728 error (_("Junk at end of arguments."));
731 t1
= get_tracepoint_by_number (&args
, 1, 1);
738 if (t1
== (struct tracepoint
*) -1 || t1
== t2
)
740 t2
->pass_count
= count
;
741 tracepoint_modify_event (t2
->number
);
743 printf_filtered ("Setting tracepoint %d's passcount to %d\n",
747 t1
= get_tracepoint_by_number (&args
, 1, 0);
753 /* ACTIONS functions: */
755 /* Prototypes for action-parsing utility commands */
756 static void read_actions (struct tracepoint
*);
758 /* The three functions:
759 collect_pseudocommand,
760 while_stepping_pseudocommand, and
761 end_actions_pseudocommand
762 are placeholders for "commands" that are actually ONLY to be used
763 within a tracepoint action list. If the actual function is ever called,
764 it means that somebody issued the "command" at the top level,
765 which is always an error. */
768 end_actions_pseudocommand (char *args
, int from_tty
)
770 error (_("This command cannot be used at the top level."));
774 while_stepping_pseudocommand (char *args
, int from_tty
)
776 error (_("This command can only be used in a tracepoint actions list."));
780 collect_pseudocommand (char *args
, int from_tty
)
782 error (_("This command can only be used in a tracepoint actions list."));
785 /* Enter a list of actions for a tracepoint. */
787 trace_actions_command (char *args
, int from_tty
)
789 struct tracepoint
*t
;
791 char *end_msg
= "End with a line saying just \"end\".";
793 t
= get_tracepoint_by_number (&args
, 0, 1);
796 sprintf (tmpbuf
, "Enter actions for tracepoint %d, one per line.",
801 if (deprecated_readline_begin_hook
)
802 (*deprecated_readline_begin_hook
) ("%s %s\n", tmpbuf
, end_msg
);
803 else if (input_from_terminal_p ())
804 printf_filtered ("%s\n%s\n", tmpbuf
, end_msg
);
808 t
->step_count
= 0; /* read_actions may set this */
811 if (deprecated_readline_end_hook
)
812 (*deprecated_readline_end_hook
) ();
813 /* tracepoints_changed () */
815 /* else just return */
818 /* worker function */
820 read_actions (struct tracepoint
*t
)
823 char *prompt1
= "> ", *prompt2
= " > ";
824 char *prompt
= prompt1
;
825 enum actionline_type linetype
;
826 extern FILE *instream
;
827 struct action_line
*next
= NULL
, *temp
;
828 struct cleanup
*old_chain
;
830 /* Control-C quits instantly if typed while in this loop
831 since it should not wait until the user types a newline. */
833 /* FIXME: kettenis/20010823: Something is wrong here. In this file
834 STOP_SIGNAL is never defined. So this code has been left out, at
835 least for quite a while now. Replacing STOP_SIGNAL with SIGTSTP
836 leads to compilation failures since the variable job_control
837 isn't declared. Leave this alone for now. */
840 signal (STOP_SIGNAL
, handle_stop_sig
);
842 old_chain
= make_cleanup_free_actions (t
);
845 /* Make sure that all output has been output. Some machines may
846 let you get away with leaving out some of the gdb_flush, but
849 gdb_flush (gdb_stdout
);
850 gdb_flush (gdb_stderr
);
852 if (deprecated_readline_hook
&& instream
== NULL
)
853 line
= (*deprecated_readline_hook
) (prompt
);
854 else if (instream
== stdin
&& ISATTY (instream
))
856 line
= gdb_readline_wrapper (prompt
);
857 if (line
&& *line
) /* add it to command history */
861 line
= gdb_readline (0);
866 linetype
= validate_actionline (&line
, t
);
867 if (linetype
== BADLINE
)
868 continue; /* already warned -- collect another line */
870 temp
= xmalloc (sizeof (struct action_line
));
874 if (next
== NULL
) /* first action for this tracepoint? */
875 t
->actions
= next
= temp
;
882 if (linetype
== STEPPING
) /* begin "while-stepping" */
884 if (prompt
== prompt2
)
886 warning (_("Already processing 'while-stepping'"));
890 prompt
= prompt2
; /* change prompt for stepping actions */
892 else if (linetype
== END
)
894 if (prompt
== prompt2
)
896 prompt
= prompt1
; /* end of single-stepping actions */
899 { /* end of actions */
900 if (t
->actions
->next
== NULL
)
902 /* An "end" all by itself with no other actions
903 means this tracepoint has no actions.
904 Discard empty list. */
913 signal (STOP_SIGNAL
, SIG_DFL
);
916 discard_cleanups (old_chain
);
919 /* worker function */
921 validate_actionline (char **line
, struct tracepoint
*t
)
923 struct cmd_list_element
*c
;
924 struct expression
*exp
= NULL
;
925 struct cleanup
*old_chain
= NULL
;
928 /* if EOF is typed, *line is NULL */
932 for (p
= *line
; isspace ((int) *p
);)
935 /* Symbol lookup etc. */
936 if (*p
== '\0') /* empty line: just prompt for another line. */
939 if (*p
== '#') /* comment line */
942 c
= lookup_cmd (&p
, cmdlist
, "", -1, 1);
945 warning (_("'%s' is not an action that I know, or is ambiguous."),
950 if (cmd_cfunc_eq (c
, collect_pseudocommand
))
952 struct agent_expr
*aexpr
;
953 struct agent_reqs areqs
;
956 { /* repeat over a comma-separated list */
957 QUIT
; /* allow user to bail out with ^C */
958 while (isspace ((int) *p
))
961 if (*p
== '$') /* look for special pseudo-symbols */
963 if ((0 == strncasecmp ("reg", p
+ 1, 3)) ||
964 (0 == strncasecmp ("arg", p
+ 1, 3)) ||
965 (0 == strncasecmp ("loc", p
+ 1, 3)))
970 /* else fall thru, treat p as an expression and parse it! */
972 exp
= parse_exp_1 (&p
, block_for_pc (t
->address
), 1);
973 old_chain
= make_cleanup (free_current_contents
, &exp
);
975 if (exp
->elts
[0].opcode
== OP_VAR_VALUE
)
977 if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_CONST
)
979 warning (_("constant %s (value %ld) will not be collected."),
980 DEPRECATED_SYMBOL_NAME (exp
->elts
[2].symbol
),
981 SYMBOL_VALUE (exp
->elts
[2].symbol
));
984 else if (SYMBOL_CLASS (exp
->elts
[2].symbol
) == LOC_OPTIMIZED_OUT
)
986 warning (_("%s is optimized away and cannot be collected."),
987 DEPRECATED_SYMBOL_NAME (exp
->elts
[2].symbol
));
992 /* We have something to collect, make sure that the expr to
993 bytecode translator can handle it and that it's not too
995 aexpr
= gen_trace_for_expr (t
->address
, exp
);
996 make_cleanup_free_agent_expr (aexpr
);
998 if (aexpr
->len
> MAX_AGENT_EXPR_LEN
)
999 error (_("expression too complicated, try simplifying"));
1001 ax_reqs (aexpr
, &areqs
);
1002 (void) make_cleanup (xfree
, areqs
.reg_mask
);
1004 if (areqs
.flaw
!= agent_flaw_none
)
1005 error (_("malformed expression"));
1007 if (areqs
.min_height
< 0)
1008 error (_("gdb: Internal error: expression has min height < 0"));
1010 if (areqs
.max_height
> 20)
1011 error (_("expression too complicated, try simplifying"));
1013 do_cleanups (old_chain
);
1015 while (p
&& *p
++ == ',');
1018 else if (cmd_cfunc_eq (c
, while_stepping_pseudocommand
))
1020 char *steparg
; /* in case warning is necessary */
1022 while (isspace ((int) *p
))
1027 (t
->step_count
= strtol (p
, &p
, 0)) == 0)
1029 warning (_("'%s': bad step-count; command ignored."), *line
);
1034 else if (cmd_cfunc_eq (c
, end_actions_pseudocommand
))
1038 warning (_("'%s' is not a supported tracepoint action."), *line
);
1043 /* worker function */
1045 free_actions (struct tracepoint
*t
)
1047 struct action_line
*line
, *next
;
1049 for (line
= t
->actions
; line
; line
= next
)
1053 xfree (line
->action
);
1060 do_free_actions_cleanup (void *t
)
1065 static struct cleanup
*
1066 make_cleanup_free_actions (struct tracepoint
*t
)
1068 return make_cleanup (do_free_actions_cleanup
, t
);
1072 memrange_absolute
= -1
1077 int type
; /* memrange_absolute for absolute memory range,
1078 else basereg number */
1079 bfd_signed_vma start
;
1083 struct collection_list
1085 unsigned char regs_mask
[32]; /* room for up to 256 regs */
1088 struct memrange
*list
;
1089 long aexpr_listsize
; /* size of array pointed to by expr_list elt */
1090 long next_aexpr_elt
;
1091 struct agent_expr
**aexpr_list
;
1094 tracepoint_list
, stepping_list
;
1096 /* MEMRANGE functions: */
1098 static int memrange_cmp (const void *, const void *);
1100 /* compare memranges for qsort */
1102 memrange_cmp (const void *va
, const void *vb
)
1104 const struct memrange
*a
= va
, *b
= vb
;
1106 if (a
->type
< b
->type
)
1108 if (a
->type
> b
->type
)
1110 if (a
->type
== memrange_absolute
)
1112 if ((bfd_vma
) a
->start
< (bfd_vma
) b
->start
)
1114 if ((bfd_vma
) a
->start
> (bfd_vma
) b
->start
)
1119 if (a
->start
< b
->start
)
1121 if (a
->start
> b
->start
)
1127 /* Sort the memrange list using qsort, and merge adjacent memranges. */
1129 memrange_sortmerge (struct collection_list
*memranges
)
1133 qsort (memranges
->list
, memranges
->next_memrange
,
1134 sizeof (struct memrange
), memrange_cmp
);
1135 if (memranges
->next_memrange
> 0)
1137 for (a
= 0, b
= 1; b
< memranges
->next_memrange
; b
++)
1139 if (memranges
->list
[a
].type
== memranges
->list
[b
].type
&&
1140 memranges
->list
[b
].start
- memranges
->list
[a
].end
<=
1143 /* memrange b starts before memrange a ends; merge them. */
1144 if (memranges
->list
[b
].end
> memranges
->list
[a
].end
)
1145 memranges
->list
[a
].end
= memranges
->list
[b
].end
;
1146 continue; /* next b, same a */
1150 memcpy (&memranges
->list
[a
], &memranges
->list
[b
],
1151 sizeof (struct memrange
));
1153 memranges
->next_memrange
= a
+ 1;
1157 /* Add a register to a collection list. */
1159 add_register (struct collection_list
*collection
, unsigned int regno
)
1162 printf_filtered ("collect register %d\n", regno
);
1163 if (regno
>= (8 * sizeof (collection
->regs_mask
)))
1164 error (_("Internal: register number %d too large for tracepoint"),
1166 collection
->regs_mask
[regno
/ 8] |= 1 << (regno
% 8);
1169 /* Add a memrange to a collection list */
1171 add_memrange (struct collection_list
*memranges
,
1172 int type
, bfd_signed_vma base
,
1177 printf_filtered ("(%d,", type
);
1179 printf_filtered (",%ld)\n", len
);
1182 /* type: memrange_absolute == memory, other n == basereg */
1183 memranges
->list
[memranges
->next_memrange
].type
= type
;
1184 /* base: addr if memory, offset if reg relative. */
1185 memranges
->list
[memranges
->next_memrange
].start
= base
;
1186 /* len: we actually save end (base + len) for convenience */
1187 memranges
->list
[memranges
->next_memrange
].end
= base
+ len
;
1188 memranges
->next_memrange
++;
1189 if (memranges
->next_memrange
>= memranges
->listsize
)
1191 memranges
->listsize
*= 2;
1192 memranges
->list
= xrealloc (memranges
->list
,
1193 memranges
->listsize
);
1196 if (type
!= memrange_absolute
) /* Better collect the base register! */
1197 add_register (memranges
, type
);
1200 /* Add a symbol to a collection list. */
1202 collect_symbol (struct collection_list
*collect
,
1204 long frame_regno
, long frame_offset
)
1208 bfd_signed_vma offset
;
1210 len
= TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
)));
1211 switch (SYMBOL_CLASS (sym
))
1214 printf_filtered ("%s: don't know symbol class %d\n",
1215 DEPRECATED_SYMBOL_NAME (sym
),
1216 SYMBOL_CLASS (sym
));
1219 printf_filtered ("constant %s (value %ld) will not be collected.\n",
1220 DEPRECATED_SYMBOL_NAME (sym
), SYMBOL_VALUE (sym
));
1223 offset
= SYMBOL_VALUE_ADDRESS (sym
);
1228 sprintf_vma (tmp
, offset
);
1229 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1230 DEPRECATED_SYMBOL_NAME (sym
), len
,
1233 add_memrange (collect
, memrange_absolute
, offset
, len
);
1237 reg
= SYMBOL_VALUE (sym
);
1239 printf_filtered ("LOC_REG[parm] %s: ",
1240 DEPRECATED_SYMBOL_NAME (sym
));
1241 add_register (collect
, reg
);
1242 /* Check for doubles stored in two registers. */
1243 /* FIXME: how about larger types stored in 3 or more regs? */
1244 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FLT
&&
1245 len
> register_size (current_gdbarch
, reg
))
1246 add_register (collect
, reg
+ 1);
1249 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1250 printf_filtered (" (will not collect %s)\n",
1251 DEPRECATED_SYMBOL_NAME (sym
));
1255 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1258 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1259 DEPRECATED_SYMBOL_NAME (sym
), len
);
1260 printf_vma (offset
);
1261 printf_filtered (" from frame ptr reg %d\n", reg
);
1263 add_memrange (collect
, reg
, offset
, len
);
1265 case LOC_REGPARM_ADDR
:
1266 reg
= SYMBOL_VALUE (sym
);
1270 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1271 DEPRECATED_SYMBOL_NAME (sym
), len
);
1272 printf_vma (offset
);
1273 printf_filtered (" from reg %d\n", reg
);
1275 add_memrange (collect
, reg
, offset
, len
);
1280 offset
= frame_offset
+ SYMBOL_VALUE (sym
);
1283 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1284 DEPRECATED_SYMBOL_NAME (sym
), len
);
1285 printf_vma (offset
);
1286 printf_filtered (" from frame ptr reg %d\n", reg
);
1288 add_memrange (collect
, reg
, offset
, len
);
1291 case LOC_BASEREG_ARG
:
1292 reg
= SYMBOL_BASEREG (sym
);
1293 offset
= SYMBOL_VALUE (sym
);
1296 printf_filtered ("LOC_BASEREG %s: collect %ld bytes at offset ",
1297 DEPRECATED_SYMBOL_NAME (sym
), len
);
1298 printf_vma (offset
);
1299 printf_filtered (" from basereg %d\n", reg
);
1301 add_memrange (collect
, reg
, offset
, len
);
1303 case LOC_UNRESOLVED
:
1304 printf_filtered ("Don't know LOC_UNRESOLVED %s\n",
1305 DEPRECATED_SYMBOL_NAME (sym
));
1307 case LOC_OPTIMIZED_OUT
:
1308 printf_filtered ("%s has been optimized out of existence.\n",
1309 DEPRECATED_SYMBOL_NAME (sym
));
1314 /* Add all locals (or args) symbols to collection list */
1316 add_local_symbols (struct collection_list
*collect
, CORE_ADDR pc
,
1317 long frame_regno
, long frame_offset
, int type
)
1320 struct block
*block
;
1321 struct dict_iterator iter
;
1324 block
= block_for_pc (pc
);
1327 QUIT
; /* allow user to bail out with ^C */
1328 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
1330 switch (SYMBOL_CLASS (sym
))
1333 warning (_("don't know how to trace local symbol %s"),
1334 DEPRECATED_SYMBOL_NAME (sym
));
1339 if (type
== 'L') /* collecting Locals */
1342 collect_symbol (collect
, sym
, frame_regno
,
1350 case LOC_REGPARM_ADDR
:
1351 case LOC_BASEREG_ARG
:
1352 if (type
== 'A') /* collecting Arguments */
1355 collect_symbol (collect
, sym
, frame_regno
,
1360 if (BLOCK_FUNCTION (block
))
1363 block
= BLOCK_SUPERBLOCK (block
);
1366 warning (_("No %s found in scope."),
1367 type
== 'L' ? "locals" : "args");
1370 /* worker function */
1372 clear_collection_list (struct collection_list
*list
)
1376 list
->next_memrange
= 0;
1377 for (ndx
= 0; ndx
< list
->next_aexpr_elt
; ndx
++)
1379 free_agent_expr (list
->aexpr_list
[ndx
]);
1380 list
->aexpr_list
[ndx
] = NULL
;
1382 list
->next_aexpr_elt
= 0;
1383 memset (list
->regs_mask
, 0, sizeof (list
->regs_mask
));
1386 /* reduce a collection list to string form (for gdb protocol) */
1388 stringify_collection_list (struct collection_list
*list
, char *string
)
1390 char temp_buf
[2048];
1394 char *(*str_list
)[];
1398 count
= 1 + list
->next_memrange
+ list
->next_aexpr_elt
+ 1;
1399 str_list
= (char *(*)[]) xmalloc (count
* sizeof (char *));
1401 for (i
= sizeof (list
->regs_mask
) - 1; i
> 0; i
--)
1402 if (list
->regs_mask
[i
] != 0) /* skip leading zeroes in regs_mask */
1404 if (list
->regs_mask
[i
] != 0) /* prepare to send regs_mask to the stub */
1407 printf_filtered ("\nCollecting registers (mask): 0x");
1412 QUIT
; /* allow user to bail out with ^C */
1414 printf_filtered ("%02X", list
->regs_mask
[i
]);
1415 sprintf (end
, "%02X", list
->regs_mask
[i
]);
1418 (*str_list
)[ndx
] = savestring (temp_buf
, end
- temp_buf
);
1422 printf_filtered ("\n");
1423 if (list
->next_memrange
> 0 && info_verbose
)
1424 printf_filtered ("Collecting memranges: \n");
1425 for (i
= 0, count
= 0, end
= temp_buf
; i
< list
->next_memrange
; i
++)
1427 QUIT
; /* allow user to bail out with ^C */
1428 sprintf_vma (tmp2
, list
->list
[i
].start
);
1431 printf_filtered ("(%d, %s, %ld)\n",
1434 (long) (list
->list
[i
].end
- list
->list
[i
].start
));
1436 if (count
+ 27 > MAX_AGENT_EXPR_LEN
)
1438 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1445 bfd_signed_vma length
= list
->list
[i
].end
- list
->list
[i
].start
;
1447 /* The "%X" conversion specifier expects an unsigned argument,
1448 so passing -1 (memrange_absolute) to it directly gives you
1449 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1451 if (list
->list
[i
].type
== memrange_absolute
)
1452 sprintf (end
, "M-1,%s,%lX", tmp2
, (long) length
);
1454 sprintf (end
, "M%X,%s,%lX", list
->list
[i
].type
, tmp2
, (long) length
);
1457 count
+= strlen (end
);
1458 end
= temp_buf
+ count
;
1461 for (i
= 0; i
< list
->next_aexpr_elt
; i
++)
1463 QUIT
; /* allow user to bail out with ^C */
1464 if ((count
+ 10 + 2 * list
->aexpr_list
[i
]->len
) > MAX_AGENT_EXPR_LEN
)
1466 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1471 sprintf (end
, "X%08X,", list
->aexpr_list
[i
]->len
);
1472 end
+= 10; /* 'X' + 8 hex digits + ',' */
1475 end
= mem2hex (list
->aexpr_list
[i
]->buf
,
1476 end
, list
->aexpr_list
[i
]->len
);
1477 count
+= 2 * list
->aexpr_list
[i
]->len
;
1482 (*str_list
)[ndx
] = savestring (temp_buf
, count
);
1487 (*str_list
)[ndx
] = NULL
;
1499 free_actions_list_cleanup_wrapper (void *al
)
1501 free_actions_list (al
);
1505 free_actions_list (char **actions_list
)
1509 if (actions_list
== 0)
1512 for (ndx
= 0; actions_list
[ndx
]; ndx
++)
1513 xfree (actions_list
[ndx
]);
1515 xfree (actions_list
);
1518 /* Render all actions into gdb protocol. */
1520 encode_actions (struct tracepoint
*t
, char ***tdp_actions
,
1521 char ***stepping_actions
)
1523 static char tdp_buff
[2048], step_buff
[2048];
1525 struct expression
*exp
= NULL
;
1526 struct action_line
*action
;
1528 struct value
*tempval
;
1529 struct collection_list
*collect
;
1530 struct cmd_list_element
*cmd
;
1531 struct agent_expr
*aexpr
;
1533 LONGEST frame_offset
;
1536 clear_collection_list (&tracepoint_list
);
1537 clear_collection_list (&stepping_list
);
1538 collect
= &tracepoint_list
;
1540 *tdp_actions
= NULL
;
1541 *stepping_actions
= NULL
;
1543 gdbarch_virtual_frame_pointer (current_gdbarch
,
1544 t
->address
, &frame_reg
, &frame_offset
);
1546 for (action
= t
->actions
; action
; action
= action
->next
)
1548 QUIT
; /* allow user to bail out with ^C */
1549 action_exp
= action
->action
;
1550 while (isspace ((int) *action_exp
))
1553 if (*action_exp
== '#') /* comment line */
1556 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
1558 error (_("Bad action list item: %s"), action_exp
);
1560 if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
1563 { /* repeat over a comma-separated list */
1564 QUIT
; /* allow user to bail out with ^C */
1565 while (isspace ((int) *action_exp
))
1568 if (0 == strncasecmp ("$reg", action_exp
, 4))
1570 for (i
= 0; i
< gdbarch_num_regs (current_gdbarch
); i
++)
1571 add_register (collect
, i
);
1572 action_exp
= strchr (action_exp
, ','); /* more? */
1574 else if (0 == strncasecmp ("$arg", action_exp
, 4))
1576 add_local_symbols (collect
,
1581 action_exp
= strchr (action_exp
, ','); /* more? */
1583 else if (0 == strncasecmp ("$loc", action_exp
, 4))
1585 add_local_symbols (collect
,
1590 action_exp
= strchr (action_exp
, ','); /* more? */
1594 unsigned long addr
, len
;
1595 struct cleanup
*old_chain
= NULL
;
1596 struct cleanup
*old_chain1
= NULL
;
1597 struct agent_reqs areqs
;
1599 exp
= parse_exp_1 (&action_exp
,
1600 block_for_pc (t
->address
), 1);
1601 old_chain
= make_cleanup (free_current_contents
, &exp
);
1603 switch (exp
->elts
[0].opcode
)
1607 const char *name
= &exp
->elts
[2].string
;
1609 i
= frame_map_name_to_regnum (deprecated_safe_get_selected_frame (),
1610 name
, strlen (name
));
1612 internal_error (__FILE__
, __LINE__
,
1613 _("Register $%s not available"),
1616 printf_filtered ("OP_REGISTER: ");
1617 add_register (collect
, i
);
1622 /* safe because we know it's a simple expression */
1623 tempval
= evaluate_expression (exp
);
1624 addr
= VALUE_ADDRESS (tempval
) + value_offset (tempval
);
1625 len
= TYPE_LENGTH (check_typedef (exp
->elts
[1].type
));
1626 add_memrange (collect
, memrange_absolute
, addr
, len
);
1630 collect_symbol (collect
,
1631 exp
->elts
[2].symbol
,
1636 default: /* full-fledged expression */
1637 aexpr
= gen_trace_for_expr (t
->address
, exp
);
1639 old_chain1
= make_cleanup_free_agent_expr (aexpr
);
1641 ax_reqs (aexpr
, &areqs
);
1642 if (areqs
.flaw
!= agent_flaw_none
)
1643 error (_("malformed expression"));
1645 if (areqs
.min_height
< 0)
1646 error (_("gdb: Internal error: expression has min height < 0"));
1647 if (areqs
.max_height
> 20)
1648 error (_("expression too complicated, try simplifying"));
1650 discard_cleanups (old_chain1
);
1651 add_aexpr (collect
, aexpr
);
1653 /* take care of the registers */
1654 if (areqs
.reg_mask_len
> 0)
1659 for (ndx1
= 0; ndx1
< areqs
.reg_mask_len
; ndx1
++)
1661 QUIT
; /* allow user to bail out with ^C */
1662 if (areqs
.reg_mask
[ndx1
] != 0)
1664 /* assume chars have 8 bits */
1665 for (ndx2
= 0; ndx2
< 8; ndx2
++)
1666 if (areqs
.reg_mask
[ndx1
] & (1 << ndx2
))
1667 /* it's used -- record it */
1668 add_register (collect
,
1675 do_cleanups (old_chain
);
1678 while (action_exp
&& *action_exp
++ == ',');
1680 else if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
1682 collect
= &stepping_list
;
1684 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
1686 if (collect
== &stepping_list
) /* end stepping actions */
1687 collect
= &tracepoint_list
;
1689 break; /* end tracepoint actions */
1692 memrange_sortmerge (&tracepoint_list
);
1693 memrange_sortmerge (&stepping_list
);
1695 *tdp_actions
= stringify_collection_list (&tracepoint_list
,
1697 *stepping_actions
= stringify_collection_list (&stepping_list
,
1702 add_aexpr (struct collection_list
*collect
, struct agent_expr
*aexpr
)
1704 if (collect
->next_aexpr_elt
>= collect
->aexpr_listsize
)
1706 collect
->aexpr_list
=
1707 xrealloc (collect
->aexpr_list
,
1708 2 * collect
->aexpr_listsize
* sizeof (struct agent_expr
*));
1709 collect
->aexpr_listsize
*= 2;
1711 collect
->aexpr_list
[collect
->next_aexpr_elt
] = aexpr
;
1712 collect
->next_aexpr_elt
++;
1715 static char *target_buf
;
1716 static long target_buf_size
;
1718 /* Set "transparent" memory ranges
1720 Allow trace mechanism to treat text-like sections
1721 (and perhaps all read-only sections) transparently,
1722 i.e. don't reject memory requests from these address ranges
1723 just because they haven't been collected. */
1726 remote_set_transparent_ranges (void)
1728 extern bfd
*exec_bfd
;
1735 return; /* No information to give. */
1737 strcpy (target_buf
, "QTro");
1738 for (s
= exec_bfd
->sections
; s
; s
= s
->next
)
1740 char tmp1
[40], tmp2
[40];
1742 if ((s
->flags
& SEC_LOAD
) == 0 ||
1743 /* (s->flags & SEC_CODE) == 0 || */
1744 (s
->flags
& SEC_READONLY
) == 0)
1749 size
= bfd_get_section_size (s
);
1750 sprintf_vma (tmp1
, lma
);
1751 sprintf_vma (tmp2
, lma
+ size
);
1752 sprintf (target_buf
+ strlen (target_buf
),
1753 ":%s,%s", tmp1
, tmp2
);
1757 putpkt (target_buf
);
1758 getpkt (&target_buf
, &target_buf_size
, 0);
1764 Tell target to clear any previous trace experiment.
1765 Walk the list of tracepoints, and send them (and their actions)
1766 to the target. If no errors,
1767 Tell target to start a new trace experiment. */
1770 trace_start_command (char *args
, int from_tty
)
1772 struct tracepoint
*t
;
1775 char **stepping_actions
;
1777 struct cleanup
*old_chain
= NULL
;
1779 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1781 if (target_is_remote ())
1784 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1785 if (strcmp (target_buf
, "OK"))
1786 error (_("Target does not support this command."));
1792 sprintf_vma (tmp
, t
->address
);
1793 sprintf (buf
, "QTDP:%x:%s:%c:%lx:%x", t
->number
,
1795 t
->enabled_p
? 'E' : 'D',
1796 t
->step_count
, t
->pass_count
);
1801 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1802 if (strcmp (target_buf
, "OK"))
1803 error (_("Target does not support tracepoints."));
1807 encode_actions (t
, &tdp_actions
, &stepping_actions
);
1808 old_chain
= make_cleanup (free_actions_list_cleanup_wrapper
,
1810 (void) make_cleanup (free_actions_list_cleanup_wrapper
,
1813 /* do_single_steps (t); */
1816 for (ndx
= 0; tdp_actions
[ndx
]; ndx
++)
1818 QUIT
; /* allow user to bail out with ^C */
1819 sprintf (buf
, "QTDP:-%x:%s:%s%c",
1820 t
->number
, tmp
, /* address */
1822 ((tdp_actions
[ndx
+ 1] || stepping_actions
)
1825 remote_get_noisy_reply (&target_buf
,
1827 if (strcmp (target_buf
, "OK"))
1828 error (_("Error on target while setting tracepoints."));
1831 if (stepping_actions
)
1833 for (ndx
= 0; stepping_actions
[ndx
]; ndx
++)
1835 QUIT
; /* allow user to bail out with ^C */
1836 sprintf (buf
, "QTDP:-%x:%s:%s%s%s",
1837 t
->number
, tmp
, /* address */
1838 ((ndx
== 0) ? "S" : ""),
1839 stepping_actions
[ndx
],
1840 (stepping_actions
[ndx
+ 1] ? "-" : ""));
1842 remote_get_noisy_reply (&target_buf
,
1844 if (strcmp (target_buf
, "OK"))
1845 error (_("Error on target while setting tracepoints."));
1849 do_cleanups (old_chain
);
1852 /* Tell target to treat text-like sections as transparent. */
1853 remote_set_transparent_ranges ();
1854 /* Now insert traps and begin collecting data. */
1856 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1857 if (strcmp (target_buf
, "OK"))
1858 error (_("Bogus reply from target: %s"), target_buf
);
1859 set_traceframe_num (-1); /* All old traceframes invalidated. */
1860 set_tracepoint_num (-1);
1861 set_traceframe_context (-1);
1862 trace_running_p
= 1;
1863 if (deprecated_trace_start_stop_hook
)
1864 deprecated_trace_start_stop_hook (1, from_tty
);
1868 error (_("Trace can only be run on remote targets."));
1873 trace_stop_command (char *args
, int from_tty
)
1875 if (target_is_remote ())
1878 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1879 if (strcmp (target_buf
, "OK"))
1880 error (_("Bogus reply from target: %s"), target_buf
);
1881 trace_running_p
= 0;
1882 if (deprecated_trace_start_stop_hook
)
1883 deprecated_trace_start_stop_hook (0, from_tty
);
1886 error (_("Trace can only be run on remote targets."));
1889 unsigned long trace_running_p
;
1891 /* tstatus command */
1893 trace_status_command (char *args
, int from_tty
)
1895 if (target_is_remote ())
1897 putpkt ("qTStatus");
1898 remote_get_noisy_reply (&target_buf
, &target_buf_size
);
1900 if (target_buf
[0] != 'T' ||
1901 (target_buf
[1] != '0' && target_buf
[1] != '1'))
1902 error (_("Bogus reply from target: %s"), target_buf
);
1904 /* exported for use by the GUI */
1905 trace_running_p
= (target_buf
[1] == '1');
1908 error (_("Trace can only be run on remote targets."));
1911 /* Worker function for the various flavors of the tfind command. */
1913 finish_tfind_command (char **msg
,
1917 int target_frameno
= -1, target_tracept
= -1;
1918 CORE_ADDR old_frame_addr
;
1919 struct symbol
*old_func
;
1922 old_frame_addr
= get_frame_base (get_current_frame ());
1923 old_func
= find_pc_function (read_pc ());
1926 reply
= remote_get_noisy_reply (msg
, sizeof_msg
);
1928 while (reply
&& *reply
)
1932 if ((target_frameno
= (int) strtol (++reply
, &reply
, 16)) == -1)
1934 /* A request for a non-existant trace frame has failed.
1935 Our response will be different, depending on FROM_TTY:
1937 If FROM_TTY is true, meaning that this command was
1938 typed interactively by the user, then give an error
1939 and DO NOT change the state of traceframe_number etc.
1941 However if FROM_TTY is false, meaning that we're either
1942 in a script, a loop, or a user-defined command, then
1943 DON'T give an error, but DO change the state of
1944 traceframe_number etc. to invalid.
1946 The rationalle is that if you typed the command, you
1947 might just have committed a typo or something, and you'd
1948 like to NOT lose your current debugging state. However
1949 if you're in a user-defined command or especially in a
1950 loop, then you need a way to detect that the command
1951 failed WITHOUT aborting. This allows you to write
1952 scripts that search thru the trace buffer until the end,
1953 and then continue on to do something else. */
1956 error (_("Target failed to find requested trace frame."));
1960 printf_filtered ("End of trace buffer.\n");
1961 /* The following will not recurse, since it's
1963 trace_find_command ("-1", from_tty
);
1964 reply
= NULL
; /* Break out of loop
1965 (avoid recursive nonsense). */
1970 if ((target_tracept
= (int) strtol (++reply
, &reply
, 16)) == -1)
1971 error (_("Target failed to find requested trace frame."));
1973 case 'O': /* "OK"? */
1974 if (reply
[1] == 'K' && reply
[2] == '\0')
1977 error (_("Bogus reply from target: %s"), reply
);
1980 error (_("Bogus reply from target: %s"), reply
);
1983 reinit_frame_cache ();
1984 registers_changed ();
1985 set_traceframe_num (target_frameno
);
1986 set_tracepoint_num (target_tracept
);
1987 if (target_frameno
== -1)
1988 set_traceframe_context (-1);
1990 set_traceframe_context (read_pc ());
1994 enum print_what print_what
;
1996 /* NOTE: in immitation of the step command, try to determine
1997 whether we have made a transition from one function to
1998 another. If so, we'll print the "stack frame" (ie. the new
1999 function and it's arguments) -- otherwise we'll just show the
2002 This determination is made by checking (1) whether the
2003 current function has changed, and (2) whether the current FP
2004 has changed. Hack: if the FP wasn't collected, either at the
2005 current or the previous frame, assume that the FP has NOT
2008 if (old_func
== find_pc_function (read_pc ()) &&
2009 (old_frame_addr
== 0 ||
2010 get_frame_base (get_current_frame ()) == 0 ||
2011 old_frame_addr
== get_frame_base (get_current_frame ())))
2012 print_what
= SRC_LINE
;
2014 print_what
= SRC_AND_LOC
;
2016 print_stack_frame (get_selected_frame (NULL
), 1, print_what
);
2021 /* trace_find_command takes a trace frame number n,
2022 sends "QTFrame:<n>" to the target,
2023 and accepts a reply that may contain several optional pieces
2024 of information: a frame number, a tracepoint number, and an
2025 indication of whether this is a trap frame or a stepping frame.
2027 The minimal response is just "OK" (which indicates that the
2028 target does not give us a frame number or a tracepoint number).
2029 Instead of that, the target may send us a string containing
2031 F<hexnum> (gives the selected frame number)
2032 T<hexnum> (gives the selected tracepoint number)
2037 trace_find_command (char *args
, int from_tty
)
2038 { /* this should only be called with a numeric argument */
2041 if (target_is_remote ())
2043 if (deprecated_trace_find_hook
)
2044 deprecated_trace_find_hook (args
, from_tty
);
2046 if (args
== 0 || *args
== 0)
2047 { /* TFIND with no args means find NEXT trace frame. */
2048 if (traceframe_number
== -1)
2049 frameno
= 0; /* "next" is first one */
2051 frameno
= traceframe_number
+ 1;
2053 else if (0 == strcmp (args
, "-"))
2055 if (traceframe_number
== -1)
2056 error (_("not debugging trace buffer"));
2057 else if (from_tty
&& traceframe_number
== 0)
2058 error (_("already at start of trace buffer"));
2060 frameno
= traceframe_number
- 1;
2063 frameno
= parse_and_eval_long (args
);
2066 error (_("invalid input (%d is less than zero)"), frameno
);
2068 sprintf (target_buf
, "QTFrame:%x", frameno
);
2069 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2072 error (_("Trace can only be run on remote targets."));
2077 trace_find_end_command (char *args
, int from_tty
)
2079 trace_find_command ("-1", from_tty
);
2084 trace_find_none_command (char *args
, int from_tty
)
2086 trace_find_command ("-1", from_tty
);
2091 trace_find_start_command (char *args
, int from_tty
)
2093 trace_find_command ("0", from_tty
);
2096 /* tfind pc command */
2098 trace_find_pc_command (char *args
, int from_tty
)
2103 if (target_is_remote ())
2105 if (args
== 0 || *args
== 0)
2106 pc
= read_pc (); /* default is current pc */
2108 pc
= parse_and_eval_address (args
);
2110 sprintf_vma (tmp
, pc
);
2111 sprintf (target_buf
, "QTFrame:pc:%s", tmp
);
2112 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2115 error (_("Trace can only be run on remote targets."));
2118 /* tfind tracepoint command */
2120 trace_find_tracepoint_command (char *args
, int from_tty
)
2124 if (target_is_remote ())
2126 if (args
== 0 || *args
== 0)
2128 if (tracepoint_number
== -1)
2129 error (_("No current tracepoint -- please supply an argument."));
2131 tdp
= tracepoint_number
; /* default is current TDP */
2134 tdp
= parse_and_eval_long (args
);
2136 sprintf (target_buf
, "QTFrame:tdp:%x", tdp
);
2137 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2140 error (_("Trace can only be run on remote targets."));
2143 /* TFIND LINE command:
2145 This command will take a sourceline for argument, just like BREAK
2146 or TRACE (ie. anything that "decode_line_1" can handle).
2148 With no argument, this command will find the next trace frame
2149 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2152 trace_find_line_command (char *args
, int from_tty
)
2154 static CORE_ADDR start_pc
, end_pc
;
2155 struct symtabs_and_lines sals
;
2156 struct symtab_and_line sal
;
2157 struct cleanup
*old_chain
;
2158 char startpc_str
[40], endpc_str
[40];
2160 if (target_is_remote ())
2162 if (args
== 0 || *args
== 0)
2164 sal
= find_pc_line (get_frame_pc (get_current_frame ()), 0);
2166 sals
.sals
= (struct symtab_and_line
*)
2167 xmalloc (sizeof (struct symtab_and_line
));
2172 sals
= decode_line_spec (args
, 1);
2176 old_chain
= make_cleanup (xfree
, sals
.sals
);
2177 if (sal
.symtab
== 0)
2179 printf_filtered ("TFIND: No line number information available");
2182 /* This is useful for "info line *0x7f34". If we can't
2183 tell the user about a source line, at least let them
2184 have the symbolic address. */
2185 printf_filtered (" for address ");
2187 print_address (sal
.pc
, gdb_stdout
);
2188 printf_filtered (";\n -- will attempt to find by PC. \n");
2192 printf_filtered (".\n");
2193 return; /* No line, no PC; what can we do? */
2196 else if (sal
.line
> 0
2197 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2199 if (start_pc
== end_pc
)
2201 printf_filtered ("Line %d of \"%s\"",
2202 sal
.line
, sal
.symtab
->filename
);
2204 printf_filtered (" is at address ");
2205 print_address (start_pc
, gdb_stdout
);
2207 printf_filtered (" but contains no code.\n");
2208 sal
= find_pc_line (start_pc
, 0);
2210 find_line_pc_range (sal
, &start_pc
, &end_pc
) &&
2212 printf_filtered ("Attempting to find line %d instead.\n",
2215 error (_("Cannot find a good line."));
2219 /* Is there any case in which we get here, and have an address
2220 which the user would want to see? If we have debugging
2221 symbols and no line numbers? */
2222 error (_("Line number %d is out of range for \"%s\"."),
2223 sal
.line
, sal
.symtab
->filename
);
2225 sprintf_vma (startpc_str
, start_pc
);
2226 sprintf_vma (endpc_str
, end_pc
- 1);
2227 /* Find within range of stated line. */
2229 sprintf (target_buf
, "QTFrame:range:%s:%s",
2230 startpc_str
, endpc_str
);
2231 /* Find OUTSIDE OF range of CURRENT line. */
2233 sprintf (target_buf
, "QTFrame:outside:%s:%s",
2234 startpc_str
, endpc_str
);
2235 finish_tfind_command (&target_buf
, &target_buf_size
,
2237 do_cleanups (old_chain
);
2240 error (_("Trace can only be run on remote targets."));
2243 /* tfind range command */
2245 trace_find_range_command (char *args
, int from_tty
)
2247 static CORE_ADDR start
, stop
;
2248 char start_str
[40], stop_str
[40];
2251 if (target_is_remote ())
2253 if (args
== 0 || *args
== 0)
2254 { /* XXX FIXME: what should default behavior be? */
2255 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2259 if (0 != (tmp
= strchr (args
, ',')))
2261 *tmp
++ = '\0'; /* terminate start address */
2262 while (isspace ((int) *tmp
))
2264 start
= parse_and_eval_address (args
);
2265 stop
= parse_and_eval_address (tmp
);
2268 { /* no explicit end address? */
2269 start
= parse_and_eval_address (args
);
2270 stop
= start
+ 1; /* ??? */
2273 sprintf_vma (start_str
, start
);
2274 sprintf_vma (stop_str
, stop
);
2275 sprintf (target_buf
, "QTFrame:range:%s:%s", start_str
, stop_str
);
2276 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2279 error (_("Trace can only be run on remote targets."));
2282 /* tfind outside command */
2284 trace_find_outside_command (char *args
, int from_tty
)
2286 CORE_ADDR start
, stop
;
2287 char start_str
[40], stop_str
[40];
2290 if (target_is_remote ())
2292 if (args
== 0 || *args
== 0)
2293 { /* XXX FIXME: what should default behavior be? */
2294 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2298 if (0 != (tmp
= strchr (args
, ',')))
2300 *tmp
++ = '\0'; /* terminate start address */
2301 while (isspace ((int) *tmp
))
2303 start
= parse_and_eval_address (args
);
2304 stop
= parse_and_eval_address (tmp
);
2307 { /* no explicit end address? */
2308 start
= parse_and_eval_address (args
);
2309 stop
= start
+ 1; /* ??? */
2312 sprintf_vma (start_str
, start
);
2313 sprintf_vma (stop_str
, stop
);
2314 sprintf (target_buf
, "QTFrame:outside:%s:%s", start_str
, stop_str
);
2315 finish_tfind_command (&target_buf
, &target_buf_size
, from_tty
);
2318 error (_("Trace can only be run on remote targets."));
2321 /* save-tracepoints command */
2323 tracepoint_save_command (char *args
, int from_tty
)
2325 struct tracepoint
*tp
;
2326 struct action_line
*line
;
2328 char *i1
= " ", *i2
= " ";
2329 char *indent
, *actionline
, *pathname
;
2332 if (args
== 0 || *args
== 0)
2333 error (_("Argument required (file name in which to save tracepoints)"));
2335 if (tracepoint_chain
== 0)
2337 warning (_("save-tracepoints: no tracepoints to save."));
2341 pathname
= tilde_expand (args
);
2342 if (!(fp
= fopen (pathname
, "w")))
2343 error (_("Unable to open file '%s' for saving tracepoints (%s)"),
2344 args
, safe_strerror (errno
));
2347 ALL_TRACEPOINTS (tp
)
2349 if (tp
->addr_string
)
2350 fprintf (fp
, "trace %s\n", tp
->addr_string
);
2353 sprintf_vma (tmp
, tp
->address
);
2354 fprintf (fp
, "trace *0x%s\n", tmp
);
2358 fprintf (fp
, " passcount %d\n", tp
->pass_count
);
2362 fprintf (fp
, " actions\n");
2364 for (line
= tp
->actions
; line
; line
= line
->next
)
2366 struct cmd_list_element
*cmd
;
2368 QUIT
; /* allow user to bail out with ^C */
2369 actionline
= line
->action
;
2370 while (isspace ((int) *actionline
))
2373 fprintf (fp
, "%s%s\n", indent
, actionline
);
2374 if (*actionline
!= '#') /* skip for comment lines */
2376 cmd
= lookup_cmd (&actionline
, cmdlist
, "", -1, 1);
2378 error (_("Bad action list item: %s"), actionline
);
2379 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2381 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2389 printf_filtered ("Tracepoints saved to file '%s'.\n", args
);
2393 /* info scope command: list the locals for a scope. */
2395 scope_info (char *args
, int from_tty
)
2397 struct symtabs_and_lines sals
;
2399 struct minimal_symbol
*msym
;
2400 struct block
*block
;
2401 char **canonical
, *symname
, *save_args
= args
;
2402 struct dict_iterator iter
;
2405 if (args
== 0 || *args
== 0)
2406 error (_("requires an argument (function, line or *addr) to define a scope"));
2408 sals
= decode_line_1 (&args
, 1, NULL
, 0, &canonical
, NULL
);
2409 if (sals
.nelts
== 0)
2410 return; /* presumably decode_line_1 has already warned */
2412 /* Resolve line numbers to PC */
2413 resolve_sal_pc (&sals
.sals
[0]);
2414 block
= block_for_pc (sals
.sals
[0].pc
);
2418 QUIT
; /* allow user to bail out with ^C */
2419 ALL_BLOCK_SYMBOLS (block
, iter
, sym
)
2421 QUIT
; /* allow user to bail out with ^C */
2423 printf_filtered ("Scope for %s:\n", save_args
);
2426 symname
= DEPRECATED_SYMBOL_NAME (sym
);
2427 if (symname
== NULL
|| *symname
== '\0')
2428 continue; /* probably botched, certainly useless */
2430 printf_filtered ("Symbol %s is ", symname
);
2431 switch (SYMBOL_CLASS (sym
))
2434 case LOC_UNDEF
: /* messed up symbol? */
2435 printf_filtered ("a bogus symbol, class %d.\n",
2436 SYMBOL_CLASS (sym
));
2437 count
--; /* don't count this one */
2440 printf_filtered ("a constant with value %ld (0x%lx)",
2441 SYMBOL_VALUE (sym
), SYMBOL_VALUE (sym
));
2443 case LOC_CONST_BYTES
:
2444 printf_filtered ("constant bytes: ");
2445 if (SYMBOL_TYPE (sym
))
2446 for (j
= 0; j
< TYPE_LENGTH (SYMBOL_TYPE (sym
)); j
++)
2447 fprintf_filtered (gdb_stdout
, " %02x",
2448 (unsigned) SYMBOL_VALUE_BYTES (sym
)[j
]);
2451 printf_filtered ("in static storage at address ");
2452 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
),
2456 printf_filtered ("a local variable in register $%s",
2457 gdbarch_register_name
2458 (current_gdbarch
, SYMBOL_VALUE (sym
)));
2462 printf_filtered ("an argument at stack/frame offset %ld",
2463 SYMBOL_VALUE (sym
));
2466 printf_filtered ("a local variable at frame offset %ld",
2467 SYMBOL_VALUE (sym
));
2470 printf_filtered ("a reference argument at offset %ld",
2471 SYMBOL_VALUE (sym
));
2474 printf_filtered ("an argument in register $%s",
2475 gdbarch_register_name
2476 (current_gdbarch
, SYMBOL_VALUE (sym
)));
2478 case LOC_REGPARM_ADDR
:
2479 printf_filtered ("the address of an argument, in register $%s",
2480 gdbarch_register_name
2481 (current_gdbarch
, SYMBOL_VALUE (sym
)));
2484 printf_filtered ("a typedef.\n");
2487 printf_filtered ("a label at address ");
2488 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
),
2492 printf_filtered ("a function at address ");
2493 deprecated_print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)),
2497 printf_filtered ("a variable at offset %ld from register $%s",
2499 gdbarch_register_name
2500 (current_gdbarch
, SYMBOL_BASEREG (sym
)));
2502 case LOC_BASEREG_ARG
:
2503 printf_filtered ("an argument at offset %ld from register $%s",
2505 gdbarch_register_name
2506 (current_gdbarch
, SYMBOL_BASEREG (sym
)));
2508 case LOC_UNRESOLVED
:
2509 msym
= lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (sym
),
2512 printf_filtered ("Unresolved Static");
2515 printf_filtered ("static storage at address ");
2516 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (msym
), 1,
2520 case LOC_OPTIMIZED_OUT
:
2521 printf_filtered ("optimized out.\n");
2523 case LOC_HP_THREAD_LOCAL_STATIC
:
2524 printf_filtered ("HP thread local static ");
2527 printf_filtered ("extern (local indirect) at address ");
2528 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (sym
),
2532 case LOC_COMPUTED_ARG
:
2533 SYMBOL_OPS (sym
)->describe_location (sym
, gdb_stdout
);
2536 if (SYMBOL_TYPE (sym
))
2537 printf_filtered (", length %d.\n",
2538 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym
))));
2540 if (BLOCK_FUNCTION (block
))
2543 block
= BLOCK_SUPERBLOCK (block
);
2546 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2550 /* worker function (cleanup) */
2552 replace_comma (void *data
)
2560 trace_dump_command (char *args
, int from_tty
)
2562 struct tracepoint
*t
;
2563 struct action_line
*action
;
2564 char *action_exp
, *next_comma
;
2565 struct cleanup
*old_cleanups
;
2566 int stepping_actions
= 0;
2567 int stepping_frame
= 0;
2569 if (!target_is_remote ())
2571 error (_("Trace can only be run on remote targets."));
2575 if (tracepoint_number
== -1)
2577 warning (_("No current trace frame."));
2582 if (t
->number
== tracepoint_number
)
2586 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2589 old_cleanups
= make_cleanup (null_cleanup
, NULL
);
2591 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2592 tracepoint_number
, traceframe_number
);
2594 /* The current frame is a trap frame if the frame PC is equal
2595 to the tracepoint PC. If not, then the current frame was
2596 collected during single-stepping. */
2598 stepping_frame
= (t
->address
!= (read_pc () - gdbarch_decr_pc_after_break
2599 (current_gdbarch
)));
2601 for (action
= t
->actions
; action
; action
= action
->next
)
2603 struct cmd_list_element
*cmd
;
2605 QUIT
; /* allow user to bail out with ^C */
2606 action_exp
= action
->action
;
2607 while (isspace ((int) *action_exp
))
2610 /* The collection actions to be done while stepping are
2611 bracketed by the commands "while-stepping" and "end". */
2613 if (*action_exp
== '#') /* comment line */
2616 cmd
= lookup_cmd (&action_exp
, cmdlist
, "", -1, 1);
2618 error (_("Bad action list item: %s"), action_exp
);
2620 if (cmd_cfunc_eq (cmd
, while_stepping_pseudocommand
))
2621 stepping_actions
= 1;
2622 else if (cmd_cfunc_eq (cmd
, end_actions_pseudocommand
))
2623 stepping_actions
= 0;
2624 else if (cmd_cfunc_eq (cmd
, collect_pseudocommand
))
2626 /* Display the collected data.
2627 For the trap frame, display only what was collected at
2628 the trap. Likewise for stepping frames, display only
2629 what was collected while stepping. This means that the
2630 two boolean variables, STEPPING_FRAME and
2631 STEPPING_ACTIONS should be equal. */
2632 if (stepping_frame
== stepping_actions
)
2635 { /* repeat over a comma-separated list */
2636 QUIT
; /* allow user to bail out with ^C */
2637 if (*action_exp
== ',')
2639 while (isspace ((int) *action_exp
))
2642 next_comma
= strchr (action_exp
, ',');
2644 if (0 == strncasecmp (action_exp
, "$reg", 4))
2645 registers_info (NULL
, from_tty
);
2646 else if (0 == strncasecmp (action_exp
, "$loc", 4))
2647 locals_info (NULL
, from_tty
);
2648 else if (0 == strncasecmp (action_exp
, "$arg", 4))
2649 args_info (NULL
, from_tty
);
2654 make_cleanup (replace_comma
, next_comma
);
2657 printf_filtered ("%s = ", action_exp
);
2658 output_command (action_exp
, from_tty
);
2659 printf_filtered ("\n");
2663 action_exp
= next_comma
;
2665 while (action_exp
&& *action_exp
== ',');
2669 discard_cleanups (old_cleanups
);
2672 /* Convert the memory pointed to by mem into hex, placing result in buf.
2673 * Return a pointer to the last char put in buf (null)
2674 * "stolen" from sparc-stub.c
2677 static const char hexchars
[] = "0123456789abcdef";
2680 mem2hex (gdb_byte
*mem
, char *buf
, int count
)
2688 *buf
++ = hexchars
[ch
>> 4];
2689 *buf
++ = hexchars
[ch
& 0xf];
2698 get_traceframe_number (void)
2700 return traceframe_number
;
2704 /* module initialization */
2706 _initialize_tracepoint (void)
2708 struct cmd_list_element
*c
;
2710 tracepoint_chain
= 0;
2711 tracepoint_count
= 0;
2712 traceframe_number
= -1;
2713 tracepoint_number
= -1;
2715 if (tracepoint_list
.list
== NULL
)
2717 tracepoint_list
.listsize
= 128;
2718 tracepoint_list
.list
= xmalloc
2719 (tracepoint_list
.listsize
* sizeof (struct memrange
));
2721 if (tracepoint_list
.aexpr_list
== NULL
)
2723 tracepoint_list
.aexpr_listsize
= 128;
2724 tracepoint_list
.aexpr_list
= xmalloc
2725 (tracepoint_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
2728 if (stepping_list
.list
== NULL
)
2730 stepping_list
.listsize
= 128;
2731 stepping_list
.list
= xmalloc
2732 (stepping_list
.listsize
* sizeof (struct memrange
));
2735 if (stepping_list
.aexpr_list
== NULL
)
2737 stepping_list
.aexpr_listsize
= 128;
2738 stepping_list
.aexpr_list
= xmalloc
2739 (stepping_list
.aexpr_listsize
* sizeof (struct agent_expr
*));
2742 add_info ("scope", scope_info
,
2743 _("List the variables local to a scope"));
2745 add_cmd ("tracepoints", class_trace
, NULL
,
2746 _("Tracing of program execution without stopping the program."),
2749 add_info ("tracepoints", tracepoints_info
, _("\
2750 Status of tracepoints, or tracepoint number NUMBER.\n\
2751 Convenience variable \"$tpnum\" contains the number of the\n\
2752 last tracepoint set."));
2754 add_info_alias ("tp", "tracepoints", 1);
2756 c
= add_com ("save-tracepoints", class_trace
, tracepoint_save_command
, _("\
2757 Save current tracepoint definitions as a script.\n\
2758 Use the 'source' command in another debug session to restore them."));
2759 set_cmd_completer (c
, filename_completer
);
2761 add_com ("tdump", class_trace
, trace_dump_command
,
2762 _("Print everything collected at the current tracepoint."));
2764 add_prefix_cmd ("tfind", class_trace
, trace_find_command
, _("\
2765 Select a trace frame;\n\
2766 No argument means forward by one frame; '-' means backward by one frame."),
2767 &tfindlist
, "tfind ", 1, &cmdlist
);
2769 add_cmd ("outside", class_trace
, trace_find_outside_command
, _("\
2770 Select a trace frame whose PC is outside the given range.\n\
2771 Usage: tfind outside addr1, addr2"),
2774 add_cmd ("range", class_trace
, trace_find_range_command
, _("\
2775 Select a trace frame whose PC is in the given range.\n\
2776 Usage: tfind range addr1,addr2"),
2779 add_cmd ("line", class_trace
, trace_find_line_command
, _("\
2780 Select a trace frame by source line.\n\
2781 Argument can be a line number (with optional source file), \n\
2782 a function name, or '*' followed by an address.\n\
2783 Default argument is 'the next source line that was traced'."),
2786 add_cmd ("tracepoint", class_trace
, trace_find_tracepoint_command
, _("\
2787 Select a trace frame by tracepoint number.\n\
2788 Default is the tracepoint for the current trace frame."),
2791 add_cmd ("pc", class_trace
, trace_find_pc_command
, _("\
2792 Select a trace frame by PC.\n\
2793 Default is the current PC, or the PC of the current trace frame."),
2796 add_cmd ("end", class_trace
, trace_find_end_command
, _("\
2797 Synonym for 'none'.\n\
2798 De-select any trace frame and resume 'live' debugging."),
2801 add_cmd ("none", class_trace
, trace_find_none_command
,
2802 _("De-select any trace frame and resume 'live' debugging."),
2805 add_cmd ("start", class_trace
, trace_find_start_command
,
2806 _("Select the first trace frame in the trace buffer."),
2809 add_com ("tstatus", class_trace
, trace_status_command
,
2810 _("Display the status of the current trace data collection."));
2812 add_com ("tstop", class_trace
, trace_stop_command
,
2813 _("Stop trace data collection."));
2815 add_com ("tstart", class_trace
, trace_start_command
,
2816 _("Start trace data collection."));
2818 add_com ("passcount", class_trace
, trace_pass_command
, _("\
2819 Set the passcount for a tracepoint.\n\
2820 The trace will end when the tracepoint has been passed 'count' times.\n\
2821 Usage: passcount COUNT TPNUM, where TPNUM may also be \"all\";\n\
2822 if TPNUM is omitted, passcount refers to the last tracepoint defined."));
2824 add_com ("end", class_trace
, end_actions_pseudocommand
, _("\
2825 Ends a list of commands or actions.\n\
2826 Several GDB commands allow you to enter a list of commands or actions.\n\
2827 Entering \"end\" on a line by itself is the normal way to terminate\n\
2829 Note: the \"end\" command cannot be used at the gdb prompt."));
2831 add_com ("while-stepping", class_trace
, while_stepping_pseudocommand
, _("\
2832 Specify single-stepping behavior at a tracepoint.\n\
2833 Argument is number of instructions to trace in single-step mode\n\
2834 following the tracepoint. This command is normally followed by\n\
2835 one or more \"collect\" commands, to specify what to collect\n\
2836 while single-stepping.\n\n\
2837 Note: this command can only be used in a tracepoint \"actions\" list."));
2839 add_com_alias ("ws", "while-stepping", class_alias
, 0);
2840 add_com_alias ("stepping", "while-stepping", class_alias
, 0);
2842 add_com ("collect", class_trace
, collect_pseudocommand
, _("\
2843 Specify one or more data items to be collected at a tracepoint.\n\
2844 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
2845 collect all data (variables, registers) referenced by that expression.\n\
2846 Also accepts the following special arguments:\n\
2847 $regs -- all registers.\n\
2848 $args -- all function arguments.\n\
2849 $locals -- all variables local to the block/function scope.\n\
2850 Note: this command can only be used in a tracepoint \"actions\" list."));
2852 add_com ("actions", class_trace
, trace_actions_command
, _("\
2853 Specify the actions to be taken at a tracepoint.\n\
2854 Tracepoint actions may include collecting of specified data, \n\
2855 single-stepping, or enabling/disabling other tracepoints, \n\
2856 depending on target's capabilities."));
2858 add_cmd ("tracepoints", class_trace
, delete_trace_command
, _("\
2859 Delete specified tracepoints.\n\
2860 Arguments are tracepoint numbers, separated by spaces.\n\
2861 No argument means delete all tracepoints."),
2864 add_cmd ("tracepoints", class_trace
, disable_trace_command
, _("\
2865 Disable specified tracepoints.\n\
2866 Arguments are tracepoint numbers, separated by spaces.\n\
2867 No argument means disable all tracepoints."),
2870 add_cmd ("tracepoints", class_trace
, enable_trace_command
, _("\
2871 Enable specified tracepoints.\n\
2872 Arguments are tracepoint numbers, separated by spaces.\n\
2873 No argument means enable all tracepoints."),
2876 c
= add_com ("trace", class_trace
, trace_command
, _("\
2877 Set a tracepoint at a specified line or function or address.\n\
2878 Argument may be a line number, function name, or '*' plus an address.\n\
2879 For a line number or function, trace at the start of its code.\n\
2880 If an address is specified, trace at that exact address.\n\n\
2881 Do \"help tracepoints\" for info on other tracepoint commands."));
2882 set_cmd_completer (c
, location_completer
);
2884 add_com_alias ("tp", "trace", class_alias
, 0);
2885 add_com_alias ("tr", "trace", class_alias
, 1);
2886 add_com_alias ("tra", "trace", class_alias
, 1);
2887 add_com_alias ("trac", "trace", class_alias
, 1);
2889 target_buf_size
= 2048;
2890 target_buf
= xmalloc (target_buf_size
);