1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2015 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"
60 /* readline include files */
61 #include "readline/readline.h"
62 #include "readline/history.h"
64 /* readline defines this. */
69 /* Maximum length of an agent aexpression.
70 This accounts for the fact that packets are limited to 400 bytes
71 (which includes everything -- including the checksum), and assumes
72 the worst case of maximum length for each of the pieces of a
75 NOTE: expressions get mem2hex'ed otherwise this would be twice as
76 large. (400 - 31)/2 == 184 */
77 #define MAX_AGENT_EXPR_LEN 184
79 /* A hook used to notify the UI of tracepoint operations. */
81 void (*deprecated_trace_find_hook) (char *arg, int from_tty);
82 void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
87 This module defines the following debugger commands:
88 trace : set a tracepoint on a function, line, or address.
89 info trace : list all debugger-defined tracepoints.
90 delete trace : delete one or more tracepoints.
91 enable trace : enable one or more tracepoints.
92 disable trace : disable one or more tracepoints.
93 actions : specify actions to be taken at a tracepoint.
94 passcount : specify a pass count for a tracepoint.
95 tstart : start a trace experiment.
96 tstop : stop a trace experiment.
97 tstatus : query the status of a trace experiment.
98 tfind : find a trace frame in the trace buffer.
99 tdump : print everything collected at the current tracepoint.
100 save-tracepoints : write tracepoint setup into a file.
102 This module defines the following user-visible debugger variables:
103 $trace_frame : sequence number of trace frame currently being debugged.
104 $trace_line : source line of trace frame currently being debugged.
105 $trace_file : source file of trace frame currently being debugged.
106 $tracepoint : tracepoint number of trace frame currently being debugged.
110 /* ======= Important global variables: ======= */
112 /* The list of all trace state variables. We don't retain pointers to
113 any of these for any reason - API is by name or number only - so it
114 works to have a vector of objects. */
116 typedef struct trace_state_variable tsv_s;
119 static VEC(tsv_s) *tvariables;
121 /* The next integer to assign to a variable. */
123 static int next_tsv_number = 1;
125 /* Number of last traceframe collected. */
126 static int traceframe_number;
128 /* Tracepoint for last traceframe collected. */
129 static int tracepoint_number;
131 /* The traceframe info of the current traceframe. NULL if we haven't
132 yet attempted to fetch it, or if the target does not support
133 fetching this object, or if we're not inspecting a traceframe
135 static struct traceframe_info *traceframe_info;
137 /* Tracing command lists. */
138 static struct cmd_list_element *tfindlist;
140 /* List of expressions to collect by default at each tracepoint hit. */
141 char *default_collect = "";
143 static int disconnected_tracing;
145 /* This variable controls whether we ask the target for a linear or
146 circular trace buffer. */
148 static int circular_trace_buffer;
150 /* This variable is the requested trace buffer size, or -1 to indicate
151 that we don't care and leave it up to the target to set a size. */
153 static int trace_buffer_size = -1;
155 /* Textual notes applying to the current and/or future trace runs. */
157 char *trace_user = NULL;
159 /* Textual notes applying to the current and/or future trace runs. */
161 char *trace_notes = NULL;
163 /* Textual notes applying to the stopping of a trace. */
165 char *trace_stop_notes = NULL;
167 /* ======= Important command functions: ======= */
168 static void trace_actions_command (char *, int);
169 static void trace_start_command (char *, int);
170 static void trace_stop_command (char *, int);
171 static void trace_status_command (char *, int);
172 static void trace_find_command (char *, int);
173 static void trace_find_pc_command (char *, int);
174 static void trace_find_tracepoint_command (char *, int);
175 static void trace_find_line_command (char *, int);
176 static void trace_find_range_command (char *, int);
177 static void trace_find_outside_command (char *, int);
178 static void trace_dump_command (char *, int);
180 /* support routines */
182 struct collection_list;
183 static void add_aexpr (struct collection_list *, struct agent_expr *);
184 static char *mem2hex (gdb_byte *, char *, int);
185 static void add_register (struct collection_list *collection,
188 static struct command_line *
189 all_tracepoint_actions_and_cleanup (struct breakpoint *t);
191 extern void _initialize_tracepoint (void);
193 static struct trace_status trace_status;
195 const char *stop_reason_names[] = {
205 struct trace_status *
206 current_trace_status (void)
208 return &trace_status;
214 free_traceframe_info (struct traceframe_info *info)
218 VEC_free (mem_range_s, info->memory);
219 VEC_free (int, info->tvars);
225 /* Free and clear the traceframe info cache of the current
229 clear_traceframe_info (void)
231 free_traceframe_info (traceframe_info);
232 traceframe_info = NULL;
235 /* Set traceframe number to NUM. */
237 set_traceframe_num (int num)
239 traceframe_number = num;
240 set_internalvar_integer (lookup_internalvar ("trace_frame"), num);
243 /* Set tracepoint number to NUM. */
245 set_tracepoint_num (int num)
247 tracepoint_number = num;
248 set_internalvar_integer (lookup_internalvar ("tracepoint"), num);
251 /* Set externally visible debug variables for querying/printing
252 the traceframe context (line, function, file). */
255 set_traceframe_context (struct frame_info *trace_frame)
258 struct symbol *traceframe_fun;
259 struct symtab_and_line traceframe_sal;
261 /* Save as globals for internal use. */
262 if (trace_frame != NULL
263 && get_frame_pc_if_available (trace_frame, &trace_pc))
265 traceframe_sal = find_pc_line (trace_pc, 0);
266 traceframe_fun = find_pc_function (trace_pc);
268 /* Save linenumber as "$trace_line", a debugger variable visible to
270 set_internalvar_integer (lookup_internalvar ("trace_line"),
271 traceframe_sal.line);
275 init_sal (&traceframe_sal);
276 traceframe_fun = NULL;
277 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
280 /* Save func name as "$trace_func", a debugger variable visible to
282 if (traceframe_fun == NULL
283 || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
284 clear_internalvar (lookup_internalvar ("trace_func"));
286 set_internalvar_string (lookup_internalvar ("trace_func"),
287 SYMBOL_LINKAGE_NAME (traceframe_fun));
289 /* Save file name as "$trace_file", a debugger variable visible to
291 if (traceframe_sal.symtab == NULL)
292 clear_internalvar (lookup_internalvar ("trace_file"));
294 set_internalvar_string (lookup_internalvar ("trace_file"),
295 symtab_to_filename_for_display (traceframe_sal.symtab));
298 /* Create a new trace state variable with the given name. */
300 struct trace_state_variable *
301 create_trace_state_variable (const char *name)
303 struct trace_state_variable tsv;
305 memset (&tsv, 0, sizeof (tsv));
306 tsv.name = xstrdup (name);
307 tsv.number = next_tsv_number++;
308 return VEC_safe_push (tsv_s, tvariables, &tsv);
311 /* Look for a trace state variable of the given name. */
313 struct trace_state_variable *
314 find_trace_state_variable (const char *name)
316 struct trace_state_variable *tsv;
319 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
320 if (strcmp (name, tsv->name) == 0)
326 /* Look for a trace state variable of the given number. Return NULL if
329 struct trace_state_variable *
330 find_trace_state_variable_by_number (int number)
332 struct trace_state_variable *tsv;
335 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
336 if (tsv->number == number)
343 delete_trace_state_variable (const char *name)
345 struct trace_state_variable *tsv;
348 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
349 if (strcmp (name, tsv->name) == 0)
351 observer_notify_tsv_deleted (tsv);
353 xfree ((void *)tsv->name);
354 VEC_unordered_remove (tsv_s, tvariables, ix);
359 warning (_("No trace variable named \"$%s\", not deleting"), name);
362 /* Throws an error if NAME is not valid syntax for a trace state
366 validate_trace_state_variable_name (const char *name)
371 error (_("Must supply a non-empty variable name"));
373 /* All digits in the name is reserved for value history
375 for (p = name; isdigit (*p); p++)
378 error (_("$%s is not a valid trace state variable name"), name);
380 for (p = name; isalnum (*p) || *p == '_'; p++)
383 error (_("$%s is not a valid trace state variable name"), name);
386 /* The 'tvariable' command collects a name and optional expression to
387 evaluate into an initial value. */
390 trace_variable_command (char *args, int from_tty)
392 struct cleanup *old_chain;
394 struct trace_state_variable *tsv;
398 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
400 /* Only allow two syntaxes; "$name" and "$name=value". */
401 p = skip_spaces (args);
404 error (_("Name of trace variable should start with '$'"));
407 while (isalnum (*p) || *p == '_')
409 name = savestring (name, p - name);
410 old_chain = make_cleanup (xfree, name);
413 if (*p != '=' && *p != '\0')
414 error (_("Syntax must be $NAME [ = EXPR ]"));
416 validate_trace_state_variable_name (name);
419 initval = value_as_long (parse_and_eval (++p));
421 /* If the variable already exists, just change its initial value. */
422 tsv = find_trace_state_variable (name);
425 if (tsv->initial_value != initval)
427 tsv->initial_value = initval;
428 observer_notify_tsv_modified (tsv);
430 printf_filtered (_("Trace state variable $%s "
431 "now has initial value %s.\n"),
432 tsv->name, plongest (tsv->initial_value));
433 do_cleanups (old_chain);
437 /* Create a new variable. */
438 tsv = create_trace_state_variable (name);
439 tsv->initial_value = initval;
441 observer_notify_tsv_created (tsv);
443 printf_filtered (_("Trace state variable $%s "
444 "created, with initial value %s.\n"),
445 tsv->name, plongest (tsv->initial_value));
447 do_cleanups (old_chain);
451 delete_trace_variable_command (char *args, int from_tty)
455 struct cleanup *back_to;
459 if (query (_("Delete all trace state variables? ")))
460 VEC_free (tsv_s, tvariables);
462 observer_notify_tsv_deleted (NULL);
466 argv = gdb_buildargv (args);
467 back_to = make_cleanup_freeargv (argv);
469 for (ix = 0; argv[ix] != NULL; ix++)
471 if (*argv[ix] == '$')
472 delete_trace_state_variable (argv[ix] + 1);
474 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv[ix]);
477 do_cleanups (back_to);
483 tvariables_info_1 (void)
485 struct trace_state_variable *tsv;
488 struct cleanup *back_to;
489 struct ui_out *uiout = current_uiout;
491 if (VEC_length (tsv_s, tvariables) == 0 && !ui_out_is_mi_like_p (uiout))
493 printf_filtered (_("No trace state variables.\n"));
497 /* Try to acquire values from the target. */
498 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix, ++count)
499 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
502 back_to = make_cleanup_ui_out_table_begin_end (uiout, 3,
503 count, "trace-variables");
504 ui_out_table_header (uiout, 15, ui_left, "name", "Name");
505 ui_out_table_header (uiout, 11, ui_left, "initial", "Initial");
506 ui_out_table_header (uiout, 11, ui_left, "current", "Current");
508 ui_out_table_body (uiout);
510 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
512 struct cleanup *back_to2;
516 back_to2 = make_cleanup_ui_out_tuple_begin_end (uiout, "variable");
518 name = concat ("$", tsv->name, (char *) NULL);
519 make_cleanup (xfree, name);
520 ui_out_field_string (uiout, "name", name);
521 ui_out_field_string (uiout, "initial", plongest (tsv->initial_value));
523 if (tsv->value_known)
524 c = plongest (tsv->value);
525 else if (ui_out_is_mi_like_p (uiout))
526 /* For MI, we prefer not to use magic string constants, but rather
527 omit the field completely. The difference between unknown and
528 undefined does not seem important enough to represent. */
530 else if (current_trace_status ()->running || traceframe_number >= 0)
531 /* The value is/was defined, but we don't have it. */
534 /* It is not meaningful to ask about the value. */
537 ui_out_field_string (uiout, "current", c);
538 ui_out_text (uiout, "\n");
540 do_cleanups (back_to2);
543 do_cleanups (back_to);
546 /* List all the trace state variables. */
549 tvariables_info (char *args, int from_tty)
551 tvariables_info_1 ();
554 /* Stash definitions of tsvs into the given file. */
557 save_trace_state_variables (struct ui_file *fp)
559 struct trace_state_variable *tsv;
562 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
564 fprintf_unfiltered (fp, "tvariable $%s", tsv->name);
565 if (tsv->initial_value)
566 fprintf_unfiltered (fp, " = %s", plongest (tsv->initial_value));
567 fprintf_unfiltered (fp, "\n");
571 /* ACTIONS functions: */
573 /* The three functions:
574 collect_pseudocommand,
575 while_stepping_pseudocommand, and
576 end_actions_pseudocommand
577 are placeholders for "commands" that are actually ONLY to be used
578 within a tracepoint action list. If the actual function is ever called,
579 it means that somebody issued the "command" at the top level,
580 which is always an error. */
583 end_actions_pseudocommand (char *args, int from_tty)
585 error (_("This command cannot be used at the top level."));
589 while_stepping_pseudocommand (char *args, int from_tty)
591 error (_("This command can only be used in a tracepoint actions list."));
595 collect_pseudocommand (char *args, int from_tty)
597 error (_("This command can only be used in a tracepoint actions list."));
601 teval_pseudocommand (char *args, int from_tty)
603 error (_("This command can only be used in a tracepoint actions list."));
606 /* Parse any collection options, such as /s for strings. */
609 decode_agent_options (const char *exp, int *trace_string)
611 struct value_print_options opts;
618 /* Call this to borrow the print elements default for collection
620 get_user_print_options (&opts);
625 if (target_supports_string_tracing ())
627 /* Allow an optional decimal number giving an explicit maximum
628 string length, defaulting it to the "print elements" value;
629 so "collect/s80 mystr" gets at most 80 bytes of string. */
630 *trace_string = opts.print_max;
632 if (*exp >= '0' && *exp <= '9')
633 *trace_string = atoi (exp);
634 while (*exp >= '0' && *exp <= '9')
638 error (_("Target does not support \"/s\" option for string tracing."));
641 error (_("Undefined collection format \"%c\"."), *exp);
643 exp = skip_spaces_const (exp);
648 /* Enter a list of actions for a tracepoint. */
650 trace_actions_command (char *args, int from_tty)
652 struct tracepoint *t;
653 struct command_line *l;
655 t = get_tracepoint_by_number (&args, NULL);
659 xstrprintf ("Enter actions for tracepoint %d, one per line.",
661 struct cleanup *cleanups = make_cleanup (xfree, tmpbuf);
663 l = read_command_lines (tmpbuf, from_tty, 1,
664 check_tracepoint_command, t);
665 do_cleanups (cleanups);
666 breakpoint_set_commands (&t->base, l);
668 /* else just return */
671 /* Report the results of checking the agent expression, as errors or
675 report_agent_reqs_errors (struct agent_expr *aexpr)
677 /* All of the "flaws" are serious bytecode generation issues that
678 should never occur. */
679 if (aexpr->flaw != agent_flaw_none)
680 internal_error (__FILE__, __LINE__, _("expression is malformed"));
682 /* If analysis shows a stack underflow, GDB must have done something
683 badly wrong in its bytecode generation. */
684 if (aexpr->min_height < 0)
685 internal_error (__FILE__, __LINE__,
686 _("expression has min height < 0"));
688 /* Issue this error if the stack is predicted to get too deep. The
689 limit is rather arbitrary; a better scheme might be for the
690 target to report how much stack it will have available. The
691 depth roughly corresponds to parenthesization, so a limit of 20
692 amounts to 20 levels of expression nesting, which is actually
693 a pretty big hairy expression. */
694 if (aexpr->max_height > 20)
695 error (_("Expression is too complicated."));
698 /* worker function */
700 validate_actionline (const char *line, struct breakpoint *b)
702 struct cmd_list_element *c;
703 struct expression *exp = NULL;
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 exp = parse_exp_1 (&p, loc->address,
758 block_for_pc (loc->address), 1);
759 old_chain = make_cleanup (free_current_contents, &exp);
761 if (exp->elts[0].opcode == OP_VAR_VALUE)
763 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
765 error (_("constant `%s' (value %s) "
766 "will not be collected."),
767 SYMBOL_PRINT_NAME (exp->elts[2].symbol),
768 plongest (SYMBOL_VALUE (exp->elts[2].symbol)));
770 else if (SYMBOL_CLASS (exp->elts[2].symbol)
771 == LOC_OPTIMIZED_OUT)
773 error (_("`%s' is optimized away "
774 "and cannot be collected."),
775 SYMBOL_PRINT_NAME (exp->elts[2].symbol));
779 /* We have something to collect, make sure that the expr to
780 bytecode translator can handle it and that it's not too
782 aexpr = gen_trace_for_expr (loc->address, exp, trace_string);
783 make_cleanup_free_agent_expr (aexpr);
785 if (aexpr->len > MAX_AGENT_EXPR_LEN)
786 error (_("Expression is too complicated."));
790 report_agent_reqs_errors (aexpr);
792 do_cleanups (old_chain);
795 while (p && *p++ == ',');
798 else if (cmd_cfunc_eq (c, teval_pseudocommand))
801 { /* Repeat over a comma-separated list. */
802 QUIT; /* Allow user to bail out with ^C. */
803 p = skip_spaces_const (p);
806 for (loc = t->base.loc; loc; loc = loc->next)
810 /* Only expressions are allowed for this action. */
811 exp = parse_exp_1 (&p, loc->address,
812 block_for_pc (loc->address), 1);
813 old_chain = make_cleanup (free_current_contents, &exp);
815 /* We have something to evaluate, make sure that the expr to
816 bytecode translator can handle it and that it's not too
818 aexpr = gen_eval_for_expr (loc->address, exp);
819 make_cleanup_free_agent_expr (aexpr);
821 if (aexpr->len > MAX_AGENT_EXPR_LEN)
822 error (_("Expression is too complicated."));
825 report_agent_reqs_errors (aexpr);
827 do_cleanups (old_chain);
830 while (p && *p++ == ',');
833 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
837 p = skip_spaces_const (p);
838 t->step_count = strtol (p, &endp, 0);
839 if (endp == p || t->step_count == 0)
840 error (_("while-stepping step count `%s' is malformed."), line);
844 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
848 error (_("`%s' is not a supported tracepoint action."), line);
852 memrange_absolute = -1
855 /* MEMRANGE functions: */
857 static int memrange_cmp (const void *, const void *);
859 /* Compare memranges for qsort. */
861 memrange_cmp (const void *va, const void *vb)
863 const struct memrange *a = va, *b = vb;
865 if (a->type < b->type)
867 if (a->type > b->type)
869 if (a->type == memrange_absolute)
871 if ((bfd_vma) a->start < (bfd_vma) b->start)
873 if ((bfd_vma) a->start > (bfd_vma) b->start)
878 if (a->start < b->start)
880 if (a->start > b->start)
886 /* Sort the memrange list using qsort, and merge adjacent memranges. */
888 memrange_sortmerge (struct collection_list *memranges)
892 qsort (memranges->list, memranges->next_memrange,
893 sizeof (struct memrange), memrange_cmp);
894 if (memranges->next_memrange > 0)
896 for (a = 0, b = 1; b < memranges->next_memrange; b++)
898 /* If memrange b overlaps or is adjacent to memrange a,
900 if (memranges->list[a].type == memranges->list[b].type
901 && memranges->list[b].start <= memranges->list[a].end)
903 if (memranges->list[b].end > memranges->list[a].end)
904 memranges->list[a].end = memranges->list[b].end;
905 continue; /* next b, same a */
909 memcpy (&memranges->list[a], &memranges->list[b],
910 sizeof (struct memrange));
912 memranges->next_memrange = a + 1;
916 /* Add a register to a collection list. */
918 add_register (struct collection_list *collection, unsigned int regno)
921 printf_filtered ("collect register %d\n", regno);
922 if (regno >= (8 * sizeof (collection->regs_mask)))
923 error (_("Internal: register number %d too large for tracepoint"),
925 collection->regs_mask[regno / 8] |= 1 << (regno % 8);
928 /* Add a memrange to a collection list. */
930 add_memrange (struct collection_list *memranges,
931 int type, bfd_signed_vma base,
936 printf_filtered ("(%d,", type);
938 printf_filtered (",%ld)\n", len);
941 /* type: memrange_absolute == memory, other n == basereg */
942 memranges->list[memranges->next_memrange].type = type;
943 /* base: addr if memory, offset if reg relative. */
944 memranges->list[memranges->next_memrange].start = base;
945 /* len: we actually save end (base + len) for convenience */
946 memranges->list[memranges->next_memrange].end = base + len;
947 memranges->next_memrange++;
948 if (memranges->next_memrange >= memranges->listsize)
950 memranges->listsize *= 2;
951 memranges->list = xrealloc (memranges->list,
952 memranges->listsize);
955 if (type != memrange_absolute) /* Better collect the base register! */
956 add_register (memranges, type);
959 /* Add a symbol to a collection list. */
961 collect_symbol (struct collection_list *collect,
963 struct gdbarch *gdbarch,
964 long frame_regno, long frame_offset,
970 bfd_signed_vma offset;
971 int treat_as_expr = 0;
973 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
974 switch (SYMBOL_CLASS (sym))
977 printf_filtered ("%s: don't know symbol class %d\n",
978 SYMBOL_PRINT_NAME (sym),
982 printf_filtered ("constant %s (value %s) will not be collected.\n",
983 SYMBOL_PRINT_NAME (sym), plongest (SYMBOL_VALUE (sym)));
986 offset = SYMBOL_VALUE_ADDRESS (sym);
991 sprintf_vma (tmp, offset);
992 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
993 SYMBOL_PRINT_NAME (sym), len,
996 /* A struct may be a C++ class with static fields, go to general
997 expression handling. */
998 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
1001 add_memrange (collect, memrange_absolute, offset, len);
1004 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
1006 printf_filtered ("LOC_REG[parm] %s: ",
1007 SYMBOL_PRINT_NAME (sym));
1008 add_register (collect, reg);
1009 /* Check for doubles stored in two registers. */
1010 /* FIXME: how about larger types stored in 3 or more regs? */
1011 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
1012 len > register_size (gdbarch, reg))
1013 add_register (collect, reg + 1);
1016 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1017 printf_filtered (" (will not collect %s)\n",
1018 SYMBOL_PRINT_NAME (sym));
1022 offset = frame_offset + SYMBOL_VALUE (sym);
1025 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1026 SYMBOL_PRINT_NAME (sym), len);
1027 printf_vma (offset);
1028 printf_filtered (" from frame ptr reg %d\n", reg);
1030 add_memrange (collect, reg, offset, len);
1032 case LOC_REGPARM_ADDR:
1033 reg = SYMBOL_VALUE (sym);
1037 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1038 SYMBOL_PRINT_NAME (sym), len);
1039 printf_vma (offset);
1040 printf_filtered (" from reg %d\n", reg);
1042 add_memrange (collect, reg, offset, len);
1046 offset = frame_offset + SYMBOL_VALUE (sym);
1049 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1050 SYMBOL_PRINT_NAME (sym), len);
1051 printf_vma (offset);
1052 printf_filtered (" from frame ptr reg %d\n", reg);
1054 add_memrange (collect, reg, offset, len);
1057 case LOC_UNRESOLVED:
1061 case LOC_OPTIMIZED_OUT:
1062 printf_filtered ("%s has been optimized out of existence.\n",
1063 SYMBOL_PRINT_NAME (sym));
1071 /* Expressions are the most general case. */
1074 struct agent_expr *aexpr;
1075 struct cleanup *old_chain1 = NULL;
1077 aexpr = gen_trace_for_var (scope, gdbarch, sym, trace_string);
1079 /* It can happen that the symbol is recorded as a computed
1080 location, but it's been optimized away and doesn't actually
1081 have a location expression. */
1084 printf_filtered ("%s has been optimized out of existence.\n",
1085 SYMBOL_PRINT_NAME (sym));
1089 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1093 report_agent_reqs_errors (aexpr);
1095 discard_cleanups (old_chain1);
1096 add_aexpr (collect, aexpr);
1098 /* Take care of the registers. */
1099 if (aexpr->reg_mask_len > 0)
1103 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1105 QUIT; /* Allow user to bail out with ^C. */
1106 if (aexpr->reg_mask[ndx1] != 0)
1108 /* Assume chars have 8 bits. */
1109 for (ndx2 = 0; ndx2 < 8; ndx2++)
1110 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1111 /* It's used -- record it. */
1112 add_register (collect, ndx1 * 8 + ndx2);
1119 /* Data to be passed around in the calls to the locals and args
1122 struct add_local_symbols_data
1124 struct collection_list *collect;
1125 struct gdbarch *gdbarch;
1133 /* The callback for the locals and args iterators. */
1136 do_collect_symbol (const char *print_name,
1140 struct add_local_symbols_data *p = cb_data;
1142 collect_symbol (p->collect, sym, p->gdbarch, p->frame_regno,
1143 p->frame_offset, p->pc, p->trace_string);
1146 VEC_safe_push (char_ptr, p->collect->wholly_collected,
1147 xstrdup (print_name));
1150 /* Add all locals (or args) symbols to collection list. */
1152 add_local_symbols (struct collection_list *collect,
1153 struct gdbarch *gdbarch, CORE_ADDR pc,
1154 long frame_regno, long frame_offset, int type,
1157 const struct block *block;
1158 struct add_local_symbols_data cb_data;
1160 cb_data.collect = collect;
1161 cb_data.gdbarch = gdbarch;
1163 cb_data.frame_regno = frame_regno;
1164 cb_data.frame_offset = frame_offset;
1166 cb_data.trace_string = trace_string;
1170 block = block_for_pc (pc);
1173 warning (_("Can't collect locals; "
1174 "no symbol table info available.\n"));
1178 iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1179 if (cb_data.count == 0)
1180 warning (_("No locals found in scope."));
1184 pc = get_pc_function_start (pc);
1185 block = block_for_pc (pc);
1188 warning (_("Can't collect args; no symbol table info available."));
1192 iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1193 if (cb_data.count == 0)
1194 warning (_("No args found in scope."));
1199 add_static_trace_data (struct collection_list *collection)
1202 printf_filtered ("collect static trace data\n");
1203 collection->strace_data = 1;
1206 /* worker function */
1208 clear_collection_list (struct collection_list *list)
1212 list->next_memrange = 0;
1213 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1215 free_agent_expr (list->aexpr_list[ndx]);
1216 list->aexpr_list[ndx] = NULL;
1218 list->next_aexpr_elt = 0;
1219 memset (list->regs_mask, 0, sizeof (list->regs_mask));
1220 list->strace_data = 0;
1222 xfree (list->aexpr_list);
1225 VEC_free (char_ptr, list->wholly_collected);
1226 VEC_free (char_ptr, list->computed);
1229 /* A cleanup wrapper for function clear_collection_list. */
1232 do_clear_collection_list (void *list)
1234 struct collection_list *l = list;
1236 clear_collection_list (l);
1239 /* Initialize collection_list CLIST. */
1242 init_collection_list (struct collection_list *clist)
1244 memset (clist, 0, sizeof *clist);
1246 clist->listsize = 128;
1247 clist->list = xcalloc (clist->listsize,
1248 sizeof (struct memrange));
1250 clist->aexpr_listsize = 128;
1251 clist->aexpr_list = xcalloc (clist->aexpr_listsize,
1252 sizeof (struct agent_expr *));
1255 /* Reduce a collection list to string form (for gdb protocol). */
1257 stringify_collection_list (struct collection_list *list)
1259 char temp_buf[2048];
1263 char *(*str_list)[];
1267 count = 1 + 1 + list->next_memrange + list->next_aexpr_elt + 1;
1268 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1270 if (list->strace_data)
1273 printf_filtered ("\nCollecting static trace data\n");
1276 (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
1280 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1281 if (list->regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */
1283 if (list->regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
1286 printf_filtered ("\nCollecting registers (mask): 0x");
1291 QUIT; /* Allow user to bail out with ^C. */
1293 printf_filtered ("%02X", list->regs_mask[i]);
1294 sprintf (end, "%02X", list->regs_mask[i]);
1297 (*str_list)[ndx] = xstrdup (temp_buf);
1301 printf_filtered ("\n");
1302 if (list->next_memrange > 0 && info_verbose)
1303 printf_filtered ("Collecting memranges: \n");
1304 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1306 QUIT; /* Allow user to bail out with ^C. */
1307 sprintf_vma (tmp2, list->list[i].start);
1310 printf_filtered ("(%d, %s, %ld)\n",
1313 (long) (list->list[i].end - list->list[i].start));
1315 if (count + 27 > MAX_AGENT_EXPR_LEN)
1317 (*str_list)[ndx] = savestring (temp_buf, count);
1324 bfd_signed_vma length = list->list[i].end - list->list[i].start;
1326 /* The "%X" conversion specifier expects an unsigned argument,
1327 so passing -1 (memrange_absolute) to it directly gives you
1328 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1330 if (list->list[i].type == memrange_absolute)
1331 sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
1333 sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
1336 count += strlen (end);
1337 end = temp_buf + count;
1340 for (i = 0; i < list->next_aexpr_elt; i++)
1342 QUIT; /* Allow user to bail out with ^C. */
1343 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1345 (*str_list)[ndx] = savestring (temp_buf, count);
1350 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1351 end += 10; /* 'X' + 8 hex digits + ',' */
1354 end = mem2hex (list->aexpr_list[i]->buf,
1355 end, list->aexpr_list[i]->len);
1356 count += 2 * list->aexpr_list[i]->len;
1361 (*str_list)[ndx] = savestring (temp_buf, count);
1366 (*str_list)[ndx] = NULL;
1377 /* Add the printed expression EXP to *LIST. */
1380 append_exp (struct expression *exp, VEC(char_ptr) **list)
1382 struct ui_file *tmp_stream = mem_fileopen ();
1385 print_expression (exp, tmp_stream);
1387 text = ui_file_xstrdup (tmp_stream, NULL);
1389 VEC_safe_push (char_ptr, *list, text);
1390 ui_file_delete (tmp_stream);
1394 encode_actions_1 (struct command_line *action,
1395 struct bp_location *tloc,
1397 LONGEST frame_offset,
1398 struct collection_list *collect,
1399 struct collection_list *stepping_list)
1401 const char *action_exp;
1402 struct expression *exp = NULL;
1404 struct value *tempval;
1405 struct cmd_list_element *cmd;
1406 struct agent_expr *aexpr;
1408 for (; action; action = action->next)
1410 QUIT; /* Allow user to bail out with ^C. */
1411 action_exp = action->line;
1412 action_exp = skip_spaces_const (action_exp);
1414 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1416 error (_("Bad action list item: %s"), action_exp);
1418 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1420 int trace_string = 0;
1422 if (*action_exp == '/')
1423 action_exp = decode_agent_options (action_exp, &trace_string);
1426 { /* Repeat over a comma-separated list. */
1427 QUIT; /* Allow user to bail out with ^C. */
1428 action_exp = skip_spaces_const (action_exp);
1430 if (0 == strncasecmp ("$reg", action_exp, 4))
1432 for (i = 0; i < gdbarch_num_regs (tloc->gdbarch); i++)
1433 add_register (collect, i);
1434 action_exp = strchr (action_exp, ','); /* more? */
1436 else if (0 == strncasecmp ("$arg", action_exp, 4))
1438 add_local_symbols (collect,
1445 action_exp = strchr (action_exp, ','); /* more? */
1447 else if (0 == strncasecmp ("$loc", action_exp, 4))
1449 add_local_symbols (collect,
1456 action_exp = strchr (action_exp, ','); /* more? */
1458 else if (0 == strncasecmp ("$_ret", action_exp, 5))
1460 struct cleanup *old_chain1 = NULL;
1462 aexpr = gen_trace_for_return_address (tloc->address,
1466 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1469 report_agent_reqs_errors (aexpr);
1471 discard_cleanups (old_chain1);
1472 add_aexpr (collect, aexpr);
1474 /* take care of the registers */
1475 if (aexpr->reg_mask_len > 0)
1479 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1481 QUIT; /* allow user to bail out with ^C */
1482 if (aexpr->reg_mask[ndx1] != 0)
1484 /* assume chars have 8 bits */
1485 for (ndx2 = 0; ndx2 < 8; ndx2++)
1486 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1487 /* it's used -- record it */
1488 add_register (collect,
1494 action_exp = strchr (action_exp, ','); /* more? */
1496 else if (0 == strncasecmp ("$_sdata", action_exp, 7))
1498 add_static_trace_data (collect);
1499 action_exp = strchr (action_exp, ','); /* more? */
1504 struct cleanup *old_chain = NULL;
1505 struct cleanup *old_chain1 = NULL;
1507 exp = parse_exp_1 (&action_exp, tloc->address,
1508 block_for_pc (tloc->address), 1);
1509 old_chain = make_cleanup (free_current_contents, &exp);
1511 switch (exp->elts[0].opcode)
1515 const char *name = &exp->elts[2].string;
1517 i = user_reg_map_name_to_regnum (tloc->gdbarch,
1518 name, strlen (name));
1520 internal_error (__FILE__, __LINE__,
1521 _("Register $%s not available"),
1524 printf_filtered ("OP_REGISTER: ");
1525 add_register (collect, i);
1530 /* Safe because we know it's a simple expression. */
1531 tempval = evaluate_expression (exp);
1532 addr = value_address (tempval);
1533 /* Initialize the TYPE_LENGTH if it is a typedef. */
1534 check_typedef (exp->elts[1].type);
1535 add_memrange (collect, memrange_absolute, addr,
1536 TYPE_LENGTH (exp->elts[1].type));
1537 append_exp (exp, &collect->computed);
1542 struct symbol *sym = exp->elts[2].symbol;
1543 char_ptr name = (char_ptr) SYMBOL_NATURAL_NAME (sym);
1545 collect_symbol (collect,
1546 exp->elts[2].symbol,
1552 VEC_safe_push (char_ptr,
1553 collect->wholly_collected,
1558 default: /* Full-fledged expression. */
1559 aexpr = gen_trace_for_expr (tloc->address, exp,
1562 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1566 report_agent_reqs_errors (aexpr);
1568 discard_cleanups (old_chain1);
1569 add_aexpr (collect, aexpr);
1571 /* Take care of the registers. */
1572 if (aexpr->reg_mask_len > 0)
1577 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1579 QUIT; /* Allow user to bail out with ^C. */
1580 if (aexpr->reg_mask[ndx1] != 0)
1582 /* Assume chars have 8 bits. */
1583 for (ndx2 = 0; ndx2 < 8; ndx2++)
1584 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1585 /* It's used -- record it. */
1586 add_register (collect,
1592 append_exp (exp, &collect->computed);
1595 do_cleanups (old_chain);
1598 while (action_exp && *action_exp++ == ',');
1600 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1603 { /* Repeat over a comma-separated list. */
1604 QUIT; /* Allow user to bail out with ^C. */
1605 action_exp = skip_spaces_const (action_exp);
1608 struct cleanup *old_chain = NULL;
1609 struct cleanup *old_chain1 = NULL;
1611 exp = parse_exp_1 (&action_exp, tloc->address,
1612 block_for_pc (tloc->address), 1);
1613 old_chain = make_cleanup (free_current_contents, &exp);
1615 aexpr = gen_eval_for_expr (tloc->address, exp);
1616 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1619 report_agent_reqs_errors (aexpr);
1621 discard_cleanups (old_chain1);
1622 /* Even though we're not officially collecting, add
1623 to the collect list anyway. */
1624 add_aexpr (collect, aexpr);
1626 do_cleanups (old_chain);
1629 while (action_exp && *action_exp++ == ',');
1631 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1633 /* We check against nested while-stepping when setting
1634 breakpoint action, so no way to run into nested
1636 gdb_assert (stepping_list);
1638 encode_actions_1 (action->body_list[0], tloc, frame_reg,
1639 frame_offset, stepping_list, NULL);
1642 error (_("Invalid tracepoint command '%s'"), action->line);
1646 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1647 and STEPPING_LIST. Return a cleanup pointer to clean up both
1648 TRACEPOINT_LIST and STEPPING_LIST. */
1651 encode_actions_and_make_cleanup (struct bp_location *tloc,
1652 struct collection_list *tracepoint_list,
1653 struct collection_list *stepping_list)
1655 char *default_collect_line = NULL;
1656 struct command_line *actions;
1657 struct command_line *default_collect_action = NULL;
1659 LONGEST frame_offset;
1660 struct cleanup *back_to, *return_chain;
1662 return_chain = make_cleanup (null_cleanup, NULL);
1663 init_collection_list (tracepoint_list);
1664 init_collection_list (stepping_list);
1666 make_cleanup (do_clear_collection_list, tracepoint_list);
1667 make_cleanup (do_clear_collection_list, stepping_list);
1669 back_to = make_cleanup (null_cleanup, NULL);
1670 gdbarch_virtual_frame_pointer (tloc->gdbarch,
1671 tloc->address, &frame_reg, &frame_offset);
1673 actions = all_tracepoint_actions_and_cleanup (tloc->owner);
1675 encode_actions_1 (actions, tloc, frame_reg, frame_offset,
1676 tracepoint_list, stepping_list);
1678 memrange_sortmerge (tracepoint_list);
1679 memrange_sortmerge (stepping_list);
1681 do_cleanups (back_to);
1682 return return_chain;
1685 /* Render all actions into gdb protocol. */
1688 encode_actions_rsp (struct bp_location *tloc, char ***tdp_actions,
1689 char ***stepping_actions)
1691 struct collection_list tracepoint_list, stepping_list;
1692 struct cleanup *cleanup;
1694 *tdp_actions = NULL;
1695 *stepping_actions = NULL;
1697 cleanup = encode_actions_and_make_cleanup (tloc, &tracepoint_list,
1700 *tdp_actions = stringify_collection_list (&tracepoint_list);
1701 *stepping_actions = stringify_collection_list (&stepping_list);
1703 do_cleanups (cleanup);
1707 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1709 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1711 collect->aexpr_list =
1712 xrealloc (collect->aexpr_list,
1713 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1714 collect->aexpr_listsize *= 2;
1716 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1717 collect->next_aexpr_elt++;
1721 process_tracepoint_on_disconnect (void)
1723 VEC(breakpoint_p) *tp_vec = NULL;
1725 struct breakpoint *b;
1726 int has_pending_p = 0;
1728 /* Check whether we still have pending tracepoint. If we have, warn the
1729 user that pending tracepoint will no longer work. */
1730 tp_vec = all_tracepoints ();
1731 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1740 struct bp_location *loc1;
1742 for (loc1 = b->loc; loc1; loc1 = loc1->next)
1744 if (loc1->shlib_disabled)
1755 VEC_free (breakpoint_p, tp_vec);
1758 warning (_("Pending tracepoints will not be resolved while"
1759 " GDB is disconnected\n"));
1762 /* Reset local state of tracing. */
1765 trace_reset_local_state (void)
1767 set_traceframe_num (-1);
1768 set_tracepoint_num (-1);
1769 set_traceframe_context (NULL);
1770 clear_traceframe_info ();
1774 start_tracing (char *notes)
1776 VEC(breakpoint_p) *tp_vec = NULL;
1778 struct breakpoint *b;
1779 struct trace_state_variable *tsv;
1780 int any_enabled = 0, num_to_download = 0;
1783 tp_vec = all_tracepoints ();
1785 /* No point in tracing without any tracepoints... */
1786 if (VEC_length (breakpoint_p, tp_vec) == 0)
1788 VEC_free (breakpoint_p, tp_vec);
1789 error (_("No tracepoints defined, not starting trace"));
1792 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1794 struct tracepoint *t = (struct tracepoint *) b;
1795 struct bp_location *loc;
1797 if (b->enable_state == bp_enabled)
1800 if ((b->type == bp_fast_tracepoint
1801 ? may_insert_fast_tracepoints
1802 : may_insert_tracepoints))
1805 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1806 (b->type == bp_fast_tracepoint ? "fast " : ""), b->number);
1811 if (target_supports_enable_disable_tracepoint ())
1812 warning (_("No tracepoints enabled"));
1815 /* No point in tracing with only disabled tracepoints that
1816 cannot be re-enabled. */
1817 VEC_free (breakpoint_p, tp_vec);
1818 error (_("No tracepoints enabled, not starting trace"));
1822 if (num_to_download <= 0)
1824 VEC_free (breakpoint_p, tp_vec);
1825 error (_("No tracepoints that may be downloaded, not starting trace"));
1828 target_trace_init ();
1830 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1832 struct tracepoint *t = (struct tracepoint *) b;
1833 struct bp_location *loc;
1834 int bp_location_downloaded = 0;
1836 /* Clear `inserted' flag. */
1837 for (loc = b->loc; loc; loc = loc->next)
1840 if ((b->type == bp_fast_tracepoint
1841 ? !may_insert_fast_tracepoints
1842 : !may_insert_tracepoints))
1845 t->number_on_target = 0;
1847 for (loc = b->loc; loc; loc = loc->next)
1849 /* Since tracepoint locations are never duplicated, `inserted'
1850 flag should be zero. */
1851 gdb_assert (!loc->inserted);
1853 target_download_tracepoint (loc);
1856 bp_location_downloaded = 1;
1859 t->number_on_target = b->number;
1861 for (loc = b->loc; loc; loc = loc->next)
1862 if (loc->probe.probe != NULL
1863 && loc->probe.probe->pops->set_semaphore != NULL)
1864 loc->probe.probe->pops->set_semaphore (loc->probe.probe,
1868 if (bp_location_downloaded)
1869 observer_notify_breakpoint_modified (b);
1871 VEC_free (breakpoint_p, tp_vec);
1873 /* Send down all the trace state variables too. */
1874 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1876 target_download_trace_state_variable (tsv);
1879 /* Tell target to treat text-like sections as transparent. */
1880 target_trace_set_readonly_regions ();
1881 /* Set some mode flags. */
1882 target_set_disconnected_tracing (disconnected_tracing);
1883 target_set_circular_trace_buffer (circular_trace_buffer);
1884 target_set_trace_buffer_size (trace_buffer_size);
1887 notes = trace_notes;
1888 ret = target_set_trace_notes (trace_user, notes, NULL);
1890 if (!ret && (trace_user || notes))
1891 warning (_("Target does not support trace user/notes, info ignored"));
1893 /* Now insert traps and begin collecting data. */
1894 target_trace_start ();
1896 /* Reset our local state. */
1897 trace_reset_local_state ();
1898 current_trace_status()->running = 1;
1901 /* The tstart command requests the target to start a new trace run.
1902 The command passes any arguments it has to the target verbatim, as
1903 an optional "trace note". This is useful as for instance a warning
1904 to other users if the trace runs disconnected, and you don't want
1905 anybody else messing with the target. */
1908 trace_start_command (char *args, int from_tty)
1910 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1912 if (current_trace_status ()->running)
1915 && !query (_("A trace is running already. Start a new run? ")))
1916 error (_("New trace run not started."));
1919 start_tracing (args);
1922 /* The tstop command stops the tracing run. The command passes any
1923 supplied arguments to the target verbatim as a "stop note"; if the
1924 target supports trace notes, then it will be reported back as part
1925 of the trace run's status. */
1928 trace_stop_command (char *args, int from_tty)
1930 if (!current_trace_status ()->running)
1931 error (_("Trace is not running."));
1933 stop_tracing (args);
1937 stop_tracing (char *note)
1940 VEC(breakpoint_p) *tp_vec = NULL;
1942 struct breakpoint *t;
1944 target_trace_stop ();
1946 tp_vec = all_tracepoints ();
1947 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1949 struct bp_location *loc;
1951 if ((t->type == bp_fast_tracepoint
1952 ? !may_insert_fast_tracepoints
1953 : !may_insert_tracepoints))
1956 for (loc = t->loc; loc; loc = loc->next)
1958 /* GDB can be totally absent in some disconnected trace scenarios,
1959 but we don't really care if this semaphore goes out of sync.
1960 That's why we are decrementing it here, but not taking care
1962 if (loc->probe.probe != NULL
1963 && loc->probe.probe->pops->clear_semaphore != NULL)
1964 loc->probe.probe->pops->clear_semaphore (loc->probe.probe,
1970 VEC_free (breakpoint_p, tp_vec);
1973 note = trace_stop_notes;
1974 ret = target_set_trace_notes (NULL, NULL, note);
1977 warning (_("Target does not support trace notes, note ignored"));
1979 /* Should change in response to reply? */
1980 current_trace_status ()->running = 0;
1983 /* tstatus command */
1985 trace_status_command (char *args, int from_tty)
1987 struct trace_status *ts = current_trace_status ();
1989 VEC(breakpoint_p) *tp_vec = NULL;
1990 struct breakpoint *t;
1992 status = target_get_trace_status (ts);
1996 if (ts->filename != NULL)
1997 printf_filtered (_("Using a trace file.\n"));
2000 printf_filtered (_("Trace can not be run on this target.\n"));
2005 if (!ts->running_known)
2007 printf_filtered (_("Run/stop status is unknown.\n"));
2009 else if (ts->running)
2011 printf_filtered (_("Trace is running on the target.\n"));
2015 switch (ts->stop_reason)
2017 case trace_never_run:
2018 printf_filtered (_("No trace has been run on the target.\n"));
2022 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
2025 printf_filtered (_("Trace stopped by a tstop command.\n"));
2027 case trace_buffer_full:
2028 printf_filtered (_("Trace stopped because the buffer was full.\n"));
2030 case trace_disconnected:
2031 printf_filtered (_("Trace stopped because of disconnection.\n"));
2033 case tracepoint_passcount:
2034 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
2035 ts->stopping_tracepoint);
2037 case tracepoint_error:
2038 if (ts->stopping_tracepoint)
2039 printf_filtered (_("Trace stopped by an "
2040 "error (%s, tracepoint %d).\n"),
2041 ts->stop_desc, ts->stopping_tracepoint);
2043 printf_filtered (_("Trace stopped by an error (%s).\n"),
2046 case trace_stop_reason_unknown:
2047 printf_filtered (_("Trace stopped for an unknown reason.\n"));
2050 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
2056 if (ts->traceframes_created >= 0
2057 && ts->traceframe_count != ts->traceframes_created)
2059 printf_filtered (_("Buffer contains %d trace "
2060 "frames (of %d created total).\n"),
2061 ts->traceframe_count, ts->traceframes_created);
2063 else if (ts->traceframe_count >= 0)
2065 printf_filtered (_("Collected %d trace frames.\n"),
2066 ts->traceframe_count);
2069 if (ts->buffer_free >= 0)
2071 if (ts->buffer_size >= 0)
2073 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2074 ts->buffer_free, ts->buffer_size);
2075 if (ts->buffer_size > 0)
2076 printf_filtered (_(" (%d%% full)"),
2077 ((int) ((((long long) (ts->buffer_size
2078 - ts->buffer_free)) * 100)
2079 / ts->buffer_size)));
2080 printf_filtered (_(".\n"));
2083 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2087 if (ts->disconnected_tracing)
2088 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2090 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2092 if (ts->circular_buffer)
2093 printf_filtered (_("Trace buffer is circular.\n"));
2095 if (ts->user_name && strlen (ts->user_name) > 0)
2096 printf_filtered (_("Trace user is %s.\n"), ts->user_name);
2098 if (ts->notes && strlen (ts->notes) > 0)
2099 printf_filtered (_("Trace notes: %s.\n"), ts->notes);
2101 /* Now report on what we're doing with tfind. */
2102 if (traceframe_number >= 0)
2103 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2104 traceframe_number, tracepoint_number);
2106 printf_filtered (_("Not looking at any trace frame.\n"));
2108 /* Report start/stop times if supplied. */
2113 LONGEST run_time = ts->stop_time - ts->start_time;
2115 /* Reporting a run time is more readable than two long numbers. */
2116 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2117 (long int) (ts->start_time / 1000000),
2118 (long int) (ts->start_time % 1000000),
2119 (long int) (run_time / 1000000),
2120 (long int) (run_time % 1000000));
2123 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2124 (long int) (ts->start_time / 1000000),
2125 (long int) (ts->start_time % 1000000));
2127 else if (ts->stop_time)
2128 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2129 (long int) (ts->stop_time / 1000000),
2130 (long int) (ts->stop_time % 1000000));
2132 /* Now report any per-tracepoint status available. */
2133 tp_vec = all_tracepoints ();
2135 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
2136 target_get_tracepoint_status (t, NULL);
2138 VEC_free (breakpoint_p, tp_vec);
2141 /* Report the trace status to uiout, in a way suitable for MI, and not
2142 suitable for CLI. If ON_STOP is true, suppress a few fields that
2143 are not meaningful in the -trace-stop response.
2145 The implementation is essentially parallel to trace_status_command, but
2146 merging them will result in unreadable code. */
2148 trace_status_mi (int on_stop)
2150 struct ui_out *uiout = current_uiout;
2151 struct trace_status *ts = current_trace_status ();
2154 status = target_get_trace_status (ts);
2156 if (status == -1 && ts->filename == NULL)
2158 ui_out_field_string (uiout, "supported", "0");
2162 if (ts->filename != NULL)
2163 ui_out_field_string (uiout, "supported", "file");
2165 ui_out_field_string (uiout, "supported", "1");
2167 if (ts->filename != NULL)
2168 ui_out_field_string (uiout, "trace-file", ts->filename);
2170 gdb_assert (ts->running_known);
2174 ui_out_field_string (uiout, "running", "1");
2176 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2177 Given that the frontend gets the status either on -trace-stop, or from
2178 -trace-status after re-connection, it does not seem like this
2179 information is necessary for anything. It is not necessary for either
2180 figuring the vital state of the target nor for navigation of trace
2181 frames. If the frontend wants to show the current state is some
2182 configure dialog, it can request the value when such dialog is
2183 invoked by the user. */
2187 char *stop_reason = NULL;
2188 int stopping_tracepoint = -1;
2191 ui_out_field_string (uiout, "running", "0");
2193 if (ts->stop_reason != trace_stop_reason_unknown)
2195 switch (ts->stop_reason)
2198 stop_reason = "request";
2200 case trace_buffer_full:
2201 stop_reason = "overflow";
2203 case trace_disconnected:
2204 stop_reason = "disconnection";
2206 case tracepoint_passcount:
2207 stop_reason = "passcount";
2208 stopping_tracepoint = ts->stopping_tracepoint;
2210 case tracepoint_error:
2211 stop_reason = "error";
2212 stopping_tracepoint = ts->stopping_tracepoint;
2218 ui_out_field_string (uiout, "stop-reason", stop_reason);
2219 if (stopping_tracepoint != -1)
2220 ui_out_field_int (uiout, "stopping-tracepoint",
2221 stopping_tracepoint);
2222 if (ts->stop_reason == tracepoint_error)
2223 ui_out_field_string (uiout, "error-description",
2229 if (ts->traceframe_count != -1)
2230 ui_out_field_int (uiout, "frames", ts->traceframe_count);
2231 if (ts->traceframes_created != -1)
2232 ui_out_field_int (uiout, "frames-created", ts->traceframes_created);
2233 if (ts->buffer_size != -1)
2234 ui_out_field_int (uiout, "buffer-size", ts->buffer_size);
2235 if (ts->buffer_free != -1)
2236 ui_out_field_int (uiout, "buffer-free", ts->buffer_free);
2238 ui_out_field_int (uiout, "disconnected", ts->disconnected_tracing);
2239 ui_out_field_int (uiout, "circular", ts->circular_buffer);
2241 ui_out_field_string (uiout, "user-name", ts->user_name);
2242 ui_out_field_string (uiout, "notes", ts->notes);
2247 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2248 (long int) (ts->start_time / 1000000),
2249 (long int) (ts->start_time % 1000000));
2250 ui_out_field_string (uiout, "start-time", buf);
2251 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2252 (long int) (ts->stop_time / 1000000),
2253 (long int) (ts->stop_time % 1000000));
2254 ui_out_field_string (uiout, "stop-time", buf);
2258 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2259 user if she really wants to detach. */
2262 query_if_trace_running (int from_tty)
2267 /* It can happen that the target that was tracing went away on its
2268 own, and we didn't notice. Get a status update, and if the
2269 current target doesn't even do tracing, then assume it's not
2271 if (target_get_trace_status (current_trace_status ()) < 0)
2272 current_trace_status ()->running = 0;
2274 /* If running interactively, give the user the option to cancel and
2275 then decide what to do differently with the run. Scripts are
2276 just going to disconnect and let the target deal with it,
2277 according to how it's been instructed previously via
2278 disconnected-tracing. */
2279 if (current_trace_status ()->running)
2281 process_tracepoint_on_disconnect ();
2283 if (current_trace_status ()->disconnected_tracing)
2285 if (!query (_("Trace is running and will "
2286 "continue after detach; detach anyway? ")))
2287 error (_("Not confirmed."));
2291 if (!query (_("Trace is running but will "
2292 "stop on detach; detach anyway? ")))
2293 error (_("Not confirmed."));
2298 /* This function handles the details of what to do about an ongoing
2299 tracing run if the user has asked to detach or otherwise disconnect
2303 disconnect_tracing (void)
2305 /* Also we want to be out of tfind mode, otherwise things can get
2306 confusing upon reconnection. Just use these calls instead of
2307 full tfind_1 behavior because we're in the middle of detaching,
2308 and there's no point to updating current stack frame etc. */
2309 trace_reset_local_state ();
2312 /* Worker function for the various flavors of the tfind command. */
2314 tfind_1 (enum trace_find_type type, int num,
2315 CORE_ADDR addr1, CORE_ADDR addr2,
2318 int target_frameno = -1, target_tracept = -1;
2319 struct frame_id old_frame_id = null_frame_id;
2320 struct tracepoint *tp;
2321 struct ui_out *uiout = current_uiout;
2323 /* Only try to get the current stack frame if we have a chance of
2324 succeeding. In particular, if we're trying to get a first trace
2325 frame while all threads are running, it's not going to succeed,
2326 so leave it with a default value and let the frame comparison
2327 below (correctly) decide to print out the source location of the
2329 if (!(type == tfind_number && num == -1)
2330 && (has_stack_frames () || traceframe_number >= 0))
2331 old_frame_id = get_frame_id (get_current_frame ());
2333 target_frameno = target_trace_find (type, num, addr1, addr2,
2336 if (type == tfind_number
2338 && target_frameno == -1)
2340 /* We told the target to get out of tfind mode, and it did. */
2342 else if (target_frameno == -1)
2344 /* A request for a non-existent trace frame has failed.
2345 Our response will be different, depending on FROM_TTY:
2347 If FROM_TTY is true, meaning that this command was
2348 typed interactively by the user, then give an error
2349 and DO NOT change the state of traceframe_number etc.
2351 However if FROM_TTY is false, meaning that we're either
2352 in a script, a loop, or a user-defined command, then
2353 DON'T give an error, but DO change the state of
2354 traceframe_number etc. to invalid.
2356 The rationalle is that if you typed the command, you
2357 might just have committed a typo or something, and you'd
2358 like to NOT lose your current debugging state. However
2359 if you're in a user-defined command or especially in a
2360 loop, then you need a way to detect that the command
2361 failed WITHOUT aborting. This allows you to write
2362 scripts that search thru the trace buffer until the end,
2363 and then continue on to do something else. */
2366 error (_("Target failed to find requested trace frame."));
2370 printf_filtered ("End of trace buffer.\n");
2371 #if 0 /* dubious now? */
2372 /* The following will not recurse, since it's
2374 trace_find_command ("-1", from_tty);
2379 tp = get_tracepoint_by_number_on_target (target_tracept);
2381 reinit_frame_cache ();
2382 target_dcache_invalidate ();
2384 set_tracepoint_num (tp ? tp->base.number : target_tracept);
2386 if (target_frameno != get_traceframe_number ())
2387 observer_notify_traceframe_changed (target_frameno, tracepoint_number);
2389 set_current_traceframe (target_frameno);
2391 if (target_frameno == -1)
2392 set_traceframe_context (NULL);
2394 set_traceframe_context (get_current_frame ());
2396 if (traceframe_number >= 0)
2398 /* Use different branches for MI and CLI to make CLI messages
2400 if (ui_out_is_mi_like_p (uiout))
2402 ui_out_field_string (uiout, "found", "1");
2403 ui_out_field_int (uiout, "tracepoint", tracepoint_number);
2404 ui_out_field_int (uiout, "traceframe", traceframe_number);
2408 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2409 traceframe_number, tracepoint_number);
2414 if (ui_out_is_mi_like_p (uiout))
2415 ui_out_field_string (uiout, "found", "0");
2416 else if (type == tfind_number && num == -1)
2417 printf_unfiltered (_("No longer looking at any trace frame\n"));
2418 else /* This case may never occur, check. */
2419 printf_unfiltered (_("No trace frame found\n"));
2422 /* If we're in nonstop mode and getting out of looking at trace
2423 frames, there won't be any current frame to go back to and
2426 && (has_stack_frames () || traceframe_number >= 0))
2428 enum print_what print_what;
2430 /* NOTE: in imitation of the step command, try to determine
2431 whether we have made a transition from one function to
2432 another. If so, we'll print the "stack frame" (ie. the new
2433 function and it's arguments) -- otherwise we'll just show the
2436 if (frame_id_eq (old_frame_id,
2437 get_frame_id (get_current_frame ())))
2438 print_what = SRC_LINE;
2440 print_what = SRC_AND_LOC;
2442 print_stack_frame (get_selected_frame (NULL), 1, print_what, 1);
2447 /* Error on looking at traceframes while trace is running. */
2450 check_trace_running (struct trace_status *status)
2452 if (status->running && status->filename == NULL)
2453 error (_("May not look at trace frames while trace is running."));
2456 /* trace_find_command takes a trace frame number n,
2457 sends "QTFrame:<n>" to the target,
2458 and accepts a reply that may contain several optional pieces
2459 of information: a frame number, a tracepoint number, and an
2460 indication of whether this is a trap frame or a stepping frame.
2462 The minimal response is just "OK" (which indicates that the
2463 target does not give us a frame number or a tracepoint number).
2464 Instead of that, the target may send us a string containing
2466 F<hexnum> (gives the selected frame number)
2467 T<hexnum> (gives the selected tracepoint number)
2472 trace_find_command (char *args, int from_tty)
2473 { /* This should only be called with a numeric argument. */
2476 check_trace_running (current_trace_status ());
2478 if (args == 0 || *args == 0)
2479 { /* TFIND with no args means find NEXT trace frame. */
2480 if (traceframe_number == -1)
2481 frameno = 0; /* "next" is first one. */
2483 frameno = traceframe_number + 1;
2485 else if (0 == strcmp (args, "-"))
2487 if (traceframe_number == -1)
2488 error (_("not debugging trace buffer"));
2489 else if (from_tty && traceframe_number == 0)
2490 error (_("already at start of trace buffer"));
2492 frameno = traceframe_number - 1;
2494 /* A hack to work around eval's need for fp to have been collected. */
2495 else if (0 == strcmp (args, "-1"))
2498 frameno = parse_and_eval_long (args);
2501 error (_("invalid input (%d is less than zero)"), frameno);
2503 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2508 trace_find_end_command (char *args, int from_tty)
2510 trace_find_command ("-1", from_tty);
2515 trace_find_start_command (char *args, int from_tty)
2517 trace_find_command ("0", from_tty);
2520 /* tfind pc command */
2522 trace_find_pc_command (char *args, int from_tty)
2526 check_trace_running (current_trace_status ());
2528 if (args == 0 || *args == 0)
2529 pc = regcache_read_pc (get_current_regcache ());
2531 pc = parse_and_eval_address (args);
2533 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2536 /* tfind tracepoint command */
2538 trace_find_tracepoint_command (char *args, int from_tty)
2541 struct tracepoint *tp;
2543 check_trace_running (current_trace_status ());
2545 if (args == 0 || *args == 0)
2547 if (tracepoint_number == -1)
2548 error (_("No current tracepoint -- please supply an argument."));
2550 tdp = tracepoint_number; /* Default is current TDP. */
2553 tdp = parse_and_eval_long (args);
2555 /* If we have the tracepoint on hand, use the number that the
2556 target knows about (which may be different if we disconnected
2557 and reconnected). */
2558 tp = get_tracepoint (tdp);
2560 tdp = tp->number_on_target;
2562 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2565 /* TFIND LINE command:
2567 This command will take a sourceline for argument, just like BREAK
2568 or TRACE (ie. anything that "decode_line_1" can handle).
2570 With no argument, this command will find the next trace frame
2571 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2574 trace_find_line_command (char *args, int from_tty)
2576 static CORE_ADDR start_pc, end_pc;
2577 struct symtabs_and_lines sals;
2578 struct symtab_and_line sal;
2579 struct cleanup *old_chain;
2581 check_trace_running (current_trace_status ());
2583 if (args == 0 || *args == 0)
2585 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2587 sals.sals = XNEW (struct symtab_and_line);
2592 sals = decode_line_with_current_source (args, DECODE_LINE_FUNFIRSTLINE);
2596 old_chain = make_cleanup (xfree, sals.sals);
2597 if (sal.symtab == 0)
2598 error (_("No line number information available."));
2600 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2602 if (start_pc == end_pc)
2604 printf_filtered ("Line %d of \"%s\"",
2606 symtab_to_filename_for_display (sal.symtab));
2608 printf_filtered (" is at address ");
2609 print_address (get_current_arch (), start_pc, gdb_stdout);
2611 printf_filtered (" but contains no code.\n");
2612 sal = find_pc_line (start_pc, 0);
2614 && find_line_pc_range (sal, &start_pc, &end_pc)
2615 && start_pc != end_pc)
2616 printf_filtered ("Attempting to find line %d instead.\n",
2619 error (_("Cannot find a good line."));
2623 /* Is there any case in which we get here, and have an address
2624 which the user would want to see? If we have debugging
2625 symbols and no line numbers? */
2626 error (_("Line number %d is out of range for \"%s\"."),
2627 sal.line, symtab_to_filename_for_display (sal.symtab));
2629 /* Find within range of stated line. */
2631 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2633 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2634 do_cleanups (old_chain);
2637 /* tfind range command */
2639 trace_find_range_command (char *args, int from_tty)
2641 static CORE_ADDR start, stop;
2644 check_trace_running (current_trace_status ());
2646 if (args == 0 || *args == 0)
2647 { /* XXX FIXME: what should default behavior be? */
2648 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2652 if (0 != (tmp = strchr (args, ',')))
2654 *tmp++ = '\0'; /* Terminate start address. */
2655 tmp = skip_spaces (tmp);
2656 start = parse_and_eval_address (args);
2657 stop = parse_and_eval_address (tmp);
2660 { /* No explicit end address? */
2661 start = parse_and_eval_address (args);
2662 stop = start + 1; /* ??? */
2665 tfind_1 (tfind_range, 0, start, stop, from_tty);
2668 /* tfind outside command */
2670 trace_find_outside_command (char *args, int from_tty)
2672 CORE_ADDR start, stop;
2675 if (current_trace_status ()->running
2676 && current_trace_status ()->filename == NULL)
2677 error (_("May not look at trace frames while trace is running."));
2679 if (args == 0 || *args == 0)
2680 { /* XXX FIXME: what should default behavior be? */
2681 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2685 if (0 != (tmp = strchr (args, ',')))
2687 *tmp++ = '\0'; /* Terminate start address. */
2688 tmp = skip_spaces (tmp);
2689 start = parse_and_eval_address (args);
2690 stop = parse_and_eval_address (tmp);
2693 { /* No explicit end address? */
2694 start = parse_and_eval_address (args);
2695 stop = start + 1; /* ??? */
2698 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2701 /* info scope command: list the locals for a scope. */
2703 scope_info (char *args, int from_tty)
2705 struct symtabs_and_lines sals;
2707 struct bound_minimal_symbol msym;
2708 const struct block *block;
2709 const char *symname;
2710 char *save_args = args;
2711 struct block_iterator iter;
2713 struct gdbarch *gdbarch;
2715 struct event_location *location;
2716 struct cleanup *back_to;
2718 if (args == 0 || *args == 0)
2719 error (_("requires an argument (function, "
2720 "line or *addr) to define a scope"));
2722 location = string_to_event_location (&args, current_language);
2723 back_to = make_cleanup_delete_event_location (location);
2724 sals = decode_line_1 (location, DECODE_LINE_FUNFIRSTLINE, NULL, 0);
2725 if (sals.nelts == 0)
2727 /* Presumably decode_line_1 has already warned. */
2728 do_cleanups (back_to);
2732 /* Resolve line numbers to PC. */
2733 resolve_sal_pc (&sals.sals[0]);
2734 block = block_for_pc (sals.sals[0].pc);
2738 QUIT; /* Allow user to bail out with ^C. */
2739 ALL_BLOCK_SYMBOLS (block, iter, sym)
2741 QUIT; /* Allow user to bail out with ^C. */
2743 printf_filtered ("Scope for %s:\n", save_args);
2746 symname = SYMBOL_PRINT_NAME (sym);
2747 if (symname == NULL || *symname == '\0')
2748 continue; /* Probably botched, certainly useless. */
2750 gdbarch = symbol_arch (sym);
2752 printf_filtered ("Symbol %s is ", symname);
2754 if (SYMBOL_COMPUTED_OPS (sym) != NULL)
2755 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2756 BLOCK_START (block),
2760 switch (SYMBOL_CLASS (sym))
2763 case LOC_UNDEF: /* Messed up symbol? */
2764 printf_filtered ("a bogus symbol, class %d.\n",
2765 SYMBOL_CLASS (sym));
2766 count--; /* Don't count this one. */
2769 printf_filtered ("a constant with value %s (%s)",
2770 plongest (SYMBOL_VALUE (sym)),
2771 hex_string (SYMBOL_VALUE (sym)));
2773 case LOC_CONST_BYTES:
2774 printf_filtered ("constant bytes: ");
2775 if (SYMBOL_TYPE (sym))
2776 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2777 fprintf_filtered (gdb_stdout, " %02x",
2778 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2781 printf_filtered ("in static storage at address ");
2782 printf_filtered ("%s", paddress (gdbarch,
2783 SYMBOL_VALUE_ADDRESS (sym)));
2786 /* GDBARCH is the architecture associated with the objfile
2787 the symbol is defined in; the target architecture may be
2788 different, and may provide additional registers. However,
2789 we do not know the target architecture at this point.
2790 We assume the objfile architecture will contain all the
2791 standard registers that occur in debug info in that
2793 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2796 if (SYMBOL_IS_ARGUMENT (sym))
2797 printf_filtered ("an argument in register $%s",
2798 gdbarch_register_name (gdbarch, regno));
2800 printf_filtered ("a local variable in register $%s",
2801 gdbarch_register_name (gdbarch, regno));
2804 printf_filtered ("an argument at stack/frame offset %s",
2805 plongest (SYMBOL_VALUE (sym)));
2808 printf_filtered ("a local variable at frame offset %s",
2809 plongest (SYMBOL_VALUE (sym)));
2812 printf_filtered ("a reference argument at offset %s",
2813 plongest (SYMBOL_VALUE (sym)));
2815 case LOC_REGPARM_ADDR:
2816 /* Note comment at LOC_REGISTER. */
2817 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2819 printf_filtered ("the address of an argument, in register $%s",
2820 gdbarch_register_name (gdbarch, regno));
2823 printf_filtered ("a typedef.\n");
2826 printf_filtered ("a label at address ");
2827 printf_filtered ("%s", paddress (gdbarch,
2828 SYMBOL_VALUE_ADDRESS (sym)));
2831 printf_filtered ("a function at address ");
2832 printf_filtered ("%s",
2833 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2835 case LOC_UNRESOLVED:
2836 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2838 if (msym.minsym == NULL)
2839 printf_filtered ("Unresolved Static");
2842 printf_filtered ("static storage at address ");
2843 printf_filtered ("%s",
2845 BMSYMBOL_VALUE_ADDRESS (msym)));
2848 case LOC_OPTIMIZED_OUT:
2849 printf_filtered ("optimized out.\n");
2852 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2855 if (SYMBOL_TYPE (sym))
2856 printf_filtered (", length %d.\n",
2857 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2859 if (BLOCK_FUNCTION (block))
2862 block = BLOCK_SUPERBLOCK (block);
2865 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2867 do_cleanups (back_to);
2870 /* Helper for trace_dump_command. Dump the action list starting at
2871 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2872 actions of the body of a while-stepping action. STEPPING_FRAME is
2873 set if the current traceframe was determined to be a while-stepping
2877 trace_dump_actions (struct command_line *action,
2878 int stepping_actions, int stepping_frame,
2881 const char *action_exp, *next_comma;
2883 for (; action != NULL; action = action->next)
2885 struct cmd_list_element *cmd;
2887 QUIT; /* Allow user to bail out with ^C. */
2888 action_exp = action->line;
2889 action_exp = skip_spaces_const (action_exp);
2891 /* The collection actions to be done while stepping are
2892 bracketed by the commands "while-stepping" and "end". */
2894 if (*action_exp == '#') /* comment line */
2897 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2899 error (_("Bad action list item: %s"), action_exp);
2901 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2905 for (i = 0; i < action->body_count; ++i)
2906 trace_dump_actions (action->body_list[i],
2907 1, stepping_frame, from_tty);
2909 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2911 /* Display the collected data.
2912 For the trap frame, display only what was collected at
2913 the trap. Likewise for stepping frames, display only
2914 what was collected while stepping. This means that the
2915 two boolean variables, STEPPING_FRAME and
2916 STEPPING_ACTIONS should be equal. */
2917 if (stepping_frame == stepping_actions)
2920 struct cleanup *old_chain
2921 = make_cleanup (free_current_contents, &cmd);
2922 int trace_string = 0;
2924 if (*action_exp == '/')
2925 action_exp = decode_agent_options (action_exp, &trace_string);
2928 { /* Repeat over a comma-separated list. */
2929 QUIT; /* Allow user to bail out with ^C. */
2930 if (*action_exp == ',')
2932 action_exp = skip_spaces_const (action_exp);
2934 next_comma = strchr (action_exp, ',');
2936 if (0 == strncasecmp (action_exp, "$reg", 4))
2937 registers_info (NULL, from_tty);
2938 else if (0 == strncasecmp (action_exp, "$_ret", 5))
2940 else if (0 == strncasecmp (action_exp, "$loc", 4))
2941 locals_info (NULL, from_tty);
2942 else if (0 == strncasecmp (action_exp, "$arg", 4))
2943 args_info (NULL, from_tty);
2946 if (next_comma != NULL)
2948 size_t len = next_comma - action_exp;
2950 cmd = xrealloc (cmd, len + 1);
2951 memcpy (cmd, action_exp, len);
2956 size_t len = strlen (action_exp);
2958 cmd = xrealloc (cmd, len + 1);
2959 memcpy (cmd, action_exp, len + 1);
2962 printf_filtered ("%s = ", cmd);
2963 output_command_const (cmd, from_tty);
2964 printf_filtered ("\n");
2966 action_exp = next_comma;
2968 while (action_exp && *action_exp == ',');
2970 do_cleanups (old_chain);
2976 /* Return bp_location of the tracepoint associated with the current
2977 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2978 is a stepping traceframe. */
2980 struct bp_location *
2981 get_traceframe_location (int *stepping_frame_p)
2983 struct tracepoint *t;
2984 struct bp_location *tloc;
2985 struct regcache *regcache;
2987 if (tracepoint_number == -1)
2988 error (_("No current trace frame."));
2990 t = get_tracepoint (tracepoint_number);
2993 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2996 /* The current frame is a trap frame if the frame PC is equal to the
2997 tracepoint PC. If not, then the current frame was collected
2998 during single-stepping. */
2999 regcache = get_current_regcache ();
3001 /* If the traceframe's address matches any of the tracepoint's
3002 locations, assume it is a direct hit rather than a while-stepping
3003 frame. (FIXME this is not reliable, should record each frame's
3005 for (tloc = t->base.loc; tloc; tloc = tloc->next)
3006 if (tloc->address == regcache_read_pc (regcache))
3008 *stepping_frame_p = 0;
3012 /* If this is a stepping frame, we don't know which location
3013 triggered. The first is as good (or bad) a guess as any... */
3014 *stepping_frame_p = 1;
3018 /* Return all the actions, including default collect, of a tracepoint
3019 T. It constructs cleanups into the chain, and leaves the caller to
3020 handle them (call do_cleanups). */
3022 static struct command_line *
3023 all_tracepoint_actions_and_cleanup (struct breakpoint *t)
3025 struct command_line *actions;
3027 actions = breakpoint_commands (t);
3029 /* If there are default expressions to collect, make up a collect
3030 action and prepend to the action list to encode. Note that since
3031 validation is per-tracepoint (local var "xyz" might be valid for
3032 one tracepoint and not another, etc), we make up the action on
3033 the fly, and don't cache it. */
3034 if (*default_collect)
3036 struct command_line *default_collect_action;
3037 char *default_collect_line;
3039 default_collect_line = xstrprintf ("collect %s", default_collect);
3040 make_cleanup (xfree, default_collect_line);
3042 validate_actionline (default_collect_line, t);
3043 default_collect_action = XNEW (struct command_line);
3044 make_cleanup (xfree, default_collect_action);
3045 default_collect_action->next = actions;
3046 default_collect_action->line = default_collect_line;
3047 actions = default_collect_action;
3053 /* The tdump command. */
3056 trace_dump_command (char *args, int from_tty)
3058 int stepping_frame = 0;
3059 struct bp_location *loc;
3060 struct cleanup *old_chain;
3061 struct command_line *actions;
3063 /* This throws an error is not inspecting a trace frame. */
3064 loc = get_traceframe_location (&stepping_frame);
3066 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
3067 tracepoint_number, traceframe_number);
3069 old_chain = make_cleanup (null_cleanup, NULL);
3071 /* This command only makes sense for the current frame, not the
3073 make_cleanup_restore_current_thread ();
3074 select_frame (get_current_frame ());
3076 actions = all_tracepoint_actions_and_cleanup (loc->owner);
3078 trace_dump_actions (actions, 0, stepping_frame, from_tty);
3080 do_cleanups (old_chain);
3083 /* Encode a piece of a tracepoint's source-level definition in a form
3084 that is suitable for both protocol and saving in files. */
3085 /* This version does not do multiple encodes for long strings; it should
3086 return an offset to the next piece to encode. FIXME */
3089 encode_source_string (int tpnum, ULONGEST addr,
3090 char *srctype, const char *src, char *buf, int buf_size)
3092 if (80 + strlen (srctype) > buf_size)
3093 error (_("Buffer too small for source encoding"));
3094 sprintf (buf, "%x:%s:%s:%x:%x:",
3095 tpnum, phex_nz (addr, sizeof (addr)),
3096 srctype, 0, (int) strlen (src));
3097 if (strlen (buf) + strlen (src) * 2 >= buf_size)
3098 error (_("Source string too long for buffer"));
3099 bin2hex ((gdb_byte *) src, buf + strlen (buf), strlen (src));
3103 /* Tell the target what to do with an ongoing tracing run if GDB
3104 disconnects for some reason. */
3107 set_disconnected_tracing (char *args, int from_tty,
3108 struct cmd_list_element *c)
3110 target_set_disconnected_tracing (disconnected_tracing);
3114 set_circular_trace_buffer (char *args, int from_tty,
3115 struct cmd_list_element *c)
3117 target_set_circular_trace_buffer (circular_trace_buffer);
3121 set_trace_buffer_size (char *args, int from_tty,
3122 struct cmd_list_element *c)
3124 target_set_trace_buffer_size (trace_buffer_size);
3128 set_trace_user (char *args, int from_tty,
3129 struct cmd_list_element *c)
3133 ret = target_set_trace_notes (trace_user, NULL, NULL);
3136 warning (_("Target does not support trace notes, user ignored"));
3140 set_trace_notes (char *args, int from_tty,
3141 struct cmd_list_element *c)
3145 ret = target_set_trace_notes (NULL, trace_notes, NULL);
3148 warning (_("Target does not support trace notes, note ignored"));
3152 set_trace_stop_notes (char *args, int from_tty,
3153 struct cmd_list_element *c)
3157 ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
3160 warning (_("Target does not support trace notes, stop note ignored"));
3163 /* Convert the memory pointed to by mem into hex, placing result in buf.
3164 * Return a pointer to the last char put in buf (null)
3165 * "stolen" from sparc-stub.c
3168 static const char hexchars[] = "0123456789abcdef";
3171 mem2hex (gdb_byte *mem, char *buf, int count)
3179 *buf++ = hexchars[ch >> 4];
3180 *buf++ = hexchars[ch & 0xf];
3189 get_traceframe_number (void)
3191 return traceframe_number;
3195 get_tracepoint_number (void)
3197 return tracepoint_number;
3200 /* Make the traceframe NUM be the current trace frame. Does nothing
3201 if NUM is already current. */
3204 set_current_traceframe (int num)
3208 if (traceframe_number == num)
3210 /* Nothing to do. */
3214 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
3217 warning (_("could not change traceframe"));
3219 set_traceframe_num (newnum);
3221 /* Changing the traceframe changes our view of registers and of the
3223 registers_changed ();
3225 clear_traceframe_info ();
3228 /* A cleanup used when switching away and back from tfind mode. */
3230 struct current_traceframe_cleanup
3232 /* The traceframe we were inspecting. */
3233 int traceframe_number;
3237 do_restore_current_traceframe_cleanup (void *arg)
3239 struct current_traceframe_cleanup *old = arg;
3241 set_current_traceframe (old->traceframe_number);
3245 restore_current_traceframe_cleanup_dtor (void *arg)
3247 struct current_traceframe_cleanup *old = arg;
3253 make_cleanup_restore_current_traceframe (void)
3255 struct current_traceframe_cleanup *old =
3256 XNEW (struct current_traceframe_cleanup);
3258 old->traceframe_number = traceframe_number;
3260 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
3261 restore_current_traceframe_cleanup_dtor);
3264 /* Given a number and address, return an uploaded tracepoint with that
3265 number, creating if necessary. */
3267 struct uploaded_tp *
3268 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
3270 struct uploaded_tp *utp;
3272 for (utp = *utpp; utp; utp = utp->next)
3273 if (utp->number == num && utp->addr == addr)
3276 utp = XCNEW (struct uploaded_tp);
3279 utp->actions = NULL;
3280 utp->step_actions = NULL;
3281 utp->cmd_strings = NULL;
3289 free_uploaded_tps (struct uploaded_tp **utpp)
3291 struct uploaded_tp *next_one;
3295 next_one = (*utpp)->next;
3301 /* Given a number and address, return an uploaded tracepoint with that
3302 number, creating if necessary. */
3304 struct uploaded_tsv *
3305 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3307 struct uploaded_tsv *utsv;
3309 for (utsv = *utsvp; utsv; utsv = utsv->next)
3310 if (utsv->number == num)
3313 utsv = XCNEW (struct uploaded_tsv);
3315 utsv->next = *utsvp;
3322 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3324 struct uploaded_tsv *next_one;
3328 next_one = (*utsvp)->next;
3334 /* FIXME this function is heuristic and will miss the cases where the
3335 conditional is semantically identical but differs in whitespace,
3336 such as "x == 0" vs "x==0". */
3339 cond_string_is_same (char *str1, char *str2)
3341 if (str1 == NULL || str2 == NULL)
3342 return (str1 == str2);
3344 return (strcmp (str1, str2) == 0);
3347 /* Look for an existing tracepoint that seems similar enough to the
3348 uploaded one. Enablement isn't compared, because the user can
3349 toggle that freely, and may have done so in anticipation of the
3350 next trace run. Return the location of matched tracepoint. */
3352 static struct bp_location *
3353 find_matching_tracepoint_location (struct uploaded_tp *utp)
3355 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
3357 struct breakpoint *b;
3358 struct bp_location *loc;
3360 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
3362 struct tracepoint *t = (struct tracepoint *) b;
3364 if (b->type == utp->type
3365 && t->step_count == utp->step
3366 && t->pass_count == utp->pass
3367 && cond_string_is_same (t->base.cond_string, utp->cond_string)
3368 /* FIXME also test actions. */
3371 /* Scan the locations for an address match. */
3372 for (loc = b->loc; loc; loc = loc->next)
3374 if (loc->address == utp->addr)
3382 /* Given a list of tracepoints uploaded from a target, attempt to
3383 match them up with existing tracepoints, and create new ones if not
3387 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3389 struct uploaded_tp *utp;
3390 /* A set of tracepoints which are modified. */
3391 VEC(breakpoint_p) *modified_tp = NULL;
3393 struct breakpoint *b;
3395 /* Look for GDB tracepoints that match up with our uploaded versions. */
3396 for (utp = *uploaded_tps; utp; utp = utp->next)
3398 struct bp_location *loc;
3399 struct tracepoint *t;
3401 loc = find_matching_tracepoint_location (utp);
3406 /* Mark this location as already inserted. */
3408 t = (struct tracepoint *) loc->owner;
3409 printf_filtered (_("Assuming tracepoint %d is same "
3410 "as target's tracepoint %d at %s.\n"),
3411 loc->owner->number, utp->number,
3412 paddress (loc->gdbarch, utp->addr));
3414 /* The tracepoint LOC->owner was modified (the location LOC
3415 was marked as inserted in the target). Save it in
3416 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3417 observers will be notified later once for each tracepoint
3418 saved in MODIFIED_TP. */
3420 VEC_iterate (breakpoint_p, modified_tp, ix, b);
3422 if (b == loc->owner)
3428 VEC_safe_push (breakpoint_p, modified_tp, loc->owner);
3432 t = create_tracepoint_from_upload (utp);
3434 printf_filtered (_("Created tracepoint %d for "
3435 "target's tracepoint %d at %s.\n"),
3436 t->base.number, utp->number,
3437 paddress (get_current_arch (), utp->addr));
3439 printf_filtered (_("Failed to create tracepoint for target's "
3440 "tracepoint %d at %s, skipping it.\n"),
3442 paddress (get_current_arch (), utp->addr));
3444 /* Whether found or created, record the number used by the
3445 target, to help with mapping target tracepoints back to their
3446 counterparts here. */
3448 t->number_on_target = utp->number;
3451 /* Notify 'breakpoint-modified' observer that at least one of B's
3452 locations was changed. */
3453 for (ix = 0; VEC_iterate (breakpoint_p, modified_tp, ix, b); ix++)
3454 observer_notify_breakpoint_modified (b);
3456 VEC_free (breakpoint_p, modified_tp);
3457 free_uploaded_tps (uploaded_tps);
3460 /* Trace state variables don't have much to identify them beyond their
3461 name, so just use that to detect matches. */
3463 static struct trace_state_variable *
3464 find_matching_tsv (struct uploaded_tsv *utsv)
3469 return find_trace_state_variable (utsv->name);
3472 static struct trace_state_variable *
3473 create_tsv_from_upload (struct uploaded_tsv *utsv)
3475 const char *namebase;
3478 struct trace_state_variable *tsv;
3479 struct cleanup *old_chain;
3483 namebase = utsv->name;
3484 buf = xstrprintf ("%s", namebase);
3489 buf = xstrprintf ("%s_%d", namebase, try_num++);
3492 /* Fish for a name that is not in use. */
3493 /* (should check against all internal vars?) */
3494 while (find_trace_state_variable (buf))
3497 buf = xstrprintf ("%s_%d", namebase, try_num++);
3500 old_chain = make_cleanup (xfree, buf);
3502 /* We have an available name, create the variable. */
3503 tsv = create_trace_state_variable (buf);
3504 tsv->initial_value = utsv->initial_value;
3505 tsv->builtin = utsv->builtin;
3507 observer_notify_tsv_created (tsv);
3509 do_cleanups (old_chain);
3514 /* Given a list of uploaded trace state variables, try to match them
3515 up with existing variables, or create additional ones. */
3518 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
3521 struct uploaded_tsv *utsv;
3522 struct trace_state_variable *tsv;
3525 /* Most likely some numbers will have to be reassigned as part of
3526 the merge, so clear them all in anticipation. */
3527 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3530 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
3532 tsv = find_matching_tsv (utsv);
3536 printf_filtered (_("Assuming trace state variable $%s "
3537 "is same as target's variable %d.\n"),
3538 tsv->name, utsv->number);
3542 tsv = create_tsv_from_upload (utsv);
3544 printf_filtered (_("Created trace state variable "
3545 "$%s for target's variable %d.\n"),
3546 tsv->name, utsv->number);
3548 /* Give precedence to numberings that come from the target. */
3550 tsv->number = utsv->number;
3553 /* Renumber everything that didn't get a target-assigned number. */
3555 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3556 if (tsv->number > highest)
3557 highest = tsv->number;
3560 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3561 if (tsv->number == 0)
3562 tsv->number = highest++;
3564 free_uploaded_tsvs (uploaded_tsvs);
3567 /* Parse the part of trace status syntax that is shared between
3568 the remote protocol and the trace file reader. */
3571 parse_trace_status (char *line, struct trace_status *ts)
3573 char *p = line, *p1, *p2, *p3, *p_temp;
3577 ts->running_known = 1;
3578 ts->running = (*p++ == '1');
3579 ts->stop_reason = trace_stop_reason_unknown;
3580 xfree (ts->stop_desc);
3581 ts->stop_desc = NULL;
3582 ts->traceframe_count = -1;
3583 ts->traceframes_created = -1;
3584 ts->buffer_free = -1;
3585 ts->buffer_size = -1;
3586 ts->disconnected_tracing = 0;
3587 ts->circular_buffer = 0;
3588 xfree (ts->user_name);
3589 ts->user_name = NULL;
3592 ts->start_time = ts->stop_time = 0;
3596 p1 = strchr (p, ':');
3598 error (_("Malformed trace status, at %s\n\
3599 Status line: '%s'\n"), p, line);
3600 p3 = strchr (p, ';');
3602 p3 = p + strlen (p);
3603 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3605 p = unpack_varlen_hex (++p1, &val);
3606 ts->stop_reason = trace_buffer_full;
3608 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3610 p = unpack_varlen_hex (++p1, &val);
3611 ts->stop_reason = trace_never_run;
3613 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
3616 p = unpack_varlen_hex (++p1, &val);
3617 ts->stop_reason = tracepoint_passcount;
3618 ts->stopping_tracepoint = val;
3620 else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
3622 p2 = strchr (++p1, ':');
3630 ts->stop_desc = xmalloc (strlen (line));
3631 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
3632 ts->stop_desc[end] = '\0';
3635 ts->stop_desc = xstrdup ("");
3637 p = unpack_varlen_hex (++p2, &val);
3638 ts->stop_reason = tstop_command;
3640 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3642 p = unpack_varlen_hex (++p1, &val);
3643 ts->stop_reason = trace_disconnected;
3645 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3647 p2 = strchr (++p1, ':');
3650 ts->stop_desc = xmalloc ((p2 - p1) / 2 + 1);
3651 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
3652 ts->stop_desc[end] = '\0';
3655 ts->stop_desc = xstrdup ("");
3657 p = unpack_varlen_hex (++p2, &val);
3658 ts->stopping_tracepoint = val;
3659 ts->stop_reason = tracepoint_error;
3661 else if (strncmp (p, "tframes", p1 - p) == 0)
3663 p = unpack_varlen_hex (++p1, &val);
3664 ts->traceframe_count = val;
3666 else if (strncmp (p, "tcreated", p1 - p) == 0)
3668 p = unpack_varlen_hex (++p1, &val);
3669 ts->traceframes_created = val;
3671 else if (strncmp (p, "tfree", p1 - p) == 0)
3673 p = unpack_varlen_hex (++p1, &val);
3674 ts->buffer_free = val;
3676 else if (strncmp (p, "tsize", p1 - p) == 0)
3678 p = unpack_varlen_hex (++p1, &val);
3679 ts->buffer_size = val;
3681 else if (strncmp (p, "disconn", p1 - p) == 0)
3683 p = unpack_varlen_hex (++p1, &val);
3684 ts->disconnected_tracing = val;
3686 else if (strncmp (p, "circular", p1 - p) == 0)
3688 p = unpack_varlen_hex (++p1, &val);
3689 ts->circular_buffer = val;
3691 else if (strncmp (p, "starttime", p1 - p) == 0)
3693 p = unpack_varlen_hex (++p1, &val);
3694 ts->start_time = val;
3696 else if (strncmp (p, "stoptime", p1 - p) == 0)
3698 p = unpack_varlen_hex (++p1, &val);
3699 ts->stop_time = val;
3701 else if (strncmp (p, "username", p1 - p) == 0)
3704 ts->user_name = xmalloc (strlen (p) / 2);
3705 end = hex2bin (p1, (gdb_byte *) ts->user_name, (p3 - p1) / 2);
3706 ts->user_name[end] = '\0';
3709 else if (strncmp (p, "notes", p1 - p) == 0)
3712 ts->notes = xmalloc (strlen (p) / 2);
3713 end = hex2bin (p1, (gdb_byte *) ts->notes, (p3 - p1) / 2);
3714 ts->notes[end] = '\0';
3719 /* Silently skip unknown optional info. */
3720 p_temp = strchr (p1 + 1, ';');
3724 /* Must be at the end. */
3731 parse_tracepoint_status (char *p, struct breakpoint *bp,
3732 struct uploaded_tp *utp)
3735 struct tracepoint *tp = (struct tracepoint *) bp;
3737 p = unpack_varlen_hex (p, &uval);
3739 tp->base.hit_count += uval;
3741 utp->hit_count += uval;
3742 p = unpack_varlen_hex (p + 1, &uval);
3744 tp->traceframe_usage += uval;
3746 utp->traceframe_usage += uval;
3747 /* Ignore any extra, allowing for future extensions. */
3750 /* Given a line of text defining a part of a tracepoint, parse it into
3751 an "uploaded tracepoint". */
3754 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
3758 ULONGEST num, addr, step, pass, orig_size, xlen, start;
3761 char *cond, *srctype, *buf;
3762 struct uploaded_tp *utp = NULL;
3765 /* Both tracepoint and action definitions start with the same number
3766 and address sequence. */
3768 p = unpack_varlen_hex (p, &num);
3769 p++; /* skip a colon */
3770 p = unpack_varlen_hex (p, &addr);
3771 p++; /* skip a colon */
3774 enabled = (*p++ == 'E');
3775 p++; /* skip a colon */
3776 p = unpack_varlen_hex (p, &step);
3777 p++; /* skip a colon */
3778 p = unpack_varlen_hex (p, &pass);
3779 type = bp_tracepoint;
3781 /* Thumb through optional fields. */
3784 p++; /* skip a colon */
3787 type = bp_fast_tracepoint;
3789 p = unpack_varlen_hex (p, &orig_size);
3793 type = bp_static_tracepoint;
3799 p = unpack_varlen_hex (p, &xlen);
3800 p++; /* skip a comma */
3801 cond = (char *) xmalloc (2 * xlen + 1);
3802 strncpy (cond, p, 2 * xlen);
3803 cond[2 * xlen] = '\0';
3807 warning (_("Unrecognized char '%c' in tracepoint "
3808 "definition, skipping rest"), *p);
3810 utp = get_uploaded_tp (num, addr, utpp);
3812 utp->enabled = enabled;
3817 else if (piece == 'A')
3819 utp = get_uploaded_tp (num, addr, utpp);
3820 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
3822 else if (piece == 'S')
3824 utp = get_uploaded_tp (num, addr, utpp);
3825 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
3827 else if (piece == 'Z')
3829 /* Parse a chunk of source form definition. */
3830 utp = get_uploaded_tp (num, addr, utpp);
3832 p = strchr (p, ':');
3833 p++; /* skip a colon */
3834 p = unpack_varlen_hex (p, &start);
3835 p++; /* skip a colon */
3836 p = unpack_varlen_hex (p, &xlen);
3837 p++; /* skip a colon */
3839 buf = alloca (strlen (line));
3841 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3844 if (startswith (srctype, "at:"))
3845 utp->at_string = xstrdup (buf);
3846 else if (startswith (srctype, "cond:"))
3847 utp->cond_string = xstrdup (buf);
3848 else if (startswith (srctype, "cmd:"))
3849 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
3851 else if (piece == 'V')
3853 utp = get_uploaded_tp (num, addr, utpp);
3855 parse_tracepoint_status (p, NULL, utp);
3859 /* Don't error out, the target might be sending us optional
3860 info that we don't care about. */
3861 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
3865 /* Convert a textual description of a trace state variable into an
3869 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
3872 ULONGEST num, initval, builtin;
3874 struct uploaded_tsv *utsv = NULL;
3876 buf = alloca (strlen (line));
3879 p = unpack_varlen_hex (p, &num);
3880 p++; /* skip a colon */
3881 p = unpack_varlen_hex (p, &initval);
3882 p++; /* skip a colon */
3883 p = unpack_varlen_hex (p, &builtin);
3884 p++; /* skip a colon */
3885 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3888 utsv = get_uploaded_tsv (num, utsvp);
3889 utsv->initial_value = initval;
3890 utsv->builtin = builtin;
3891 utsv->name = xstrdup (buf);
3895 free_current_marker (void *arg)
3897 struct static_tracepoint_marker **marker_p = arg;
3899 if (*marker_p != NULL)
3901 release_static_tracepoint_marker (*marker_p);
3908 /* Given a line of text defining a static tracepoint marker, parse it
3909 into a "static tracepoint marker" object. Throws an error is
3910 parsing fails. If PP is non-null, it points to one past the end of
3911 the parsed marker definition. */
3914 parse_static_tracepoint_marker_definition (char *line, char **pp,
3915 struct static_tracepoint_marker *marker)
3922 p = unpack_varlen_hex (p, &addr);
3923 p++; /* skip a colon */
3925 marker->gdbarch = target_gdbarch ();
3926 marker->address = (CORE_ADDR) addr;
3928 endp = strchr (p, ':');
3930 error (_("bad marker definition: %s"), line);
3932 marker->str_id = xmalloc (endp - p + 1);
3933 end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
3934 marker->str_id[end] = '\0';
3937 p++; /* skip a colon */
3939 marker->extra = xmalloc (strlen (p) + 1);
3940 end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
3941 marker->extra[end] = '\0';
3947 /* Release a static tracepoint marker's contents. Note that the
3948 object itself isn't released here. There objects are usually on
3952 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
3954 xfree (marker->str_id);
3955 marker->str_id = NULL;
3958 /* Print MARKER to gdb_stdout. */
3961 print_one_static_tracepoint_marker (int count,
3962 struct static_tracepoint_marker *marker)
3964 struct command_line *l;
3967 char wrap_indent[80];
3968 char extra_field_indent[80];
3969 struct ui_out *uiout = current_uiout;
3970 struct cleanup *bkpt_chain;
3971 VEC(breakpoint_p) *tracepoints;
3973 struct symtab_and_line sal;
3977 sal.pc = marker->address;
3979 tracepoints = static_tracepoints_here (marker->address);
3981 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
3983 /* A counter field to help readability. This is not a stable
3985 ui_out_field_int (uiout, "count", count);
3987 ui_out_field_string (uiout, "marker-id", marker->str_id);
3989 ui_out_field_fmt (uiout, "enabled", "%c",
3990 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
3991 ui_out_spaces (uiout, 2);
3993 strcpy (wrap_indent, " ");
3995 if (gdbarch_addr_bit (marker->gdbarch) <= 32)
3996 strcat (wrap_indent, " ");
3998 strcat (wrap_indent, " ");
4000 strcpy (extra_field_indent, " ");
4002 ui_out_field_core_addr (uiout, "addr", marker->gdbarch, marker->address);
4004 sal = find_pc_line (marker->address, 0);
4005 sym = find_pc_sect_function (marker->address, NULL);
4008 ui_out_text (uiout, "in ");
4009 ui_out_field_string (uiout, "func",
4010 SYMBOL_PRINT_NAME (sym));
4011 ui_out_wrap_hint (uiout, wrap_indent);
4012 ui_out_text (uiout, " at ");
4015 ui_out_field_skip (uiout, "func");
4017 if (sal.symtab != NULL)
4019 ui_out_field_string (uiout, "file",
4020 symtab_to_filename_for_display (sal.symtab));
4021 ui_out_text (uiout, ":");
4023 if (ui_out_is_mi_like_p (uiout))
4025 const char *fullname = symtab_to_fullname (sal.symtab);
4027 ui_out_field_string (uiout, "fullname", fullname);
4030 ui_out_field_skip (uiout, "fullname");
4032 ui_out_field_int (uiout, "line", sal.line);
4036 ui_out_field_skip (uiout, "fullname");
4037 ui_out_field_skip (uiout, "line");
4040 ui_out_text (uiout, "\n");
4041 ui_out_text (uiout, extra_field_indent);
4042 ui_out_text (uiout, _("Data: \""));
4043 ui_out_field_string (uiout, "extra-data", marker->extra);
4044 ui_out_text (uiout, "\"\n");
4046 if (!VEC_empty (breakpoint_p, tracepoints))
4048 struct cleanup *cleanup_chain;
4050 struct breakpoint *b;
4052 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
4055 ui_out_text (uiout, extra_field_indent);
4056 ui_out_text (uiout, _("Probed by static tracepoints: "));
4057 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
4060 ui_out_text (uiout, ", ");
4061 ui_out_text (uiout, "#");
4062 ui_out_field_int (uiout, "tracepoint-id", b->number);
4065 do_cleanups (cleanup_chain);
4067 if (ui_out_is_mi_like_p (uiout))
4068 ui_out_field_int (uiout, "number-of-tracepoints",
4069 VEC_length(breakpoint_p, tracepoints));
4071 ui_out_text (uiout, "\n");
4073 VEC_free (breakpoint_p, tracepoints);
4075 do_cleanups (bkpt_chain);
4079 info_static_tracepoint_markers_command (char *arg, int from_tty)
4081 VEC(static_tracepoint_marker_p) *markers;
4082 struct cleanup *old_chain;
4083 struct static_tracepoint_marker *marker;
4084 struct ui_out *uiout = current_uiout;
4087 /* We don't have to check target_can_use_agent and agent's capability on
4088 static tracepoint here, in order to be compatible with older GDBserver.
4089 We don't check USE_AGENT is true or not, because static tracepoints
4090 don't work without in-process agent, so we don't bother users to type
4091 `set agent on' when to use static tracepoint. */
4094 = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
4095 "StaticTracepointMarkersTable");
4097 ui_out_table_header (uiout, 7, ui_left, "counter", "Cnt");
4099 ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
4101 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
4102 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
4103 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
4105 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
4106 ui_out_table_header (uiout, 40, ui_noalign, "what", "What");
4108 ui_out_table_body (uiout);
4110 markers = target_static_tracepoint_markers_by_strid (NULL);
4111 make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
4114 VEC_iterate (static_tracepoint_marker_p,
4115 markers, i, marker);
4118 print_one_static_tracepoint_marker (i + 1, marker);
4119 release_static_tracepoint_marker (marker);
4122 do_cleanups (old_chain);
4125 /* The $_sdata convenience variable is a bit special. We don't know
4126 for sure type of the value until we actually have a chance to fetch
4127 the data --- the size of the object depends on what has been
4128 collected. We solve this by making $_sdata be an internalvar that
4129 creates a new value on access. */
4131 /* Return a new value with the correct type for the sdata object of
4132 the current trace frame. Return a void value if there's no object
4135 static struct value *
4136 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
4142 /* We need to read the whole object before we know its size. */
4143 size = target_read_alloc (¤t_target,
4144 TARGET_OBJECT_STATIC_TRACE_DATA,
4151 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
4153 v = allocate_value (type);
4154 memcpy (value_contents_raw (v), buf, size);
4159 return allocate_value (builtin_type (gdbarch)->builtin_void);
4162 #if !defined(HAVE_LIBEXPAT)
4164 struct traceframe_info *
4165 parse_traceframe_info (const char *tframe_info)
4167 static int have_warned;
4172 warning (_("Can not parse XML trace frame info; XML support "
4173 "was disabled at compile time"));
4179 #else /* HAVE_LIBEXPAT */
4181 #include "xml-support.h"
4183 /* Handle the start of a <memory> element. */
4186 traceframe_info_start_memory (struct gdb_xml_parser *parser,
4187 const struct gdb_xml_element *element,
4188 void *user_data, VEC(gdb_xml_value_s) *attributes)
4190 struct traceframe_info *info = user_data;
4191 struct mem_range *r = VEC_safe_push (mem_range_s, info->memory, NULL);
4192 ULONGEST *start_p, *length_p;
4194 start_p = xml_find_attribute (attributes, "start")->value;
4195 length_p = xml_find_attribute (attributes, "length")->value;
4197 r->start = *start_p;
4198 r->length = *length_p;
4201 /* Handle the start of a <tvar> element. */
4204 traceframe_info_start_tvar (struct gdb_xml_parser *parser,
4205 const struct gdb_xml_element *element,
4207 VEC(gdb_xml_value_s) *attributes)
4209 struct traceframe_info *info = user_data;
4210 const char *id_attrib = xml_find_attribute (attributes, "id")->value;
4211 int id = gdb_xml_parse_ulongest (parser, id_attrib);
4213 VEC_safe_push (int, info->tvars, id);
4216 /* Discard the constructed trace frame info (if an error occurs). */
4219 free_result (void *p)
4221 struct traceframe_info *result = p;
4223 free_traceframe_info (result);
4226 /* The allowed elements and attributes for an XML memory map. */
4228 static const struct gdb_xml_attribute memory_attributes[] = {
4229 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4230 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4231 { NULL, GDB_XML_AF_NONE, NULL, NULL }
4234 static const struct gdb_xml_attribute tvar_attributes[] = {
4235 { "id", GDB_XML_AF_NONE, NULL, NULL },
4236 { NULL, GDB_XML_AF_NONE, NULL, NULL }
4239 static const struct gdb_xml_element traceframe_info_children[] = {
4240 { "memory", memory_attributes, NULL,
4241 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
4242 traceframe_info_start_memory, NULL },
4243 { "tvar", tvar_attributes, NULL,
4244 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
4245 traceframe_info_start_tvar, NULL },
4246 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4249 static const struct gdb_xml_element traceframe_info_elements[] = {
4250 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
4252 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4255 /* Parse a traceframe-info XML document. */
4257 struct traceframe_info *
4258 parse_traceframe_info (const char *tframe_info)
4260 struct traceframe_info *result;
4261 struct cleanup *back_to;
4263 result = XCNEW (struct traceframe_info);
4264 back_to = make_cleanup (free_result, result);
4266 if (gdb_xml_parse_quick (_("trace frame info"),
4267 "traceframe-info.dtd", traceframe_info_elements,
4268 tframe_info, result) == 0)
4270 /* Parsed successfully, keep the result. */
4271 discard_cleanups (back_to);
4276 do_cleanups (back_to);
4280 #endif /* HAVE_LIBEXPAT */
4282 /* Returns the traceframe_info object for the current traceframe.
4283 This is where we avoid re-fetching the object from the target if we
4284 already have it cached. */
4286 struct traceframe_info *
4287 get_traceframe_info (void)
4289 if (traceframe_info == NULL)
4290 traceframe_info = target_traceframe_info ();
4292 return traceframe_info;
4295 /* If the target supports the query, return in RESULT the set of
4296 collected memory in the current traceframe, found within the LEN
4297 bytes range starting at MEMADDR. Returns true if the target
4298 supports the query, otherwise returns false, and RESULT is left
4302 traceframe_available_memory (VEC(mem_range_s) **result,
4303 CORE_ADDR memaddr, ULONGEST len)
4305 struct traceframe_info *info = get_traceframe_info ();
4309 struct mem_range *r;
4314 for (i = 0; VEC_iterate (mem_range_s, info->memory, i, r); i++)
4315 if (mem_ranges_overlap (r->start, r->length, memaddr, len))
4317 ULONGEST lo1, hi1, lo2, hi2;
4318 struct mem_range *nr;
4321 hi1 = memaddr + len;
4324 hi2 = r->start + r->length;
4326 nr = VEC_safe_push (mem_range_s, *result, NULL);
4328 nr->start = max (lo1, lo2);
4329 nr->length = min (hi1, hi2) - nr->start;
4332 normalize_mem_ranges (*result);
4339 /* Implementation of `sdata' variable. */
4341 static const struct internalvar_funcs sdata_funcs =
4348 /* module initialization */
4350 _initialize_tracepoint (void)
4352 struct cmd_list_element *c;
4354 /* Explicitly create without lookup, since that tries to create a
4355 value with a void typed value, and when we get here, gdbarch
4356 isn't initialized yet. At this point, we're quite sure there
4357 isn't another convenience variable of the same name. */
4358 create_internalvar_type_lazy ("_sdata", &sdata_funcs, NULL);
4360 traceframe_number = -1;
4361 tracepoint_number = -1;
4363 add_info ("scope", scope_info,
4364 _("List the variables local to a scope"));
4366 add_cmd ("tracepoints", class_trace, NULL,
4367 _("Tracing of program execution without stopping the program."),
4370 add_com ("tdump", class_trace, trace_dump_command,
4371 _("Print everything collected at the current tracepoint."));
4373 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
4374 Define a trace state variable.\n\
4375 Argument is a $-prefixed name, optionally followed\n\
4376 by '=' and an expression that sets the initial value\n\
4377 at the start of tracing."));
4378 set_cmd_completer (c, expression_completer);
4380 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
4381 Delete one or more trace state variables.\n\
4382 Arguments are the names of the variables to delete.\n\
4383 If no arguments are supplied, delete all variables."), &deletelist);
4384 /* FIXME add a trace variable completer. */
4386 add_info ("tvariables", tvariables_info, _("\
4387 Status of trace state variables and their values.\n\
4390 add_info ("static-tracepoint-markers",
4391 info_static_tracepoint_markers_command, _("\
4392 List target static tracepoints markers.\n\
4395 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
4396 Select a trace frame;\n\
4397 No argument means forward by one frame; '-' means backward by one frame."),
4398 &tfindlist, "tfind ", 1, &cmdlist);
4400 add_cmd ("outside", class_trace, trace_find_outside_command, _("\
4401 Select a trace frame whose PC is outside the given range (exclusive).\n\
4402 Usage: tfind outside addr1, addr2"),
4405 add_cmd ("range", class_trace, trace_find_range_command, _("\
4406 Select a trace frame whose PC is in the given range (inclusive).\n\
4407 Usage: tfind range addr1,addr2"),
4410 add_cmd ("line", class_trace, trace_find_line_command, _("\
4411 Select a trace frame by source line.\n\
4412 Argument can be a line number (with optional source file),\n\
4413 a function name, or '*' followed by an address.\n\
4414 Default argument is 'the next source line that was traced'."),
4417 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
4418 Select a trace frame by tracepoint number.\n\
4419 Default is the tracepoint for the current trace frame."),
4422 add_cmd ("pc", class_trace, trace_find_pc_command, _("\
4423 Select a trace frame by PC.\n\
4424 Default is the current PC, or the PC of the current trace frame."),
4427 add_cmd ("end", class_trace, trace_find_end_command, _("\
4428 De-select any trace frame and resume 'live' debugging."),
4431 add_alias_cmd ("none", "end", class_trace, 0, &tfindlist);
4433 add_cmd ("start", class_trace, trace_find_start_command,
4434 _("Select the first trace frame in the trace buffer."),
4437 add_com ("tstatus", class_trace, trace_status_command,
4438 _("Display the status of the current trace data collection."));
4440 add_com ("tstop", class_trace, trace_stop_command, _("\
4441 Stop trace data collection.\n\
4442 Usage: tstop [ <notes> ... ]\n\
4443 Any arguments supplied are recorded with the trace as a stop reason and\n\
4444 reported by tstatus (if the target supports trace notes)."));
4446 add_com ("tstart", class_trace, trace_start_command, _("\
4447 Start trace data collection.\n\
4448 Usage: tstart [ <notes> ... ]\n\
4449 Any arguments supplied are recorded with the trace as a note and\n\
4450 reported by tstatus (if the target supports trace notes)."));
4452 add_com ("end", class_trace, end_actions_pseudocommand, _("\
4453 Ends a list of commands or actions.\n\
4454 Several GDB commands allow you to enter a list of commands or actions.\n\
4455 Entering \"end\" on a line by itself is the normal way to terminate\n\
4457 Note: the \"end\" command cannot be used at the gdb prompt."));
4459 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
4460 Specify single-stepping behavior at a tracepoint.\n\
4461 Argument is number of instructions to trace in single-step mode\n\
4462 following the tracepoint. This command is normally followed by\n\
4463 one or more \"collect\" commands, to specify what to collect\n\
4464 while single-stepping.\n\n\
4465 Note: this command can only be used in a tracepoint \"actions\" list."));
4467 add_com_alias ("ws", "while-stepping", class_alias, 0);
4468 add_com_alias ("stepping", "while-stepping", class_alias, 0);
4470 add_com ("collect", class_trace, collect_pseudocommand, _("\
4471 Specify one or more data items to be collected at a tracepoint.\n\
4472 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4473 collect all data (variables, registers) referenced by that expression.\n\
4474 Also accepts the following special arguments:\n\
4475 $regs -- all registers.\n\
4476 $args -- all function arguments.\n\
4477 $locals -- all variables local to the block/function scope.\n\
4478 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4479 Note: this command can only be used in a tracepoint \"actions\" list."));
4481 add_com ("teval", class_trace, teval_pseudocommand, _("\
4482 Specify one or more expressions to be evaluated at a tracepoint.\n\
4483 Accepts a comma-separated list of (one or more) expressions.\n\
4484 The result of each evaluation will be discarded.\n\
4485 Note: this command can only be used in a tracepoint \"actions\" list."));
4487 add_com ("actions", class_trace, trace_actions_command, _("\
4488 Specify the actions to be taken at a tracepoint.\n\
4489 Tracepoint actions may include collecting of specified data,\n\
4490 single-stepping, or enabling/disabling other tracepoints,\n\
4491 depending on target's capabilities."));
4493 default_collect = xstrdup ("");
4494 add_setshow_string_cmd ("default-collect", class_trace,
4495 &default_collect, _("\
4496 Set the list of expressions to collect by default"), _("\
4497 Show the list of expressions to collect by default"), NULL,
4499 &setlist, &showlist);
4501 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
4502 &disconnected_tracing, _("\
4503 Set whether tracing continues after GDB disconnects."), _("\
4504 Show whether tracing continues after GDB disconnects."), _("\
4505 Use this to continue a tracing run even if GDB disconnects\n\
4506 or detaches from the target. You can reconnect later and look at\n\
4507 trace data collected in the meantime."),
4508 set_disconnected_tracing,
4513 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
4514 &circular_trace_buffer, _("\
4515 Set target's use of circular trace buffer."), _("\
4516 Show target's use of circular trace buffer."), _("\
4517 Use this to make the trace buffer into a circular buffer,\n\
4518 which will discard traceframes (oldest first) instead of filling\n\
4519 up and stopping the trace run."),
4520 set_circular_trace_buffer,
4525 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class,
4526 &trace_buffer_size, _("\
4527 Set requested size of trace buffer."), _("\
4528 Show requested size of trace buffer."), _("\
4529 Use this to choose a size for the trace buffer. Some targets\n\
4530 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
4531 disables any attempt to set the buffer size and lets the target choose."),
4532 set_trace_buffer_size, NULL,
4533 &setlist, &showlist);
4535 add_setshow_string_cmd ("trace-user", class_trace,
4537 Set the user name to use for current and future trace runs"), _("\
4538 Show the user name to use for current and future trace runs"), NULL,
4539 set_trace_user, NULL,
4540 &setlist, &showlist);
4542 add_setshow_string_cmd ("trace-notes", class_trace,
4544 Set notes string to use for current and future trace runs"), _("\
4545 Show the notes string to use for current and future trace runs"), NULL,
4546 set_trace_notes, NULL,
4547 &setlist, &showlist);
4549 add_setshow_string_cmd ("trace-stop-notes", class_trace,
4550 &trace_stop_notes, _("\
4551 Set notes string to use for future tstop commands"), _("\
4552 Show the notes string to use for future tstop commands"), NULL,
4553 set_trace_stop_notes, NULL,
4554 &setlist, &showlist);