1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
25 #include "expression.h"
29 #include "target-dcache.h"
32 #include "breakpoint.h"
33 #include "tracepoint.h"
36 #include "completer.h"
38 #include "dictionary.h"
40 #include "user-regs.h"
44 #include "filenames.h"
45 #include "gdbthread.h"
52 #include "cli/cli-utils.h"
55 #include "filestuff.h"
57 #include "tracefile.h"
59 /* readline include files */
60 #include "readline/readline.h"
61 #include "readline/history.h"
63 /* readline defines this. */
68 /* Maximum length of an agent aexpression.
69 This accounts for the fact that packets are limited to 400 bytes
70 (which includes everything -- including the checksum), and assumes
71 the worst case of maximum length for each of the pieces of a
74 NOTE: expressions get mem2hex'ed otherwise this would be twice as
75 large. (400 - 31)/2 == 184 */
76 #define MAX_AGENT_EXPR_LEN 184
78 /* A hook used to notify the UI of tracepoint operations. */
80 void (*deprecated_trace_find_hook) (char *arg, int from_tty);
81 void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
86 This module defines the following debugger commands:
87 trace : set a tracepoint on a function, line, or address.
88 info trace : list all debugger-defined tracepoints.
89 delete trace : delete one or more tracepoints.
90 enable trace : enable one or more tracepoints.
91 disable trace : disable one or more tracepoints.
92 actions : specify actions to be taken at a tracepoint.
93 passcount : specify a pass count for a tracepoint.
94 tstart : start a trace experiment.
95 tstop : stop a trace experiment.
96 tstatus : query the status of a trace experiment.
97 tfind : find a trace frame in the trace buffer.
98 tdump : print everything collected at the current tracepoint.
99 save-tracepoints : write tracepoint setup into a file.
101 This module defines the following user-visible debugger variables:
102 $trace_frame : sequence number of trace frame currently being debugged.
103 $trace_line : source line of trace frame currently being debugged.
104 $trace_file : source file of trace frame currently being debugged.
105 $tracepoint : tracepoint number of trace frame currently being debugged.
109 /* ======= Important global variables: ======= */
111 /* The list of all trace state variables. We don't retain pointers to
112 any of these for any reason - API is by name or number only - so it
113 works to have a vector of objects. */
115 typedef struct trace_state_variable tsv_s;
118 static VEC(tsv_s) *tvariables;
120 /* The next integer to assign to a variable. */
122 static int next_tsv_number = 1;
124 /* Number of last traceframe collected. */
125 static int traceframe_number;
127 /* Tracepoint for last traceframe collected. */
128 static int tracepoint_number;
130 /* The traceframe info of the current traceframe. NULL if we haven't
131 yet attempted to fetch it, or if the target does not support
132 fetching this object, or if we're not inspecting a traceframe
134 static struct traceframe_info *traceframe_info;
136 /* Tracing command lists. */
137 static struct cmd_list_element *tfindlist;
139 /* List of expressions to collect by default at each tracepoint hit. */
140 char *default_collect = "";
142 static int disconnected_tracing;
144 /* This variable controls whether we ask the target for a linear or
145 circular trace buffer. */
147 static int circular_trace_buffer;
149 /* This variable is the requested trace buffer size, or -1 to indicate
150 that we don't care and leave it up to the target to set a size. */
152 static int trace_buffer_size = -1;
154 /* Textual notes applying to the current and/or future trace runs. */
156 char *trace_user = NULL;
158 /* Textual notes applying to the current and/or future trace runs. */
160 char *trace_notes = NULL;
162 /* Textual notes applying to the stopping of a trace. */
164 char *trace_stop_notes = NULL;
166 /* ======= Important command functions: ======= */
167 static void trace_actions_command (char *, int);
168 static void trace_start_command (char *, int);
169 static void trace_stop_command (char *, int);
170 static void trace_status_command (char *, int);
171 static void trace_find_command (char *, int);
172 static void trace_find_pc_command (char *, int);
173 static void trace_find_tracepoint_command (char *, int);
174 static void trace_find_line_command (char *, int);
175 static void trace_find_range_command (char *, int);
176 static void trace_find_outside_command (char *, int);
177 static void trace_dump_command (char *, int);
179 /* support routines */
181 struct collection_list;
182 static void add_aexpr (struct collection_list *, struct agent_expr *);
183 static char *mem2hex (gdb_byte *, char *, int);
184 static void add_register (struct collection_list *collection,
187 static struct command_line *
188 all_tracepoint_actions_and_cleanup (struct breakpoint *t);
190 extern void _initialize_tracepoint (void);
192 static struct trace_status trace_status;
194 const char *stop_reason_names[] = {
204 struct trace_status *
205 current_trace_status (void)
207 return &trace_status;
213 free_traceframe_info (struct traceframe_info *info)
217 VEC_free (mem_range_s, info->memory);
218 VEC_free (int, info->tvars);
224 /* Free and clear the traceframe info cache of the current
228 clear_traceframe_info (void)
230 free_traceframe_info (traceframe_info);
231 traceframe_info = NULL;
234 /* Set traceframe number to NUM. */
236 set_traceframe_num (int num)
238 traceframe_number = num;
239 set_internalvar_integer (lookup_internalvar ("trace_frame"), num);
242 /* Set tracepoint number to NUM. */
244 set_tracepoint_num (int num)
246 tracepoint_number = num;
247 set_internalvar_integer (lookup_internalvar ("tracepoint"), num);
250 /* Set externally visible debug variables for querying/printing
251 the traceframe context (line, function, file). */
254 set_traceframe_context (struct frame_info *trace_frame)
257 struct symbol *traceframe_fun;
258 struct symtab_and_line traceframe_sal;
260 /* Save as globals for internal use. */
261 if (trace_frame != NULL
262 && get_frame_pc_if_available (trace_frame, &trace_pc))
264 traceframe_sal = find_pc_line (trace_pc, 0);
265 traceframe_fun = find_pc_function (trace_pc);
267 /* Save linenumber as "$trace_line", a debugger variable visible to
269 set_internalvar_integer (lookup_internalvar ("trace_line"),
270 traceframe_sal.line);
274 init_sal (&traceframe_sal);
275 traceframe_fun = NULL;
276 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
279 /* Save func name as "$trace_func", a debugger variable visible to
281 if (traceframe_fun == NULL
282 || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
283 clear_internalvar (lookup_internalvar ("trace_func"));
285 set_internalvar_string (lookup_internalvar ("trace_func"),
286 SYMBOL_LINKAGE_NAME (traceframe_fun));
288 /* Save file name as "$trace_file", a debugger variable visible to
290 if (traceframe_sal.symtab == NULL)
291 clear_internalvar (lookup_internalvar ("trace_file"));
293 set_internalvar_string (lookup_internalvar ("trace_file"),
294 symtab_to_filename_for_display (traceframe_sal.symtab));
297 /* Create a new trace state variable with the given name. */
299 struct trace_state_variable *
300 create_trace_state_variable (const char *name)
302 struct trace_state_variable tsv;
304 memset (&tsv, 0, sizeof (tsv));
305 tsv.name = xstrdup (name);
306 tsv.number = next_tsv_number++;
307 return VEC_safe_push (tsv_s, tvariables, &tsv);
310 /* Look for a trace state variable of the given name. */
312 struct trace_state_variable *
313 find_trace_state_variable (const char *name)
315 struct trace_state_variable *tsv;
318 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
319 if (strcmp (name, tsv->name) == 0)
325 /* Look for a trace state variable of the given number. Return NULL if
328 struct trace_state_variable *
329 find_trace_state_variable_by_number (int number)
331 struct trace_state_variable *tsv;
334 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
335 if (tsv->number == number)
342 delete_trace_state_variable (const char *name)
344 struct trace_state_variable *tsv;
347 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
348 if (strcmp (name, tsv->name) == 0)
350 observer_notify_tsv_deleted (tsv);
352 xfree ((void *)tsv->name);
353 VEC_unordered_remove (tsv_s, tvariables, ix);
358 warning (_("No trace variable named \"$%s\", not deleting"), name);
361 /* Throws an error if NAME is not valid syntax for a trace state
365 validate_trace_state_variable_name (const char *name)
370 error (_("Must supply a non-empty variable name"));
372 /* All digits in the name is reserved for value history
374 for (p = name; isdigit (*p); p++)
377 error (_("$%s is not a valid trace state variable name"), name);
379 for (p = name; isalnum (*p) || *p == '_'; p++)
382 error (_("$%s is not a valid trace state variable name"), name);
385 /* The 'tvariable' command collects a name and optional expression to
386 evaluate into an initial value. */
389 trace_variable_command (char *args, int from_tty)
391 struct cleanup *old_chain;
393 struct trace_state_variable *tsv;
397 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
399 /* Only allow two syntaxes; "$name" and "$name=value". */
400 p = skip_spaces (args);
403 error (_("Name of trace variable should start with '$'"));
406 while (isalnum (*p) || *p == '_')
408 name = savestring (name, p - name);
409 old_chain = make_cleanup (xfree, name);
412 if (*p != '=' && *p != '\0')
413 error (_("Syntax must be $NAME [ = EXPR ]"));
415 validate_trace_state_variable_name (name);
418 initval = value_as_long (parse_and_eval (++p));
420 /* If the variable already exists, just change its initial value. */
421 tsv = find_trace_state_variable (name);
424 if (tsv->initial_value != initval)
426 tsv->initial_value = initval;
427 observer_notify_tsv_modified (tsv);
429 printf_filtered (_("Trace state variable $%s "
430 "now has initial value %s.\n"),
431 tsv->name, plongest (tsv->initial_value));
432 do_cleanups (old_chain);
436 /* Create a new variable. */
437 tsv = create_trace_state_variable (name);
438 tsv->initial_value = initval;
440 observer_notify_tsv_created (tsv);
442 printf_filtered (_("Trace state variable $%s "
443 "created, with initial value %s.\n"),
444 tsv->name, plongest (tsv->initial_value));
446 do_cleanups (old_chain);
450 delete_trace_variable_command (char *args, int from_tty)
454 struct cleanup *back_to;
458 if (query (_("Delete all trace state variables? ")))
459 VEC_free (tsv_s, tvariables);
461 observer_notify_tsv_deleted (NULL);
465 argv = gdb_buildargv (args);
466 back_to = make_cleanup_freeargv (argv);
468 for (ix = 0; argv[ix] != NULL; ix++)
470 if (*argv[ix] == '$')
471 delete_trace_state_variable (argv[ix] + 1);
473 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv[ix]);
476 do_cleanups (back_to);
482 tvariables_info_1 (void)
484 struct trace_state_variable *tsv;
487 struct cleanup *back_to;
488 struct ui_out *uiout = current_uiout;
490 if (VEC_length (tsv_s, tvariables) == 0 && !ui_out_is_mi_like_p (uiout))
492 printf_filtered (_("No trace state variables.\n"));
496 /* Try to acquire values from the target. */
497 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix, ++count)
498 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
501 back_to = make_cleanup_ui_out_table_begin_end (uiout, 3,
502 count, "trace-variables");
503 ui_out_table_header (uiout, 15, ui_left, "name", "Name");
504 ui_out_table_header (uiout, 11, ui_left, "initial", "Initial");
505 ui_out_table_header (uiout, 11, ui_left, "current", "Current");
507 ui_out_table_body (uiout);
509 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
511 struct cleanup *back_to2;
515 back_to2 = make_cleanup_ui_out_tuple_begin_end (uiout, "variable");
517 name = concat ("$", tsv->name, (char *) NULL);
518 make_cleanup (xfree, name);
519 ui_out_field_string (uiout, "name", name);
520 ui_out_field_string (uiout, "initial", plongest (tsv->initial_value));
522 if (tsv->value_known)
523 c = plongest (tsv->value);
524 else if (ui_out_is_mi_like_p (uiout))
525 /* For MI, we prefer not to use magic string constants, but rather
526 omit the field completely. The difference between unknown and
527 undefined does not seem important enough to represent. */
529 else if (current_trace_status ()->running || traceframe_number >= 0)
530 /* The value is/was defined, but we don't have it. */
533 /* It is not meaningful to ask about the value. */
536 ui_out_field_string (uiout, "current", c);
537 ui_out_text (uiout, "\n");
539 do_cleanups (back_to2);
542 do_cleanups (back_to);
545 /* List all the trace state variables. */
548 tvariables_info (char *args, int from_tty)
550 tvariables_info_1 ();
553 /* Stash definitions of tsvs into the given file. */
556 save_trace_state_variables (struct ui_file *fp)
558 struct trace_state_variable *tsv;
561 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
563 fprintf_unfiltered (fp, "tvariable $%s", tsv->name);
564 if (tsv->initial_value)
565 fprintf_unfiltered (fp, " = %s", plongest (tsv->initial_value));
566 fprintf_unfiltered (fp, "\n");
570 /* ACTIONS functions: */
572 /* The three functions:
573 collect_pseudocommand,
574 while_stepping_pseudocommand, and
575 end_actions_pseudocommand
576 are placeholders for "commands" that are actually ONLY to be used
577 within a tracepoint action list. If the actual function is ever called,
578 it means that somebody issued the "command" at the top level,
579 which is always an error. */
582 end_actions_pseudocommand (char *args, int from_tty)
584 error (_("This command cannot be used at the top level."));
588 while_stepping_pseudocommand (char *args, int from_tty)
590 error (_("This command can only be used in a tracepoint actions list."));
594 collect_pseudocommand (char *args, int from_tty)
596 error (_("This command can only be used in a tracepoint actions list."));
600 teval_pseudocommand (char *args, int from_tty)
602 error (_("This command can only be used in a tracepoint actions list."));
605 /* Parse any collection options, such as /s for strings. */
608 decode_agent_options (const char *exp, int *trace_string)
610 struct value_print_options opts;
617 /* Call this to borrow the print elements default for collection
619 get_user_print_options (&opts);
624 if (target_supports_string_tracing ())
626 /* Allow an optional decimal number giving an explicit maximum
627 string length, defaulting it to the "print elements" value;
628 so "collect/s80 mystr" gets at most 80 bytes of string. */
629 *trace_string = opts.print_max;
631 if (*exp >= '0' && *exp <= '9')
632 *trace_string = atoi (exp);
633 while (*exp >= '0' && *exp <= '9')
637 error (_("Target does not support \"/s\" option for string tracing."));
640 error (_("Undefined collection format \"%c\"."), *exp);
642 exp = skip_spaces_const (exp);
647 /* Enter a list of actions for a tracepoint. */
649 trace_actions_command (char *args, int from_tty)
651 struct tracepoint *t;
652 struct command_line *l;
654 t = get_tracepoint_by_number (&args, NULL);
658 xstrprintf ("Enter actions for tracepoint %d, one per line.",
660 struct cleanup *cleanups = make_cleanup (xfree, tmpbuf);
662 l = read_command_lines (tmpbuf, from_tty, 1,
663 check_tracepoint_command, t);
664 do_cleanups (cleanups);
665 breakpoint_set_commands (&t->base, l);
667 /* else just return */
670 /* Report the results of checking the agent expression, as errors or
674 report_agent_reqs_errors (struct agent_expr *aexpr)
676 /* All of the "flaws" are serious bytecode generation issues that
677 should never occur. */
678 if (aexpr->flaw != agent_flaw_none)
679 internal_error (__FILE__, __LINE__, _("expression is malformed"));
681 /* If analysis shows a stack underflow, GDB must have done something
682 badly wrong in its bytecode generation. */
683 if (aexpr->min_height < 0)
684 internal_error (__FILE__, __LINE__,
685 _("expression has min height < 0"));
687 /* Issue this error if the stack is predicted to get too deep. The
688 limit is rather arbitrary; a better scheme might be for the
689 target to report how much stack it will have available. The
690 depth roughly corresponds to parenthesization, so a limit of 20
691 amounts to 20 levels of expression nesting, which is actually
692 a pretty big hairy expression. */
693 if (aexpr->max_height > 20)
694 error (_("Expression is too complicated."));
697 /* worker function */
699 validate_actionline (const char *line, struct breakpoint *b)
701 struct cmd_list_element *c;
702 struct expression *exp = NULL;
703 struct cleanup *old_chain = NULL;
706 struct bp_location *loc;
707 struct agent_expr *aexpr;
708 struct tracepoint *t = (struct tracepoint *) b;
710 /* If EOF is typed, *line is NULL. */
714 p = skip_spaces_const (line);
716 /* Symbol lookup etc. */
717 if (*p == '\0') /* empty line: just prompt for another line. */
720 if (*p == '#') /* comment line */
723 c = lookup_cmd (&p, cmdlist, "", -1, 1);
725 error (_("`%s' is not a tracepoint action, or is ambiguous."), p);
727 if (cmd_cfunc_eq (c, collect_pseudocommand))
729 int trace_string = 0;
732 p = decode_agent_options (p, &trace_string);
735 { /* Repeat over a comma-separated list. */
736 QUIT; /* Allow user to bail out with ^C. */
737 p = skip_spaces_const (p);
739 if (*p == '$') /* Look for special pseudo-symbols. */
741 if (0 == strncasecmp ("reg", p + 1, 3)
742 || 0 == strncasecmp ("arg", p + 1, 3)
743 || 0 == strncasecmp ("loc", p + 1, 3)
744 || 0 == strncasecmp ("_ret", p + 1, 4)
745 || 0 == strncasecmp ("_sdata", p + 1, 6))
750 /* else fall thru, treat p as an expression and parse it! */
753 for (loc = t->base.loc; loc; loc = loc->next)
756 exp = parse_exp_1 (&p, loc->address,
757 block_for_pc (loc->address), 1);
758 old_chain = make_cleanup (free_current_contents, &exp);
760 if (exp->elts[0].opcode == OP_VAR_VALUE)
762 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
764 error (_("constant `%s' (value %s) "
765 "will not be collected."),
766 SYMBOL_PRINT_NAME (exp->elts[2].symbol),
767 plongest (SYMBOL_VALUE (exp->elts[2].symbol)));
769 else if (SYMBOL_CLASS (exp->elts[2].symbol)
770 == LOC_OPTIMIZED_OUT)
772 error (_("`%s' is optimized away "
773 "and cannot be collected."),
774 SYMBOL_PRINT_NAME (exp->elts[2].symbol));
778 /* We have something to collect, make sure that the expr to
779 bytecode translator can handle it and that it's not too
781 aexpr = gen_trace_for_expr (loc->address, exp, trace_string);
782 make_cleanup_free_agent_expr (aexpr);
784 if (aexpr->len > MAX_AGENT_EXPR_LEN)
785 error (_("Expression is too complicated."));
789 report_agent_reqs_errors (aexpr);
791 do_cleanups (old_chain);
794 while (p && *p++ == ',');
797 else if (cmd_cfunc_eq (c, teval_pseudocommand))
800 { /* Repeat over a comma-separated list. */
801 QUIT; /* Allow user to bail out with ^C. */
802 p = skip_spaces_const (p);
805 for (loc = t->base.loc; loc; loc = loc->next)
809 /* Only expressions are allowed for this action. */
810 exp = parse_exp_1 (&p, loc->address,
811 block_for_pc (loc->address), 1);
812 old_chain = make_cleanup (free_current_contents, &exp);
814 /* We have something to evaluate, make sure that the expr to
815 bytecode translator can handle it and that it's not too
817 aexpr = gen_eval_for_expr (loc->address, exp);
818 make_cleanup_free_agent_expr (aexpr);
820 if (aexpr->len > MAX_AGENT_EXPR_LEN)
821 error (_("Expression is too complicated."));
824 report_agent_reqs_errors (aexpr);
826 do_cleanups (old_chain);
829 while (p && *p++ == ',');
832 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
836 p = skip_spaces_const (p);
837 t->step_count = strtol (p, &endp, 0);
838 if (endp == p || t->step_count == 0)
839 error (_("while-stepping step count `%s' is malformed."), line);
843 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
847 error (_("`%s' is not a supported tracepoint action."), line);
851 memrange_absolute = -1
854 /* MEMRANGE functions: */
856 static int memrange_cmp (const void *, const void *);
858 /* Compare memranges for qsort. */
860 memrange_cmp (const void *va, const void *vb)
862 const struct memrange *a = va, *b = vb;
864 if (a->type < b->type)
866 if (a->type > b->type)
868 if (a->type == memrange_absolute)
870 if ((bfd_vma) a->start < (bfd_vma) b->start)
872 if ((bfd_vma) a->start > (bfd_vma) b->start)
877 if (a->start < b->start)
879 if (a->start > b->start)
885 /* Sort the memrange list using qsort, and merge adjacent memranges. */
887 memrange_sortmerge (struct collection_list *memranges)
891 qsort (memranges->list, memranges->next_memrange,
892 sizeof (struct memrange), memrange_cmp);
893 if (memranges->next_memrange > 0)
895 for (a = 0, b = 1; b < memranges->next_memrange; b++)
897 /* If memrange b overlaps or is adjacent to memrange a,
899 if (memranges->list[a].type == memranges->list[b].type
900 && memranges->list[b].start <= memranges->list[a].end)
902 if (memranges->list[b].end > memranges->list[a].end)
903 memranges->list[a].end = memranges->list[b].end;
904 continue; /* next b, same a */
908 memcpy (&memranges->list[a], &memranges->list[b],
909 sizeof (struct memrange));
911 memranges->next_memrange = a + 1;
915 /* Add a register to a collection list. */
917 add_register (struct collection_list *collection, unsigned int regno)
920 printf_filtered ("collect register %d\n", regno);
921 if (regno >= (8 * sizeof (collection->regs_mask)))
922 error (_("Internal: register number %d too large for tracepoint"),
924 collection->regs_mask[regno / 8] |= 1 << (regno % 8);
927 /* Add a memrange to a collection list. */
929 add_memrange (struct collection_list *memranges,
930 int type, bfd_signed_vma base,
935 printf_filtered ("(%d,", type);
937 printf_filtered (",%ld)\n", len);
940 /* type: memrange_absolute == memory, other n == basereg */
941 memranges->list[memranges->next_memrange].type = type;
942 /* base: addr if memory, offset if reg relative. */
943 memranges->list[memranges->next_memrange].start = base;
944 /* len: we actually save end (base + len) for convenience */
945 memranges->list[memranges->next_memrange].end = base + len;
946 memranges->next_memrange++;
947 if (memranges->next_memrange >= memranges->listsize)
949 memranges->listsize *= 2;
950 memranges->list = xrealloc (memranges->list,
951 memranges->listsize);
954 if (type != memrange_absolute) /* Better collect the base register! */
955 add_register (memranges, type);
958 /* Add a symbol to a collection list. */
960 collect_symbol (struct collection_list *collect,
962 struct gdbarch *gdbarch,
963 long frame_regno, long frame_offset,
969 bfd_signed_vma offset;
970 int treat_as_expr = 0;
972 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
973 switch (SYMBOL_CLASS (sym))
976 printf_filtered ("%s: don't know symbol class %d\n",
977 SYMBOL_PRINT_NAME (sym),
981 printf_filtered ("constant %s (value %s) will not be collected.\n",
982 SYMBOL_PRINT_NAME (sym), plongest (SYMBOL_VALUE (sym)));
985 offset = SYMBOL_VALUE_ADDRESS (sym);
990 sprintf_vma (tmp, offset);
991 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
992 SYMBOL_PRINT_NAME (sym), len,
995 /* A struct may be a C++ class with static fields, go to general
996 expression handling. */
997 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
1000 add_memrange (collect, memrange_absolute, offset, len);
1003 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
1005 printf_filtered ("LOC_REG[parm] %s: ",
1006 SYMBOL_PRINT_NAME (sym));
1007 add_register (collect, reg);
1008 /* Check for doubles stored in two registers. */
1009 /* FIXME: how about larger types stored in 3 or more regs? */
1010 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
1011 len > register_size (gdbarch, reg))
1012 add_register (collect, reg + 1);
1015 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1016 printf_filtered (" (will not collect %s)\n",
1017 SYMBOL_PRINT_NAME (sym));
1021 offset = frame_offset + SYMBOL_VALUE (sym);
1024 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1025 SYMBOL_PRINT_NAME (sym), len);
1026 printf_vma (offset);
1027 printf_filtered (" from frame ptr reg %d\n", reg);
1029 add_memrange (collect, reg, offset, len);
1031 case LOC_REGPARM_ADDR:
1032 reg = SYMBOL_VALUE (sym);
1036 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1037 SYMBOL_PRINT_NAME (sym), len);
1038 printf_vma (offset);
1039 printf_filtered (" from reg %d\n", reg);
1041 add_memrange (collect, reg, offset, len);
1045 offset = frame_offset + SYMBOL_VALUE (sym);
1048 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1049 SYMBOL_PRINT_NAME (sym), len);
1050 printf_vma (offset);
1051 printf_filtered (" from frame ptr reg %d\n", reg);
1053 add_memrange (collect, reg, offset, len);
1056 case LOC_UNRESOLVED:
1060 case LOC_OPTIMIZED_OUT:
1061 printf_filtered ("%s has been optimized out of existence.\n",
1062 SYMBOL_PRINT_NAME (sym));
1070 /* Expressions are the most general case. */
1073 struct agent_expr *aexpr;
1074 struct cleanup *old_chain1 = NULL;
1076 aexpr = gen_trace_for_var (scope, gdbarch, sym, trace_string);
1078 /* It can happen that the symbol is recorded as a computed
1079 location, but it's been optimized away and doesn't actually
1080 have a location expression. */
1083 printf_filtered ("%s has been optimized out of existence.\n",
1084 SYMBOL_PRINT_NAME (sym));
1088 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1092 report_agent_reqs_errors (aexpr);
1094 discard_cleanups (old_chain1);
1095 add_aexpr (collect, aexpr);
1097 /* Take care of the registers. */
1098 if (aexpr->reg_mask_len > 0)
1102 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1104 QUIT; /* Allow user to bail out with ^C. */
1105 if (aexpr->reg_mask[ndx1] != 0)
1107 /* Assume chars have 8 bits. */
1108 for (ndx2 = 0; ndx2 < 8; ndx2++)
1109 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1110 /* It's used -- record it. */
1111 add_register (collect, ndx1 * 8 + ndx2);
1118 /* Data to be passed around in the calls to the locals and args
1121 struct add_local_symbols_data
1123 struct collection_list *collect;
1124 struct gdbarch *gdbarch;
1132 /* The callback for the locals and args iterators. */
1135 do_collect_symbol (const char *print_name,
1139 struct add_local_symbols_data *p = cb_data;
1141 collect_symbol (p->collect, sym, p->gdbarch, p->frame_regno,
1142 p->frame_offset, p->pc, p->trace_string);
1145 VEC_safe_push (char_ptr, p->collect->wholly_collected,
1146 xstrdup (print_name));
1149 /* Add all locals (or args) symbols to collection list. */
1151 add_local_symbols (struct collection_list *collect,
1152 struct gdbarch *gdbarch, CORE_ADDR pc,
1153 long frame_regno, long frame_offset, int type,
1156 const struct block *block;
1157 struct add_local_symbols_data cb_data;
1159 cb_data.collect = collect;
1160 cb_data.gdbarch = gdbarch;
1162 cb_data.frame_regno = frame_regno;
1163 cb_data.frame_offset = frame_offset;
1165 cb_data.trace_string = trace_string;
1169 block = block_for_pc (pc);
1172 warning (_("Can't collect locals; "
1173 "no symbol table info available.\n"));
1177 iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1178 if (cb_data.count == 0)
1179 warning (_("No locals found in scope."));
1183 pc = get_pc_function_start (pc);
1184 block = block_for_pc (pc);
1187 warning (_("Can't collect args; no symbol table info available."));
1191 iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1192 if (cb_data.count == 0)
1193 warning (_("No args found in scope."));
1198 add_static_trace_data (struct collection_list *collection)
1201 printf_filtered ("collect static trace data\n");
1202 collection->strace_data = 1;
1205 /* worker function */
1207 clear_collection_list (struct collection_list *list)
1211 list->next_memrange = 0;
1212 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1214 free_agent_expr (list->aexpr_list[ndx]);
1215 list->aexpr_list[ndx] = NULL;
1217 list->next_aexpr_elt = 0;
1218 memset (list->regs_mask, 0, sizeof (list->regs_mask));
1219 list->strace_data = 0;
1221 xfree (list->aexpr_list);
1224 VEC_free (char_ptr, list->wholly_collected);
1225 VEC_free (char_ptr, list->computed);
1228 /* A cleanup wrapper for function clear_collection_list. */
1231 do_clear_collection_list (void *list)
1233 struct collection_list *l = list;
1235 clear_collection_list (l);
1238 /* Initialize collection_list CLIST. */
1241 init_collection_list (struct collection_list *clist)
1243 memset (clist, 0, sizeof *clist);
1245 clist->listsize = 128;
1246 clist->list = xcalloc (clist->listsize,
1247 sizeof (struct memrange));
1249 clist->aexpr_listsize = 128;
1250 clist->aexpr_list = xcalloc (clist->aexpr_listsize,
1251 sizeof (struct agent_expr *));
1254 /* Reduce a collection list to string form (for gdb protocol). */
1256 stringify_collection_list (struct collection_list *list)
1258 char temp_buf[2048];
1262 char *(*str_list)[];
1266 count = 1 + 1 + list->next_memrange + list->next_aexpr_elt + 1;
1267 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1269 if (list->strace_data)
1272 printf_filtered ("\nCollecting static trace data\n");
1275 (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
1279 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1280 if (list->regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */
1282 if (list->regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
1285 printf_filtered ("\nCollecting registers (mask): 0x");
1290 QUIT; /* Allow user to bail out with ^C. */
1292 printf_filtered ("%02X", list->regs_mask[i]);
1293 sprintf (end, "%02X", list->regs_mask[i]);
1296 (*str_list)[ndx] = xstrdup (temp_buf);
1300 printf_filtered ("\n");
1301 if (list->next_memrange > 0 && info_verbose)
1302 printf_filtered ("Collecting memranges: \n");
1303 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1305 QUIT; /* Allow user to bail out with ^C. */
1306 sprintf_vma (tmp2, list->list[i].start);
1309 printf_filtered ("(%d, %s, %ld)\n",
1312 (long) (list->list[i].end - list->list[i].start));
1314 if (count + 27 > MAX_AGENT_EXPR_LEN)
1316 (*str_list)[ndx] = savestring (temp_buf, count);
1323 bfd_signed_vma length = list->list[i].end - list->list[i].start;
1325 /* The "%X" conversion specifier expects an unsigned argument,
1326 so passing -1 (memrange_absolute) to it directly gives you
1327 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1329 if (list->list[i].type == memrange_absolute)
1330 sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
1332 sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
1335 count += strlen (end);
1336 end = temp_buf + count;
1339 for (i = 0; i < list->next_aexpr_elt; i++)
1341 QUIT; /* Allow user to bail out with ^C. */
1342 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1344 (*str_list)[ndx] = savestring (temp_buf, count);
1349 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1350 end += 10; /* 'X' + 8 hex digits + ',' */
1353 end = mem2hex (list->aexpr_list[i]->buf,
1354 end, list->aexpr_list[i]->len);
1355 count += 2 * list->aexpr_list[i]->len;
1360 (*str_list)[ndx] = savestring (temp_buf, count);
1365 (*str_list)[ndx] = NULL;
1376 /* Add the printed expression EXP to *LIST. */
1379 append_exp (struct expression *exp, VEC(char_ptr) **list)
1381 struct ui_file *tmp_stream = mem_fileopen ();
1384 print_expression (exp, tmp_stream);
1386 text = ui_file_xstrdup (tmp_stream, NULL);
1388 VEC_safe_push (char_ptr, *list, text);
1389 ui_file_delete (tmp_stream);
1393 encode_actions_1 (struct command_line *action,
1394 struct bp_location *tloc,
1396 LONGEST frame_offset,
1397 struct collection_list *collect,
1398 struct collection_list *stepping_list)
1400 const char *action_exp;
1401 struct expression *exp = NULL;
1403 struct value *tempval;
1404 struct cmd_list_element *cmd;
1405 struct agent_expr *aexpr;
1407 for (; action; action = action->next)
1409 QUIT; /* Allow user to bail out with ^C. */
1410 action_exp = action->line;
1411 action_exp = skip_spaces_const (action_exp);
1413 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1415 error (_("Bad action list item: %s"), action_exp);
1417 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1419 int trace_string = 0;
1421 if (*action_exp == '/')
1422 action_exp = decode_agent_options (action_exp, &trace_string);
1425 { /* Repeat over a comma-separated list. */
1426 QUIT; /* Allow user to bail out with ^C. */
1427 action_exp = skip_spaces_const (action_exp);
1429 if (0 == strncasecmp ("$reg", action_exp, 4))
1431 for (i = 0; i < gdbarch_num_regs (tloc->gdbarch); i++)
1432 add_register (collect, i);
1433 action_exp = strchr (action_exp, ','); /* more? */
1435 else if (0 == strncasecmp ("$arg", action_exp, 4))
1437 add_local_symbols (collect,
1444 action_exp = strchr (action_exp, ','); /* more? */
1446 else if (0 == strncasecmp ("$loc", action_exp, 4))
1448 add_local_symbols (collect,
1455 action_exp = strchr (action_exp, ','); /* more? */
1457 else if (0 == strncasecmp ("$_ret", action_exp, 5))
1459 struct cleanup *old_chain1 = NULL;
1461 aexpr = gen_trace_for_return_address (tloc->address,
1465 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1468 report_agent_reqs_errors (aexpr);
1470 discard_cleanups (old_chain1);
1471 add_aexpr (collect, aexpr);
1473 /* take care of the registers */
1474 if (aexpr->reg_mask_len > 0)
1478 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1480 QUIT; /* allow user to bail out with ^C */
1481 if (aexpr->reg_mask[ndx1] != 0)
1483 /* assume chars have 8 bits */
1484 for (ndx2 = 0; ndx2 < 8; ndx2++)
1485 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1486 /* it's used -- record it */
1487 add_register (collect,
1493 action_exp = strchr (action_exp, ','); /* more? */
1495 else if (0 == strncasecmp ("$_sdata", action_exp, 7))
1497 add_static_trace_data (collect);
1498 action_exp = strchr (action_exp, ','); /* more? */
1503 struct cleanup *old_chain = NULL;
1504 struct cleanup *old_chain1 = NULL;
1506 exp = parse_exp_1 (&action_exp, tloc->address,
1507 block_for_pc (tloc->address), 1);
1508 old_chain = make_cleanup (free_current_contents, &exp);
1510 switch (exp->elts[0].opcode)
1514 const char *name = &exp->elts[2].string;
1516 i = user_reg_map_name_to_regnum (tloc->gdbarch,
1517 name, strlen (name));
1519 internal_error (__FILE__, __LINE__,
1520 _("Register $%s not available"),
1523 printf_filtered ("OP_REGISTER: ");
1524 add_register (collect, i);
1529 /* Safe because we know it's a simple expression. */
1530 tempval = evaluate_expression (exp);
1531 addr = value_address (tempval);
1532 /* Initialize the TYPE_LENGTH if it is a typedef. */
1533 check_typedef (exp->elts[1].type);
1534 add_memrange (collect, memrange_absolute, addr,
1535 TYPE_LENGTH (exp->elts[1].type));
1536 append_exp (exp, &collect->computed);
1541 struct symbol *sym = exp->elts[2].symbol;
1542 char_ptr name = (char_ptr) SYMBOL_NATURAL_NAME (sym);
1544 collect_symbol (collect,
1545 exp->elts[2].symbol,
1551 VEC_safe_push (char_ptr,
1552 collect->wholly_collected,
1557 default: /* Full-fledged expression. */
1558 aexpr = gen_trace_for_expr (tloc->address, exp,
1561 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1565 report_agent_reqs_errors (aexpr);
1567 discard_cleanups (old_chain1);
1568 add_aexpr (collect, aexpr);
1570 /* Take care of the registers. */
1571 if (aexpr->reg_mask_len > 0)
1576 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1578 QUIT; /* Allow user to bail out with ^C. */
1579 if (aexpr->reg_mask[ndx1] != 0)
1581 /* Assume chars have 8 bits. */
1582 for (ndx2 = 0; ndx2 < 8; ndx2++)
1583 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1584 /* It's used -- record it. */
1585 add_register (collect,
1591 append_exp (exp, &collect->computed);
1594 do_cleanups (old_chain);
1597 while (action_exp && *action_exp++ == ',');
1599 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1602 { /* Repeat over a comma-separated list. */
1603 QUIT; /* Allow user to bail out with ^C. */
1604 action_exp = skip_spaces_const (action_exp);
1607 struct cleanup *old_chain = NULL;
1608 struct cleanup *old_chain1 = NULL;
1610 exp = parse_exp_1 (&action_exp, tloc->address,
1611 block_for_pc (tloc->address), 1);
1612 old_chain = make_cleanup (free_current_contents, &exp);
1614 aexpr = gen_eval_for_expr (tloc->address, exp);
1615 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1618 report_agent_reqs_errors (aexpr);
1620 discard_cleanups (old_chain1);
1621 /* Even though we're not officially collecting, add
1622 to the collect list anyway. */
1623 add_aexpr (collect, aexpr);
1625 do_cleanups (old_chain);
1628 while (action_exp && *action_exp++ == ',');
1630 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1632 /* We check against nested while-stepping when setting
1633 breakpoint action, so no way to run into nested
1635 gdb_assert (stepping_list);
1637 encode_actions_1 (action->body_list[0], tloc, frame_reg,
1638 frame_offset, stepping_list, NULL);
1641 error (_("Invalid tracepoint command '%s'"), action->line);
1645 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1646 and STEPPING_LIST. Return a cleanup pointer to clean up both
1647 TRACEPOINT_LIST and STEPPING_LIST. */
1650 encode_actions_and_make_cleanup (struct bp_location *tloc,
1651 struct collection_list *tracepoint_list,
1652 struct collection_list *stepping_list)
1654 char *default_collect_line = NULL;
1655 struct command_line *actions;
1656 struct command_line *default_collect_action = NULL;
1658 LONGEST frame_offset;
1659 struct cleanup *back_to, *return_chain;
1661 return_chain = make_cleanup (null_cleanup, NULL);
1662 init_collection_list (tracepoint_list);
1663 init_collection_list (stepping_list);
1665 make_cleanup (do_clear_collection_list, tracepoint_list);
1666 make_cleanup (do_clear_collection_list, stepping_list);
1668 back_to = make_cleanup (null_cleanup, NULL);
1669 gdbarch_virtual_frame_pointer (tloc->gdbarch,
1670 tloc->address, &frame_reg, &frame_offset);
1672 actions = all_tracepoint_actions_and_cleanup (tloc->owner);
1674 encode_actions_1 (actions, tloc, frame_reg, frame_offset,
1675 tracepoint_list, stepping_list);
1677 memrange_sortmerge (tracepoint_list);
1678 memrange_sortmerge (stepping_list);
1680 do_cleanups (back_to);
1681 return return_chain;
1684 /* Render all actions into gdb protocol. */
1687 encode_actions_rsp (struct bp_location *tloc, char ***tdp_actions,
1688 char ***stepping_actions)
1690 struct collection_list tracepoint_list, stepping_list;
1691 struct cleanup *cleanup;
1693 *tdp_actions = NULL;
1694 *stepping_actions = NULL;
1696 cleanup = encode_actions_and_make_cleanup (tloc, &tracepoint_list,
1699 *tdp_actions = stringify_collection_list (&tracepoint_list);
1700 *stepping_actions = stringify_collection_list (&stepping_list);
1702 do_cleanups (cleanup);
1706 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1708 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1710 collect->aexpr_list =
1711 xrealloc (collect->aexpr_list,
1712 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1713 collect->aexpr_listsize *= 2;
1715 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1716 collect->next_aexpr_elt++;
1720 process_tracepoint_on_disconnect (void)
1722 VEC(breakpoint_p) *tp_vec = NULL;
1724 struct breakpoint *b;
1725 int has_pending_p = 0;
1727 /* Check whether we still have pending tracepoint. If we have, warn the
1728 user that pending tracepoint will no longer work. */
1729 tp_vec = all_tracepoints ();
1730 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1739 struct bp_location *loc1;
1741 for (loc1 = b->loc; loc1; loc1 = loc1->next)
1743 if (loc1->shlib_disabled)
1754 VEC_free (breakpoint_p, tp_vec);
1757 warning (_("Pending tracepoints will not be resolved while"
1758 " GDB is disconnected\n"));
1761 /* Reset local state of tracing. */
1764 trace_reset_local_state (void)
1766 set_traceframe_num (-1);
1767 set_tracepoint_num (-1);
1768 set_traceframe_context (NULL);
1769 clear_traceframe_info ();
1773 start_tracing (char *notes)
1775 VEC(breakpoint_p) *tp_vec = NULL;
1777 struct breakpoint *b;
1778 struct trace_state_variable *tsv;
1779 int any_enabled = 0, num_to_download = 0;
1782 tp_vec = all_tracepoints ();
1784 /* No point in tracing without any tracepoints... */
1785 if (VEC_length (breakpoint_p, tp_vec) == 0)
1787 VEC_free (breakpoint_p, tp_vec);
1788 error (_("No tracepoints defined, not starting trace"));
1791 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1793 struct tracepoint *t = (struct tracepoint *) b;
1794 struct bp_location *loc;
1796 if (b->enable_state == bp_enabled)
1799 if ((b->type == bp_fast_tracepoint
1800 ? may_insert_fast_tracepoints
1801 : may_insert_tracepoints))
1804 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1805 (b->type == bp_fast_tracepoint ? "fast " : ""), b->number);
1810 if (target_supports_enable_disable_tracepoint ())
1811 warning (_("No tracepoints enabled"));
1814 /* No point in tracing with only disabled tracepoints that
1815 cannot be re-enabled. */
1816 VEC_free (breakpoint_p, tp_vec);
1817 error (_("No tracepoints enabled, not starting trace"));
1821 if (num_to_download <= 0)
1823 VEC_free (breakpoint_p, tp_vec);
1824 error (_("No tracepoints that may be downloaded, not starting trace"));
1827 target_trace_init ();
1829 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1831 struct tracepoint *t = (struct tracepoint *) b;
1832 struct bp_location *loc;
1833 int bp_location_downloaded = 0;
1835 /* Clear `inserted' flag. */
1836 for (loc = b->loc; loc; loc = loc->next)
1839 if ((b->type == bp_fast_tracepoint
1840 ? !may_insert_fast_tracepoints
1841 : !may_insert_tracepoints))
1844 t->number_on_target = 0;
1846 for (loc = b->loc; loc; loc = loc->next)
1848 /* Since tracepoint locations are never duplicated, `inserted'
1849 flag should be zero. */
1850 gdb_assert (!loc->inserted);
1852 target_download_tracepoint (loc);
1855 bp_location_downloaded = 1;
1858 t->number_on_target = b->number;
1860 for (loc = b->loc; loc; loc = loc->next)
1861 if (loc->probe.probe != NULL)
1862 loc->probe.probe->pops->set_semaphore (loc->probe.probe,
1866 if (bp_location_downloaded)
1867 observer_notify_breakpoint_modified (b);
1869 VEC_free (breakpoint_p, tp_vec);
1871 /* Send down all the trace state variables too. */
1872 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1874 target_download_trace_state_variable (tsv);
1877 /* Tell target to treat text-like sections as transparent. */
1878 target_trace_set_readonly_regions ();
1879 /* Set some mode flags. */
1880 target_set_disconnected_tracing (disconnected_tracing);
1881 target_set_circular_trace_buffer (circular_trace_buffer);
1882 target_set_trace_buffer_size (trace_buffer_size);
1885 notes = trace_notes;
1886 ret = target_set_trace_notes (trace_user, notes, NULL);
1888 if (!ret && (trace_user || notes))
1889 warning (_("Target does not support trace user/notes, info ignored"));
1891 /* Now insert traps and begin collecting data. */
1892 target_trace_start ();
1894 /* Reset our local state. */
1895 trace_reset_local_state ();
1896 current_trace_status()->running = 1;
1899 /* The tstart command requests the target to start a new trace run.
1900 The command passes any arguments it has to the target verbatim, as
1901 an optional "trace note". This is useful as for instance a warning
1902 to other users if the trace runs disconnected, and you don't want
1903 anybody else messing with the target. */
1906 trace_start_command (char *args, int from_tty)
1908 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1910 if (current_trace_status ()->running)
1913 && !query (_("A trace is running already. Start a new run? ")))
1914 error (_("New trace run not started."));
1917 start_tracing (args);
1920 /* The tstop command stops the tracing run. The command passes any
1921 supplied arguments to the target verbatim as a "stop note"; if the
1922 target supports trace notes, then it will be reported back as part
1923 of the trace run's status. */
1926 trace_stop_command (char *args, int from_tty)
1928 if (!current_trace_status ()->running)
1929 error (_("Trace is not running."));
1931 stop_tracing (args);
1935 stop_tracing (char *note)
1938 VEC(breakpoint_p) *tp_vec = NULL;
1940 struct breakpoint *t;
1942 target_trace_stop ();
1944 tp_vec = all_tracepoints ();
1945 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1947 struct bp_location *loc;
1949 if ((t->type == bp_fast_tracepoint
1950 ? !may_insert_fast_tracepoints
1951 : !may_insert_tracepoints))
1954 for (loc = t->loc; loc; loc = loc->next)
1956 /* GDB can be totally absent in some disconnected trace scenarios,
1957 but we don't really care if this semaphore goes out of sync.
1958 That's why we are decrementing it here, but not taking care
1960 if (loc->probe.probe != NULL)
1961 loc->probe.probe->pops->clear_semaphore (loc->probe.probe,
1967 VEC_free (breakpoint_p, tp_vec);
1970 note = trace_stop_notes;
1971 ret = target_set_trace_notes (NULL, NULL, note);
1974 warning (_("Target does not support trace notes, note ignored"));
1976 /* Should change in response to reply? */
1977 current_trace_status ()->running = 0;
1980 /* tstatus command */
1982 trace_status_command (char *args, int from_tty)
1984 struct trace_status *ts = current_trace_status ();
1986 VEC(breakpoint_p) *tp_vec = NULL;
1987 struct breakpoint *t;
1989 status = target_get_trace_status (ts);
1993 if (ts->filename != NULL)
1994 printf_filtered (_("Using a trace file.\n"));
1997 printf_filtered (_("Trace can not be run on this target.\n"));
2002 if (!ts->running_known)
2004 printf_filtered (_("Run/stop status is unknown.\n"));
2006 else if (ts->running)
2008 printf_filtered (_("Trace is running on the target.\n"));
2012 switch (ts->stop_reason)
2014 case trace_never_run:
2015 printf_filtered (_("No trace has been run on the target.\n"));
2019 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
2022 printf_filtered (_("Trace stopped by a tstop command.\n"));
2024 case trace_buffer_full:
2025 printf_filtered (_("Trace stopped because the buffer was full.\n"));
2027 case trace_disconnected:
2028 printf_filtered (_("Trace stopped because of disconnection.\n"));
2030 case tracepoint_passcount:
2031 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
2032 ts->stopping_tracepoint);
2034 case tracepoint_error:
2035 if (ts->stopping_tracepoint)
2036 printf_filtered (_("Trace stopped by an "
2037 "error (%s, tracepoint %d).\n"),
2038 ts->stop_desc, ts->stopping_tracepoint);
2040 printf_filtered (_("Trace stopped by an error (%s).\n"),
2043 case trace_stop_reason_unknown:
2044 printf_filtered (_("Trace stopped for an unknown reason.\n"));
2047 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
2053 if (ts->traceframes_created >= 0
2054 && ts->traceframe_count != ts->traceframes_created)
2056 printf_filtered (_("Buffer contains %d trace "
2057 "frames (of %d created total).\n"),
2058 ts->traceframe_count, ts->traceframes_created);
2060 else if (ts->traceframe_count >= 0)
2062 printf_filtered (_("Collected %d trace frames.\n"),
2063 ts->traceframe_count);
2066 if (ts->buffer_free >= 0)
2068 if (ts->buffer_size >= 0)
2070 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2071 ts->buffer_free, ts->buffer_size);
2072 if (ts->buffer_size > 0)
2073 printf_filtered (_(" (%d%% full)"),
2074 ((int) ((((long long) (ts->buffer_size
2075 - ts->buffer_free)) * 100)
2076 / ts->buffer_size)));
2077 printf_filtered (_(".\n"));
2080 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2084 if (ts->disconnected_tracing)
2085 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2087 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2089 if (ts->circular_buffer)
2090 printf_filtered (_("Trace buffer is circular.\n"));
2092 if (ts->user_name && strlen (ts->user_name) > 0)
2093 printf_filtered (_("Trace user is %s.\n"), ts->user_name);
2095 if (ts->notes && strlen (ts->notes) > 0)
2096 printf_filtered (_("Trace notes: %s.\n"), ts->notes);
2098 /* Now report on what we're doing with tfind. */
2099 if (traceframe_number >= 0)
2100 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2101 traceframe_number, tracepoint_number);
2103 printf_filtered (_("Not looking at any trace frame.\n"));
2105 /* Report start/stop times if supplied. */
2110 LONGEST run_time = ts->stop_time - ts->start_time;
2112 /* Reporting a run time is more readable than two long numbers. */
2113 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2114 (long int) (ts->start_time / 1000000),
2115 (long int) (ts->start_time % 1000000),
2116 (long int) (run_time / 1000000),
2117 (long int) (run_time % 1000000));
2120 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2121 (long int) (ts->start_time / 1000000),
2122 (long int) (ts->start_time % 1000000));
2124 else if (ts->stop_time)
2125 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2126 (long int) (ts->stop_time / 1000000),
2127 (long int) (ts->stop_time % 1000000));
2129 /* Now report any per-tracepoint status available. */
2130 tp_vec = all_tracepoints ();
2132 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
2133 target_get_tracepoint_status (t, NULL);
2135 VEC_free (breakpoint_p, tp_vec);
2138 /* Report the trace status to uiout, in a way suitable for MI, and not
2139 suitable for CLI. If ON_STOP is true, suppress a few fields that
2140 are not meaningful in the -trace-stop response.
2142 The implementation is essentially parallel to trace_status_command, but
2143 merging them will result in unreadable code. */
2145 trace_status_mi (int on_stop)
2147 struct ui_out *uiout = current_uiout;
2148 struct trace_status *ts = current_trace_status ();
2151 status = target_get_trace_status (ts);
2153 if (status == -1 && ts->filename == NULL)
2155 ui_out_field_string (uiout, "supported", "0");
2159 if (ts->filename != NULL)
2160 ui_out_field_string (uiout, "supported", "file");
2162 ui_out_field_string (uiout, "supported", "1");
2164 if (ts->filename != NULL)
2165 ui_out_field_string (uiout, "trace-file", ts->filename);
2167 gdb_assert (ts->running_known);
2171 ui_out_field_string (uiout, "running", "1");
2173 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2174 Given that the frontend gets the status either on -trace-stop, or from
2175 -trace-status after re-connection, it does not seem like this
2176 information is necessary for anything. It is not necessary for either
2177 figuring the vital state of the target nor for navigation of trace
2178 frames. If the frontend wants to show the current state is some
2179 configure dialog, it can request the value when such dialog is
2180 invoked by the user. */
2184 char *stop_reason = NULL;
2185 int stopping_tracepoint = -1;
2188 ui_out_field_string (uiout, "running", "0");
2190 if (ts->stop_reason != trace_stop_reason_unknown)
2192 switch (ts->stop_reason)
2195 stop_reason = "request";
2197 case trace_buffer_full:
2198 stop_reason = "overflow";
2200 case trace_disconnected:
2201 stop_reason = "disconnection";
2203 case tracepoint_passcount:
2204 stop_reason = "passcount";
2205 stopping_tracepoint = ts->stopping_tracepoint;
2207 case tracepoint_error:
2208 stop_reason = "error";
2209 stopping_tracepoint = ts->stopping_tracepoint;
2215 ui_out_field_string (uiout, "stop-reason", stop_reason);
2216 if (stopping_tracepoint != -1)
2217 ui_out_field_int (uiout, "stopping-tracepoint",
2218 stopping_tracepoint);
2219 if (ts->stop_reason == tracepoint_error)
2220 ui_out_field_string (uiout, "error-description",
2226 if (ts->traceframe_count != -1)
2227 ui_out_field_int (uiout, "frames", ts->traceframe_count);
2228 if (ts->traceframes_created != -1)
2229 ui_out_field_int (uiout, "frames-created", ts->traceframes_created);
2230 if (ts->buffer_size != -1)
2231 ui_out_field_int (uiout, "buffer-size", ts->buffer_size);
2232 if (ts->buffer_free != -1)
2233 ui_out_field_int (uiout, "buffer-free", ts->buffer_free);
2235 ui_out_field_int (uiout, "disconnected", ts->disconnected_tracing);
2236 ui_out_field_int (uiout, "circular", ts->circular_buffer);
2238 ui_out_field_string (uiout, "user-name", ts->user_name);
2239 ui_out_field_string (uiout, "notes", ts->notes);
2244 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2245 (long int) (ts->start_time / 1000000),
2246 (long int) (ts->start_time % 1000000));
2247 ui_out_field_string (uiout, "start-time", buf);
2248 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2249 (long int) (ts->stop_time / 1000000),
2250 (long int) (ts->stop_time % 1000000));
2251 ui_out_field_string (uiout, "stop-time", buf);
2255 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2256 user if she really wants to detach. */
2259 query_if_trace_running (int from_tty)
2264 /* It can happen that the target that was tracing went away on its
2265 own, and we didn't notice. Get a status update, and if the
2266 current target doesn't even do tracing, then assume it's not
2268 if (target_get_trace_status (current_trace_status ()) < 0)
2269 current_trace_status ()->running = 0;
2271 /* If running interactively, give the user the option to cancel and
2272 then decide what to do differently with the run. Scripts are
2273 just going to disconnect and let the target deal with it,
2274 according to how it's been instructed previously via
2275 disconnected-tracing. */
2276 if (current_trace_status ()->running)
2278 process_tracepoint_on_disconnect ();
2280 if (current_trace_status ()->disconnected_tracing)
2282 if (!query (_("Trace is running and will "
2283 "continue after detach; detach anyway? ")))
2284 error (_("Not confirmed."));
2288 if (!query (_("Trace is running but will "
2289 "stop on detach; detach anyway? ")))
2290 error (_("Not confirmed."));
2295 /* This function handles the details of what to do about an ongoing
2296 tracing run if the user has asked to detach or otherwise disconnect
2300 disconnect_tracing (void)
2302 /* Also we want to be out of tfind mode, otherwise things can get
2303 confusing upon reconnection. Just use these calls instead of
2304 full tfind_1 behavior because we're in the middle of detaching,
2305 and there's no point to updating current stack frame etc. */
2306 trace_reset_local_state ();
2309 /* Worker function for the various flavors of the tfind command. */
2311 tfind_1 (enum trace_find_type type, int num,
2312 CORE_ADDR addr1, CORE_ADDR addr2,
2315 int target_frameno = -1, target_tracept = -1;
2316 struct frame_id old_frame_id = null_frame_id;
2317 struct tracepoint *tp;
2318 struct ui_out *uiout = current_uiout;
2320 /* Only try to get the current stack frame if we have a chance of
2321 succeeding. In particular, if we're trying to get a first trace
2322 frame while all threads are running, it's not going to succeed,
2323 so leave it with a default value and let the frame comparison
2324 below (correctly) decide to print out the source location of the
2326 if (!(type == tfind_number && num == -1)
2327 && (has_stack_frames () || traceframe_number >= 0))
2328 old_frame_id = get_frame_id (get_current_frame ());
2330 target_frameno = target_trace_find (type, num, addr1, addr2,
2333 if (type == tfind_number
2335 && target_frameno == -1)
2337 /* We told the target to get out of tfind mode, and it did. */
2339 else if (target_frameno == -1)
2341 /* A request for a non-existent trace frame has failed.
2342 Our response will be different, depending on FROM_TTY:
2344 If FROM_TTY is true, meaning that this command was
2345 typed interactively by the user, then give an error
2346 and DO NOT change the state of traceframe_number etc.
2348 However if FROM_TTY is false, meaning that we're either
2349 in a script, a loop, or a user-defined command, then
2350 DON'T give an error, but DO change the state of
2351 traceframe_number etc. to invalid.
2353 The rationalle is that if you typed the command, you
2354 might just have committed a typo or something, and you'd
2355 like to NOT lose your current debugging state. However
2356 if you're in a user-defined command or especially in a
2357 loop, then you need a way to detect that the command
2358 failed WITHOUT aborting. This allows you to write
2359 scripts that search thru the trace buffer until the end,
2360 and then continue on to do something else. */
2363 error (_("Target failed to find requested trace frame."));
2367 printf_filtered ("End of trace buffer.\n");
2368 #if 0 /* dubious now? */
2369 /* The following will not recurse, since it's
2371 trace_find_command ("-1", from_tty);
2376 tp = get_tracepoint_by_number_on_target (target_tracept);
2378 reinit_frame_cache ();
2379 target_dcache_invalidate ();
2381 set_tracepoint_num (tp ? tp->base.number : target_tracept);
2383 if (target_frameno != get_traceframe_number ())
2384 observer_notify_traceframe_changed (target_frameno, tracepoint_number);
2386 set_current_traceframe (target_frameno);
2388 if (target_frameno == -1)
2389 set_traceframe_context (NULL);
2391 set_traceframe_context (get_current_frame ());
2393 if (traceframe_number >= 0)
2395 /* Use different branches for MI and CLI to make CLI messages
2397 if (ui_out_is_mi_like_p (uiout))
2399 ui_out_field_string (uiout, "found", "1");
2400 ui_out_field_int (uiout, "tracepoint", tracepoint_number);
2401 ui_out_field_int (uiout, "traceframe", traceframe_number);
2405 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2406 traceframe_number, tracepoint_number);
2411 if (ui_out_is_mi_like_p (uiout))
2412 ui_out_field_string (uiout, "found", "0");
2413 else if (type == tfind_number && num == -1)
2414 printf_unfiltered (_("No longer looking at any trace frame\n"));
2415 else /* This case may never occur, check. */
2416 printf_unfiltered (_("No trace frame found\n"));
2419 /* If we're in nonstop mode and getting out of looking at trace
2420 frames, there won't be any current frame to go back to and
2423 && (has_stack_frames () || traceframe_number >= 0))
2425 enum print_what print_what;
2427 /* NOTE: in imitation of the step command, try to determine
2428 whether we have made a transition from one function to
2429 another. If so, we'll print the "stack frame" (ie. the new
2430 function and it's arguments) -- otherwise we'll just show the
2433 if (frame_id_eq (old_frame_id,
2434 get_frame_id (get_current_frame ())))
2435 print_what = SRC_LINE;
2437 print_what = SRC_AND_LOC;
2439 print_stack_frame (get_selected_frame (NULL), 1, print_what, 1);
2444 /* Error on looking at traceframes while trace is running. */
2447 check_trace_running (struct trace_status *status)
2449 if (status->running && status->filename == NULL)
2450 error (_("May not look at trace frames while trace is running."));
2453 /* trace_find_command takes a trace frame number n,
2454 sends "QTFrame:<n>" to the target,
2455 and accepts a reply that may contain several optional pieces
2456 of information: a frame number, a tracepoint number, and an
2457 indication of whether this is a trap frame or a stepping frame.
2459 The minimal response is just "OK" (which indicates that the
2460 target does not give us a frame number or a tracepoint number).
2461 Instead of that, the target may send us a string containing
2463 F<hexnum> (gives the selected frame number)
2464 T<hexnum> (gives the selected tracepoint number)
2469 trace_find_command (char *args, int from_tty)
2470 { /* This should only be called with a numeric argument. */
2473 check_trace_running (current_trace_status ());
2475 if (args == 0 || *args == 0)
2476 { /* TFIND with no args means find NEXT trace frame. */
2477 if (traceframe_number == -1)
2478 frameno = 0; /* "next" is first one. */
2480 frameno = traceframe_number + 1;
2482 else if (0 == strcmp (args, "-"))
2484 if (traceframe_number == -1)
2485 error (_("not debugging trace buffer"));
2486 else if (from_tty && traceframe_number == 0)
2487 error (_("already at start of trace buffer"));
2489 frameno = traceframe_number - 1;
2491 /* A hack to work around eval's need for fp to have been collected. */
2492 else if (0 == strcmp (args, "-1"))
2495 frameno = parse_and_eval_long (args);
2498 error (_("invalid input (%d is less than zero)"), frameno);
2500 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2505 trace_find_end_command (char *args, int from_tty)
2507 trace_find_command ("-1", from_tty);
2512 trace_find_start_command (char *args, int from_tty)
2514 trace_find_command ("0", from_tty);
2517 /* tfind pc command */
2519 trace_find_pc_command (char *args, int from_tty)
2523 check_trace_running (current_trace_status ());
2525 if (args == 0 || *args == 0)
2526 pc = regcache_read_pc (get_current_regcache ());
2528 pc = parse_and_eval_address (args);
2530 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2533 /* tfind tracepoint command */
2535 trace_find_tracepoint_command (char *args, int from_tty)
2538 struct tracepoint *tp;
2540 check_trace_running (current_trace_status ());
2542 if (args == 0 || *args == 0)
2544 if (tracepoint_number == -1)
2545 error (_("No current tracepoint -- please supply an argument."));
2547 tdp = tracepoint_number; /* Default is current TDP. */
2550 tdp = parse_and_eval_long (args);
2552 /* If we have the tracepoint on hand, use the number that the
2553 target knows about (which may be different if we disconnected
2554 and reconnected). */
2555 tp = get_tracepoint (tdp);
2557 tdp = tp->number_on_target;
2559 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2562 /* TFIND LINE command:
2564 This command will take a sourceline for argument, just like BREAK
2565 or TRACE (ie. anything that "decode_line_1" can handle).
2567 With no argument, this command will find the next trace frame
2568 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2571 trace_find_line_command (char *args, int from_tty)
2573 static CORE_ADDR start_pc, end_pc;
2574 struct symtabs_and_lines sals;
2575 struct symtab_and_line sal;
2576 struct cleanup *old_chain;
2578 check_trace_running (current_trace_status ());
2580 if (args == 0 || *args == 0)
2582 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2584 sals.sals = (struct symtab_and_line *)
2585 xmalloc (sizeof (struct symtab_and_line));
2590 sals = decode_line_with_current_source (args, DECODE_LINE_FUNFIRSTLINE);
2594 old_chain = make_cleanup (xfree, sals.sals);
2595 if (sal.symtab == 0)
2596 error (_("No line number information available."));
2598 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2600 if (start_pc == end_pc)
2602 printf_filtered ("Line %d of \"%s\"",
2604 symtab_to_filename_for_display (sal.symtab));
2606 printf_filtered (" is at address ");
2607 print_address (get_current_arch (), start_pc, gdb_stdout);
2609 printf_filtered (" but contains no code.\n");
2610 sal = find_pc_line (start_pc, 0);
2612 && find_line_pc_range (sal, &start_pc, &end_pc)
2613 && start_pc != end_pc)
2614 printf_filtered ("Attempting to find line %d instead.\n",
2617 error (_("Cannot find a good line."));
2621 /* Is there any case in which we get here, and have an address
2622 which the user would want to see? If we have debugging
2623 symbols and no line numbers? */
2624 error (_("Line number %d is out of range for \"%s\"."),
2625 sal.line, symtab_to_filename_for_display (sal.symtab));
2627 /* Find within range of stated line. */
2629 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2631 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2632 do_cleanups (old_chain);
2635 /* tfind range command */
2637 trace_find_range_command (char *args, int from_tty)
2639 static CORE_ADDR start, stop;
2642 check_trace_running (current_trace_status ());
2644 if (args == 0 || *args == 0)
2645 { /* XXX FIXME: what should default behavior be? */
2646 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2650 if (0 != (tmp = strchr (args, ',')))
2652 *tmp++ = '\0'; /* Terminate start address. */
2653 tmp = skip_spaces (tmp);
2654 start = parse_and_eval_address (args);
2655 stop = parse_and_eval_address (tmp);
2658 { /* No explicit end address? */
2659 start = parse_and_eval_address (args);
2660 stop = start + 1; /* ??? */
2663 tfind_1 (tfind_range, 0, start, stop, from_tty);
2666 /* tfind outside command */
2668 trace_find_outside_command (char *args, int from_tty)
2670 CORE_ADDR start, stop;
2673 if (current_trace_status ()->running
2674 && current_trace_status ()->filename == NULL)
2675 error (_("May not look at trace frames while trace is running."));
2677 if (args == 0 || *args == 0)
2678 { /* XXX FIXME: what should default behavior be? */
2679 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2683 if (0 != (tmp = strchr (args, ',')))
2685 *tmp++ = '\0'; /* Terminate start address. */
2686 tmp = skip_spaces (tmp);
2687 start = parse_and_eval_address (args);
2688 stop = parse_and_eval_address (tmp);
2691 { /* No explicit end address? */
2692 start = parse_and_eval_address (args);
2693 stop = start + 1; /* ??? */
2696 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2699 /* info scope command: list the locals for a scope. */
2701 scope_info (char *args, int from_tty)
2703 struct symtabs_and_lines sals;
2705 struct bound_minimal_symbol msym;
2706 const struct block *block;
2707 const char *symname;
2708 char *save_args = args;
2709 struct block_iterator iter;
2711 struct gdbarch *gdbarch;
2714 if (args == 0 || *args == 0)
2715 error (_("requires an argument (function, "
2716 "line or *addr) to define a scope"));
2718 sals = decode_line_1 (&args, DECODE_LINE_FUNFIRSTLINE, NULL, 0);
2719 if (sals.nelts == 0)
2720 return; /* Presumably decode_line_1 has already warned. */
2722 /* Resolve line numbers to PC. */
2723 resolve_sal_pc (&sals.sals[0]);
2724 block = block_for_pc (sals.sals[0].pc);
2728 QUIT; /* Allow user to bail out with ^C. */
2729 ALL_BLOCK_SYMBOLS (block, iter, sym)
2731 QUIT; /* Allow user to bail out with ^C. */
2733 printf_filtered ("Scope for %s:\n", save_args);
2736 symname = SYMBOL_PRINT_NAME (sym);
2737 if (symname == NULL || *symname == '\0')
2738 continue; /* Probably botched, certainly useless. */
2740 gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
2742 printf_filtered ("Symbol %s is ", symname);
2744 if (SYMBOL_COMPUTED_OPS (sym) != NULL)
2745 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2746 BLOCK_START (block),
2750 switch (SYMBOL_CLASS (sym))
2753 case LOC_UNDEF: /* Messed up symbol? */
2754 printf_filtered ("a bogus symbol, class %d.\n",
2755 SYMBOL_CLASS (sym));
2756 count--; /* Don't count this one. */
2759 printf_filtered ("a constant with value %s (%s)",
2760 plongest (SYMBOL_VALUE (sym)),
2761 hex_string (SYMBOL_VALUE (sym)));
2763 case LOC_CONST_BYTES:
2764 printf_filtered ("constant bytes: ");
2765 if (SYMBOL_TYPE (sym))
2766 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2767 fprintf_filtered (gdb_stdout, " %02x",
2768 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2771 printf_filtered ("in static storage at address ");
2772 printf_filtered ("%s", paddress (gdbarch,
2773 SYMBOL_VALUE_ADDRESS (sym)));
2776 /* GDBARCH is the architecture associated with the objfile
2777 the symbol is defined in; the target architecture may be
2778 different, and may provide additional registers. However,
2779 we do not know the target architecture at this point.
2780 We assume the objfile architecture will contain all the
2781 standard registers that occur in debug info in that
2783 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2786 if (SYMBOL_IS_ARGUMENT (sym))
2787 printf_filtered ("an argument in register $%s",
2788 gdbarch_register_name (gdbarch, regno));
2790 printf_filtered ("a local variable in register $%s",
2791 gdbarch_register_name (gdbarch, regno));
2794 printf_filtered ("an argument at stack/frame offset %s",
2795 plongest (SYMBOL_VALUE (sym)));
2798 printf_filtered ("a local variable at frame offset %s",
2799 plongest (SYMBOL_VALUE (sym)));
2802 printf_filtered ("a reference argument at offset %s",
2803 plongest (SYMBOL_VALUE (sym)));
2805 case LOC_REGPARM_ADDR:
2806 /* Note comment at LOC_REGISTER. */
2807 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2809 printf_filtered ("the address of an argument, in register $%s",
2810 gdbarch_register_name (gdbarch, regno));
2813 printf_filtered ("a typedef.\n");
2816 printf_filtered ("a label at address ");
2817 printf_filtered ("%s", paddress (gdbarch,
2818 SYMBOL_VALUE_ADDRESS (sym)));
2821 printf_filtered ("a function at address ");
2822 printf_filtered ("%s",
2823 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2825 case LOC_UNRESOLVED:
2826 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2828 if (msym.minsym == NULL)
2829 printf_filtered ("Unresolved Static");
2832 printf_filtered ("static storage at address ");
2833 printf_filtered ("%s",
2835 BMSYMBOL_VALUE_ADDRESS (msym)));
2838 case LOC_OPTIMIZED_OUT:
2839 printf_filtered ("optimized out.\n");
2842 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2845 if (SYMBOL_TYPE (sym))
2846 printf_filtered (", length %d.\n",
2847 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2849 if (BLOCK_FUNCTION (block))
2852 block = BLOCK_SUPERBLOCK (block);
2855 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2859 /* Helper for trace_dump_command. Dump the action list starting at
2860 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2861 actions of the body of a while-stepping action. STEPPING_FRAME is
2862 set if the current traceframe was determined to be a while-stepping
2866 trace_dump_actions (struct command_line *action,
2867 int stepping_actions, int stepping_frame,
2870 const char *action_exp, *next_comma;
2872 for (; action != NULL; action = action->next)
2874 struct cmd_list_element *cmd;
2876 QUIT; /* Allow user to bail out with ^C. */
2877 action_exp = action->line;
2878 action_exp = skip_spaces_const (action_exp);
2880 /* The collection actions to be done while stepping are
2881 bracketed by the commands "while-stepping" and "end". */
2883 if (*action_exp == '#') /* comment line */
2886 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2888 error (_("Bad action list item: %s"), action_exp);
2890 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2894 for (i = 0; i < action->body_count; ++i)
2895 trace_dump_actions (action->body_list[i],
2896 1, stepping_frame, from_tty);
2898 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2900 /* Display the collected data.
2901 For the trap frame, display only what was collected at
2902 the trap. Likewise for stepping frames, display only
2903 what was collected while stepping. This means that the
2904 two boolean variables, STEPPING_FRAME and
2905 STEPPING_ACTIONS should be equal. */
2906 if (stepping_frame == stepping_actions)
2909 struct cleanup *old_chain
2910 = make_cleanup (free_current_contents, &cmd);
2911 int trace_string = 0;
2913 if (*action_exp == '/')
2914 action_exp = decode_agent_options (action_exp, &trace_string);
2917 { /* Repeat over a comma-separated list. */
2918 QUIT; /* Allow user to bail out with ^C. */
2919 if (*action_exp == ',')
2921 action_exp = skip_spaces_const (action_exp);
2923 next_comma = strchr (action_exp, ',');
2925 if (0 == strncasecmp (action_exp, "$reg", 4))
2926 registers_info (NULL, from_tty);
2927 else if (0 == strncasecmp (action_exp, "$_ret", 5))
2929 else if (0 == strncasecmp (action_exp, "$loc", 4))
2930 locals_info (NULL, from_tty);
2931 else if (0 == strncasecmp (action_exp, "$arg", 4))
2932 args_info (NULL, from_tty);
2935 if (next_comma != NULL)
2937 size_t len = next_comma - action_exp;
2939 cmd = xrealloc (cmd, len + 1);
2940 memcpy (cmd, action_exp, len);
2945 size_t len = strlen (action_exp);
2947 cmd = xrealloc (cmd, len + 1);
2948 memcpy (cmd, action_exp, len + 1);
2951 printf_filtered ("%s = ", cmd);
2952 output_command_const (cmd, from_tty);
2953 printf_filtered ("\n");
2955 action_exp = next_comma;
2957 while (action_exp && *action_exp == ',');
2959 do_cleanups (old_chain);
2965 /* Return bp_location of the tracepoint associated with the current
2966 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2967 is a stepping traceframe. */
2969 struct bp_location *
2970 get_traceframe_location (int *stepping_frame_p)
2972 struct tracepoint *t;
2973 struct bp_location *tloc;
2974 struct regcache *regcache;
2976 if (tracepoint_number == -1)
2977 error (_("No current trace frame."));
2979 t = get_tracepoint (tracepoint_number);
2982 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2985 /* The current frame is a trap frame if the frame PC is equal to the
2986 tracepoint PC. If not, then the current frame was collected
2987 during single-stepping. */
2988 regcache = get_current_regcache ();
2990 /* If the traceframe's address matches any of the tracepoint's
2991 locations, assume it is a direct hit rather than a while-stepping
2992 frame. (FIXME this is not reliable, should record each frame's
2994 for (tloc = t->base.loc; tloc; tloc = tloc->next)
2995 if (tloc->address == regcache_read_pc (regcache))
2997 *stepping_frame_p = 0;
3001 /* If this is a stepping frame, we don't know which location
3002 triggered. The first is as good (or bad) a guess as any... */
3003 *stepping_frame_p = 1;
3007 /* Return all the actions, including default collect, of a tracepoint
3008 T. It constructs cleanups into the chain, and leaves the caller to
3009 handle them (call do_cleanups). */
3011 static struct command_line *
3012 all_tracepoint_actions_and_cleanup (struct breakpoint *t)
3014 struct command_line *actions;
3016 actions = breakpoint_commands (t);
3018 /* If there are default expressions to collect, make up a collect
3019 action and prepend to the action list to encode. Note that since
3020 validation is per-tracepoint (local var "xyz" might be valid for
3021 one tracepoint and not another, etc), we make up the action on
3022 the fly, and don't cache it. */
3023 if (*default_collect)
3025 struct command_line *default_collect_action;
3026 char *default_collect_line;
3028 default_collect_line = xstrprintf ("collect %s", default_collect);
3029 make_cleanup (xfree, default_collect_line);
3031 validate_actionline (default_collect_line, t);
3032 default_collect_action = xmalloc (sizeof (struct command_line));
3033 make_cleanup (xfree, default_collect_action);
3034 default_collect_action->next = actions;
3035 default_collect_action->line = default_collect_line;
3036 actions = default_collect_action;
3042 /* The tdump command. */
3045 trace_dump_command (char *args, int from_tty)
3047 int stepping_frame = 0;
3048 struct bp_location *loc;
3049 struct cleanup *old_chain;
3050 struct command_line *actions;
3052 /* This throws an error is not inspecting a trace frame. */
3053 loc = get_traceframe_location (&stepping_frame);
3055 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
3056 tracepoint_number, traceframe_number);
3058 old_chain = make_cleanup (null_cleanup, NULL);
3060 /* This command only makes sense for the current frame, not the
3062 make_cleanup_restore_current_thread ();
3063 select_frame (get_current_frame ());
3065 actions = all_tracepoint_actions_and_cleanup (loc->owner);
3067 trace_dump_actions (actions, 0, stepping_frame, from_tty);
3069 do_cleanups (old_chain);
3072 /* Encode a piece of a tracepoint's source-level definition in a form
3073 that is suitable for both protocol and saving in files. */
3074 /* This version does not do multiple encodes for long strings; it should
3075 return an offset to the next piece to encode. FIXME */
3078 encode_source_string (int tpnum, ULONGEST addr,
3079 char *srctype, char *src, char *buf, int buf_size)
3081 if (80 + strlen (srctype) > buf_size)
3082 error (_("Buffer too small for source encoding"));
3083 sprintf (buf, "%x:%s:%s:%x:%x:",
3084 tpnum, phex_nz (addr, sizeof (addr)),
3085 srctype, 0, (int) strlen (src));
3086 if (strlen (buf) + strlen (src) * 2 >= buf_size)
3087 error (_("Source string too long for buffer"));
3088 bin2hex ((gdb_byte *) src, buf + strlen (buf), strlen (src));
3092 /* Tell the target what to do with an ongoing tracing run if GDB
3093 disconnects for some reason. */
3096 set_disconnected_tracing (char *args, int from_tty,
3097 struct cmd_list_element *c)
3099 target_set_disconnected_tracing (disconnected_tracing);
3103 set_circular_trace_buffer (char *args, int from_tty,
3104 struct cmd_list_element *c)
3106 target_set_circular_trace_buffer (circular_trace_buffer);
3110 set_trace_buffer_size (char *args, int from_tty,
3111 struct cmd_list_element *c)
3113 target_set_trace_buffer_size (trace_buffer_size);
3117 set_trace_user (char *args, int from_tty,
3118 struct cmd_list_element *c)
3122 ret = target_set_trace_notes (trace_user, NULL, NULL);
3125 warning (_("Target does not support trace notes, user ignored"));
3129 set_trace_notes (char *args, int from_tty,
3130 struct cmd_list_element *c)
3134 ret = target_set_trace_notes (NULL, trace_notes, NULL);
3137 warning (_("Target does not support trace notes, note ignored"));
3141 set_trace_stop_notes (char *args, int from_tty,
3142 struct cmd_list_element *c)
3146 ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
3149 warning (_("Target does not support trace notes, stop note ignored"));
3152 /* Convert the memory pointed to by mem into hex, placing result in buf.
3153 * Return a pointer to the last char put in buf (null)
3154 * "stolen" from sparc-stub.c
3157 static const char hexchars[] = "0123456789abcdef";
3160 mem2hex (gdb_byte *mem, char *buf, int count)
3168 *buf++ = hexchars[ch >> 4];
3169 *buf++ = hexchars[ch & 0xf];
3178 get_traceframe_number (void)
3180 return traceframe_number;
3184 get_tracepoint_number (void)
3186 return tracepoint_number;
3189 /* Make the traceframe NUM be the current trace frame. Does nothing
3190 if NUM is already current. */
3193 set_current_traceframe (int num)
3197 if (traceframe_number == num)
3199 /* Nothing to do. */
3203 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
3206 warning (_("could not change traceframe"));
3208 set_traceframe_num (newnum);
3210 /* Changing the traceframe changes our view of registers and of the
3212 registers_changed ();
3214 clear_traceframe_info ();
3217 /* A cleanup used when switching away and back from tfind mode. */
3219 struct current_traceframe_cleanup
3221 /* The traceframe we were inspecting. */
3222 int traceframe_number;
3226 do_restore_current_traceframe_cleanup (void *arg)
3228 struct current_traceframe_cleanup *old = arg;
3230 set_current_traceframe (old->traceframe_number);
3234 restore_current_traceframe_cleanup_dtor (void *arg)
3236 struct current_traceframe_cleanup *old = arg;
3242 make_cleanup_restore_current_traceframe (void)
3244 struct current_traceframe_cleanup *old;
3246 old = xmalloc (sizeof (struct current_traceframe_cleanup));
3247 old->traceframe_number = traceframe_number;
3249 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
3250 restore_current_traceframe_cleanup_dtor);
3253 /* Given a number and address, return an uploaded tracepoint with that
3254 number, creating if necessary. */
3256 struct uploaded_tp *
3257 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
3259 struct uploaded_tp *utp;
3261 for (utp = *utpp; utp; utp = utp->next)
3262 if (utp->number == num && utp->addr == addr)
3264 utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
3265 memset (utp, 0, sizeof (struct uploaded_tp));
3268 utp->actions = NULL;
3269 utp->step_actions = NULL;
3270 utp->cmd_strings = NULL;
3277 free_uploaded_tps (struct uploaded_tp **utpp)
3279 struct uploaded_tp *next_one;
3283 next_one = (*utpp)->next;
3289 /* Given a number and address, return an uploaded tracepoint with that
3290 number, creating if necessary. */
3292 struct uploaded_tsv *
3293 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3295 struct uploaded_tsv *utsv;
3297 for (utsv = *utsvp; utsv; utsv = utsv->next)
3298 if (utsv->number == num)
3300 utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
3301 memset (utsv, 0, sizeof (struct uploaded_tsv));
3303 utsv->next = *utsvp;
3309 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3311 struct uploaded_tsv *next_one;
3315 next_one = (*utsvp)->next;
3321 /* FIXME this function is heuristic and will miss the cases where the
3322 conditional is semantically identical but differs in whitespace,
3323 such as "x == 0" vs "x==0". */
3326 cond_string_is_same (char *str1, char *str2)
3328 if (str1 == NULL || str2 == NULL)
3329 return (str1 == str2);
3331 return (strcmp (str1, str2) == 0);
3334 /* Look for an existing tracepoint that seems similar enough to the
3335 uploaded one. Enablement isn't compared, because the user can
3336 toggle that freely, and may have done so in anticipation of the
3337 next trace run. Return the location of matched tracepoint. */
3339 static struct bp_location *
3340 find_matching_tracepoint_location (struct uploaded_tp *utp)
3342 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
3344 struct breakpoint *b;
3345 struct bp_location *loc;
3347 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
3349 struct tracepoint *t = (struct tracepoint *) b;
3351 if (b->type == utp->type
3352 && t->step_count == utp->step
3353 && t->pass_count == utp->pass
3354 && cond_string_is_same (t->base.cond_string, utp->cond_string)
3355 /* FIXME also test actions. */
3358 /* Scan the locations for an address match. */
3359 for (loc = b->loc; loc; loc = loc->next)
3361 if (loc->address == utp->addr)
3369 /* Given a list of tracepoints uploaded from a target, attempt to
3370 match them up with existing tracepoints, and create new ones if not
3374 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3376 struct uploaded_tp *utp;
3377 /* A set of tracepoints which are modified. */
3378 VEC(breakpoint_p) *modified_tp = NULL;
3380 struct breakpoint *b;
3382 /* Look for GDB tracepoints that match up with our uploaded versions. */
3383 for (utp = *uploaded_tps; utp; utp = utp->next)
3385 struct bp_location *loc;
3386 struct tracepoint *t;
3388 loc = find_matching_tracepoint_location (utp);
3393 /* Mark this location as already inserted. */
3395 t = (struct tracepoint *) loc->owner;
3396 printf_filtered (_("Assuming tracepoint %d is same "
3397 "as target's tracepoint %d at %s.\n"),
3398 loc->owner->number, utp->number,
3399 paddress (loc->gdbarch, utp->addr));
3401 /* The tracepoint LOC->owner was modified (the location LOC
3402 was marked as inserted in the target). Save it in
3403 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3404 observers will be notified later once for each tracepoint
3405 saved in MODIFIED_TP. */
3407 VEC_iterate (breakpoint_p, modified_tp, ix, b);
3409 if (b == loc->owner)
3415 VEC_safe_push (breakpoint_p, modified_tp, loc->owner);
3419 t = create_tracepoint_from_upload (utp);
3421 printf_filtered (_("Created tracepoint %d for "
3422 "target's tracepoint %d at %s.\n"),
3423 t->base.number, utp->number,
3424 paddress (get_current_arch (), utp->addr));
3426 printf_filtered (_("Failed to create tracepoint for target's "
3427 "tracepoint %d at %s, skipping it.\n"),
3429 paddress (get_current_arch (), utp->addr));
3431 /* Whether found or created, record the number used by the
3432 target, to help with mapping target tracepoints back to their
3433 counterparts here. */
3435 t->number_on_target = utp->number;
3438 /* Notify 'breakpoint-modified' observer that at least one of B's
3439 locations was changed. */
3440 for (ix = 0; VEC_iterate (breakpoint_p, modified_tp, ix, b); ix++)
3441 observer_notify_breakpoint_modified (b);
3443 VEC_free (breakpoint_p, modified_tp);
3444 free_uploaded_tps (uploaded_tps);
3447 /* Trace state variables don't have much to identify them beyond their
3448 name, so just use that to detect matches. */
3450 static struct trace_state_variable *
3451 find_matching_tsv (struct uploaded_tsv *utsv)
3456 return find_trace_state_variable (utsv->name);
3459 static struct trace_state_variable *
3460 create_tsv_from_upload (struct uploaded_tsv *utsv)
3462 const char *namebase;
3465 struct trace_state_variable *tsv;
3466 struct cleanup *old_chain;
3470 namebase = utsv->name;
3471 buf = xstrprintf ("%s", namebase);
3476 buf = xstrprintf ("%s_%d", namebase, try_num++);
3479 /* Fish for a name that is not in use. */
3480 /* (should check against all internal vars?) */
3481 while (find_trace_state_variable (buf))
3484 buf = xstrprintf ("%s_%d", namebase, try_num++);
3487 old_chain = make_cleanup (xfree, buf);
3489 /* We have an available name, create the variable. */
3490 tsv = create_trace_state_variable (buf);
3491 tsv->initial_value = utsv->initial_value;
3492 tsv->builtin = utsv->builtin;
3494 observer_notify_tsv_created (tsv);
3496 do_cleanups (old_chain);
3501 /* Given a list of uploaded trace state variables, try to match them
3502 up with existing variables, or create additional ones. */
3505 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
3508 struct uploaded_tsv *utsv;
3509 struct trace_state_variable *tsv;
3512 /* Most likely some numbers will have to be reassigned as part of
3513 the merge, so clear them all in anticipation. */
3514 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3517 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
3519 tsv = find_matching_tsv (utsv);
3523 printf_filtered (_("Assuming trace state variable $%s "
3524 "is same as target's variable %d.\n"),
3525 tsv->name, utsv->number);
3529 tsv = create_tsv_from_upload (utsv);
3531 printf_filtered (_("Created trace state variable "
3532 "$%s for target's variable %d.\n"),
3533 tsv->name, utsv->number);
3535 /* Give precedence to numberings that come from the target. */
3537 tsv->number = utsv->number;
3540 /* Renumber everything that didn't get a target-assigned number. */
3542 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3543 if (tsv->number > highest)
3544 highest = tsv->number;
3547 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3548 if (tsv->number == 0)
3549 tsv->number = highest++;
3551 free_uploaded_tsvs (uploaded_tsvs);
3554 /* Parse the part of trace status syntax that is shared between
3555 the remote protocol and the trace file reader. */
3558 parse_trace_status (char *line, struct trace_status *ts)
3560 char *p = line, *p1, *p2, *p3, *p_temp;
3564 ts->running_known = 1;
3565 ts->running = (*p++ == '1');
3566 ts->stop_reason = trace_stop_reason_unknown;
3567 xfree (ts->stop_desc);
3568 ts->stop_desc = NULL;
3569 ts->traceframe_count = -1;
3570 ts->traceframes_created = -1;
3571 ts->buffer_free = -1;
3572 ts->buffer_size = -1;
3573 ts->disconnected_tracing = 0;
3574 ts->circular_buffer = 0;
3575 xfree (ts->user_name);
3576 ts->user_name = NULL;
3579 ts->start_time = ts->stop_time = 0;
3583 p1 = strchr (p, ':');
3585 error (_("Malformed trace status, at %s\n\
3586 Status line: '%s'\n"), p, line);
3587 p3 = strchr (p, ';');
3589 p3 = p + strlen (p);
3590 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3592 p = unpack_varlen_hex (++p1, &val);
3593 ts->stop_reason = trace_buffer_full;
3595 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3597 p = unpack_varlen_hex (++p1, &val);
3598 ts->stop_reason = trace_never_run;
3600 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
3603 p = unpack_varlen_hex (++p1, &val);
3604 ts->stop_reason = tracepoint_passcount;
3605 ts->stopping_tracepoint = val;
3607 else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
3609 p2 = strchr (++p1, ':');
3617 ts->stop_desc = xmalloc (strlen (line));
3618 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
3619 ts->stop_desc[end] = '\0';
3622 ts->stop_desc = xstrdup ("");
3624 p = unpack_varlen_hex (++p2, &val);
3625 ts->stop_reason = tstop_command;
3627 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3629 p = unpack_varlen_hex (++p1, &val);
3630 ts->stop_reason = trace_disconnected;
3632 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3634 p2 = strchr (++p1, ':');
3637 ts->stop_desc = xmalloc ((p2 - p1) / 2 + 1);
3638 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
3639 ts->stop_desc[end] = '\0';
3642 ts->stop_desc = xstrdup ("");
3644 p = unpack_varlen_hex (++p2, &val);
3645 ts->stopping_tracepoint = val;
3646 ts->stop_reason = tracepoint_error;
3648 else if (strncmp (p, "tframes", p1 - p) == 0)
3650 p = unpack_varlen_hex (++p1, &val);
3651 ts->traceframe_count = val;
3653 else if (strncmp (p, "tcreated", p1 - p) == 0)
3655 p = unpack_varlen_hex (++p1, &val);
3656 ts->traceframes_created = val;
3658 else if (strncmp (p, "tfree", p1 - p) == 0)
3660 p = unpack_varlen_hex (++p1, &val);
3661 ts->buffer_free = val;
3663 else if (strncmp (p, "tsize", p1 - p) == 0)
3665 p = unpack_varlen_hex (++p1, &val);
3666 ts->buffer_size = val;
3668 else if (strncmp (p, "disconn", p1 - p) == 0)
3670 p = unpack_varlen_hex (++p1, &val);
3671 ts->disconnected_tracing = val;
3673 else if (strncmp (p, "circular", p1 - p) == 0)
3675 p = unpack_varlen_hex (++p1, &val);
3676 ts->circular_buffer = val;
3678 else if (strncmp (p, "starttime", p1 - p) == 0)
3680 p = unpack_varlen_hex (++p1, &val);
3681 ts->start_time = val;
3683 else if (strncmp (p, "stoptime", p1 - p) == 0)
3685 p = unpack_varlen_hex (++p1, &val);
3686 ts->stop_time = val;
3688 else if (strncmp (p, "username", p1 - p) == 0)
3691 ts->user_name = xmalloc (strlen (p) / 2);
3692 end = hex2bin (p1, (gdb_byte *) ts->user_name, (p3 - p1) / 2);
3693 ts->user_name[end] = '\0';
3696 else if (strncmp (p, "notes", p1 - p) == 0)
3699 ts->notes = xmalloc (strlen (p) / 2);
3700 end = hex2bin (p1, (gdb_byte *) ts->notes, (p3 - p1) / 2);
3701 ts->notes[end] = '\0';
3706 /* Silently skip unknown optional info. */
3707 p_temp = strchr (p1 + 1, ';');
3711 /* Must be at the end. */
3718 parse_tracepoint_status (char *p, struct breakpoint *bp,
3719 struct uploaded_tp *utp)
3722 struct tracepoint *tp = (struct tracepoint *) bp;
3724 p = unpack_varlen_hex (p, &uval);
3726 tp->base.hit_count += uval;
3728 utp->hit_count += uval;
3729 p = unpack_varlen_hex (p + 1, &uval);
3731 tp->traceframe_usage += uval;
3733 utp->traceframe_usage += uval;
3734 /* Ignore any extra, allowing for future extensions. */
3737 /* Given a line of text defining a part of a tracepoint, parse it into
3738 an "uploaded tracepoint". */
3741 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
3745 ULONGEST num, addr, step, pass, orig_size, xlen, start;
3748 char *cond, *srctype, *buf;
3749 struct uploaded_tp *utp = NULL;
3752 /* Both tracepoint and action definitions start with the same number
3753 and address sequence. */
3755 p = unpack_varlen_hex (p, &num);
3756 p++; /* skip a colon */
3757 p = unpack_varlen_hex (p, &addr);
3758 p++; /* skip a colon */
3761 enabled = (*p++ == 'E');
3762 p++; /* skip a colon */
3763 p = unpack_varlen_hex (p, &step);
3764 p++; /* skip a colon */
3765 p = unpack_varlen_hex (p, &pass);
3766 type = bp_tracepoint;
3768 /* Thumb through optional fields. */
3771 p++; /* skip a colon */
3774 type = bp_fast_tracepoint;
3776 p = unpack_varlen_hex (p, &orig_size);
3780 type = bp_static_tracepoint;
3786 p = unpack_varlen_hex (p, &xlen);
3787 p++; /* skip a comma */
3788 cond = (char *) xmalloc (2 * xlen + 1);
3789 strncpy (cond, p, 2 * xlen);
3790 cond[2 * xlen] = '\0';
3794 warning (_("Unrecognized char '%c' in tracepoint "
3795 "definition, skipping rest"), *p);
3797 utp = get_uploaded_tp (num, addr, utpp);
3799 utp->enabled = enabled;
3804 else if (piece == 'A')
3806 utp = get_uploaded_tp (num, addr, utpp);
3807 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
3809 else if (piece == 'S')
3811 utp = get_uploaded_tp (num, addr, utpp);
3812 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
3814 else if (piece == 'Z')
3816 /* Parse a chunk of source form definition. */
3817 utp = get_uploaded_tp (num, addr, utpp);
3819 p = strchr (p, ':');
3820 p++; /* skip a colon */
3821 p = unpack_varlen_hex (p, &start);
3822 p++; /* skip a colon */
3823 p = unpack_varlen_hex (p, &xlen);
3824 p++; /* skip a colon */
3826 buf = alloca (strlen (line));
3828 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3831 if (strncmp (srctype, "at:", strlen ("at:")) == 0)
3832 utp->at_string = xstrdup (buf);
3833 else if (strncmp (srctype, "cond:", strlen ("cond:")) == 0)
3834 utp->cond_string = xstrdup (buf);
3835 else if (strncmp (srctype, "cmd:", strlen ("cmd:")) == 0)
3836 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
3838 else if (piece == 'V')
3840 utp = get_uploaded_tp (num, addr, utpp);
3842 parse_tracepoint_status (p, NULL, utp);
3846 /* Don't error out, the target might be sending us optional
3847 info that we don't care about. */
3848 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
3852 /* Convert a textual description of a trace state variable into an
3856 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
3859 ULONGEST num, initval, builtin;
3861 struct uploaded_tsv *utsv = NULL;
3863 buf = alloca (strlen (line));
3866 p = unpack_varlen_hex (p, &num);
3867 p++; /* skip a colon */
3868 p = unpack_varlen_hex (p, &initval);
3869 p++; /* skip a colon */
3870 p = unpack_varlen_hex (p, &builtin);
3871 p++; /* skip a colon */
3872 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3875 utsv = get_uploaded_tsv (num, utsvp);
3876 utsv->initial_value = initval;
3877 utsv->builtin = builtin;
3878 utsv->name = xstrdup (buf);
3882 free_current_marker (void *arg)
3884 struct static_tracepoint_marker **marker_p = arg;
3886 if (*marker_p != NULL)
3888 release_static_tracepoint_marker (*marker_p);
3895 /* Given a line of text defining a static tracepoint marker, parse it
3896 into a "static tracepoint marker" object. Throws an error is
3897 parsing fails. If PP is non-null, it points to one past the end of
3898 the parsed marker definition. */
3901 parse_static_tracepoint_marker_definition (char *line, char **pp,
3902 struct static_tracepoint_marker *marker)
3909 p = unpack_varlen_hex (p, &addr);
3910 p++; /* skip a colon */
3912 marker->gdbarch = target_gdbarch ();
3913 marker->address = (CORE_ADDR) addr;
3915 endp = strchr (p, ':');
3917 error (_("bad marker definition: %s"), line);
3919 marker->str_id = xmalloc (endp - p + 1);
3920 end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
3921 marker->str_id[end] = '\0';
3924 p++; /* skip a colon */
3926 marker->extra = xmalloc (strlen (p) + 1);
3927 end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
3928 marker->extra[end] = '\0';
3934 /* Release a static tracepoint marker's contents. Note that the
3935 object itself isn't released here. There objects are usually on
3939 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
3941 xfree (marker->str_id);
3942 marker->str_id = NULL;
3945 /* Print MARKER to gdb_stdout. */
3948 print_one_static_tracepoint_marker (int count,
3949 struct static_tracepoint_marker *marker)
3951 struct command_line *l;
3954 char wrap_indent[80];
3955 char extra_field_indent[80];
3956 struct ui_out *uiout = current_uiout;
3957 struct cleanup *bkpt_chain;
3958 VEC(breakpoint_p) *tracepoints;
3960 struct symtab_and_line sal;
3964 sal.pc = marker->address;
3966 tracepoints = static_tracepoints_here (marker->address);
3968 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
3970 /* A counter field to help readability. This is not a stable
3972 ui_out_field_int (uiout, "count", count);
3974 ui_out_field_string (uiout, "marker-id", marker->str_id);
3976 ui_out_field_fmt (uiout, "enabled", "%c",
3977 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
3978 ui_out_spaces (uiout, 2);
3980 strcpy (wrap_indent, " ");
3982 if (gdbarch_addr_bit (marker->gdbarch) <= 32)
3983 strcat (wrap_indent, " ");
3985 strcat (wrap_indent, " ");
3987 strcpy (extra_field_indent, " ");
3989 ui_out_field_core_addr (uiout, "addr", marker->gdbarch, marker->address);
3991 sal = find_pc_line (marker->address, 0);
3992 sym = find_pc_sect_function (marker->address, NULL);
3995 ui_out_text (uiout, "in ");
3996 ui_out_field_string (uiout, "func",
3997 SYMBOL_PRINT_NAME (sym));
3998 ui_out_wrap_hint (uiout, wrap_indent);
3999 ui_out_text (uiout, " at ");
4002 ui_out_field_skip (uiout, "func");
4004 if (sal.symtab != NULL)
4006 ui_out_field_string (uiout, "file",
4007 symtab_to_filename_for_display (sal.symtab));
4008 ui_out_text (uiout, ":");
4010 if (ui_out_is_mi_like_p (uiout))
4012 const char *fullname = symtab_to_fullname (sal.symtab);
4014 ui_out_field_string (uiout, "fullname", fullname);
4017 ui_out_field_skip (uiout, "fullname");
4019 ui_out_field_int (uiout, "line", sal.line);
4023 ui_out_field_skip (uiout, "fullname");
4024 ui_out_field_skip (uiout, "line");
4027 ui_out_text (uiout, "\n");
4028 ui_out_text (uiout, extra_field_indent);
4029 ui_out_text (uiout, _("Data: \""));
4030 ui_out_field_string (uiout, "extra-data", marker->extra);
4031 ui_out_text (uiout, "\"\n");
4033 if (!VEC_empty (breakpoint_p, tracepoints))
4035 struct cleanup *cleanup_chain;
4037 struct breakpoint *b;
4039 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
4042 ui_out_text (uiout, extra_field_indent);
4043 ui_out_text (uiout, _("Probed by static tracepoints: "));
4044 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
4047 ui_out_text (uiout, ", ");
4048 ui_out_text (uiout, "#");
4049 ui_out_field_int (uiout, "tracepoint-id", b->number);
4052 do_cleanups (cleanup_chain);
4054 if (ui_out_is_mi_like_p (uiout))
4055 ui_out_field_int (uiout, "number-of-tracepoints",
4056 VEC_length(breakpoint_p, tracepoints));
4058 ui_out_text (uiout, "\n");
4060 VEC_free (breakpoint_p, tracepoints);
4062 do_cleanups (bkpt_chain);
4066 info_static_tracepoint_markers_command (char *arg, int from_tty)
4068 VEC(static_tracepoint_marker_p) *markers;
4069 struct cleanup *old_chain;
4070 struct static_tracepoint_marker *marker;
4071 struct ui_out *uiout = current_uiout;
4074 /* We don't have to check target_can_use_agent and agent's capability on
4075 static tracepoint here, in order to be compatible with older GDBserver.
4076 We don't check USE_AGENT is true or not, because static tracepoints
4077 don't work without in-process agent, so we don't bother users to type
4078 `set agent on' when to use static tracepoint. */
4081 = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
4082 "StaticTracepointMarkersTable");
4084 ui_out_table_header (uiout, 7, ui_left, "counter", "Cnt");
4086 ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
4088 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
4089 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
4090 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
4092 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
4093 ui_out_table_header (uiout, 40, ui_noalign, "what", "What");
4095 ui_out_table_body (uiout);
4097 markers = target_static_tracepoint_markers_by_strid (NULL);
4098 make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
4101 VEC_iterate (static_tracepoint_marker_p,
4102 markers, i, marker);
4105 print_one_static_tracepoint_marker (i + 1, marker);
4106 release_static_tracepoint_marker (marker);
4109 do_cleanups (old_chain);
4112 /* The $_sdata convenience variable is a bit special. We don't know
4113 for sure type of the value until we actually have a chance to fetch
4114 the data --- the size of the object depends on what has been
4115 collected. We solve this by making $_sdata be an internalvar that
4116 creates a new value on access. */
4118 /* Return a new value with the correct type for the sdata object of
4119 the current trace frame. Return a void value if there's no object
4122 static struct value *
4123 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
4129 /* We need to read the whole object before we know its size. */
4130 size = target_read_alloc (¤t_target,
4131 TARGET_OBJECT_STATIC_TRACE_DATA,
4138 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
4140 v = allocate_value (type);
4141 memcpy (value_contents_raw (v), buf, size);
4146 return allocate_value (builtin_type (gdbarch)->builtin_void);
4149 #if !defined(HAVE_LIBEXPAT)
4151 struct traceframe_info *
4152 parse_traceframe_info (const char *tframe_info)
4154 static int have_warned;
4159 warning (_("Can not parse XML trace frame info; XML support "
4160 "was disabled at compile time"));
4166 #else /* HAVE_LIBEXPAT */
4168 #include "xml-support.h"
4170 /* Handle the start of a <memory> element. */
4173 traceframe_info_start_memory (struct gdb_xml_parser *parser,
4174 const struct gdb_xml_element *element,
4175 void *user_data, VEC(gdb_xml_value_s) *attributes)
4177 struct traceframe_info *info = user_data;
4178 struct mem_range *r = VEC_safe_push (mem_range_s, info->memory, NULL);
4179 ULONGEST *start_p, *length_p;
4181 start_p = xml_find_attribute (attributes, "start")->value;
4182 length_p = xml_find_attribute (attributes, "length")->value;
4184 r->start = *start_p;
4185 r->length = *length_p;
4188 /* Handle the start of a <tvar> element. */
4191 traceframe_info_start_tvar (struct gdb_xml_parser *parser,
4192 const struct gdb_xml_element *element,
4194 VEC(gdb_xml_value_s) *attributes)
4196 struct traceframe_info *info = user_data;
4197 const char *id_attrib = xml_find_attribute (attributes, "id")->value;
4198 int id = gdb_xml_parse_ulongest (parser, id_attrib);
4200 VEC_safe_push (int, info->tvars, id);
4203 /* Discard the constructed trace frame info (if an error occurs). */
4206 free_result (void *p)
4208 struct traceframe_info *result = p;
4210 free_traceframe_info (result);
4213 /* The allowed elements and attributes for an XML memory map. */
4215 static const struct gdb_xml_attribute memory_attributes[] = {
4216 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4217 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4218 { NULL, GDB_XML_AF_NONE, NULL, NULL }
4221 static const struct gdb_xml_attribute tvar_attributes[] = {
4222 { "id", GDB_XML_AF_NONE, NULL, NULL },
4223 { NULL, GDB_XML_AF_NONE, NULL, NULL }
4226 static const struct gdb_xml_element traceframe_info_children[] = {
4227 { "memory", memory_attributes, NULL,
4228 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
4229 traceframe_info_start_memory, NULL },
4230 { "tvar", tvar_attributes, NULL,
4231 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
4232 traceframe_info_start_tvar, NULL },
4233 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4236 static const struct gdb_xml_element traceframe_info_elements[] = {
4237 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
4239 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4242 /* Parse a traceframe-info XML document. */
4244 struct traceframe_info *
4245 parse_traceframe_info (const char *tframe_info)
4247 struct traceframe_info *result;
4248 struct cleanup *back_to;
4250 result = XCNEW (struct traceframe_info);
4251 back_to = make_cleanup (free_result, result);
4253 if (gdb_xml_parse_quick (_("trace frame info"),
4254 "traceframe-info.dtd", traceframe_info_elements,
4255 tframe_info, result) == 0)
4257 /* Parsed successfully, keep the result. */
4258 discard_cleanups (back_to);
4263 do_cleanups (back_to);
4267 #endif /* HAVE_LIBEXPAT */
4269 /* Returns the traceframe_info object for the current traceframe.
4270 This is where we avoid re-fetching the object from the target if we
4271 already have it cached. */
4273 struct traceframe_info *
4274 get_traceframe_info (void)
4276 if (traceframe_info == NULL)
4277 traceframe_info = target_traceframe_info ();
4279 return traceframe_info;
4282 /* If the target supports the query, return in RESULT the set of
4283 collected memory in the current traceframe, found within the LEN
4284 bytes range starting at MEMADDR. Returns true if the target
4285 supports the query, otherwise returns false, and RESULT is left
4289 traceframe_available_memory (VEC(mem_range_s) **result,
4290 CORE_ADDR memaddr, ULONGEST len)
4292 struct traceframe_info *info = get_traceframe_info ();
4296 struct mem_range *r;
4301 for (i = 0; VEC_iterate (mem_range_s, info->memory, i, r); i++)
4302 if (mem_ranges_overlap (r->start, r->length, memaddr, len))
4304 ULONGEST lo1, hi1, lo2, hi2;
4305 struct mem_range *nr;
4308 hi1 = memaddr + len;
4311 hi2 = r->start + r->length;
4313 nr = VEC_safe_push (mem_range_s, *result, NULL);
4315 nr->start = max (lo1, lo2);
4316 nr->length = min (hi1, hi2) - nr->start;
4319 normalize_mem_ranges (*result);
4326 /* Implementation of `sdata' variable. */
4328 static const struct internalvar_funcs sdata_funcs =
4335 /* module initialization */
4337 _initialize_tracepoint (void)
4339 struct cmd_list_element *c;
4341 /* Explicitly create without lookup, since that tries to create a
4342 value with a void typed value, and when we get here, gdbarch
4343 isn't initialized yet. At this point, we're quite sure there
4344 isn't another convenience variable of the same name. */
4345 create_internalvar_type_lazy ("_sdata", &sdata_funcs, NULL);
4347 traceframe_number = -1;
4348 tracepoint_number = -1;
4350 add_info ("scope", scope_info,
4351 _("List the variables local to a scope"));
4353 add_cmd ("tracepoints", class_trace, NULL,
4354 _("Tracing of program execution without stopping the program."),
4357 add_com ("tdump", class_trace, trace_dump_command,
4358 _("Print everything collected at the current tracepoint."));
4360 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
4361 Define a trace state variable.\n\
4362 Argument is a $-prefixed name, optionally followed\n\
4363 by '=' and an expression that sets the initial value\n\
4364 at the start of tracing."));
4365 set_cmd_completer (c, expression_completer);
4367 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
4368 Delete one or more trace state variables.\n\
4369 Arguments are the names of the variables to delete.\n\
4370 If no arguments are supplied, delete all variables."), &deletelist);
4371 /* FIXME add a trace variable completer. */
4373 add_info ("tvariables", tvariables_info, _("\
4374 Status of trace state variables and their values.\n\
4377 add_info ("static-tracepoint-markers",
4378 info_static_tracepoint_markers_command, _("\
4379 List target static tracepoints markers.\n\
4382 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
4383 Select a trace frame;\n\
4384 No argument means forward by one frame; '-' means backward by one frame."),
4385 &tfindlist, "tfind ", 1, &cmdlist);
4387 add_cmd ("outside", class_trace, trace_find_outside_command, _("\
4388 Select a trace frame whose PC is outside the given range (exclusive).\n\
4389 Usage: tfind outside addr1, addr2"),
4392 add_cmd ("range", class_trace, trace_find_range_command, _("\
4393 Select a trace frame whose PC is in the given range (inclusive).\n\
4394 Usage: tfind range addr1,addr2"),
4397 add_cmd ("line", class_trace, trace_find_line_command, _("\
4398 Select a trace frame by source line.\n\
4399 Argument can be a line number (with optional source file),\n\
4400 a function name, or '*' followed by an address.\n\
4401 Default argument is 'the next source line that was traced'."),
4404 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
4405 Select a trace frame by tracepoint number.\n\
4406 Default is the tracepoint for the current trace frame."),
4409 add_cmd ("pc", class_trace, trace_find_pc_command, _("\
4410 Select a trace frame by PC.\n\
4411 Default is the current PC, or the PC of the current trace frame."),
4414 add_cmd ("end", class_trace, trace_find_end_command, _("\
4415 De-select any trace frame and resume 'live' debugging."),
4418 add_alias_cmd ("none", "end", class_trace, 0, &tfindlist);
4420 add_cmd ("start", class_trace, trace_find_start_command,
4421 _("Select the first trace frame in the trace buffer."),
4424 add_com ("tstatus", class_trace, trace_status_command,
4425 _("Display the status of the current trace data collection."));
4427 add_com ("tstop", class_trace, trace_stop_command, _("\
4428 Stop trace data collection.\n\
4429 Usage: tstop [ <notes> ... ]\n\
4430 Any arguments supplied are recorded with the trace as a stop reason and\n\
4431 reported by tstatus (if the target supports trace notes)."));
4433 add_com ("tstart", class_trace, trace_start_command, _("\
4434 Start trace data collection.\n\
4435 Usage: tstart [ <notes> ... ]\n\
4436 Any arguments supplied are recorded with the trace as a note and\n\
4437 reported by tstatus (if the target supports trace notes)."));
4439 add_com ("end", class_trace, end_actions_pseudocommand, _("\
4440 Ends a list of commands or actions.\n\
4441 Several GDB commands allow you to enter a list of commands or actions.\n\
4442 Entering \"end\" on a line by itself is the normal way to terminate\n\
4444 Note: the \"end\" command cannot be used at the gdb prompt."));
4446 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
4447 Specify single-stepping behavior at a tracepoint.\n\
4448 Argument is number of instructions to trace in single-step mode\n\
4449 following the tracepoint. This command is normally followed by\n\
4450 one or more \"collect\" commands, to specify what to collect\n\
4451 while single-stepping.\n\n\
4452 Note: this command can only be used in a tracepoint \"actions\" list."));
4454 add_com_alias ("ws", "while-stepping", class_alias, 0);
4455 add_com_alias ("stepping", "while-stepping", class_alias, 0);
4457 add_com ("collect", class_trace, collect_pseudocommand, _("\
4458 Specify one or more data items to be collected at a tracepoint.\n\
4459 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4460 collect all data (variables, registers) referenced by that expression.\n\
4461 Also accepts the following special arguments:\n\
4462 $regs -- all registers.\n\
4463 $args -- all function arguments.\n\
4464 $locals -- all variables local to the block/function scope.\n\
4465 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4466 Note: this command can only be used in a tracepoint \"actions\" list."));
4468 add_com ("teval", class_trace, teval_pseudocommand, _("\
4469 Specify one or more expressions to be evaluated at a tracepoint.\n\
4470 Accepts a comma-separated list of (one or more) expressions.\n\
4471 The result of each evaluation will be discarded.\n\
4472 Note: this command can only be used in a tracepoint \"actions\" list."));
4474 add_com ("actions", class_trace, trace_actions_command, _("\
4475 Specify the actions to be taken at a tracepoint.\n\
4476 Tracepoint actions may include collecting of specified data,\n\
4477 single-stepping, or enabling/disabling other tracepoints,\n\
4478 depending on target's capabilities."));
4480 default_collect = xstrdup ("");
4481 add_setshow_string_cmd ("default-collect", class_trace,
4482 &default_collect, _("\
4483 Set the list of expressions to collect by default"), _("\
4484 Show the list of expressions to collect by default"), NULL,
4486 &setlist, &showlist);
4488 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
4489 &disconnected_tracing, _("\
4490 Set whether tracing continues after GDB disconnects."), _("\
4491 Show whether tracing continues after GDB disconnects."), _("\
4492 Use this to continue a tracing run even if GDB disconnects\n\
4493 or detaches from the target. You can reconnect later and look at\n\
4494 trace data collected in the meantime."),
4495 set_disconnected_tracing,
4500 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
4501 &circular_trace_buffer, _("\
4502 Set target's use of circular trace buffer."), _("\
4503 Show target's use of circular trace buffer."), _("\
4504 Use this to make the trace buffer into a circular buffer,\n\
4505 which will discard traceframes (oldest first) instead of filling\n\
4506 up and stopping the trace run."),
4507 set_circular_trace_buffer,
4512 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class,
4513 &trace_buffer_size, _("\
4514 Set requested size of trace buffer."), _("\
4515 Show requested size of trace buffer."), _("\
4516 Use this to choose a size for the trace buffer. Some targets\n\
4517 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
4518 disables any attempt to set the buffer size and lets the target choose."),
4519 set_trace_buffer_size, NULL,
4520 &setlist, &showlist);
4522 add_setshow_string_cmd ("trace-user", class_trace,
4524 Set the user name to use for current and future trace runs"), _("\
4525 Show the user name to use for current and future trace runs"), NULL,
4526 set_trace_user, NULL,
4527 &setlist, &showlist);
4529 add_setshow_string_cmd ("trace-notes", class_trace,
4531 Set notes string to use for current and future trace runs"), _("\
4532 Show the notes string to use for current and future trace runs"), NULL,
4533 set_trace_notes, NULL,
4534 &setlist, &showlist);
4536 add_setshow_string_cmd ("trace-stop-notes", class_trace,
4537 &trace_stop_notes, _("\
4538 Set notes string to use for future tstop commands"), _("\
4539 Show the notes string to use for future tstop commands"), NULL,
4540 set_trace_stop_notes, NULL,
4541 &setlist, &showlist);