1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2016 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"
61 /* readline include files */
62 #include "readline/readline.h"
63 #include "readline/history.h"
65 /* readline defines this. */
70 /* Maximum length of an agent aexpression.
71 This accounts for the fact that packets are limited to 400 bytes
72 (which includes everything -- including the checksum), and assumes
73 the worst case of maximum length for each of the pieces of a
76 NOTE: expressions get mem2hex'ed otherwise this would be twice as
77 large. (400 - 31)/2 == 184 */
78 #define MAX_AGENT_EXPR_LEN 184
80 /* A hook used to notify the UI of tracepoint operations. */
82 void (*deprecated_trace_find_hook) (char *arg, int from_tty);
83 void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
88 This module defines the following debugger commands:
89 trace : set a tracepoint on a function, line, or address.
90 info trace : list all debugger-defined tracepoints.
91 delete trace : delete one or more tracepoints.
92 enable trace : enable one or more tracepoints.
93 disable trace : disable one or more tracepoints.
94 actions : specify actions to be taken at a tracepoint.
95 passcount : specify a pass count for a tracepoint.
96 tstart : start a trace experiment.
97 tstop : stop a trace experiment.
98 tstatus : query the status of a trace experiment.
99 tfind : find a trace frame in the trace buffer.
100 tdump : print everything collected at the current tracepoint.
101 save-tracepoints : write tracepoint setup into a file.
103 This module defines the following user-visible debugger variables:
104 $trace_frame : sequence number of trace frame currently being debugged.
105 $trace_line : source line of trace frame currently being debugged.
106 $trace_file : source file of trace frame currently being debugged.
107 $tracepoint : tracepoint number of trace frame currently being debugged.
111 /* ======= Important global variables: ======= */
113 /* The list of all trace state variables. We don't retain pointers to
114 any of these for any reason - API is by name or number only - so it
115 works to have a vector of objects. */
117 typedef struct trace_state_variable tsv_s;
120 static VEC(tsv_s) *tvariables;
122 /* The next integer to assign to a variable. */
124 static int next_tsv_number = 1;
126 /* Number of last traceframe collected. */
127 static int traceframe_number;
129 /* Tracepoint for last traceframe collected. */
130 static int tracepoint_number;
132 /* The traceframe info of the current traceframe. NULL if we haven't
133 yet attempted to fetch it, or if the target does not support
134 fetching this object, or if we're not inspecting a traceframe
136 static struct traceframe_info *traceframe_info;
138 /* Tracing command lists. */
139 static struct cmd_list_element *tfindlist;
141 /* List of expressions to collect by default at each tracepoint hit. */
142 char *default_collect = "";
144 static int disconnected_tracing;
146 /* This variable controls whether we ask the target for a linear or
147 circular trace buffer. */
149 static int circular_trace_buffer;
151 /* This variable is the requested trace buffer size, or -1 to indicate
152 that we don't care and leave it up to the target to set a size. */
154 static int trace_buffer_size = -1;
156 /* Textual notes applying to the current and/or future trace runs. */
158 char *trace_user = NULL;
160 /* Textual notes applying to the current and/or future trace runs. */
162 char *trace_notes = NULL;
164 /* Textual notes applying to the stopping of a trace. */
166 char *trace_stop_notes = NULL;
168 /* ======= Important command functions: ======= */
169 static void trace_actions_command (char *, int);
170 static void trace_start_command (char *, int);
171 static void trace_stop_command (char *, int);
172 static void trace_status_command (char *, int);
173 static void trace_find_command (char *, int);
174 static void trace_find_pc_command (char *, int);
175 static void trace_find_tracepoint_command (char *, int);
176 static void trace_find_line_command (char *, int);
177 static void trace_find_range_command (char *, int);
178 static void trace_find_outside_command (char *, int);
179 static void trace_dump_command (char *, int);
181 /* support routines */
183 struct collection_list;
184 static void add_aexpr (struct collection_list *, struct agent_expr *);
185 static char *mem2hex (gdb_byte *, char *, int);
186 static void add_register (struct collection_list *collection,
189 static struct command_line *
190 all_tracepoint_actions_and_cleanup (struct breakpoint *t);
192 extern void _initialize_tracepoint (void);
194 static struct trace_status trace_status;
196 const char *stop_reason_names[] = {
206 struct trace_status *
207 current_trace_status (void)
209 return &trace_status;
215 free_traceframe_info (struct traceframe_info *info)
219 VEC_free (mem_range_s, info->memory);
220 VEC_free (int, info->tvars);
226 /* Free and clear the traceframe info cache of the current
230 clear_traceframe_info (void)
232 free_traceframe_info (traceframe_info);
233 traceframe_info = NULL;
236 /* Set traceframe number to NUM. */
238 set_traceframe_num (int num)
240 traceframe_number = num;
241 set_internalvar_integer (lookup_internalvar ("trace_frame"), num);
244 /* Set tracepoint number to NUM. */
246 set_tracepoint_num (int num)
248 tracepoint_number = num;
249 set_internalvar_integer (lookup_internalvar ("tracepoint"), num);
252 /* Set externally visible debug variables for querying/printing
253 the traceframe context (line, function, file). */
256 set_traceframe_context (struct frame_info *trace_frame)
259 struct symbol *traceframe_fun;
260 struct symtab_and_line traceframe_sal;
262 /* Save as globals for internal use. */
263 if (trace_frame != NULL
264 && get_frame_pc_if_available (trace_frame, &trace_pc))
266 traceframe_sal = find_pc_line (trace_pc, 0);
267 traceframe_fun = find_pc_function (trace_pc);
269 /* Save linenumber as "$trace_line", a debugger variable visible to
271 set_internalvar_integer (lookup_internalvar ("trace_line"),
272 traceframe_sal.line);
276 init_sal (&traceframe_sal);
277 traceframe_fun = NULL;
278 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
281 /* Save func name as "$trace_func", a debugger variable visible to
283 if (traceframe_fun == NULL
284 || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
285 clear_internalvar (lookup_internalvar ("trace_func"));
287 set_internalvar_string (lookup_internalvar ("trace_func"),
288 SYMBOL_LINKAGE_NAME (traceframe_fun));
290 /* Save file name as "$trace_file", a debugger variable visible to
292 if (traceframe_sal.symtab == NULL)
293 clear_internalvar (lookup_internalvar ("trace_file"));
295 set_internalvar_string (lookup_internalvar ("trace_file"),
296 symtab_to_filename_for_display (traceframe_sal.symtab));
299 /* Create a new trace state variable with the given name. */
301 struct trace_state_variable *
302 create_trace_state_variable (const char *name)
304 struct trace_state_variable tsv;
306 memset (&tsv, 0, sizeof (tsv));
307 tsv.name = xstrdup (name);
308 tsv.number = next_tsv_number++;
309 return VEC_safe_push (tsv_s, tvariables, &tsv);
312 /* Look for a trace state variable of the given name. */
314 struct trace_state_variable *
315 find_trace_state_variable (const char *name)
317 struct trace_state_variable *tsv;
320 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
321 if (strcmp (name, tsv->name) == 0)
327 /* Look for a trace state variable of the given number. Return NULL if
330 struct trace_state_variable *
331 find_trace_state_variable_by_number (int number)
333 struct trace_state_variable *tsv;
336 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
337 if (tsv->number == number)
344 delete_trace_state_variable (const char *name)
346 struct trace_state_variable *tsv;
349 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
350 if (strcmp (name, tsv->name) == 0)
352 observer_notify_tsv_deleted (tsv);
354 xfree ((void *)tsv->name);
355 VEC_unordered_remove (tsv_s, tvariables, ix);
360 warning (_("No trace variable named \"$%s\", not deleting"), name);
363 /* Throws an error if NAME is not valid syntax for a trace state
367 validate_trace_state_variable_name (const char *name)
372 error (_("Must supply a non-empty variable name"));
374 /* All digits in the name is reserved for value history
376 for (p = name; isdigit (*p); p++)
379 error (_("$%s is not a valid trace state variable name"), name);
381 for (p = name; isalnum (*p) || *p == '_'; p++)
384 error (_("$%s is not a valid trace state variable name"), name);
387 /* The 'tvariable' command collects a name and optional expression to
388 evaluate into an initial value. */
391 trace_variable_command (char *args, int from_tty)
393 struct cleanup *old_chain;
395 struct trace_state_variable *tsv;
399 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
401 /* Only allow two syntaxes; "$name" and "$name=value". */
402 p = skip_spaces (args);
405 error (_("Name of trace variable should start with '$'"));
408 while (isalnum (*p) || *p == '_')
410 name = savestring (name, p - name);
411 old_chain = make_cleanup (xfree, name);
414 if (*p != '=' && *p != '\0')
415 error (_("Syntax must be $NAME [ = EXPR ]"));
417 validate_trace_state_variable_name (name);
420 initval = value_as_long (parse_and_eval (++p));
422 /* If the variable already exists, just change its initial value. */
423 tsv = find_trace_state_variable (name);
426 if (tsv->initial_value != initval)
428 tsv->initial_value = initval;
429 observer_notify_tsv_modified (tsv);
431 printf_filtered (_("Trace state variable $%s "
432 "now has initial value %s.\n"),
433 tsv->name, plongest (tsv->initial_value));
434 do_cleanups (old_chain);
438 /* Create a new variable. */
439 tsv = create_trace_state_variable (name);
440 tsv->initial_value = initval;
442 observer_notify_tsv_created (tsv);
444 printf_filtered (_("Trace state variable $%s "
445 "created, with initial value %s.\n"),
446 tsv->name, plongest (tsv->initial_value));
448 do_cleanups (old_chain);
452 delete_trace_variable_command (char *args, int from_tty)
456 struct cleanup *back_to;
460 if (query (_("Delete all trace state variables? ")))
461 VEC_free (tsv_s, tvariables);
463 observer_notify_tsv_deleted (NULL);
467 argv = gdb_buildargv (args);
468 back_to = make_cleanup_freeargv (argv);
470 for (ix = 0; argv[ix] != NULL; ix++)
472 if (*argv[ix] == '$')
473 delete_trace_state_variable (argv[ix] + 1);
475 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv[ix]);
478 do_cleanups (back_to);
484 tvariables_info_1 (void)
486 struct trace_state_variable *tsv;
489 struct cleanup *back_to;
490 struct ui_out *uiout = current_uiout;
492 if (VEC_length (tsv_s, tvariables) == 0 && !ui_out_is_mi_like_p (uiout))
494 printf_filtered (_("No trace state variables.\n"));
498 /* Try to acquire values from the target. */
499 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix, ++count)
500 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
503 back_to = make_cleanup_ui_out_table_begin_end (uiout, 3,
504 count, "trace-variables");
505 ui_out_table_header (uiout, 15, ui_left, "name", "Name");
506 ui_out_table_header (uiout, 11, ui_left, "initial", "Initial");
507 ui_out_table_header (uiout, 11, ui_left, "current", "Current");
509 ui_out_table_body (uiout);
511 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
513 struct cleanup *back_to2;
517 back_to2 = make_cleanup_ui_out_tuple_begin_end (uiout, "variable");
519 name = concat ("$", tsv->name, (char *) NULL);
520 make_cleanup (xfree, name);
521 ui_out_field_string (uiout, "name", name);
522 ui_out_field_string (uiout, "initial", plongest (tsv->initial_value));
524 if (tsv->value_known)
525 c = plongest (tsv->value);
526 else if (ui_out_is_mi_like_p (uiout))
527 /* For MI, we prefer not to use magic string constants, but rather
528 omit the field completely. The difference between unknown and
529 undefined does not seem important enough to represent. */
531 else if (current_trace_status ()->running || traceframe_number >= 0)
532 /* The value is/was defined, but we don't have it. */
535 /* It is not meaningful to ask about the value. */
538 ui_out_field_string (uiout, "current", c);
539 ui_out_text (uiout, "\n");
541 do_cleanups (back_to2);
544 do_cleanups (back_to);
547 /* List all the trace state variables. */
550 tvariables_info (char *args, int from_tty)
552 tvariables_info_1 ();
555 /* Stash definitions of tsvs into the given file. */
558 save_trace_state_variables (struct ui_file *fp)
560 struct trace_state_variable *tsv;
563 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
565 fprintf_unfiltered (fp, "tvariable $%s", tsv->name);
566 if (tsv->initial_value)
567 fprintf_unfiltered (fp, " = %s", plongest (tsv->initial_value));
568 fprintf_unfiltered (fp, "\n");
572 /* ACTIONS functions: */
574 /* The three functions:
575 collect_pseudocommand,
576 while_stepping_pseudocommand, and
577 end_actions_pseudocommand
578 are placeholders for "commands" that are actually ONLY to be used
579 within a tracepoint action list. If the actual function is ever called,
580 it means that somebody issued the "command" at the top level,
581 which is always an error. */
584 end_actions_pseudocommand (char *args, int from_tty)
586 error (_("This command cannot be used at the top level."));
590 while_stepping_pseudocommand (char *args, int from_tty)
592 error (_("This command can only be used in a tracepoint actions list."));
596 collect_pseudocommand (char *args, int from_tty)
598 error (_("This command can only be used in a tracepoint actions list."));
602 teval_pseudocommand (char *args, int from_tty)
604 error (_("This command can only be used in a tracepoint actions list."));
607 /* Parse any collection options, such as /s for strings. */
610 decode_agent_options (const char *exp, int *trace_string)
612 struct value_print_options opts;
619 /* Call this to borrow the print elements default for collection
621 get_user_print_options (&opts);
626 if (target_supports_string_tracing ())
628 /* Allow an optional decimal number giving an explicit maximum
629 string length, defaulting it to the "print elements" value;
630 so "collect/s80 mystr" gets at most 80 bytes of string. */
631 *trace_string = opts.print_max;
633 if (*exp >= '0' && *exp <= '9')
634 *trace_string = atoi (exp);
635 while (*exp >= '0' && *exp <= '9')
639 error (_("Target does not support \"/s\" option for string tracing."));
642 error (_("Undefined collection format \"%c\"."), *exp);
644 exp = skip_spaces_const (exp);
649 /* Enter a list of actions for a tracepoint. */
651 trace_actions_command (char *args, int from_tty)
653 struct tracepoint *t;
654 struct command_line *l;
656 t = get_tracepoint_by_number (&args, NULL);
660 xstrprintf ("Enter actions for tracepoint %d, one per line.",
662 struct cleanup *cleanups = make_cleanup (xfree, tmpbuf);
664 l = read_command_lines (tmpbuf, from_tty, 1,
665 check_tracepoint_command, t);
666 do_cleanups (cleanups);
667 breakpoint_set_commands (&t->base, l);
669 /* else just return */
672 /* Report the results of checking the agent expression, as errors or
676 report_agent_reqs_errors (struct agent_expr *aexpr)
678 /* All of the "flaws" are serious bytecode generation issues that
679 should never occur. */
680 if (aexpr->flaw != agent_flaw_none)
681 internal_error (__FILE__, __LINE__, _("expression is malformed"));
683 /* If analysis shows a stack underflow, GDB must have done something
684 badly wrong in its bytecode generation. */
685 if (aexpr->min_height < 0)
686 internal_error (__FILE__, __LINE__,
687 _("expression has min height < 0"));
689 /* Issue this error if the stack is predicted to get too deep. The
690 limit is rather arbitrary; a better scheme might be for the
691 target to report how much stack it will have available. The
692 depth roughly corresponds to parenthesization, so a limit of 20
693 amounts to 20 levels of expression nesting, which is actually
694 a pretty big hairy expression. */
695 if (aexpr->max_height > 20)
696 error (_("Expression is too complicated."));
699 /* worker function */
701 validate_actionline (const char *line, struct breakpoint *b)
703 struct cmd_list_element *c;
704 struct cleanup *old_chain = NULL;
707 struct bp_location *loc;
708 struct agent_expr *aexpr;
709 struct tracepoint *t = (struct tracepoint *) b;
711 /* If EOF is typed, *line is NULL. */
715 p = skip_spaces_const (line);
717 /* Symbol lookup etc. */
718 if (*p == '\0') /* empty line: just prompt for another line. */
721 if (*p == '#') /* comment line */
724 c = lookup_cmd (&p, cmdlist, "", -1, 1);
726 error (_("`%s' is not a tracepoint action, or is ambiguous."), p);
728 if (cmd_cfunc_eq (c, collect_pseudocommand))
730 int trace_string = 0;
733 p = decode_agent_options (p, &trace_string);
736 { /* Repeat over a comma-separated list. */
737 QUIT; /* Allow user to bail out with ^C. */
738 p = skip_spaces_const (p);
740 if (*p == '$') /* Look for special pseudo-symbols. */
742 if (0 == strncasecmp ("reg", p + 1, 3)
743 || 0 == strncasecmp ("arg", p + 1, 3)
744 || 0 == strncasecmp ("loc", p + 1, 3)
745 || 0 == strncasecmp ("_ret", p + 1, 4)
746 || 0 == strncasecmp ("_sdata", p + 1, 6))
751 /* else fall thru, treat p as an expression and parse it! */
754 for (loc = t->base.loc; loc; loc = loc->next)
757 expression_up exp = parse_exp_1 (&p, loc->address,
758 block_for_pc (loc->address), 1);
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.get (), trace_string);
782 old_chain = 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 expression_up exp = parse_exp_1 (&p, loc->address,
811 block_for_pc (loc->address), 1);
813 /* We have something to evaluate, make sure that the expr to
814 bytecode translator can handle it and that it's not too
816 aexpr = gen_eval_for_expr (loc->address, exp.get ());
817 old_chain = make_cleanup_free_agent_expr (aexpr);
819 if (aexpr->len > MAX_AGENT_EXPR_LEN)
820 error (_("Expression is too complicated."));
823 report_agent_reqs_errors (aexpr);
825 do_cleanups (old_chain);
828 while (p && *p++ == ',');
831 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
835 p = skip_spaces_const (p);
836 t->step_count = strtol (p, &endp, 0);
837 if (endp == p || t->step_count == 0)
838 error (_("while-stepping step count `%s' is malformed."), line);
842 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
846 error (_("`%s' is not a supported tracepoint action."), line);
850 memrange_absolute = -1
853 /* MEMRANGE functions: */
855 static int memrange_cmp (const void *, const void *);
857 /* Compare memranges for qsort. */
859 memrange_cmp (const void *va, const void *vb)
861 const struct memrange *a = (const struct memrange *) va;
862 const struct memrange *b = (const struct memrange *) 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 = (struct memrange *) 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 = (struct add_local_symbols_data *) 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 = (struct collection_list *) 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 = XCNEWVEC (struct memrange, clist->listsize);
1248 clist->aexpr_listsize = 128;
1249 clist->aexpr_list = XCNEWVEC (struct agent_expr *, clist->aexpr_listsize);
1252 /* Reduce a collection list to string form (for gdb protocol). */
1254 stringify_collection_list (struct collection_list *list)
1256 char temp_buf[2048];
1260 char *(*str_list)[];
1264 count = 1 + 1 + list->next_memrange + list->next_aexpr_elt + 1;
1265 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1267 if (list->strace_data)
1270 printf_filtered ("\nCollecting static trace data\n");
1273 (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
1277 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1278 if (list->regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */
1280 if (list->regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
1283 printf_filtered ("\nCollecting registers (mask): 0x");
1288 QUIT; /* Allow user to bail out with ^C. */
1290 printf_filtered ("%02X", list->regs_mask[i]);
1291 sprintf (end, "%02X", list->regs_mask[i]);
1294 (*str_list)[ndx] = xstrdup (temp_buf);
1298 printf_filtered ("\n");
1299 if (list->next_memrange > 0 && info_verbose)
1300 printf_filtered ("Collecting memranges: \n");
1301 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1303 QUIT; /* Allow user to bail out with ^C. */
1304 sprintf_vma (tmp2, list->list[i].start);
1307 printf_filtered ("(%d, %s, %ld)\n",
1310 (long) (list->list[i].end - list->list[i].start));
1312 if (count + 27 > MAX_AGENT_EXPR_LEN)
1314 (*str_list)[ndx] = savestring (temp_buf, count);
1321 bfd_signed_vma length = list->list[i].end - list->list[i].start;
1323 /* The "%X" conversion specifier expects an unsigned argument,
1324 so passing -1 (memrange_absolute) to it directly gives you
1325 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1327 if (list->list[i].type == memrange_absolute)
1328 sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
1330 sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
1333 count += strlen (end);
1334 end = temp_buf + count;
1337 for (i = 0; i < list->next_aexpr_elt; i++)
1339 QUIT; /* Allow user to bail out with ^C. */
1340 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1342 (*str_list)[ndx] = savestring (temp_buf, count);
1347 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1348 end += 10; /* 'X' + 8 hex digits + ',' */
1351 end = mem2hex (list->aexpr_list[i]->buf,
1352 end, list->aexpr_list[i]->len);
1353 count += 2 * list->aexpr_list[i]->len;
1358 (*str_list)[ndx] = savestring (temp_buf, count);
1363 (*str_list)[ndx] = NULL;
1374 /* Add the printed expression EXP to *LIST. */
1377 append_exp (struct expression *exp, VEC(char_ptr) **list)
1379 struct ui_file *tmp_stream = mem_fileopen ();
1382 print_expression (exp, tmp_stream);
1384 text = ui_file_xstrdup (tmp_stream, NULL);
1386 VEC_safe_push (char_ptr, *list, text);
1387 ui_file_delete (tmp_stream);
1391 encode_actions_1 (struct command_line *action,
1392 struct bp_location *tloc,
1394 LONGEST frame_offset,
1395 struct collection_list *collect,
1396 struct collection_list *stepping_list)
1398 const char *action_exp;
1400 struct value *tempval;
1401 struct cmd_list_element *cmd;
1402 struct agent_expr *aexpr;
1404 for (; action; action = action->next)
1406 QUIT; /* Allow user to bail out with ^C. */
1407 action_exp = action->line;
1408 action_exp = skip_spaces_const (action_exp);
1410 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1412 error (_("Bad action list item: %s"), action_exp);
1414 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1416 int trace_string = 0;
1418 if (*action_exp == '/')
1419 action_exp = decode_agent_options (action_exp, &trace_string);
1422 { /* Repeat over a comma-separated list. */
1423 QUIT; /* Allow user to bail out with ^C. */
1424 action_exp = skip_spaces_const (action_exp);
1426 if (0 == strncasecmp ("$reg", action_exp, 4))
1428 for (i = 0; i < gdbarch_num_regs (target_gdbarch ()); i++)
1429 add_register (collect, i);
1430 action_exp = strchr (action_exp, ','); /* more? */
1432 else if (0 == strncasecmp ("$arg", action_exp, 4))
1434 add_local_symbols (collect,
1441 action_exp = strchr (action_exp, ','); /* more? */
1443 else if (0 == strncasecmp ("$loc", action_exp, 4))
1445 add_local_symbols (collect,
1452 action_exp = strchr (action_exp, ','); /* more? */
1454 else if (0 == strncasecmp ("$_ret", action_exp, 5))
1456 struct cleanup *old_chain1 = NULL;
1458 aexpr = gen_trace_for_return_address (tloc->address,
1462 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1465 report_agent_reqs_errors (aexpr);
1467 discard_cleanups (old_chain1);
1468 add_aexpr (collect, aexpr);
1470 /* take care of the registers */
1471 if (aexpr->reg_mask_len > 0)
1475 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1477 QUIT; /* allow user to bail out with ^C */
1478 if (aexpr->reg_mask[ndx1] != 0)
1480 /* assume chars have 8 bits */
1481 for (ndx2 = 0; ndx2 < 8; ndx2++)
1482 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1483 /* it's used -- record it */
1484 add_register (collect,
1490 action_exp = strchr (action_exp, ','); /* more? */
1492 else if (0 == strncasecmp ("$_sdata", action_exp, 7))
1494 add_static_trace_data (collect);
1495 action_exp = strchr (action_exp, ','); /* more? */
1500 struct cleanup *old_chain1 = NULL;
1502 expression_up exp = parse_exp_1 (&action_exp, tloc->address,
1503 block_for_pc (tloc->address),
1506 switch (exp->elts[0].opcode)
1510 const char *name = &exp->elts[2].string;
1512 i = user_reg_map_name_to_regnum (target_gdbarch (),
1513 name, strlen (name));
1515 internal_error (__FILE__, __LINE__,
1516 _("Register $%s not available"),
1519 printf_filtered ("OP_REGISTER: ");
1520 add_register (collect, i);
1525 /* Safe because we know it's a simple expression. */
1526 tempval = evaluate_expression (exp.get ());
1527 addr = value_address (tempval);
1528 /* Initialize the TYPE_LENGTH if it is a typedef. */
1529 check_typedef (exp->elts[1].type);
1530 add_memrange (collect, memrange_absolute, addr,
1531 TYPE_LENGTH (exp->elts[1].type));
1532 append_exp (exp.get (), &collect->computed);
1537 struct symbol *sym = exp->elts[2].symbol;
1538 char_ptr name = (char_ptr) SYMBOL_NATURAL_NAME (sym);
1540 collect_symbol (collect,
1541 exp->elts[2].symbol,
1547 VEC_safe_push (char_ptr,
1548 collect->wholly_collected,
1553 default: /* Full-fledged expression. */
1554 aexpr = gen_trace_for_expr (tloc->address, exp.get (),
1557 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1561 report_agent_reqs_errors (aexpr);
1563 discard_cleanups (old_chain1);
1564 add_aexpr (collect, aexpr);
1566 /* Take care of the registers. */
1567 if (aexpr->reg_mask_len > 0)
1572 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1574 QUIT; /* Allow user to bail out with ^C. */
1575 if (aexpr->reg_mask[ndx1] != 0)
1577 /* Assume chars have 8 bits. */
1578 for (ndx2 = 0; ndx2 < 8; ndx2++)
1579 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1580 /* It's used -- record it. */
1581 add_register (collect,
1587 append_exp (exp.get (), &collect->computed);
1592 while (action_exp && *action_exp++ == ',');
1594 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1597 { /* Repeat over a comma-separated list. */
1598 QUIT; /* Allow user to bail out with ^C. */
1599 action_exp = skip_spaces_const (action_exp);
1602 struct cleanup *old_chain1 = NULL;
1604 expression_up exp = parse_exp_1 (&action_exp, tloc->address,
1605 block_for_pc (tloc->address),
1608 aexpr = gen_eval_for_expr (tloc->address, exp.get ());
1609 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1612 report_agent_reqs_errors (aexpr);
1614 discard_cleanups (old_chain1);
1615 /* Even though we're not officially collecting, add
1616 to the collect list anyway. */
1617 add_aexpr (collect, aexpr);
1620 while (action_exp && *action_exp++ == ',');
1622 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1624 /* We check against nested while-stepping when setting
1625 breakpoint action, so no way to run into nested
1627 gdb_assert (stepping_list);
1629 encode_actions_1 (action->body_list[0], tloc, frame_reg,
1630 frame_offset, stepping_list, NULL);
1633 error (_("Invalid tracepoint command '%s'"), action->line);
1637 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1638 and STEPPING_LIST. Return a cleanup pointer to clean up both
1639 TRACEPOINT_LIST and STEPPING_LIST. */
1642 encode_actions_and_make_cleanup (struct bp_location *tloc,
1643 struct collection_list *tracepoint_list,
1644 struct collection_list *stepping_list)
1646 struct command_line *actions;
1648 LONGEST frame_offset;
1649 struct cleanup *back_to, *return_chain;
1651 return_chain = make_cleanup (null_cleanup, NULL);
1652 init_collection_list (tracepoint_list);
1653 init_collection_list (stepping_list);
1655 make_cleanup (do_clear_collection_list, tracepoint_list);
1656 make_cleanup (do_clear_collection_list, stepping_list);
1658 back_to = make_cleanup (null_cleanup, NULL);
1659 gdbarch_virtual_frame_pointer (tloc->gdbarch,
1660 tloc->address, &frame_reg, &frame_offset);
1662 actions = all_tracepoint_actions_and_cleanup (tloc->owner);
1664 encode_actions_1 (actions, tloc, frame_reg, frame_offset,
1665 tracepoint_list, stepping_list);
1667 memrange_sortmerge (tracepoint_list);
1668 memrange_sortmerge (stepping_list);
1670 do_cleanups (back_to);
1671 return return_chain;
1674 /* Render all actions into gdb protocol. */
1677 encode_actions_rsp (struct bp_location *tloc, char ***tdp_actions,
1678 char ***stepping_actions)
1680 struct collection_list tracepoint_list, stepping_list;
1681 struct cleanup *cleanup;
1683 *tdp_actions = NULL;
1684 *stepping_actions = NULL;
1686 cleanup = encode_actions_and_make_cleanup (tloc, &tracepoint_list,
1689 *tdp_actions = stringify_collection_list (&tracepoint_list);
1690 *stepping_actions = stringify_collection_list (&stepping_list);
1692 do_cleanups (cleanup);
1696 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1698 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1700 collect->aexpr_list = XRESIZEVEC (struct agent_expr *,
1701 collect->aexpr_list,
1702 2 * collect->aexpr_listsize);
1703 collect->aexpr_listsize *= 2;
1705 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1706 collect->next_aexpr_elt++;
1710 process_tracepoint_on_disconnect (void)
1712 VEC(breakpoint_p) *tp_vec = NULL;
1714 struct breakpoint *b;
1715 int has_pending_p = 0;
1717 /* Check whether we still have pending tracepoint. If we have, warn the
1718 user that pending tracepoint will no longer work. */
1719 tp_vec = all_tracepoints ();
1720 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1729 struct bp_location *loc1;
1731 for (loc1 = b->loc; loc1; loc1 = loc1->next)
1733 if (loc1->shlib_disabled)
1744 VEC_free (breakpoint_p, tp_vec);
1747 warning (_("Pending tracepoints will not be resolved while"
1748 " GDB is disconnected\n"));
1751 /* Reset local state of tracing. */
1754 trace_reset_local_state (void)
1756 set_traceframe_num (-1);
1757 set_tracepoint_num (-1);
1758 set_traceframe_context (NULL);
1759 clear_traceframe_info ();
1763 start_tracing (char *notes)
1765 VEC(breakpoint_p) *tp_vec = NULL;
1767 struct breakpoint *b;
1768 struct trace_state_variable *tsv;
1769 int any_enabled = 0, num_to_download = 0;
1772 tp_vec = all_tracepoints ();
1774 /* No point in tracing without any tracepoints... */
1775 if (VEC_length (breakpoint_p, tp_vec) == 0)
1777 VEC_free (breakpoint_p, tp_vec);
1778 error (_("No tracepoints defined, not starting trace"));
1781 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1783 if (b->enable_state == bp_enabled)
1786 if ((b->type == bp_fast_tracepoint
1787 ? may_insert_fast_tracepoints
1788 : may_insert_tracepoints))
1791 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1792 (b->type == bp_fast_tracepoint ? "fast " : ""), b->number);
1797 if (target_supports_enable_disable_tracepoint ())
1798 warning (_("No tracepoints enabled"));
1801 /* No point in tracing with only disabled tracepoints that
1802 cannot be re-enabled. */
1803 VEC_free (breakpoint_p, tp_vec);
1804 error (_("No tracepoints enabled, not starting trace"));
1808 if (num_to_download <= 0)
1810 VEC_free (breakpoint_p, tp_vec);
1811 error (_("No tracepoints that may be downloaded, not starting trace"));
1814 target_trace_init ();
1816 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1818 struct tracepoint *t = (struct tracepoint *) b;
1819 struct bp_location *loc;
1820 int bp_location_downloaded = 0;
1822 /* Clear `inserted' flag. */
1823 for (loc = b->loc; loc; loc = loc->next)
1826 if ((b->type == bp_fast_tracepoint
1827 ? !may_insert_fast_tracepoints
1828 : !may_insert_tracepoints))
1831 t->number_on_target = 0;
1833 for (loc = b->loc; loc; loc = loc->next)
1835 /* Since tracepoint locations are never duplicated, `inserted'
1836 flag should be zero. */
1837 gdb_assert (!loc->inserted);
1839 target_download_tracepoint (loc);
1842 bp_location_downloaded = 1;
1845 t->number_on_target = b->number;
1847 for (loc = b->loc; loc; loc = loc->next)
1848 if (loc->probe.probe != NULL
1849 && loc->probe.probe->pops->set_semaphore != NULL)
1850 loc->probe.probe->pops->set_semaphore (loc->probe.probe,
1854 if (bp_location_downloaded)
1855 observer_notify_breakpoint_modified (b);
1857 VEC_free (breakpoint_p, tp_vec);
1859 /* Send down all the trace state variables too. */
1860 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1862 target_download_trace_state_variable (tsv);
1865 /* Tell target to treat text-like sections as transparent. */
1866 target_trace_set_readonly_regions ();
1867 /* Set some mode flags. */
1868 target_set_disconnected_tracing (disconnected_tracing);
1869 target_set_circular_trace_buffer (circular_trace_buffer);
1870 target_set_trace_buffer_size (trace_buffer_size);
1873 notes = trace_notes;
1874 ret = target_set_trace_notes (trace_user, notes, NULL);
1876 if (!ret && (trace_user || notes))
1877 warning (_("Target does not support trace user/notes, info ignored"));
1879 /* Now insert traps and begin collecting data. */
1880 target_trace_start ();
1882 /* Reset our local state. */
1883 trace_reset_local_state ();
1884 current_trace_status()->running = 1;
1887 /* The tstart command requests the target to start a new trace run.
1888 The command passes any arguments it has to the target verbatim, as
1889 an optional "trace note". This is useful as for instance a warning
1890 to other users if the trace runs disconnected, and you don't want
1891 anybody else messing with the target. */
1894 trace_start_command (char *args, int from_tty)
1896 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1898 if (current_trace_status ()->running)
1901 && !query (_("A trace is running already. Start a new run? ")))
1902 error (_("New trace run not started."));
1905 start_tracing (args);
1908 /* The tstop command stops the tracing run. The command passes any
1909 supplied arguments to the target verbatim as a "stop note"; if the
1910 target supports trace notes, then it will be reported back as part
1911 of the trace run's status. */
1914 trace_stop_command (char *args, int from_tty)
1916 if (!current_trace_status ()->running)
1917 error (_("Trace is not running."));
1919 stop_tracing (args);
1923 stop_tracing (char *note)
1926 VEC(breakpoint_p) *tp_vec = NULL;
1928 struct breakpoint *t;
1930 target_trace_stop ();
1932 tp_vec = all_tracepoints ();
1933 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1935 struct bp_location *loc;
1937 if ((t->type == bp_fast_tracepoint
1938 ? !may_insert_fast_tracepoints
1939 : !may_insert_tracepoints))
1942 for (loc = t->loc; loc; loc = loc->next)
1944 /* GDB can be totally absent in some disconnected trace scenarios,
1945 but we don't really care if this semaphore goes out of sync.
1946 That's why we are decrementing it here, but not taking care
1948 if (loc->probe.probe != NULL
1949 && loc->probe.probe->pops->clear_semaphore != NULL)
1950 loc->probe.probe->pops->clear_semaphore (loc->probe.probe,
1956 VEC_free (breakpoint_p, tp_vec);
1959 note = trace_stop_notes;
1960 ret = target_set_trace_notes (NULL, NULL, note);
1963 warning (_("Target does not support trace notes, note ignored"));
1965 /* Should change in response to reply? */
1966 current_trace_status ()->running = 0;
1969 /* tstatus command */
1971 trace_status_command (char *args, int from_tty)
1973 struct trace_status *ts = current_trace_status ();
1975 VEC(breakpoint_p) *tp_vec = NULL;
1976 struct breakpoint *t;
1978 status = target_get_trace_status (ts);
1982 if (ts->filename != NULL)
1983 printf_filtered (_("Using a trace file.\n"));
1986 printf_filtered (_("Trace can not be run on this target.\n"));
1991 if (!ts->running_known)
1993 printf_filtered (_("Run/stop status is unknown.\n"));
1995 else if (ts->running)
1997 printf_filtered (_("Trace is running on the target.\n"));
2001 switch (ts->stop_reason)
2003 case trace_never_run:
2004 printf_filtered (_("No trace has been run on the target.\n"));
2008 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
2011 printf_filtered (_("Trace stopped by a tstop command.\n"));
2013 case trace_buffer_full:
2014 printf_filtered (_("Trace stopped because the buffer was full.\n"));
2016 case trace_disconnected:
2017 printf_filtered (_("Trace stopped because of disconnection.\n"));
2019 case tracepoint_passcount:
2020 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
2021 ts->stopping_tracepoint);
2023 case tracepoint_error:
2024 if (ts->stopping_tracepoint)
2025 printf_filtered (_("Trace stopped by an "
2026 "error (%s, tracepoint %d).\n"),
2027 ts->stop_desc, ts->stopping_tracepoint);
2029 printf_filtered (_("Trace stopped by an error (%s).\n"),
2032 case trace_stop_reason_unknown:
2033 printf_filtered (_("Trace stopped for an unknown reason.\n"));
2036 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
2042 if (ts->traceframes_created >= 0
2043 && ts->traceframe_count != ts->traceframes_created)
2045 printf_filtered (_("Buffer contains %d trace "
2046 "frames (of %d created total).\n"),
2047 ts->traceframe_count, ts->traceframes_created);
2049 else if (ts->traceframe_count >= 0)
2051 printf_filtered (_("Collected %d trace frames.\n"),
2052 ts->traceframe_count);
2055 if (ts->buffer_free >= 0)
2057 if (ts->buffer_size >= 0)
2059 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2060 ts->buffer_free, ts->buffer_size);
2061 if (ts->buffer_size > 0)
2062 printf_filtered (_(" (%d%% full)"),
2063 ((int) ((((long long) (ts->buffer_size
2064 - ts->buffer_free)) * 100)
2065 / ts->buffer_size)));
2066 printf_filtered (_(".\n"));
2069 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2073 if (ts->disconnected_tracing)
2074 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2076 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2078 if (ts->circular_buffer)
2079 printf_filtered (_("Trace buffer is circular.\n"));
2081 if (ts->user_name && strlen (ts->user_name) > 0)
2082 printf_filtered (_("Trace user is %s.\n"), ts->user_name);
2084 if (ts->notes && strlen (ts->notes) > 0)
2085 printf_filtered (_("Trace notes: %s.\n"), ts->notes);
2087 /* Now report on what we're doing with tfind. */
2088 if (traceframe_number >= 0)
2089 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2090 traceframe_number, tracepoint_number);
2092 printf_filtered (_("Not looking at any trace frame.\n"));
2094 /* Report start/stop times if supplied. */
2099 LONGEST run_time = ts->stop_time - ts->start_time;
2101 /* Reporting a run time is more readable than two long numbers. */
2102 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2103 (long int) (ts->start_time / 1000000),
2104 (long int) (ts->start_time % 1000000),
2105 (long int) (run_time / 1000000),
2106 (long int) (run_time % 1000000));
2109 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2110 (long int) (ts->start_time / 1000000),
2111 (long int) (ts->start_time % 1000000));
2113 else if (ts->stop_time)
2114 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2115 (long int) (ts->stop_time / 1000000),
2116 (long int) (ts->stop_time % 1000000));
2118 /* Now report any per-tracepoint status available. */
2119 tp_vec = all_tracepoints ();
2121 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
2122 target_get_tracepoint_status (t, NULL);
2124 VEC_free (breakpoint_p, tp_vec);
2127 /* Report the trace status to uiout, in a way suitable for MI, and not
2128 suitable for CLI. If ON_STOP is true, suppress a few fields that
2129 are not meaningful in the -trace-stop response.
2131 The implementation is essentially parallel to trace_status_command, but
2132 merging them will result in unreadable code. */
2134 trace_status_mi (int on_stop)
2136 struct ui_out *uiout = current_uiout;
2137 struct trace_status *ts = current_trace_status ();
2140 status = target_get_trace_status (ts);
2142 if (status == -1 && ts->filename == NULL)
2144 ui_out_field_string (uiout, "supported", "0");
2148 if (ts->filename != NULL)
2149 ui_out_field_string (uiout, "supported", "file");
2151 ui_out_field_string (uiout, "supported", "1");
2153 if (ts->filename != NULL)
2154 ui_out_field_string (uiout, "trace-file", ts->filename);
2156 gdb_assert (ts->running_known);
2160 ui_out_field_string (uiout, "running", "1");
2162 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2163 Given that the frontend gets the status either on -trace-stop, or from
2164 -trace-status after re-connection, it does not seem like this
2165 information is necessary for anything. It is not necessary for either
2166 figuring the vital state of the target nor for navigation of trace
2167 frames. If the frontend wants to show the current state is some
2168 configure dialog, it can request the value when such dialog is
2169 invoked by the user. */
2173 char *stop_reason = NULL;
2174 int stopping_tracepoint = -1;
2177 ui_out_field_string (uiout, "running", "0");
2179 if (ts->stop_reason != trace_stop_reason_unknown)
2181 switch (ts->stop_reason)
2184 stop_reason = "request";
2186 case trace_buffer_full:
2187 stop_reason = "overflow";
2189 case trace_disconnected:
2190 stop_reason = "disconnection";
2192 case tracepoint_passcount:
2193 stop_reason = "passcount";
2194 stopping_tracepoint = ts->stopping_tracepoint;
2196 case tracepoint_error:
2197 stop_reason = "error";
2198 stopping_tracepoint = ts->stopping_tracepoint;
2204 ui_out_field_string (uiout, "stop-reason", stop_reason);
2205 if (stopping_tracepoint != -1)
2206 ui_out_field_int (uiout, "stopping-tracepoint",
2207 stopping_tracepoint);
2208 if (ts->stop_reason == tracepoint_error)
2209 ui_out_field_string (uiout, "error-description",
2215 if (ts->traceframe_count != -1)
2216 ui_out_field_int (uiout, "frames", ts->traceframe_count);
2217 if (ts->traceframes_created != -1)
2218 ui_out_field_int (uiout, "frames-created", ts->traceframes_created);
2219 if (ts->buffer_size != -1)
2220 ui_out_field_int (uiout, "buffer-size", ts->buffer_size);
2221 if (ts->buffer_free != -1)
2222 ui_out_field_int (uiout, "buffer-free", ts->buffer_free);
2224 ui_out_field_int (uiout, "disconnected", ts->disconnected_tracing);
2225 ui_out_field_int (uiout, "circular", ts->circular_buffer);
2227 ui_out_field_string (uiout, "user-name", ts->user_name);
2228 ui_out_field_string (uiout, "notes", ts->notes);
2233 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2234 (long int) (ts->start_time / 1000000),
2235 (long int) (ts->start_time % 1000000));
2236 ui_out_field_string (uiout, "start-time", buf);
2237 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2238 (long int) (ts->stop_time / 1000000),
2239 (long int) (ts->stop_time % 1000000));
2240 ui_out_field_string (uiout, "stop-time", buf);
2244 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2245 user if she really wants to detach. */
2248 query_if_trace_running (int from_tty)
2253 /* It can happen that the target that was tracing went away on its
2254 own, and we didn't notice. Get a status update, and if the
2255 current target doesn't even do tracing, then assume it's not
2257 if (target_get_trace_status (current_trace_status ()) < 0)
2258 current_trace_status ()->running = 0;
2260 /* If running interactively, give the user the option to cancel and
2261 then decide what to do differently with the run. Scripts are
2262 just going to disconnect and let the target deal with it,
2263 according to how it's been instructed previously via
2264 disconnected-tracing. */
2265 if (current_trace_status ()->running)
2267 process_tracepoint_on_disconnect ();
2269 if (current_trace_status ()->disconnected_tracing)
2271 if (!query (_("Trace is running and will "
2272 "continue after detach; detach anyway? ")))
2273 error (_("Not confirmed."));
2277 if (!query (_("Trace is running but will "
2278 "stop on detach; detach anyway? ")))
2279 error (_("Not confirmed."));
2284 /* This function handles the details of what to do about an ongoing
2285 tracing run if the user has asked to detach or otherwise disconnect
2289 disconnect_tracing (void)
2291 /* Also we want to be out of tfind mode, otherwise things can get
2292 confusing upon reconnection. Just use these calls instead of
2293 full tfind_1 behavior because we're in the middle of detaching,
2294 and there's no point to updating current stack frame etc. */
2295 trace_reset_local_state ();
2298 /* Worker function for the various flavors of the tfind command. */
2300 tfind_1 (enum trace_find_type type, int num,
2301 CORE_ADDR addr1, CORE_ADDR addr2,
2304 int target_frameno = -1, target_tracept = -1;
2305 struct frame_id old_frame_id = null_frame_id;
2306 struct tracepoint *tp;
2307 struct ui_out *uiout = current_uiout;
2309 /* Only try to get the current stack frame if we have a chance of
2310 succeeding. In particular, if we're trying to get a first trace
2311 frame while all threads are running, it's not going to succeed,
2312 so leave it with a default value and let the frame comparison
2313 below (correctly) decide to print out the source location of the
2315 if (!(type == tfind_number && num == -1)
2316 && (has_stack_frames () || traceframe_number >= 0))
2317 old_frame_id = get_frame_id (get_current_frame ());
2319 target_frameno = target_trace_find (type, num, addr1, addr2,
2322 if (type == tfind_number
2324 && target_frameno == -1)
2326 /* We told the target to get out of tfind mode, and it did. */
2328 else if (target_frameno == -1)
2330 /* A request for a non-existent trace frame has failed.
2331 Our response will be different, depending on FROM_TTY:
2333 If FROM_TTY is true, meaning that this command was
2334 typed interactively by the user, then give an error
2335 and DO NOT change the state of traceframe_number etc.
2337 However if FROM_TTY is false, meaning that we're either
2338 in a script, a loop, or a user-defined command, then
2339 DON'T give an error, but DO change the state of
2340 traceframe_number etc. to invalid.
2342 The rationalle is that if you typed the command, you
2343 might just have committed a typo or something, and you'd
2344 like to NOT lose your current debugging state. However
2345 if you're in a user-defined command or especially in a
2346 loop, then you need a way to detect that the command
2347 failed WITHOUT aborting. This allows you to write
2348 scripts that search thru the trace buffer until the end,
2349 and then continue on to do something else. */
2352 error (_("Target failed to find requested trace frame."));
2356 printf_filtered ("End of trace buffer.\n");
2357 #if 0 /* dubious now? */
2358 /* The following will not recurse, since it's
2360 trace_find_command ("-1", from_tty);
2365 tp = get_tracepoint_by_number_on_target (target_tracept);
2367 reinit_frame_cache ();
2368 target_dcache_invalidate ();
2370 set_tracepoint_num (tp ? tp->base.number : target_tracept);
2372 if (target_frameno != get_traceframe_number ())
2373 observer_notify_traceframe_changed (target_frameno, tracepoint_number);
2375 set_current_traceframe (target_frameno);
2377 if (target_frameno == -1)
2378 set_traceframe_context (NULL);
2380 set_traceframe_context (get_current_frame ());
2382 if (traceframe_number >= 0)
2384 /* Use different branches for MI and CLI to make CLI messages
2386 if (ui_out_is_mi_like_p (uiout))
2388 ui_out_field_string (uiout, "found", "1");
2389 ui_out_field_int (uiout, "tracepoint", tracepoint_number);
2390 ui_out_field_int (uiout, "traceframe", traceframe_number);
2394 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2395 traceframe_number, tracepoint_number);
2400 if (ui_out_is_mi_like_p (uiout))
2401 ui_out_field_string (uiout, "found", "0");
2402 else if (type == tfind_number && num == -1)
2403 printf_unfiltered (_("No longer looking at any trace frame\n"));
2404 else /* This case may never occur, check. */
2405 printf_unfiltered (_("No trace frame found\n"));
2408 /* If we're in nonstop mode and getting out of looking at trace
2409 frames, there won't be any current frame to go back to and
2412 && (has_stack_frames () || traceframe_number >= 0))
2414 enum print_what print_what;
2416 /* NOTE: in imitation of the step command, try to determine
2417 whether we have made a transition from one function to
2418 another. If so, we'll print the "stack frame" (ie. the new
2419 function and it's arguments) -- otherwise we'll just show the
2422 if (frame_id_eq (old_frame_id,
2423 get_frame_id (get_current_frame ())))
2424 print_what = SRC_LINE;
2426 print_what = SRC_AND_LOC;
2428 print_stack_frame (get_selected_frame (NULL), 1, print_what, 1);
2433 /* Error on looking at traceframes while trace is running. */
2436 check_trace_running (struct trace_status *status)
2438 if (status->running && status->filename == NULL)
2439 error (_("May not look at trace frames while trace is running."));
2442 /* trace_find_command takes a trace frame number n,
2443 sends "QTFrame:<n>" to the target,
2444 and accepts a reply that may contain several optional pieces
2445 of information: a frame number, a tracepoint number, and an
2446 indication of whether this is a trap frame or a stepping frame.
2448 The minimal response is just "OK" (which indicates that the
2449 target does not give us a frame number or a tracepoint number).
2450 Instead of that, the target may send us a string containing
2452 F<hexnum> (gives the selected frame number)
2453 T<hexnum> (gives the selected tracepoint number)
2458 trace_find_command (char *args, int from_tty)
2459 { /* This should only be called with a numeric argument. */
2462 check_trace_running (current_trace_status ());
2464 if (args == 0 || *args == 0)
2465 { /* TFIND with no args means find NEXT trace frame. */
2466 if (traceframe_number == -1)
2467 frameno = 0; /* "next" is first one. */
2469 frameno = traceframe_number + 1;
2471 else if (0 == strcmp (args, "-"))
2473 if (traceframe_number == -1)
2474 error (_("not debugging trace buffer"));
2475 else if (from_tty && traceframe_number == 0)
2476 error (_("already at start of trace buffer"));
2478 frameno = traceframe_number - 1;
2480 /* A hack to work around eval's need for fp to have been collected. */
2481 else if (0 == strcmp (args, "-1"))
2484 frameno = parse_and_eval_long (args);
2487 error (_("invalid input (%d is less than zero)"), frameno);
2489 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2494 trace_find_end_command (char *args, int from_tty)
2496 trace_find_command ("-1", from_tty);
2501 trace_find_start_command (char *args, int from_tty)
2503 trace_find_command ("0", from_tty);
2506 /* tfind pc command */
2508 trace_find_pc_command (char *args, int from_tty)
2512 check_trace_running (current_trace_status ());
2514 if (args == 0 || *args == 0)
2515 pc = regcache_read_pc (get_current_regcache ());
2517 pc = parse_and_eval_address (args);
2519 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2522 /* tfind tracepoint command */
2524 trace_find_tracepoint_command (char *args, int from_tty)
2527 struct tracepoint *tp;
2529 check_trace_running (current_trace_status ());
2531 if (args == 0 || *args == 0)
2533 if (tracepoint_number == -1)
2534 error (_("No current tracepoint -- please supply an argument."));
2536 tdp = tracepoint_number; /* Default is current TDP. */
2539 tdp = parse_and_eval_long (args);
2541 /* If we have the tracepoint on hand, use the number that the
2542 target knows about (which may be different if we disconnected
2543 and reconnected). */
2544 tp = get_tracepoint (tdp);
2546 tdp = tp->number_on_target;
2548 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2551 /* TFIND LINE command:
2553 This command will take a sourceline for argument, just like BREAK
2554 or TRACE (ie. anything that "decode_line_1" can handle).
2556 With no argument, this command will find the next trace frame
2557 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2560 trace_find_line_command (char *args, int from_tty)
2562 static CORE_ADDR start_pc, end_pc;
2563 struct symtabs_and_lines sals;
2564 struct symtab_and_line sal;
2565 struct cleanup *old_chain;
2567 check_trace_running (current_trace_status ());
2569 if (args == 0 || *args == 0)
2571 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2573 sals.sals = XNEW (struct symtab_and_line);
2578 sals = decode_line_with_current_source (args, DECODE_LINE_FUNFIRSTLINE);
2582 old_chain = make_cleanup (xfree, sals.sals);
2583 if (sal.symtab == 0)
2584 error (_("No line number information available."));
2586 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2588 if (start_pc == end_pc)
2590 printf_filtered ("Line %d of \"%s\"",
2592 symtab_to_filename_for_display (sal.symtab));
2594 printf_filtered (" is at address ");
2595 print_address (get_current_arch (), start_pc, gdb_stdout);
2597 printf_filtered (" but contains no code.\n");
2598 sal = find_pc_line (start_pc, 0);
2600 && find_line_pc_range (sal, &start_pc, &end_pc)
2601 && start_pc != end_pc)
2602 printf_filtered ("Attempting to find line %d instead.\n",
2605 error (_("Cannot find a good line."));
2609 /* Is there any case in which we get here, and have an address
2610 which the user would want to see? If we have debugging
2611 symbols and no line numbers? */
2612 error (_("Line number %d is out of range for \"%s\"."),
2613 sal.line, symtab_to_filename_for_display (sal.symtab));
2615 /* Find within range of stated line. */
2617 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2619 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2620 do_cleanups (old_chain);
2623 /* tfind range command */
2625 trace_find_range_command (char *args, int from_tty)
2627 static CORE_ADDR start, stop;
2630 check_trace_running (current_trace_status ());
2632 if (args == 0 || *args == 0)
2633 { /* XXX FIXME: what should default behavior be? */
2634 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2638 if (0 != (tmp = strchr (args, ',')))
2640 *tmp++ = '\0'; /* Terminate start address. */
2641 tmp = skip_spaces (tmp);
2642 start = parse_and_eval_address (args);
2643 stop = parse_and_eval_address (tmp);
2646 { /* No explicit end address? */
2647 start = parse_and_eval_address (args);
2648 stop = start + 1; /* ??? */
2651 tfind_1 (tfind_range, 0, start, stop, from_tty);
2654 /* tfind outside command */
2656 trace_find_outside_command (char *args, int from_tty)
2658 CORE_ADDR start, stop;
2661 if (current_trace_status ()->running
2662 && current_trace_status ()->filename == NULL)
2663 error (_("May not look at trace frames while trace is running."));
2665 if (args == 0 || *args == 0)
2666 { /* XXX FIXME: what should default behavior be? */
2667 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2671 if (0 != (tmp = strchr (args, ',')))
2673 *tmp++ = '\0'; /* Terminate start address. */
2674 tmp = skip_spaces (tmp);
2675 start = parse_and_eval_address (args);
2676 stop = parse_and_eval_address (tmp);
2679 { /* No explicit end address? */
2680 start = parse_and_eval_address (args);
2681 stop = start + 1; /* ??? */
2684 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2687 /* info scope command: list the locals for a scope. */
2689 scope_info (char *args, int from_tty)
2691 struct symtabs_and_lines sals;
2693 struct bound_minimal_symbol msym;
2694 const struct block *block;
2695 const char *symname;
2696 char *save_args = args;
2697 struct block_iterator iter;
2699 struct gdbarch *gdbarch;
2701 struct event_location *location;
2702 struct cleanup *back_to;
2704 if (args == 0 || *args == 0)
2705 error (_("requires an argument (function, "
2706 "line or *addr) to define a scope"));
2708 location = string_to_event_location (&args, current_language);
2709 back_to = make_cleanup_delete_event_location (location);
2710 sals = decode_line_1 (location, DECODE_LINE_FUNFIRSTLINE, NULL, NULL, 0);
2711 if (sals.nelts == 0)
2713 /* Presumably decode_line_1 has already warned. */
2714 do_cleanups (back_to);
2718 /* Resolve line numbers to PC. */
2719 resolve_sal_pc (&sals.sals[0]);
2720 block = block_for_pc (sals.sals[0].pc);
2724 QUIT; /* Allow user to bail out with ^C. */
2725 ALL_BLOCK_SYMBOLS (block, iter, sym)
2727 QUIT; /* Allow user to bail out with ^C. */
2729 printf_filtered ("Scope for %s:\n", save_args);
2732 symname = SYMBOL_PRINT_NAME (sym);
2733 if (symname == NULL || *symname == '\0')
2734 continue; /* Probably botched, certainly useless. */
2736 gdbarch = symbol_arch (sym);
2738 printf_filtered ("Symbol %s is ", symname);
2740 if (SYMBOL_COMPUTED_OPS (sym) != NULL)
2741 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2742 BLOCK_START (block),
2746 switch (SYMBOL_CLASS (sym))
2749 case LOC_UNDEF: /* Messed up symbol? */
2750 printf_filtered ("a bogus symbol, class %d.\n",
2751 SYMBOL_CLASS (sym));
2752 count--; /* Don't count this one. */
2755 printf_filtered ("a constant with value %s (%s)",
2756 plongest (SYMBOL_VALUE (sym)),
2757 hex_string (SYMBOL_VALUE (sym)));
2759 case LOC_CONST_BYTES:
2760 printf_filtered ("constant bytes: ");
2761 if (SYMBOL_TYPE (sym))
2762 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2763 fprintf_filtered (gdb_stdout, " %02x",
2764 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2767 printf_filtered ("in static storage at address ");
2768 printf_filtered ("%s", paddress (gdbarch,
2769 SYMBOL_VALUE_ADDRESS (sym)));
2772 /* GDBARCH is the architecture associated with the objfile
2773 the symbol is defined in; the target architecture may be
2774 different, and may provide additional registers. However,
2775 we do not know the target architecture at this point.
2776 We assume the objfile architecture will contain all the
2777 standard registers that occur in debug info in that
2779 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2782 if (SYMBOL_IS_ARGUMENT (sym))
2783 printf_filtered ("an argument in register $%s",
2784 gdbarch_register_name (gdbarch, regno));
2786 printf_filtered ("a local variable in register $%s",
2787 gdbarch_register_name (gdbarch, regno));
2790 printf_filtered ("an argument at stack/frame offset %s",
2791 plongest (SYMBOL_VALUE (sym)));
2794 printf_filtered ("a local variable at frame offset %s",
2795 plongest (SYMBOL_VALUE (sym)));
2798 printf_filtered ("a reference argument at offset %s",
2799 plongest (SYMBOL_VALUE (sym)));
2801 case LOC_REGPARM_ADDR:
2802 /* Note comment at LOC_REGISTER. */
2803 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2805 printf_filtered ("the address of an argument, in register $%s",
2806 gdbarch_register_name (gdbarch, regno));
2809 printf_filtered ("a typedef.\n");
2812 printf_filtered ("a label at address ");
2813 printf_filtered ("%s", paddress (gdbarch,
2814 SYMBOL_VALUE_ADDRESS (sym)));
2817 printf_filtered ("a function at address ");
2818 printf_filtered ("%s",
2819 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2821 case LOC_UNRESOLVED:
2822 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2824 if (msym.minsym == NULL)
2825 printf_filtered ("Unresolved Static");
2828 printf_filtered ("static storage at address ");
2829 printf_filtered ("%s",
2831 BMSYMBOL_VALUE_ADDRESS (msym)));
2834 case LOC_OPTIMIZED_OUT:
2835 printf_filtered ("optimized out.\n");
2838 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2841 if (SYMBOL_TYPE (sym))
2842 printf_filtered (", length %d.\n",
2843 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2845 if (BLOCK_FUNCTION (block))
2848 block = BLOCK_SUPERBLOCK (block);
2851 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2853 do_cleanups (back_to);
2856 /* Helper for trace_dump_command. Dump the action list starting at
2857 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2858 actions of the body of a while-stepping action. STEPPING_FRAME is
2859 set if the current traceframe was determined to be a while-stepping
2863 trace_dump_actions (struct command_line *action,
2864 int stepping_actions, int stepping_frame,
2867 const char *action_exp, *next_comma;
2869 for (; action != NULL; action = action->next)
2871 struct cmd_list_element *cmd;
2873 QUIT; /* Allow user to bail out with ^C. */
2874 action_exp = action->line;
2875 action_exp = skip_spaces_const (action_exp);
2877 /* The collection actions to be done while stepping are
2878 bracketed by the commands "while-stepping" and "end". */
2880 if (*action_exp == '#') /* comment line */
2883 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2885 error (_("Bad action list item: %s"), action_exp);
2887 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2891 for (i = 0; i < action->body_count; ++i)
2892 trace_dump_actions (action->body_list[i],
2893 1, stepping_frame, from_tty);
2895 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2897 /* Display the collected data.
2898 For the trap frame, display only what was collected at
2899 the trap. Likewise for stepping frames, display only
2900 what was collected while stepping. This means that the
2901 two boolean variables, STEPPING_FRAME and
2902 STEPPING_ACTIONS should be equal. */
2903 if (stepping_frame == stepping_actions)
2906 struct cleanup *old_chain
2907 = make_cleanup (free_current_contents, &cmd);
2908 int trace_string = 0;
2910 if (*action_exp == '/')
2911 action_exp = decode_agent_options (action_exp, &trace_string);
2914 { /* Repeat over a comma-separated list. */
2915 QUIT; /* Allow user to bail out with ^C. */
2916 if (*action_exp == ',')
2918 action_exp = skip_spaces_const (action_exp);
2920 next_comma = strchr (action_exp, ',');
2922 if (0 == strncasecmp (action_exp, "$reg", 4))
2923 registers_info (NULL, from_tty);
2924 else if (0 == strncasecmp (action_exp, "$_ret", 5))
2926 else if (0 == strncasecmp (action_exp, "$loc", 4))
2927 locals_info (NULL, from_tty);
2928 else if (0 == strncasecmp (action_exp, "$arg", 4))
2929 args_info (NULL, from_tty);
2932 if (next_comma != NULL)
2934 size_t len = next_comma - action_exp;
2936 cmd = (char *) xrealloc (cmd, len + 1);
2937 memcpy (cmd, action_exp, len);
2942 size_t len = strlen (action_exp);
2944 cmd = (char *) xrealloc (cmd, len + 1);
2945 memcpy (cmd, action_exp, len + 1);
2948 printf_filtered ("%s = ", cmd);
2949 output_command_const (cmd, from_tty);
2950 printf_filtered ("\n");
2952 action_exp = next_comma;
2954 while (action_exp && *action_exp == ',');
2956 do_cleanups (old_chain);
2962 /* Return bp_location of the tracepoint associated with the current
2963 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2964 is a stepping traceframe. */
2966 struct bp_location *
2967 get_traceframe_location (int *stepping_frame_p)
2969 struct tracepoint *t;
2970 struct bp_location *tloc;
2971 struct regcache *regcache;
2973 if (tracepoint_number == -1)
2974 error (_("No current trace frame."));
2976 t = get_tracepoint (tracepoint_number);
2979 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2982 /* The current frame is a trap frame if the frame PC is equal to the
2983 tracepoint PC. If not, then the current frame was collected
2984 during single-stepping. */
2985 regcache = get_current_regcache ();
2987 /* If the traceframe's address matches any of the tracepoint's
2988 locations, assume it is a direct hit rather than a while-stepping
2989 frame. (FIXME this is not reliable, should record each frame's
2991 for (tloc = t->base.loc; tloc; tloc = tloc->next)
2992 if (tloc->address == regcache_read_pc (regcache))
2994 *stepping_frame_p = 0;
2998 /* If this is a stepping frame, we don't know which location
2999 triggered. The first is as good (or bad) a guess as any... */
3000 *stepping_frame_p = 1;
3004 /* Return all the actions, including default collect, of a tracepoint
3005 T. It constructs cleanups into the chain, and leaves the caller to
3006 handle them (call do_cleanups). */
3008 static struct command_line *
3009 all_tracepoint_actions_and_cleanup (struct breakpoint *t)
3011 struct command_line *actions;
3013 actions = breakpoint_commands (t);
3015 /* If there are default expressions to collect, make up a collect
3016 action and prepend to the action list to encode. Note that since
3017 validation is per-tracepoint (local var "xyz" might be valid for
3018 one tracepoint and not another, etc), we make up the action on
3019 the fly, and don't cache it. */
3020 if (*default_collect)
3022 struct command_line *default_collect_action;
3023 char *default_collect_line;
3025 default_collect_line = xstrprintf ("collect %s", default_collect);
3026 make_cleanup (xfree, default_collect_line);
3028 validate_actionline (default_collect_line, t);
3029 default_collect_action = XNEW (struct command_line);
3030 make_cleanup (xfree, default_collect_action);
3031 default_collect_action->next = actions;
3032 default_collect_action->line = default_collect_line;
3033 actions = default_collect_action;
3039 /* The tdump command. */
3042 trace_dump_command (char *args, int from_tty)
3044 int stepping_frame = 0;
3045 struct bp_location *loc;
3046 struct cleanup *old_chain;
3047 struct command_line *actions;
3049 /* This throws an error is not inspecting a trace frame. */
3050 loc = get_traceframe_location (&stepping_frame);
3052 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
3053 tracepoint_number, traceframe_number);
3055 /* This command only makes sense for the current frame, not the
3057 old_chain = make_cleanup_restore_current_thread ();
3058 select_frame (get_current_frame ());
3060 actions = all_tracepoint_actions_and_cleanup (loc->owner);
3062 trace_dump_actions (actions, 0, stepping_frame, from_tty);
3064 do_cleanups (old_chain);
3067 /* Encode a piece of a tracepoint's source-level definition in a form
3068 that is suitable for both protocol and saving in files. */
3069 /* This version does not do multiple encodes for long strings; it should
3070 return an offset to the next piece to encode. FIXME */
3073 encode_source_string (int tpnum, ULONGEST addr,
3074 char *srctype, const char *src, char *buf, int buf_size)
3076 if (80 + strlen (srctype) > buf_size)
3077 error (_("Buffer too small for source encoding"));
3078 sprintf (buf, "%x:%s:%s:%x:%x:",
3079 tpnum, phex_nz (addr, sizeof (addr)),
3080 srctype, 0, (int) strlen (src));
3081 if (strlen (buf) + strlen (src) * 2 >= buf_size)
3082 error (_("Source string too long for buffer"));
3083 bin2hex ((gdb_byte *) src, buf + strlen (buf), strlen (src));
3087 /* Tell the target what to do with an ongoing tracing run if GDB
3088 disconnects for some reason. */
3091 set_disconnected_tracing (char *args, int from_tty,
3092 struct cmd_list_element *c)
3094 target_set_disconnected_tracing (disconnected_tracing);
3098 set_circular_trace_buffer (char *args, int from_tty,
3099 struct cmd_list_element *c)
3101 target_set_circular_trace_buffer (circular_trace_buffer);
3105 set_trace_buffer_size (char *args, int from_tty,
3106 struct cmd_list_element *c)
3108 target_set_trace_buffer_size (trace_buffer_size);
3112 set_trace_user (char *args, int from_tty,
3113 struct cmd_list_element *c)
3117 ret = target_set_trace_notes (trace_user, NULL, NULL);
3120 warning (_("Target does not support trace notes, user ignored"));
3124 set_trace_notes (char *args, int from_tty,
3125 struct cmd_list_element *c)
3129 ret = target_set_trace_notes (NULL, trace_notes, NULL);
3132 warning (_("Target does not support trace notes, note ignored"));
3136 set_trace_stop_notes (char *args, int from_tty,
3137 struct cmd_list_element *c)
3141 ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
3144 warning (_("Target does not support trace notes, stop note ignored"));
3147 /* Convert the memory pointed to by mem into hex, placing result in buf.
3148 * Return a pointer to the last char put in buf (null)
3149 * "stolen" from sparc-stub.c
3152 static const char hexchars[] = "0123456789abcdef";
3155 mem2hex (gdb_byte *mem, char *buf, int count)
3163 *buf++ = hexchars[ch >> 4];
3164 *buf++ = hexchars[ch & 0xf];
3173 get_traceframe_number (void)
3175 return traceframe_number;
3179 get_tracepoint_number (void)
3181 return tracepoint_number;
3184 /* Make the traceframe NUM be the current trace frame. Does nothing
3185 if NUM is already current. */
3188 set_current_traceframe (int num)
3192 if (traceframe_number == num)
3194 /* Nothing to do. */
3198 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
3201 warning (_("could not change traceframe"));
3203 set_traceframe_num (newnum);
3205 /* Changing the traceframe changes our view of registers and of the
3207 registers_changed ();
3209 clear_traceframe_info ();
3212 /* A cleanup used when switching away and back from tfind mode. */
3214 struct current_traceframe_cleanup
3216 /* The traceframe we were inspecting. */
3217 int traceframe_number;
3221 do_restore_current_traceframe_cleanup (void *arg)
3223 struct current_traceframe_cleanup *old
3224 = (struct current_traceframe_cleanup *) arg;
3226 set_current_traceframe (old->traceframe_number);
3230 restore_current_traceframe_cleanup_dtor (void *arg)
3232 struct current_traceframe_cleanup *old
3233 = (struct current_traceframe_cleanup *) arg;
3239 make_cleanup_restore_current_traceframe (void)
3241 struct current_traceframe_cleanup *old =
3242 XNEW (struct current_traceframe_cleanup);
3244 old->traceframe_number = traceframe_number;
3246 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
3247 restore_current_traceframe_cleanup_dtor);
3250 /* Given a number and address, return an uploaded tracepoint with that
3251 number, creating if necessary. */
3253 struct uploaded_tp *
3254 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
3256 struct uploaded_tp *utp;
3258 for (utp = *utpp; utp; utp = utp->next)
3259 if (utp->number == num && utp->addr == addr)
3262 utp = XCNEW (struct uploaded_tp);
3265 utp->actions = NULL;
3266 utp->step_actions = NULL;
3267 utp->cmd_strings = NULL;
3275 free_uploaded_tps (struct uploaded_tp **utpp)
3277 struct uploaded_tp *next_one;
3281 next_one = (*utpp)->next;
3287 /* Given a number and address, return an uploaded tracepoint with that
3288 number, creating if necessary. */
3290 struct uploaded_tsv *
3291 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3293 struct uploaded_tsv *utsv;
3295 for (utsv = *utsvp; utsv; utsv = utsv->next)
3296 if (utsv->number == num)
3299 utsv = XCNEW (struct uploaded_tsv);
3301 utsv->next = *utsvp;
3308 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3310 struct uploaded_tsv *next_one;
3314 next_one = (*utsvp)->next;
3320 /* FIXME this function is heuristic and will miss the cases where the
3321 conditional is semantically identical but differs in whitespace,
3322 such as "x == 0" vs "x==0". */
3325 cond_string_is_same (char *str1, char *str2)
3327 if (str1 == NULL || str2 == NULL)
3328 return (str1 == str2);
3330 return (strcmp (str1, str2) == 0);
3333 /* Look for an existing tracepoint that seems similar enough to the
3334 uploaded one. Enablement isn't compared, because the user can
3335 toggle that freely, and may have done so in anticipation of the
3336 next trace run. Return the location of matched tracepoint. */
3338 static struct bp_location *
3339 find_matching_tracepoint_location (struct uploaded_tp *utp)
3341 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
3343 struct breakpoint *b;
3344 struct bp_location *loc;
3346 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
3348 struct tracepoint *t = (struct tracepoint *) b;
3350 if (b->type == utp->type
3351 && t->step_count == utp->step
3352 && t->pass_count == utp->pass
3353 && cond_string_is_same (t->base.cond_string, utp->cond_string)
3354 /* FIXME also test actions. */
3357 /* Scan the locations for an address match. */
3358 for (loc = b->loc; loc; loc = loc->next)
3360 if (loc->address == utp->addr)
3368 /* Given a list of tracepoints uploaded from a target, attempt to
3369 match them up with existing tracepoints, and create new ones if not
3373 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3375 struct uploaded_tp *utp;
3376 /* A set of tracepoints which are modified. */
3377 VEC(breakpoint_p) *modified_tp = NULL;
3379 struct breakpoint *b;
3381 /* Look for GDB tracepoints that match up with our uploaded versions. */
3382 for (utp = *uploaded_tps; utp; utp = utp->next)
3384 struct bp_location *loc;
3385 struct tracepoint *t;
3387 loc = find_matching_tracepoint_location (utp);
3392 /* Mark this location as already inserted. */
3394 t = (struct tracepoint *) loc->owner;
3395 printf_filtered (_("Assuming tracepoint %d is same "
3396 "as target's tracepoint %d at %s.\n"),
3397 loc->owner->number, utp->number,
3398 paddress (loc->gdbarch, utp->addr));
3400 /* The tracepoint LOC->owner was modified (the location LOC
3401 was marked as inserted in the target). Save it in
3402 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3403 observers will be notified later once for each tracepoint
3404 saved in MODIFIED_TP. */
3406 VEC_iterate (breakpoint_p, modified_tp, ix, b);
3408 if (b == loc->owner)
3414 VEC_safe_push (breakpoint_p, modified_tp, loc->owner);
3418 t = create_tracepoint_from_upload (utp);
3420 printf_filtered (_("Created tracepoint %d for "
3421 "target's tracepoint %d at %s.\n"),
3422 t->base.number, utp->number,
3423 paddress (get_current_arch (), utp->addr));
3425 printf_filtered (_("Failed to create tracepoint for target's "
3426 "tracepoint %d at %s, skipping it.\n"),
3428 paddress (get_current_arch (), utp->addr));
3430 /* Whether found or created, record the number used by the
3431 target, to help with mapping target tracepoints back to their
3432 counterparts here. */
3434 t->number_on_target = utp->number;
3437 /* Notify 'breakpoint-modified' observer that at least one of B's
3438 locations was changed. */
3439 for (ix = 0; VEC_iterate (breakpoint_p, modified_tp, ix, b); ix++)
3440 observer_notify_breakpoint_modified (b);
3442 VEC_free (breakpoint_p, modified_tp);
3443 free_uploaded_tps (uploaded_tps);
3446 /* Trace state variables don't have much to identify them beyond their
3447 name, so just use that to detect matches. */
3449 static struct trace_state_variable *
3450 find_matching_tsv (struct uploaded_tsv *utsv)
3455 return find_trace_state_variable (utsv->name);
3458 static struct trace_state_variable *
3459 create_tsv_from_upload (struct uploaded_tsv *utsv)
3461 const char *namebase;
3464 struct trace_state_variable *tsv;
3465 struct cleanup *old_chain;
3469 namebase = utsv->name;
3470 buf = xstrprintf ("%s", namebase);
3475 buf = xstrprintf ("%s_%d", namebase, try_num++);
3478 /* Fish for a name that is not in use. */
3479 /* (should check against all internal vars?) */
3480 while (find_trace_state_variable (buf))
3483 buf = xstrprintf ("%s_%d", namebase, try_num++);
3486 old_chain = make_cleanup (xfree, buf);
3488 /* We have an available name, create the variable. */
3489 tsv = create_trace_state_variable (buf);
3490 tsv->initial_value = utsv->initial_value;
3491 tsv->builtin = utsv->builtin;
3493 observer_notify_tsv_created (tsv);
3495 do_cleanups (old_chain);
3500 /* Given a list of uploaded trace state variables, try to match them
3501 up with existing variables, or create additional ones. */
3504 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
3507 struct uploaded_tsv *utsv;
3508 struct trace_state_variable *tsv;
3511 /* Most likely some numbers will have to be reassigned as part of
3512 the merge, so clear them all in anticipation. */
3513 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3516 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
3518 tsv = find_matching_tsv (utsv);
3522 printf_filtered (_("Assuming trace state variable $%s "
3523 "is same as target's variable %d.\n"),
3524 tsv->name, utsv->number);
3528 tsv = create_tsv_from_upload (utsv);
3530 printf_filtered (_("Created trace state variable "
3531 "$%s for target's variable %d.\n"),
3532 tsv->name, utsv->number);
3534 /* Give precedence to numberings that come from the target. */
3536 tsv->number = utsv->number;
3539 /* Renumber everything that didn't get a target-assigned number. */
3541 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3542 if (tsv->number > highest)
3543 highest = tsv->number;
3546 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3547 if (tsv->number == 0)
3548 tsv->number = highest++;
3550 free_uploaded_tsvs (uploaded_tsvs);
3553 /* Parse the part of trace status syntax that is shared between
3554 the remote protocol and the trace file reader. */
3557 parse_trace_status (char *line, struct trace_status *ts)
3559 char *p = line, *p1, *p2, *p3, *p_temp;
3563 ts->running_known = 1;
3564 ts->running = (*p++ == '1');
3565 ts->stop_reason = trace_stop_reason_unknown;
3566 xfree (ts->stop_desc);
3567 ts->stop_desc = NULL;
3568 ts->traceframe_count = -1;
3569 ts->traceframes_created = -1;
3570 ts->buffer_free = -1;
3571 ts->buffer_size = -1;
3572 ts->disconnected_tracing = 0;
3573 ts->circular_buffer = 0;
3574 xfree (ts->user_name);
3575 ts->user_name = NULL;
3578 ts->start_time = ts->stop_time = 0;
3582 p1 = strchr (p, ':');
3584 error (_("Malformed trace status, at %s\n\
3585 Status line: '%s'\n"), p, line);
3586 p3 = strchr (p, ';');
3588 p3 = p + strlen (p);
3589 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3591 p = unpack_varlen_hex (++p1, &val);
3592 ts->stop_reason = trace_buffer_full;
3594 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3596 p = unpack_varlen_hex (++p1, &val);
3597 ts->stop_reason = trace_never_run;
3599 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
3602 p = unpack_varlen_hex (++p1, &val);
3603 ts->stop_reason = tracepoint_passcount;
3604 ts->stopping_tracepoint = val;
3606 else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
3608 p2 = strchr (++p1, ':');
3616 ts->stop_desc = (char *) xmalloc (strlen (line));
3617 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
3618 ts->stop_desc[end] = '\0';
3621 ts->stop_desc = xstrdup ("");
3623 p = unpack_varlen_hex (++p2, &val);
3624 ts->stop_reason = tstop_command;
3626 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3628 p = unpack_varlen_hex (++p1, &val);
3629 ts->stop_reason = trace_disconnected;
3631 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3633 p2 = strchr (++p1, ':');
3636 ts->stop_desc = (char *) xmalloc ((p2 - p1) / 2 + 1);
3637 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
3638 ts->stop_desc[end] = '\0';
3641 ts->stop_desc = xstrdup ("");
3643 p = unpack_varlen_hex (++p2, &val);
3644 ts->stopping_tracepoint = val;
3645 ts->stop_reason = tracepoint_error;
3647 else if (strncmp (p, "tframes", p1 - p) == 0)
3649 p = unpack_varlen_hex (++p1, &val);
3650 ts->traceframe_count = val;
3652 else if (strncmp (p, "tcreated", p1 - p) == 0)
3654 p = unpack_varlen_hex (++p1, &val);
3655 ts->traceframes_created = val;
3657 else if (strncmp (p, "tfree", p1 - p) == 0)
3659 p = unpack_varlen_hex (++p1, &val);
3660 ts->buffer_free = val;
3662 else if (strncmp (p, "tsize", p1 - p) == 0)
3664 p = unpack_varlen_hex (++p1, &val);
3665 ts->buffer_size = val;
3667 else if (strncmp (p, "disconn", p1 - p) == 0)
3669 p = unpack_varlen_hex (++p1, &val);
3670 ts->disconnected_tracing = val;
3672 else if (strncmp (p, "circular", p1 - p) == 0)
3674 p = unpack_varlen_hex (++p1, &val);
3675 ts->circular_buffer = val;
3677 else if (strncmp (p, "starttime", p1 - p) == 0)
3679 p = unpack_varlen_hex (++p1, &val);
3680 ts->start_time = val;
3682 else if (strncmp (p, "stoptime", p1 - p) == 0)
3684 p = unpack_varlen_hex (++p1, &val);
3685 ts->stop_time = val;
3687 else if (strncmp (p, "username", p1 - p) == 0)
3690 ts->user_name = (char *) xmalloc (strlen (p) / 2);
3691 end = hex2bin (p1, (gdb_byte *) ts->user_name, (p3 - p1) / 2);
3692 ts->user_name[end] = '\0';
3695 else if (strncmp (p, "notes", p1 - p) == 0)
3698 ts->notes = (char *) xmalloc (strlen (p) / 2);
3699 end = hex2bin (p1, (gdb_byte *) ts->notes, (p3 - p1) / 2);
3700 ts->notes[end] = '\0';
3705 /* Silently skip unknown optional info. */
3706 p_temp = strchr (p1 + 1, ';');
3710 /* Must be at the end. */
3717 parse_tracepoint_status (char *p, struct breakpoint *bp,
3718 struct uploaded_tp *utp)
3721 struct tracepoint *tp = (struct tracepoint *) bp;
3723 p = unpack_varlen_hex (p, &uval);
3725 tp->base.hit_count += uval;
3727 utp->hit_count += uval;
3728 p = unpack_varlen_hex (p + 1, &uval);
3730 tp->traceframe_usage += uval;
3732 utp->traceframe_usage += uval;
3733 /* Ignore any extra, allowing for future extensions. */
3736 /* Given a line of text defining a part of a tracepoint, parse it into
3737 an "uploaded tracepoint". */
3740 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
3744 ULONGEST num, addr, step, pass, orig_size, xlen, start;
3747 char *cond, *srctype, *buf;
3748 struct uploaded_tp *utp = NULL;
3751 /* Both tracepoint and action definitions start with the same number
3752 and address sequence. */
3754 p = unpack_varlen_hex (p, &num);
3755 p++; /* skip a colon */
3756 p = unpack_varlen_hex (p, &addr);
3757 p++; /* skip a colon */
3760 enabled = (*p++ == 'E');
3761 p++; /* skip a colon */
3762 p = unpack_varlen_hex (p, &step);
3763 p++; /* skip a colon */
3764 p = unpack_varlen_hex (p, &pass);
3765 type = bp_tracepoint;
3767 /* Thumb through optional fields. */
3770 p++; /* skip a colon */
3773 type = bp_fast_tracepoint;
3775 p = unpack_varlen_hex (p, &orig_size);
3779 type = bp_static_tracepoint;
3785 p = unpack_varlen_hex (p, &xlen);
3786 p++; /* skip a comma */
3787 cond = (char *) xmalloc (2 * xlen + 1);
3788 strncpy (cond, p, 2 * xlen);
3789 cond[2 * xlen] = '\0';
3793 warning (_("Unrecognized char '%c' in tracepoint "
3794 "definition, skipping rest"), *p);
3796 utp = get_uploaded_tp (num, addr, utpp);
3798 utp->enabled = enabled;
3803 else if (piece == 'A')
3805 utp = get_uploaded_tp (num, addr, utpp);
3806 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
3808 else if (piece == 'S')
3810 utp = get_uploaded_tp (num, addr, utpp);
3811 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
3813 else if (piece == 'Z')
3815 /* Parse a chunk of source form definition. */
3816 utp = get_uploaded_tp (num, addr, utpp);
3818 p = strchr (p, ':');
3819 p++; /* skip a colon */
3820 p = unpack_varlen_hex (p, &start);
3821 p++; /* skip a colon */
3822 p = unpack_varlen_hex (p, &xlen);
3823 p++; /* skip a colon */
3825 buf = (char *) alloca (strlen (line));
3827 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3830 if (startswith (srctype, "at:"))
3831 utp->at_string = xstrdup (buf);
3832 else if (startswith (srctype, "cond:"))
3833 utp->cond_string = xstrdup (buf);
3834 else if (startswith (srctype, "cmd:"))
3835 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
3837 else if (piece == 'V')
3839 utp = get_uploaded_tp (num, addr, utpp);
3841 parse_tracepoint_status (p, NULL, utp);
3845 /* Don't error out, the target might be sending us optional
3846 info that we don't care about. */
3847 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
3851 /* Convert a textual description of a trace state variable into an
3855 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
3858 ULONGEST num, initval, builtin;
3860 struct uploaded_tsv *utsv = NULL;
3862 buf = (char *) alloca (strlen (line));
3865 p = unpack_varlen_hex (p, &num);
3866 p++; /* skip a colon */
3867 p = unpack_varlen_hex (p, &initval);
3868 p++; /* skip a colon */
3869 p = unpack_varlen_hex (p, &builtin);
3870 p++; /* skip a colon */
3871 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3874 utsv = get_uploaded_tsv (num, utsvp);
3875 utsv->initial_value = initval;
3876 utsv->builtin = builtin;
3877 utsv->name = xstrdup (buf);
3881 free_current_marker (void *arg)
3883 struct static_tracepoint_marker **marker_p
3884 = (struct static_tracepoint_marker **) 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 = (char *) 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 = (char *) 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)
3953 char wrap_indent[80];
3954 char extra_field_indent[80];
3955 struct ui_out *uiout = current_uiout;
3956 struct cleanup *bkpt_chain;
3957 VEC(breakpoint_p) *tracepoints;
3959 struct symtab_and_line sal;
3963 sal.pc = marker->address;
3965 tracepoints = static_tracepoints_here (marker->address);
3967 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
3969 /* A counter field to help readability. This is not a stable
3971 ui_out_field_int (uiout, "count", count);
3973 ui_out_field_string (uiout, "marker-id", marker->str_id);
3975 ui_out_field_fmt (uiout, "enabled", "%c",
3976 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
3977 ui_out_spaces (uiout, 2);
3979 strcpy (wrap_indent, " ");
3981 if (gdbarch_addr_bit (marker->gdbarch) <= 32)
3982 strcat (wrap_indent, " ");
3984 strcat (wrap_indent, " ");
3986 strcpy (extra_field_indent, " ");
3988 ui_out_field_core_addr (uiout, "addr", marker->gdbarch, marker->address);
3990 sal = find_pc_line (marker->address, 0);
3991 sym = find_pc_sect_function (marker->address, NULL);
3994 ui_out_text (uiout, "in ");
3995 ui_out_field_string (uiout, "func",
3996 SYMBOL_PRINT_NAME (sym));
3997 ui_out_wrap_hint (uiout, wrap_indent);
3998 ui_out_text (uiout, " at ");
4001 ui_out_field_skip (uiout, "func");
4003 if (sal.symtab != NULL)
4005 ui_out_field_string (uiout, "file",
4006 symtab_to_filename_for_display (sal.symtab));
4007 ui_out_text (uiout, ":");
4009 if (ui_out_is_mi_like_p (uiout))
4011 const char *fullname = symtab_to_fullname (sal.symtab);
4013 ui_out_field_string (uiout, "fullname", fullname);
4016 ui_out_field_skip (uiout, "fullname");
4018 ui_out_field_int (uiout, "line", sal.line);
4022 ui_out_field_skip (uiout, "fullname");
4023 ui_out_field_skip (uiout, "line");
4026 ui_out_text (uiout, "\n");
4027 ui_out_text (uiout, extra_field_indent);
4028 ui_out_text (uiout, _("Data: \""));
4029 ui_out_field_string (uiout, "extra-data", marker->extra);
4030 ui_out_text (uiout, "\"\n");
4032 if (!VEC_empty (breakpoint_p, tracepoints))
4034 struct cleanup *cleanup_chain;
4036 struct breakpoint *b;
4038 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
4041 ui_out_text (uiout, extra_field_indent);
4042 ui_out_text (uiout, _("Probed by static tracepoints: "));
4043 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
4046 ui_out_text (uiout, ", ");
4047 ui_out_text (uiout, "#");
4048 ui_out_field_int (uiout, "tracepoint-id", b->number);
4051 do_cleanups (cleanup_chain);
4053 if (ui_out_is_mi_like_p (uiout))
4054 ui_out_field_int (uiout, "number-of-tracepoints",
4055 VEC_length(breakpoint_p, tracepoints));
4057 ui_out_text (uiout, "\n");
4059 VEC_free (breakpoint_p, tracepoints);
4061 do_cleanups (bkpt_chain);
4065 info_static_tracepoint_markers_command (char *arg, int from_tty)
4067 VEC(static_tracepoint_marker_p) *markers;
4068 struct cleanup *old_chain;
4069 struct static_tracepoint_marker *marker;
4070 struct ui_out *uiout = current_uiout;
4073 /* We don't have to check target_can_use_agent and agent's capability on
4074 static tracepoint here, in order to be compatible with older GDBserver.
4075 We don't check USE_AGENT is true or not, because static tracepoints
4076 don't work without in-process agent, so we don't bother users to type
4077 `set agent on' when to use static tracepoint. */
4080 = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
4081 "StaticTracepointMarkersTable");
4083 ui_out_table_header (uiout, 7, ui_left, "counter", "Cnt");
4085 ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
4087 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
4088 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
4089 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
4091 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
4092 ui_out_table_header (uiout, 40, ui_noalign, "what", "What");
4094 ui_out_table_body (uiout);
4096 markers = target_static_tracepoint_markers_by_strid (NULL);
4097 make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
4100 VEC_iterate (static_tracepoint_marker_p,
4101 markers, i, marker);
4104 print_one_static_tracepoint_marker (i + 1, marker);
4105 release_static_tracepoint_marker (marker);
4108 do_cleanups (old_chain);
4111 /* The $_sdata convenience variable is a bit special. We don't know
4112 for sure type of the value until we actually have a chance to fetch
4113 the data --- the size of the object depends on what has been
4114 collected. We solve this by making $_sdata be an internalvar that
4115 creates a new value on access. */
4117 /* Return a new value with the correct type for the sdata object of
4118 the current trace frame. Return a void value if there's no object
4121 static struct value *
4122 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
4128 /* We need to read the whole object before we know its size. */
4129 size = target_read_alloc (¤t_target,
4130 TARGET_OBJECT_STATIC_TRACE_DATA,
4137 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
4139 v = allocate_value (type);
4140 memcpy (value_contents_raw (v), buf, size);
4145 return allocate_value (builtin_type (gdbarch)->builtin_void);
4148 #if !defined(HAVE_LIBEXPAT)
4150 struct traceframe_info *
4151 parse_traceframe_info (const char *tframe_info)
4153 static int have_warned;
4158 warning (_("Can not parse XML trace frame info; XML support "
4159 "was disabled at compile time"));
4165 #else /* HAVE_LIBEXPAT */
4167 #include "xml-support.h"
4169 /* Handle the start of a <memory> element. */
4172 traceframe_info_start_memory (struct gdb_xml_parser *parser,
4173 const struct gdb_xml_element *element,
4174 void *user_data, VEC(gdb_xml_value_s) *attributes)
4176 struct traceframe_info *info = (struct traceframe_info *) user_data;
4177 struct mem_range *r = VEC_safe_push (mem_range_s, info->memory, NULL);
4178 ULONGEST *start_p, *length_p;
4181 = (ULONGEST *) xml_find_attribute (attributes, "start")->value;
4183 = (ULONGEST *) xml_find_attribute (attributes, "length")->value;
4185 r->start = *start_p;
4186 r->length = *length_p;
4189 /* Handle the start of a <tvar> element. */
4192 traceframe_info_start_tvar (struct gdb_xml_parser *parser,
4193 const struct gdb_xml_element *element,
4195 VEC(gdb_xml_value_s) *attributes)
4197 struct traceframe_info *info = (struct traceframe_info *) user_data;
4198 const char *id_attrib
4199 = (const char *) xml_find_attribute (attributes, "id")->value;
4200 int id = gdb_xml_parse_ulongest (parser, id_attrib);
4202 VEC_safe_push (int, info->tvars, id);
4205 /* Discard the constructed trace frame info (if an error occurs). */
4208 free_result (void *p)
4210 struct traceframe_info *result = (struct traceframe_info *) p;
4212 free_traceframe_info (result);
4215 /* The allowed elements and attributes for an XML memory map. */
4217 static const struct gdb_xml_attribute memory_attributes[] = {
4218 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4219 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4220 { NULL, GDB_XML_AF_NONE, NULL, NULL }
4223 static const struct gdb_xml_attribute tvar_attributes[] = {
4224 { "id", GDB_XML_AF_NONE, NULL, NULL },
4225 { NULL, GDB_XML_AF_NONE, NULL, NULL }
4228 static const struct gdb_xml_element traceframe_info_children[] = {
4229 { "memory", memory_attributes, NULL,
4230 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
4231 traceframe_info_start_memory, NULL },
4232 { "tvar", tvar_attributes, NULL,
4233 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
4234 traceframe_info_start_tvar, NULL },
4235 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4238 static const struct gdb_xml_element traceframe_info_elements[] = {
4239 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
4241 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4244 /* Parse a traceframe-info XML document. */
4246 struct traceframe_info *
4247 parse_traceframe_info (const char *tframe_info)
4249 struct traceframe_info *result;
4250 struct cleanup *back_to;
4252 result = XCNEW (struct traceframe_info);
4253 back_to = make_cleanup (free_result, result);
4255 if (gdb_xml_parse_quick (_("trace frame info"),
4256 "traceframe-info.dtd", traceframe_info_elements,
4257 tframe_info, result) == 0)
4259 /* Parsed successfully, keep the result. */
4260 discard_cleanups (back_to);
4265 do_cleanups (back_to);
4269 #endif /* HAVE_LIBEXPAT */
4271 /* Returns the traceframe_info object for the current traceframe.
4272 This is where we avoid re-fetching the object from the target if we
4273 already have it cached. */
4275 struct traceframe_info *
4276 get_traceframe_info (void)
4278 if (traceframe_info == NULL)
4279 traceframe_info = target_traceframe_info ();
4281 return traceframe_info;
4284 /* If the target supports the query, return in RESULT the set of
4285 collected memory in the current traceframe, found within the LEN
4286 bytes range starting at MEMADDR. Returns true if the target
4287 supports the query, otherwise returns false, and RESULT is left
4291 traceframe_available_memory (VEC(mem_range_s) **result,
4292 CORE_ADDR memaddr, ULONGEST len)
4294 struct traceframe_info *info = get_traceframe_info ();
4298 struct mem_range *r;
4303 for (i = 0; VEC_iterate (mem_range_s, info->memory, i, r); i++)
4304 if (mem_ranges_overlap (r->start, r->length, memaddr, len))
4306 ULONGEST lo1, hi1, lo2, hi2;
4307 struct mem_range *nr;
4310 hi1 = memaddr + len;
4313 hi2 = r->start + r->length;
4315 nr = VEC_safe_push (mem_range_s, *result, NULL);
4317 nr->start = std::max (lo1, lo2);
4318 nr->length = std::min (hi1, hi2) - nr->start;
4321 normalize_mem_ranges (*result);
4328 /* Implementation of `sdata' variable. */
4330 static const struct internalvar_funcs sdata_funcs =
4337 /* module initialization */
4339 _initialize_tracepoint (void)
4341 struct cmd_list_element *c;
4343 /* Explicitly create without lookup, since that tries to create a
4344 value with a void typed value, and when we get here, gdbarch
4345 isn't initialized yet. At this point, we're quite sure there
4346 isn't another convenience variable of the same name. */
4347 create_internalvar_type_lazy ("_sdata", &sdata_funcs, NULL);
4349 traceframe_number = -1;
4350 tracepoint_number = -1;
4352 add_info ("scope", scope_info,
4353 _("List the variables local to a scope"));
4355 add_cmd ("tracepoints", class_trace, NULL,
4356 _("Tracing of program execution without stopping the program."),
4359 add_com ("tdump", class_trace, trace_dump_command,
4360 _("Print everything collected at the current tracepoint."));
4362 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
4363 Define a trace state variable.\n\
4364 Argument is a $-prefixed name, optionally followed\n\
4365 by '=' and an expression that sets the initial value\n\
4366 at the start of tracing."));
4367 set_cmd_completer (c, expression_completer);
4369 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
4370 Delete one or more trace state variables.\n\
4371 Arguments are the names of the variables to delete.\n\
4372 If no arguments are supplied, delete all variables."), &deletelist);
4373 /* FIXME add a trace variable completer. */
4375 add_info ("tvariables", tvariables_info, _("\
4376 Status of trace state variables and their values.\n\
4379 add_info ("static-tracepoint-markers",
4380 info_static_tracepoint_markers_command, _("\
4381 List target static tracepoints markers.\n\
4384 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
4385 Select a trace frame;\n\
4386 No argument means forward by one frame; '-' means backward by one frame."),
4387 &tfindlist, "tfind ", 1, &cmdlist);
4389 add_cmd ("outside", class_trace, trace_find_outside_command, _("\
4390 Select a trace frame whose PC is outside the given range (exclusive).\n\
4391 Usage: tfind outside addr1, addr2"),
4394 add_cmd ("range", class_trace, trace_find_range_command, _("\
4395 Select a trace frame whose PC is in the given range (inclusive).\n\
4396 Usage: tfind range addr1,addr2"),
4399 add_cmd ("line", class_trace, trace_find_line_command, _("\
4400 Select a trace frame by source line.\n\
4401 Argument can be a line number (with optional source file),\n\
4402 a function name, or '*' followed by an address.\n\
4403 Default argument is 'the next source line that was traced'."),
4406 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
4407 Select a trace frame by tracepoint number.\n\
4408 Default is the tracepoint for the current trace frame."),
4411 add_cmd ("pc", class_trace, trace_find_pc_command, _("\
4412 Select a trace frame by PC.\n\
4413 Default is the current PC, or the PC of the current trace frame."),
4416 add_cmd ("end", class_trace, trace_find_end_command, _("\
4417 De-select any trace frame and resume 'live' debugging."),
4420 add_alias_cmd ("none", "end", class_trace, 0, &tfindlist);
4422 add_cmd ("start", class_trace, trace_find_start_command,
4423 _("Select the first trace frame in the trace buffer."),
4426 add_com ("tstatus", class_trace, trace_status_command,
4427 _("Display the status of the current trace data collection."));
4429 add_com ("tstop", class_trace, trace_stop_command, _("\
4430 Stop trace data collection.\n\
4431 Usage: tstop [ <notes> ... ]\n\
4432 Any arguments supplied are recorded with the trace as a stop reason and\n\
4433 reported by tstatus (if the target supports trace notes)."));
4435 add_com ("tstart", class_trace, trace_start_command, _("\
4436 Start trace data collection.\n\
4437 Usage: tstart [ <notes> ... ]\n\
4438 Any arguments supplied are recorded with the trace as a note and\n\
4439 reported by tstatus (if the target supports trace notes)."));
4441 add_com ("end", class_trace, end_actions_pseudocommand, _("\
4442 Ends a list of commands or actions.\n\
4443 Several GDB commands allow you to enter a list of commands or actions.\n\
4444 Entering \"end\" on a line by itself is the normal way to terminate\n\
4446 Note: the \"end\" command cannot be used at the gdb prompt."));
4448 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
4449 Specify single-stepping behavior at a tracepoint.\n\
4450 Argument is number of instructions to trace in single-step mode\n\
4451 following the tracepoint. This command is normally followed by\n\
4452 one or more \"collect\" commands, to specify what to collect\n\
4453 while single-stepping.\n\n\
4454 Note: this command can only be used in a tracepoint \"actions\" list."));
4456 add_com_alias ("ws", "while-stepping", class_alias, 0);
4457 add_com_alias ("stepping", "while-stepping", class_alias, 0);
4459 add_com ("collect", class_trace, collect_pseudocommand, _("\
4460 Specify one or more data items to be collected at a tracepoint.\n\
4461 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4462 collect all data (variables, registers) referenced by that expression.\n\
4463 Also accepts the following special arguments:\n\
4464 $regs -- all registers.\n\
4465 $args -- all function arguments.\n\
4466 $locals -- all variables local to the block/function scope.\n\
4467 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4468 Note: this command can only be used in a tracepoint \"actions\" list."));
4470 add_com ("teval", class_trace, teval_pseudocommand, _("\
4471 Specify one or more expressions to be evaluated at a tracepoint.\n\
4472 Accepts a comma-separated list of (one or more) expressions.\n\
4473 The result of each evaluation will be discarded.\n\
4474 Note: this command can only be used in a tracepoint \"actions\" list."));
4476 add_com ("actions", class_trace, trace_actions_command, _("\
4477 Specify the actions to be taken at a tracepoint.\n\
4478 Tracepoint actions may include collecting of specified data,\n\
4479 single-stepping, or enabling/disabling other tracepoints,\n\
4480 depending on target's capabilities."));
4482 default_collect = xstrdup ("");
4483 add_setshow_string_cmd ("default-collect", class_trace,
4484 &default_collect, _("\
4485 Set the list of expressions to collect by default"), _("\
4486 Show the list of expressions to collect by default"), NULL,
4488 &setlist, &showlist);
4490 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
4491 &disconnected_tracing, _("\
4492 Set whether tracing continues after GDB disconnects."), _("\
4493 Show whether tracing continues after GDB disconnects."), _("\
4494 Use this to continue a tracing run even if GDB disconnects\n\
4495 or detaches from the target. You can reconnect later and look at\n\
4496 trace data collected in the meantime."),
4497 set_disconnected_tracing,
4502 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
4503 &circular_trace_buffer, _("\
4504 Set target's use of circular trace buffer."), _("\
4505 Show target's use of circular trace buffer."), _("\
4506 Use this to make the trace buffer into a circular buffer,\n\
4507 which will discard traceframes (oldest first) instead of filling\n\
4508 up and stopping the trace run."),
4509 set_circular_trace_buffer,
4514 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class,
4515 &trace_buffer_size, _("\
4516 Set requested size of trace buffer."), _("\
4517 Show requested size of trace buffer."), _("\
4518 Use this to choose a size for the trace buffer. Some targets\n\
4519 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
4520 disables any attempt to set the buffer size and lets the target choose."),
4521 set_trace_buffer_size, NULL,
4522 &setlist, &showlist);
4524 add_setshow_string_cmd ("trace-user", class_trace,
4526 Set the user name to use for current and future trace runs"), _("\
4527 Show the user name to use for current and future trace runs"), NULL,
4528 set_trace_user, NULL,
4529 &setlist, &showlist);
4531 add_setshow_string_cmd ("trace-notes", class_trace,
4533 Set notes string to use for current and future trace runs"), _("\
4534 Show the notes string to use for current and future trace runs"), NULL,
4535 set_trace_notes, NULL,
4536 &setlist, &showlist);
4538 add_setshow_string_cmd ("trace-stop-notes", class_trace,
4539 &trace_stop_notes, _("\
4540 Set notes string to use for future tstop commands"), _("\
4541 Show the notes string to use for future tstop commands"), NULL,
4542 set_trace_stop_notes, NULL,
4543 &setlist, &showlist);