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 = (struct memrange *) 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 = XCNEWVEC (struct memrange, clist->listsize);
1249 clist->aexpr_listsize = 128;
1250 clist->aexpr_list = XCNEWVEC (struct agent_expr *, clist->aexpr_listsize);
1253 /* Reduce a collection list to string form (for gdb protocol). */
1255 stringify_collection_list (struct collection_list *list)
1257 char temp_buf[2048];
1261 char *(*str_list)[];
1265 count = 1 + 1 + list->next_memrange + list->next_aexpr_elt + 1;
1266 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1268 if (list->strace_data)
1271 printf_filtered ("\nCollecting static trace data\n");
1274 (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
1278 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1279 if (list->regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */
1281 if (list->regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
1284 printf_filtered ("\nCollecting registers (mask): 0x");
1289 QUIT; /* Allow user to bail out with ^C. */
1291 printf_filtered ("%02X", list->regs_mask[i]);
1292 sprintf (end, "%02X", list->regs_mask[i]);
1295 (*str_list)[ndx] = xstrdup (temp_buf);
1299 printf_filtered ("\n");
1300 if (list->next_memrange > 0 && info_verbose)
1301 printf_filtered ("Collecting memranges: \n");
1302 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1304 QUIT; /* Allow user to bail out with ^C. */
1305 sprintf_vma (tmp2, list->list[i].start);
1308 printf_filtered ("(%d, %s, %ld)\n",
1311 (long) (list->list[i].end - list->list[i].start));
1313 if (count + 27 > MAX_AGENT_EXPR_LEN)
1315 (*str_list)[ndx] = savestring (temp_buf, count);
1322 bfd_signed_vma length = list->list[i].end - list->list[i].start;
1324 /* The "%X" conversion specifier expects an unsigned argument,
1325 so passing -1 (memrange_absolute) to it directly gives you
1326 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1328 if (list->list[i].type == memrange_absolute)
1329 sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
1331 sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
1334 count += strlen (end);
1335 end = temp_buf + count;
1338 for (i = 0; i < list->next_aexpr_elt; i++)
1340 QUIT; /* Allow user to bail out with ^C. */
1341 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1343 (*str_list)[ndx] = savestring (temp_buf, count);
1348 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1349 end += 10; /* 'X' + 8 hex digits + ',' */
1352 end = mem2hex (list->aexpr_list[i]->buf,
1353 end, list->aexpr_list[i]->len);
1354 count += 2 * list->aexpr_list[i]->len;
1359 (*str_list)[ndx] = savestring (temp_buf, count);
1364 (*str_list)[ndx] = NULL;
1375 /* Add the printed expression EXP to *LIST. */
1378 append_exp (struct expression *exp, VEC(char_ptr) **list)
1380 struct ui_file *tmp_stream = mem_fileopen ();
1383 print_expression (exp, tmp_stream);
1385 text = ui_file_xstrdup (tmp_stream, NULL);
1387 VEC_safe_push (char_ptr, *list, text);
1388 ui_file_delete (tmp_stream);
1392 encode_actions_1 (struct command_line *action,
1393 struct bp_location *tloc,
1395 LONGEST frame_offset,
1396 struct collection_list *collect,
1397 struct collection_list *stepping_list)
1399 const char *action_exp;
1400 struct expression *exp = NULL;
1402 struct value *tempval;
1403 struct cmd_list_element *cmd;
1404 struct agent_expr *aexpr;
1406 for (; action; action = action->next)
1408 QUIT; /* Allow user to bail out with ^C. */
1409 action_exp = action->line;
1410 action_exp = skip_spaces_const (action_exp);
1412 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1414 error (_("Bad action list item: %s"), action_exp);
1416 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1418 int trace_string = 0;
1420 if (*action_exp == '/')
1421 action_exp = decode_agent_options (action_exp, &trace_string);
1424 { /* Repeat over a comma-separated list. */
1425 QUIT; /* Allow user to bail out with ^C. */
1426 action_exp = skip_spaces_const (action_exp);
1428 if (0 == strncasecmp ("$reg", action_exp, 4))
1430 for (i = 0; i < gdbarch_num_regs (tloc->gdbarch); i++)
1431 add_register (collect, i);
1432 action_exp = strchr (action_exp, ','); /* more? */
1434 else if (0 == strncasecmp ("$arg", action_exp, 4))
1436 add_local_symbols (collect,
1443 action_exp = strchr (action_exp, ','); /* more? */
1445 else if (0 == strncasecmp ("$loc", action_exp, 4))
1447 add_local_symbols (collect,
1454 action_exp = strchr (action_exp, ','); /* more? */
1456 else if (0 == strncasecmp ("$_ret", action_exp, 5))
1458 struct cleanup *old_chain1 = NULL;
1460 aexpr = gen_trace_for_return_address (tloc->address,
1464 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1467 report_agent_reqs_errors (aexpr);
1469 discard_cleanups (old_chain1);
1470 add_aexpr (collect, aexpr);
1472 /* take care of the registers */
1473 if (aexpr->reg_mask_len > 0)
1477 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1479 QUIT; /* allow user to bail out with ^C */
1480 if (aexpr->reg_mask[ndx1] != 0)
1482 /* assume chars have 8 bits */
1483 for (ndx2 = 0; ndx2 < 8; ndx2++)
1484 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1485 /* it's used -- record it */
1486 add_register (collect,
1492 action_exp = strchr (action_exp, ','); /* more? */
1494 else if (0 == strncasecmp ("$_sdata", action_exp, 7))
1496 add_static_trace_data (collect);
1497 action_exp = strchr (action_exp, ','); /* more? */
1502 struct cleanup *old_chain = NULL;
1503 struct cleanup *old_chain1 = NULL;
1505 exp = parse_exp_1 (&action_exp, tloc->address,
1506 block_for_pc (tloc->address), 1);
1507 old_chain = make_cleanup (free_current_contents, &exp);
1509 switch (exp->elts[0].opcode)
1513 const char *name = &exp->elts[2].string;
1515 i = user_reg_map_name_to_regnum (tloc->gdbarch,
1516 name, strlen (name));
1518 internal_error (__FILE__, __LINE__,
1519 _("Register $%s not available"),
1522 printf_filtered ("OP_REGISTER: ");
1523 add_register (collect, i);
1528 /* Safe because we know it's a simple expression. */
1529 tempval = evaluate_expression (exp);
1530 addr = value_address (tempval);
1531 /* Initialize the TYPE_LENGTH if it is a typedef. */
1532 check_typedef (exp->elts[1].type);
1533 add_memrange (collect, memrange_absolute, addr,
1534 TYPE_LENGTH (exp->elts[1].type));
1535 append_exp (exp, &collect->computed);
1540 struct symbol *sym = exp->elts[2].symbol;
1541 char_ptr name = (char_ptr) SYMBOL_NATURAL_NAME (sym);
1543 collect_symbol (collect,
1544 exp->elts[2].symbol,
1550 VEC_safe_push (char_ptr,
1551 collect->wholly_collected,
1556 default: /* Full-fledged expression. */
1557 aexpr = gen_trace_for_expr (tloc->address, exp,
1560 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1564 report_agent_reqs_errors (aexpr);
1566 discard_cleanups (old_chain1);
1567 add_aexpr (collect, aexpr);
1569 /* Take care of the registers. */
1570 if (aexpr->reg_mask_len > 0)
1575 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1577 QUIT; /* Allow user to bail out with ^C. */
1578 if (aexpr->reg_mask[ndx1] != 0)
1580 /* Assume chars have 8 bits. */
1581 for (ndx2 = 0; ndx2 < 8; ndx2++)
1582 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1583 /* It's used -- record it. */
1584 add_register (collect,
1590 append_exp (exp, &collect->computed);
1593 do_cleanups (old_chain);
1596 while (action_exp && *action_exp++ == ',');
1598 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1601 { /* Repeat over a comma-separated list. */
1602 QUIT; /* Allow user to bail out with ^C. */
1603 action_exp = skip_spaces_const (action_exp);
1606 struct cleanup *old_chain = NULL;
1607 struct cleanup *old_chain1 = NULL;
1609 exp = parse_exp_1 (&action_exp, tloc->address,
1610 block_for_pc (tloc->address), 1);
1611 old_chain = make_cleanup (free_current_contents, &exp);
1613 aexpr = gen_eval_for_expr (tloc->address, exp);
1614 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1617 report_agent_reqs_errors (aexpr);
1619 discard_cleanups (old_chain1);
1620 /* Even though we're not officially collecting, add
1621 to the collect list anyway. */
1622 add_aexpr (collect, aexpr);
1624 do_cleanups (old_chain);
1627 while (action_exp && *action_exp++ == ',');
1629 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1631 /* We check against nested while-stepping when setting
1632 breakpoint action, so no way to run into nested
1634 gdb_assert (stepping_list);
1636 encode_actions_1 (action->body_list[0], tloc, frame_reg,
1637 frame_offset, stepping_list, NULL);
1640 error (_("Invalid tracepoint command '%s'"), action->line);
1644 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1645 and STEPPING_LIST. Return a cleanup pointer to clean up both
1646 TRACEPOINT_LIST and STEPPING_LIST. */
1649 encode_actions_and_make_cleanup (struct bp_location *tloc,
1650 struct collection_list *tracepoint_list,
1651 struct collection_list *stepping_list)
1653 char *default_collect_line = NULL;
1654 struct command_line *actions;
1655 struct command_line *default_collect_action = NULL;
1657 LONGEST frame_offset;
1658 struct cleanup *back_to, *return_chain;
1660 return_chain = make_cleanup (null_cleanup, NULL);
1661 init_collection_list (tracepoint_list);
1662 init_collection_list (stepping_list);
1664 make_cleanup (do_clear_collection_list, tracepoint_list);
1665 make_cleanup (do_clear_collection_list, stepping_list);
1667 back_to = make_cleanup (null_cleanup, NULL);
1668 gdbarch_virtual_frame_pointer (tloc->gdbarch,
1669 tloc->address, &frame_reg, &frame_offset);
1671 actions = all_tracepoint_actions_and_cleanup (tloc->owner);
1673 encode_actions_1 (actions, tloc, frame_reg, frame_offset,
1674 tracepoint_list, stepping_list);
1676 memrange_sortmerge (tracepoint_list);
1677 memrange_sortmerge (stepping_list);
1679 do_cleanups (back_to);
1680 return return_chain;
1683 /* Render all actions into gdb protocol. */
1686 encode_actions_rsp (struct bp_location *tloc, char ***tdp_actions,
1687 char ***stepping_actions)
1689 struct collection_list tracepoint_list, stepping_list;
1690 struct cleanup *cleanup;
1692 *tdp_actions = NULL;
1693 *stepping_actions = NULL;
1695 cleanup = encode_actions_and_make_cleanup (tloc, &tracepoint_list,
1698 *tdp_actions = stringify_collection_list (&tracepoint_list);
1699 *stepping_actions = stringify_collection_list (&stepping_list);
1701 do_cleanups (cleanup);
1705 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1707 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1709 collect->aexpr_list = XRESIZEVEC (struct agent_expr *,
1710 collect->aexpr_list,
1711 2 * collect->aexpr_listsize);
1712 collect->aexpr_listsize *= 2;
1714 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1715 collect->next_aexpr_elt++;
1719 process_tracepoint_on_disconnect (void)
1721 VEC(breakpoint_p) *tp_vec = NULL;
1723 struct breakpoint *b;
1724 int has_pending_p = 0;
1726 /* Check whether we still have pending tracepoint. If we have, warn the
1727 user that pending tracepoint will no longer work. */
1728 tp_vec = all_tracepoints ();
1729 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1738 struct bp_location *loc1;
1740 for (loc1 = b->loc; loc1; loc1 = loc1->next)
1742 if (loc1->shlib_disabled)
1753 VEC_free (breakpoint_p, tp_vec);
1756 warning (_("Pending tracepoints will not be resolved while"
1757 " GDB is disconnected\n"));
1760 /* Reset local state of tracing. */
1763 trace_reset_local_state (void)
1765 set_traceframe_num (-1);
1766 set_tracepoint_num (-1);
1767 set_traceframe_context (NULL);
1768 clear_traceframe_info ();
1772 start_tracing (char *notes)
1774 VEC(breakpoint_p) *tp_vec = NULL;
1776 struct breakpoint *b;
1777 struct trace_state_variable *tsv;
1778 int any_enabled = 0, num_to_download = 0;
1781 tp_vec = all_tracepoints ();
1783 /* No point in tracing without any tracepoints... */
1784 if (VEC_length (breakpoint_p, tp_vec) == 0)
1786 VEC_free (breakpoint_p, tp_vec);
1787 error (_("No tracepoints defined, not starting trace"));
1790 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1792 struct tracepoint *t = (struct tracepoint *) b;
1793 struct bp_location *loc;
1795 if (b->enable_state == bp_enabled)
1798 if ((b->type == bp_fast_tracepoint
1799 ? may_insert_fast_tracepoints
1800 : may_insert_tracepoints))
1803 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1804 (b->type == bp_fast_tracepoint ? "fast " : ""), b->number);
1809 if (target_supports_enable_disable_tracepoint ())
1810 warning (_("No tracepoints enabled"));
1813 /* No point in tracing with only disabled tracepoints that
1814 cannot be re-enabled. */
1815 VEC_free (breakpoint_p, tp_vec);
1816 error (_("No tracepoints enabled, not starting trace"));
1820 if (num_to_download <= 0)
1822 VEC_free (breakpoint_p, tp_vec);
1823 error (_("No tracepoints that may be downloaded, not starting trace"));
1826 target_trace_init ();
1828 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1830 struct tracepoint *t = (struct tracepoint *) b;
1831 struct bp_location *loc;
1832 int bp_location_downloaded = 0;
1834 /* Clear `inserted' flag. */
1835 for (loc = b->loc; loc; loc = loc->next)
1838 if ((b->type == bp_fast_tracepoint
1839 ? !may_insert_fast_tracepoints
1840 : !may_insert_tracepoints))
1843 t->number_on_target = 0;
1845 for (loc = b->loc; loc; loc = loc->next)
1847 /* Since tracepoint locations are never duplicated, `inserted'
1848 flag should be zero. */
1849 gdb_assert (!loc->inserted);
1851 target_download_tracepoint (loc);
1854 bp_location_downloaded = 1;
1857 t->number_on_target = b->number;
1859 for (loc = b->loc; loc; loc = loc->next)
1860 if (loc->probe.probe != NULL
1861 && loc->probe.probe->pops->set_semaphore != NULL)
1862 loc->probe.probe->pops->set_semaphore (loc->probe.probe,
1866 if (bp_location_downloaded)
1867 observer_notify_breakpoint_modified (b);
1869 VEC_free (breakpoint_p, tp_vec);
1871 /* Send down all the trace state variables too. */
1872 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1874 target_download_trace_state_variable (tsv);
1877 /* Tell target to treat text-like sections as transparent. */
1878 target_trace_set_readonly_regions ();
1879 /* Set some mode flags. */
1880 target_set_disconnected_tracing (disconnected_tracing);
1881 target_set_circular_trace_buffer (circular_trace_buffer);
1882 target_set_trace_buffer_size (trace_buffer_size);
1885 notes = trace_notes;
1886 ret = target_set_trace_notes (trace_user, notes, NULL);
1888 if (!ret && (trace_user || notes))
1889 warning (_("Target does not support trace user/notes, info ignored"));
1891 /* Now insert traps and begin collecting data. */
1892 target_trace_start ();
1894 /* Reset our local state. */
1895 trace_reset_local_state ();
1896 current_trace_status()->running = 1;
1899 /* The tstart command requests the target to start a new trace run.
1900 The command passes any arguments it has to the target verbatim, as
1901 an optional "trace note". This is useful as for instance a warning
1902 to other users if the trace runs disconnected, and you don't want
1903 anybody else messing with the target. */
1906 trace_start_command (char *args, int from_tty)
1908 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1910 if (current_trace_status ()->running)
1913 && !query (_("A trace is running already. Start a new run? ")))
1914 error (_("New trace run not started."));
1917 start_tracing (args);
1920 /* The tstop command stops the tracing run. The command passes any
1921 supplied arguments to the target verbatim as a "stop note"; if the
1922 target supports trace notes, then it will be reported back as part
1923 of the trace run's status. */
1926 trace_stop_command (char *args, int from_tty)
1928 if (!current_trace_status ()->running)
1929 error (_("Trace is not running."));
1931 stop_tracing (args);
1935 stop_tracing (char *note)
1938 VEC(breakpoint_p) *tp_vec = NULL;
1940 struct breakpoint *t;
1942 target_trace_stop ();
1944 tp_vec = all_tracepoints ();
1945 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1947 struct bp_location *loc;
1949 if ((t->type == bp_fast_tracepoint
1950 ? !may_insert_fast_tracepoints
1951 : !may_insert_tracepoints))
1954 for (loc = t->loc; loc; loc = loc->next)
1956 /* GDB can be totally absent in some disconnected trace scenarios,
1957 but we don't really care if this semaphore goes out of sync.
1958 That's why we are decrementing it here, but not taking care
1960 if (loc->probe.probe != NULL
1961 && loc->probe.probe->pops->clear_semaphore != NULL)
1962 loc->probe.probe->pops->clear_semaphore (loc->probe.probe,
1968 VEC_free (breakpoint_p, tp_vec);
1971 note = trace_stop_notes;
1972 ret = target_set_trace_notes (NULL, NULL, note);
1975 warning (_("Target does not support trace notes, note ignored"));
1977 /* Should change in response to reply? */
1978 current_trace_status ()->running = 0;
1981 /* tstatus command */
1983 trace_status_command (char *args, int from_tty)
1985 struct trace_status *ts = current_trace_status ();
1987 VEC(breakpoint_p) *tp_vec = NULL;
1988 struct breakpoint *t;
1990 status = target_get_trace_status (ts);
1994 if (ts->filename != NULL)
1995 printf_filtered (_("Using a trace file.\n"));
1998 printf_filtered (_("Trace can not be run on this target.\n"));
2003 if (!ts->running_known)
2005 printf_filtered (_("Run/stop status is unknown.\n"));
2007 else if (ts->running)
2009 printf_filtered (_("Trace is running on the target.\n"));
2013 switch (ts->stop_reason)
2015 case trace_never_run:
2016 printf_filtered (_("No trace has been run on the target.\n"));
2020 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
2023 printf_filtered (_("Trace stopped by a tstop command.\n"));
2025 case trace_buffer_full:
2026 printf_filtered (_("Trace stopped because the buffer was full.\n"));
2028 case trace_disconnected:
2029 printf_filtered (_("Trace stopped because of disconnection.\n"));
2031 case tracepoint_passcount:
2032 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
2033 ts->stopping_tracepoint);
2035 case tracepoint_error:
2036 if (ts->stopping_tracepoint)
2037 printf_filtered (_("Trace stopped by an "
2038 "error (%s, tracepoint %d).\n"),
2039 ts->stop_desc, ts->stopping_tracepoint);
2041 printf_filtered (_("Trace stopped by an error (%s).\n"),
2044 case trace_stop_reason_unknown:
2045 printf_filtered (_("Trace stopped for an unknown reason.\n"));
2048 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
2054 if (ts->traceframes_created >= 0
2055 && ts->traceframe_count != ts->traceframes_created)
2057 printf_filtered (_("Buffer contains %d trace "
2058 "frames (of %d created total).\n"),
2059 ts->traceframe_count, ts->traceframes_created);
2061 else if (ts->traceframe_count >= 0)
2063 printf_filtered (_("Collected %d trace frames.\n"),
2064 ts->traceframe_count);
2067 if (ts->buffer_free >= 0)
2069 if (ts->buffer_size >= 0)
2071 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2072 ts->buffer_free, ts->buffer_size);
2073 if (ts->buffer_size > 0)
2074 printf_filtered (_(" (%d%% full)"),
2075 ((int) ((((long long) (ts->buffer_size
2076 - ts->buffer_free)) * 100)
2077 / ts->buffer_size)));
2078 printf_filtered (_(".\n"));
2081 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2085 if (ts->disconnected_tracing)
2086 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2088 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2090 if (ts->circular_buffer)
2091 printf_filtered (_("Trace buffer is circular.\n"));
2093 if (ts->user_name && strlen (ts->user_name) > 0)
2094 printf_filtered (_("Trace user is %s.\n"), ts->user_name);
2096 if (ts->notes && strlen (ts->notes) > 0)
2097 printf_filtered (_("Trace notes: %s.\n"), ts->notes);
2099 /* Now report on what we're doing with tfind. */
2100 if (traceframe_number >= 0)
2101 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2102 traceframe_number, tracepoint_number);
2104 printf_filtered (_("Not looking at any trace frame.\n"));
2106 /* Report start/stop times if supplied. */
2111 LONGEST run_time = ts->stop_time - ts->start_time;
2113 /* Reporting a run time is more readable than two long numbers. */
2114 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2115 (long int) (ts->start_time / 1000000),
2116 (long int) (ts->start_time % 1000000),
2117 (long int) (run_time / 1000000),
2118 (long int) (run_time % 1000000));
2121 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2122 (long int) (ts->start_time / 1000000),
2123 (long int) (ts->start_time % 1000000));
2125 else if (ts->stop_time)
2126 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2127 (long int) (ts->stop_time / 1000000),
2128 (long int) (ts->stop_time % 1000000));
2130 /* Now report any per-tracepoint status available. */
2131 tp_vec = all_tracepoints ();
2133 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
2134 target_get_tracepoint_status (t, NULL);
2136 VEC_free (breakpoint_p, tp_vec);
2139 /* Report the trace status to uiout, in a way suitable for MI, and not
2140 suitable for CLI. If ON_STOP is true, suppress a few fields that
2141 are not meaningful in the -trace-stop response.
2143 The implementation is essentially parallel to trace_status_command, but
2144 merging them will result in unreadable code. */
2146 trace_status_mi (int on_stop)
2148 struct ui_out *uiout = current_uiout;
2149 struct trace_status *ts = current_trace_status ();
2152 status = target_get_trace_status (ts);
2154 if (status == -1 && ts->filename == NULL)
2156 ui_out_field_string (uiout, "supported", "0");
2160 if (ts->filename != NULL)
2161 ui_out_field_string (uiout, "supported", "file");
2163 ui_out_field_string (uiout, "supported", "1");
2165 if (ts->filename != NULL)
2166 ui_out_field_string (uiout, "trace-file", ts->filename);
2168 gdb_assert (ts->running_known);
2172 ui_out_field_string (uiout, "running", "1");
2174 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2175 Given that the frontend gets the status either on -trace-stop, or from
2176 -trace-status after re-connection, it does not seem like this
2177 information is necessary for anything. It is not necessary for either
2178 figuring the vital state of the target nor for navigation of trace
2179 frames. If the frontend wants to show the current state is some
2180 configure dialog, it can request the value when such dialog is
2181 invoked by the user. */
2185 char *stop_reason = NULL;
2186 int stopping_tracepoint = -1;
2189 ui_out_field_string (uiout, "running", "0");
2191 if (ts->stop_reason != trace_stop_reason_unknown)
2193 switch (ts->stop_reason)
2196 stop_reason = "request";
2198 case trace_buffer_full:
2199 stop_reason = "overflow";
2201 case trace_disconnected:
2202 stop_reason = "disconnection";
2204 case tracepoint_passcount:
2205 stop_reason = "passcount";
2206 stopping_tracepoint = ts->stopping_tracepoint;
2208 case tracepoint_error:
2209 stop_reason = "error";
2210 stopping_tracepoint = ts->stopping_tracepoint;
2216 ui_out_field_string (uiout, "stop-reason", stop_reason);
2217 if (stopping_tracepoint != -1)
2218 ui_out_field_int (uiout, "stopping-tracepoint",
2219 stopping_tracepoint);
2220 if (ts->stop_reason == tracepoint_error)
2221 ui_out_field_string (uiout, "error-description",
2227 if (ts->traceframe_count != -1)
2228 ui_out_field_int (uiout, "frames", ts->traceframe_count);
2229 if (ts->traceframes_created != -1)
2230 ui_out_field_int (uiout, "frames-created", ts->traceframes_created);
2231 if (ts->buffer_size != -1)
2232 ui_out_field_int (uiout, "buffer-size", ts->buffer_size);
2233 if (ts->buffer_free != -1)
2234 ui_out_field_int (uiout, "buffer-free", ts->buffer_free);
2236 ui_out_field_int (uiout, "disconnected", ts->disconnected_tracing);
2237 ui_out_field_int (uiout, "circular", ts->circular_buffer);
2239 ui_out_field_string (uiout, "user-name", ts->user_name);
2240 ui_out_field_string (uiout, "notes", ts->notes);
2245 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2246 (long int) (ts->start_time / 1000000),
2247 (long int) (ts->start_time % 1000000));
2248 ui_out_field_string (uiout, "start-time", buf);
2249 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2250 (long int) (ts->stop_time / 1000000),
2251 (long int) (ts->stop_time % 1000000));
2252 ui_out_field_string (uiout, "stop-time", buf);
2256 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2257 user if she really wants to detach. */
2260 query_if_trace_running (int from_tty)
2265 /* It can happen that the target that was tracing went away on its
2266 own, and we didn't notice. Get a status update, and if the
2267 current target doesn't even do tracing, then assume it's not
2269 if (target_get_trace_status (current_trace_status ()) < 0)
2270 current_trace_status ()->running = 0;
2272 /* If running interactively, give the user the option to cancel and
2273 then decide what to do differently with the run. Scripts are
2274 just going to disconnect and let the target deal with it,
2275 according to how it's been instructed previously via
2276 disconnected-tracing. */
2277 if (current_trace_status ()->running)
2279 process_tracepoint_on_disconnect ();
2281 if (current_trace_status ()->disconnected_tracing)
2283 if (!query (_("Trace is running and will "
2284 "continue after detach; detach anyway? ")))
2285 error (_("Not confirmed."));
2289 if (!query (_("Trace is running but will "
2290 "stop on detach; detach anyway? ")))
2291 error (_("Not confirmed."));
2296 /* This function handles the details of what to do about an ongoing
2297 tracing run if the user has asked to detach or otherwise disconnect
2301 disconnect_tracing (void)
2303 /* Also we want to be out of tfind mode, otherwise things can get
2304 confusing upon reconnection. Just use these calls instead of
2305 full tfind_1 behavior because we're in the middle of detaching,
2306 and there's no point to updating current stack frame etc. */
2307 trace_reset_local_state ();
2310 /* Worker function for the various flavors of the tfind command. */
2312 tfind_1 (enum trace_find_type type, int num,
2313 CORE_ADDR addr1, CORE_ADDR addr2,
2316 int target_frameno = -1, target_tracept = -1;
2317 struct frame_id old_frame_id = null_frame_id;
2318 struct tracepoint *tp;
2319 struct ui_out *uiout = current_uiout;
2321 /* Only try to get the current stack frame if we have a chance of
2322 succeeding. In particular, if we're trying to get a first trace
2323 frame while all threads are running, it's not going to succeed,
2324 so leave it with a default value and let the frame comparison
2325 below (correctly) decide to print out the source location of the
2327 if (!(type == tfind_number && num == -1)
2328 && (has_stack_frames () || traceframe_number >= 0))
2329 old_frame_id = get_frame_id (get_current_frame ());
2331 target_frameno = target_trace_find (type, num, addr1, addr2,
2334 if (type == tfind_number
2336 && target_frameno == -1)
2338 /* We told the target to get out of tfind mode, and it did. */
2340 else if (target_frameno == -1)
2342 /* A request for a non-existent trace frame has failed.
2343 Our response will be different, depending on FROM_TTY:
2345 If FROM_TTY is true, meaning that this command was
2346 typed interactively by the user, then give an error
2347 and DO NOT change the state of traceframe_number etc.
2349 However if FROM_TTY is false, meaning that we're either
2350 in a script, a loop, or a user-defined command, then
2351 DON'T give an error, but DO change the state of
2352 traceframe_number etc. to invalid.
2354 The rationalle is that if you typed the command, you
2355 might just have committed a typo or something, and you'd
2356 like to NOT lose your current debugging state. However
2357 if you're in a user-defined command or especially in a
2358 loop, then you need a way to detect that the command
2359 failed WITHOUT aborting. This allows you to write
2360 scripts that search thru the trace buffer until the end,
2361 and then continue on to do something else. */
2364 error (_("Target failed to find requested trace frame."));
2368 printf_filtered ("End of trace buffer.\n");
2369 #if 0 /* dubious now? */
2370 /* The following will not recurse, since it's
2372 trace_find_command ("-1", from_tty);
2377 tp = get_tracepoint_by_number_on_target (target_tracept);
2379 reinit_frame_cache ();
2380 target_dcache_invalidate ();
2382 set_tracepoint_num (tp ? tp->base.number : target_tracept);
2384 if (target_frameno != get_traceframe_number ())
2385 observer_notify_traceframe_changed (target_frameno, tracepoint_number);
2387 set_current_traceframe (target_frameno);
2389 if (target_frameno == -1)
2390 set_traceframe_context (NULL);
2392 set_traceframe_context (get_current_frame ());
2394 if (traceframe_number >= 0)
2396 /* Use different branches for MI and CLI to make CLI messages
2398 if (ui_out_is_mi_like_p (uiout))
2400 ui_out_field_string (uiout, "found", "1");
2401 ui_out_field_int (uiout, "tracepoint", tracepoint_number);
2402 ui_out_field_int (uiout, "traceframe", traceframe_number);
2406 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2407 traceframe_number, tracepoint_number);
2412 if (ui_out_is_mi_like_p (uiout))
2413 ui_out_field_string (uiout, "found", "0");
2414 else if (type == tfind_number && num == -1)
2415 printf_unfiltered (_("No longer looking at any trace frame\n"));
2416 else /* This case may never occur, check. */
2417 printf_unfiltered (_("No trace frame found\n"));
2420 /* If we're in nonstop mode and getting out of looking at trace
2421 frames, there won't be any current frame to go back to and
2424 && (has_stack_frames () || traceframe_number >= 0))
2426 enum print_what print_what;
2428 /* NOTE: in imitation of the step command, try to determine
2429 whether we have made a transition from one function to
2430 another. If so, we'll print the "stack frame" (ie. the new
2431 function and it's arguments) -- otherwise we'll just show the
2434 if (frame_id_eq (old_frame_id,
2435 get_frame_id (get_current_frame ())))
2436 print_what = SRC_LINE;
2438 print_what = SRC_AND_LOC;
2440 print_stack_frame (get_selected_frame (NULL), 1, print_what, 1);
2445 /* Error on looking at traceframes while trace is running. */
2448 check_trace_running (struct trace_status *status)
2450 if (status->running && status->filename == NULL)
2451 error (_("May not look at trace frames while trace is running."));
2454 /* trace_find_command takes a trace frame number n,
2455 sends "QTFrame:<n>" to the target,
2456 and accepts a reply that may contain several optional pieces
2457 of information: a frame number, a tracepoint number, and an
2458 indication of whether this is a trap frame or a stepping frame.
2460 The minimal response is just "OK" (which indicates that the
2461 target does not give us a frame number or a tracepoint number).
2462 Instead of that, the target may send us a string containing
2464 F<hexnum> (gives the selected frame number)
2465 T<hexnum> (gives the selected tracepoint number)
2470 trace_find_command (char *args, int from_tty)
2471 { /* This should only be called with a numeric argument. */
2474 check_trace_running (current_trace_status ());
2476 if (args == 0 || *args == 0)
2477 { /* TFIND with no args means find NEXT trace frame. */
2478 if (traceframe_number == -1)
2479 frameno = 0; /* "next" is first one. */
2481 frameno = traceframe_number + 1;
2483 else if (0 == strcmp (args, "-"))
2485 if (traceframe_number == -1)
2486 error (_("not debugging trace buffer"));
2487 else if (from_tty && traceframe_number == 0)
2488 error (_("already at start of trace buffer"));
2490 frameno = traceframe_number - 1;
2492 /* A hack to work around eval's need for fp to have been collected. */
2493 else if (0 == strcmp (args, "-1"))
2496 frameno = parse_and_eval_long (args);
2499 error (_("invalid input (%d is less than zero)"), frameno);
2501 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2506 trace_find_end_command (char *args, int from_tty)
2508 trace_find_command ("-1", from_tty);
2513 trace_find_start_command (char *args, int from_tty)
2515 trace_find_command ("0", from_tty);
2518 /* tfind pc command */
2520 trace_find_pc_command (char *args, int from_tty)
2524 check_trace_running (current_trace_status ());
2526 if (args == 0 || *args == 0)
2527 pc = regcache_read_pc (get_current_regcache ());
2529 pc = parse_and_eval_address (args);
2531 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2534 /* tfind tracepoint command */
2536 trace_find_tracepoint_command (char *args, int from_tty)
2539 struct tracepoint *tp;
2541 check_trace_running (current_trace_status ());
2543 if (args == 0 || *args == 0)
2545 if (tracepoint_number == -1)
2546 error (_("No current tracepoint -- please supply an argument."));
2548 tdp = tracepoint_number; /* Default is current TDP. */
2551 tdp = parse_and_eval_long (args);
2553 /* If we have the tracepoint on hand, use the number that the
2554 target knows about (which may be different if we disconnected
2555 and reconnected). */
2556 tp = get_tracepoint (tdp);
2558 tdp = tp->number_on_target;
2560 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2563 /* TFIND LINE command:
2565 This command will take a sourceline for argument, just like BREAK
2566 or TRACE (ie. anything that "decode_line_1" can handle).
2568 With no argument, this command will find the next trace frame
2569 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2572 trace_find_line_command (char *args, int from_tty)
2574 static CORE_ADDR start_pc, end_pc;
2575 struct symtabs_and_lines sals;
2576 struct symtab_and_line sal;
2577 struct cleanup *old_chain;
2579 check_trace_running (current_trace_status ());
2581 if (args == 0 || *args == 0)
2583 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2585 sals.sals = XNEW (struct symtab_and_line);
2590 sals = decode_line_with_current_source (args, DECODE_LINE_FUNFIRSTLINE);
2594 old_chain = make_cleanup (xfree, sals.sals);
2595 if (sal.symtab == 0)
2596 error (_("No line number information available."));
2598 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2600 if (start_pc == end_pc)
2602 printf_filtered ("Line %d of \"%s\"",
2604 symtab_to_filename_for_display (sal.symtab));
2606 printf_filtered (" is at address ");
2607 print_address (get_current_arch (), start_pc, gdb_stdout);
2609 printf_filtered (" but contains no code.\n");
2610 sal = find_pc_line (start_pc, 0);
2612 && find_line_pc_range (sal, &start_pc, &end_pc)
2613 && start_pc != end_pc)
2614 printf_filtered ("Attempting to find line %d instead.\n",
2617 error (_("Cannot find a good line."));
2621 /* Is there any case in which we get here, and have an address
2622 which the user would want to see? If we have debugging
2623 symbols and no line numbers? */
2624 error (_("Line number %d is out of range for \"%s\"."),
2625 sal.line, symtab_to_filename_for_display (sal.symtab));
2627 /* Find within range of stated line. */
2629 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2631 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2632 do_cleanups (old_chain);
2635 /* tfind range command */
2637 trace_find_range_command (char *args, int from_tty)
2639 static CORE_ADDR start, stop;
2642 check_trace_running (current_trace_status ());
2644 if (args == 0 || *args == 0)
2645 { /* XXX FIXME: what should default behavior be? */
2646 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2650 if (0 != (tmp = strchr (args, ',')))
2652 *tmp++ = '\0'; /* Terminate start address. */
2653 tmp = skip_spaces (tmp);
2654 start = parse_and_eval_address (args);
2655 stop = parse_and_eval_address (tmp);
2658 { /* No explicit end address? */
2659 start = parse_and_eval_address (args);
2660 stop = start + 1; /* ??? */
2663 tfind_1 (tfind_range, 0, start, stop, from_tty);
2666 /* tfind outside command */
2668 trace_find_outside_command (char *args, int from_tty)
2670 CORE_ADDR start, stop;
2673 if (current_trace_status ()->running
2674 && current_trace_status ()->filename == NULL)
2675 error (_("May not look at trace frames while trace is running."));
2677 if (args == 0 || *args == 0)
2678 { /* XXX FIXME: what should default behavior be? */
2679 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2683 if (0 != (tmp = strchr (args, ',')))
2685 *tmp++ = '\0'; /* Terminate start address. */
2686 tmp = skip_spaces (tmp);
2687 start = parse_and_eval_address (args);
2688 stop = parse_and_eval_address (tmp);
2691 { /* No explicit end address? */
2692 start = parse_and_eval_address (args);
2693 stop = start + 1; /* ??? */
2696 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2699 /* info scope command: list the locals for a scope. */
2701 scope_info (char *args, int from_tty)
2703 struct symtabs_and_lines sals;
2705 struct bound_minimal_symbol msym;
2706 const struct block *block;
2707 const char *symname;
2708 char *save_args = args;
2709 struct block_iterator iter;
2711 struct gdbarch *gdbarch;
2713 struct event_location *location;
2714 struct cleanup *back_to;
2716 if (args == 0 || *args == 0)
2717 error (_("requires an argument (function, "
2718 "line or *addr) to define a scope"));
2720 location = string_to_event_location (&args, current_language);
2721 back_to = make_cleanup_delete_event_location (location);
2722 sals = decode_line_1 (location, DECODE_LINE_FUNFIRSTLINE, NULL, 0);
2723 if (sals.nelts == 0)
2725 /* Presumably decode_line_1 has already warned. */
2726 do_cleanups (back_to);
2730 /* Resolve line numbers to PC. */
2731 resolve_sal_pc (&sals.sals[0]);
2732 block = block_for_pc (sals.sals[0].pc);
2736 QUIT; /* Allow user to bail out with ^C. */
2737 ALL_BLOCK_SYMBOLS (block, iter, sym)
2739 QUIT; /* Allow user to bail out with ^C. */
2741 printf_filtered ("Scope for %s:\n", save_args);
2744 symname = SYMBOL_PRINT_NAME (sym);
2745 if (symname == NULL || *symname == '\0')
2746 continue; /* Probably botched, certainly useless. */
2748 gdbarch = symbol_arch (sym);
2750 printf_filtered ("Symbol %s is ", symname);
2752 if (SYMBOL_COMPUTED_OPS (sym) != NULL)
2753 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2754 BLOCK_START (block),
2758 switch (SYMBOL_CLASS (sym))
2761 case LOC_UNDEF: /* Messed up symbol? */
2762 printf_filtered ("a bogus symbol, class %d.\n",
2763 SYMBOL_CLASS (sym));
2764 count--; /* Don't count this one. */
2767 printf_filtered ("a constant with value %s (%s)",
2768 plongest (SYMBOL_VALUE (sym)),
2769 hex_string (SYMBOL_VALUE (sym)));
2771 case LOC_CONST_BYTES:
2772 printf_filtered ("constant bytes: ");
2773 if (SYMBOL_TYPE (sym))
2774 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2775 fprintf_filtered (gdb_stdout, " %02x",
2776 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2779 printf_filtered ("in static storage at address ");
2780 printf_filtered ("%s", paddress (gdbarch,
2781 SYMBOL_VALUE_ADDRESS (sym)));
2784 /* GDBARCH is the architecture associated with the objfile
2785 the symbol is defined in; the target architecture may be
2786 different, and may provide additional registers. However,
2787 we do not know the target architecture at this point.
2788 We assume the objfile architecture will contain all the
2789 standard registers that occur in debug info in that
2791 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2794 if (SYMBOL_IS_ARGUMENT (sym))
2795 printf_filtered ("an argument in register $%s",
2796 gdbarch_register_name (gdbarch, regno));
2798 printf_filtered ("a local variable in register $%s",
2799 gdbarch_register_name (gdbarch, regno));
2802 printf_filtered ("an argument at stack/frame offset %s",
2803 plongest (SYMBOL_VALUE (sym)));
2806 printf_filtered ("a local variable at frame offset %s",
2807 plongest (SYMBOL_VALUE (sym)));
2810 printf_filtered ("a reference argument at offset %s",
2811 plongest (SYMBOL_VALUE (sym)));
2813 case LOC_REGPARM_ADDR:
2814 /* Note comment at LOC_REGISTER. */
2815 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2817 printf_filtered ("the address of an argument, in register $%s",
2818 gdbarch_register_name (gdbarch, regno));
2821 printf_filtered ("a typedef.\n");
2824 printf_filtered ("a label at address ");
2825 printf_filtered ("%s", paddress (gdbarch,
2826 SYMBOL_VALUE_ADDRESS (sym)));
2829 printf_filtered ("a function at address ");
2830 printf_filtered ("%s",
2831 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2833 case LOC_UNRESOLVED:
2834 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2836 if (msym.minsym == NULL)
2837 printf_filtered ("Unresolved Static");
2840 printf_filtered ("static storage at address ");
2841 printf_filtered ("%s",
2843 BMSYMBOL_VALUE_ADDRESS (msym)));
2846 case LOC_OPTIMIZED_OUT:
2847 printf_filtered ("optimized out.\n");
2850 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2853 if (SYMBOL_TYPE (sym))
2854 printf_filtered (", length %d.\n",
2855 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2857 if (BLOCK_FUNCTION (block))
2860 block = BLOCK_SUPERBLOCK (block);
2863 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2865 do_cleanups (back_to);
2868 /* Helper for trace_dump_command. Dump the action list starting at
2869 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2870 actions of the body of a while-stepping action. STEPPING_FRAME is
2871 set if the current traceframe was determined to be a while-stepping
2875 trace_dump_actions (struct command_line *action,
2876 int stepping_actions, int stepping_frame,
2879 const char *action_exp, *next_comma;
2881 for (; action != NULL; action = action->next)
2883 struct cmd_list_element *cmd;
2885 QUIT; /* Allow user to bail out with ^C. */
2886 action_exp = action->line;
2887 action_exp = skip_spaces_const (action_exp);
2889 /* The collection actions to be done while stepping are
2890 bracketed by the commands "while-stepping" and "end". */
2892 if (*action_exp == '#') /* comment line */
2895 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2897 error (_("Bad action list item: %s"), action_exp);
2899 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2903 for (i = 0; i < action->body_count; ++i)
2904 trace_dump_actions (action->body_list[i],
2905 1, stepping_frame, from_tty);
2907 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2909 /* Display the collected data.
2910 For the trap frame, display only what was collected at
2911 the trap. Likewise for stepping frames, display only
2912 what was collected while stepping. This means that the
2913 two boolean variables, STEPPING_FRAME and
2914 STEPPING_ACTIONS should be equal. */
2915 if (stepping_frame == stepping_actions)
2918 struct cleanup *old_chain
2919 = make_cleanup (free_current_contents, &cmd);
2920 int trace_string = 0;
2922 if (*action_exp == '/')
2923 action_exp = decode_agent_options (action_exp, &trace_string);
2926 { /* Repeat over a comma-separated list. */
2927 QUIT; /* Allow user to bail out with ^C. */
2928 if (*action_exp == ',')
2930 action_exp = skip_spaces_const (action_exp);
2932 next_comma = strchr (action_exp, ',');
2934 if (0 == strncasecmp (action_exp, "$reg", 4))
2935 registers_info (NULL, from_tty);
2936 else if (0 == strncasecmp (action_exp, "$_ret", 5))
2938 else if (0 == strncasecmp (action_exp, "$loc", 4))
2939 locals_info (NULL, from_tty);
2940 else if (0 == strncasecmp (action_exp, "$arg", 4))
2941 args_info (NULL, from_tty);
2944 if (next_comma != NULL)
2946 size_t len = next_comma - action_exp;
2948 cmd = (char *) xrealloc (cmd, len + 1);
2949 memcpy (cmd, action_exp, len);
2954 size_t len = strlen (action_exp);
2956 cmd = (char *) xrealloc (cmd, len + 1);
2957 memcpy (cmd, action_exp, len + 1);
2960 printf_filtered ("%s = ", cmd);
2961 output_command_const (cmd, from_tty);
2962 printf_filtered ("\n");
2964 action_exp = next_comma;
2966 while (action_exp && *action_exp == ',');
2968 do_cleanups (old_chain);
2974 /* Return bp_location of the tracepoint associated with the current
2975 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2976 is a stepping traceframe. */
2978 struct bp_location *
2979 get_traceframe_location (int *stepping_frame_p)
2981 struct tracepoint *t;
2982 struct bp_location *tloc;
2983 struct regcache *regcache;
2985 if (tracepoint_number == -1)
2986 error (_("No current trace frame."));
2988 t = get_tracepoint (tracepoint_number);
2991 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2994 /* The current frame is a trap frame if the frame PC is equal to the
2995 tracepoint PC. If not, then the current frame was collected
2996 during single-stepping. */
2997 regcache = get_current_regcache ();
2999 /* If the traceframe's address matches any of the tracepoint's
3000 locations, assume it is a direct hit rather than a while-stepping
3001 frame. (FIXME this is not reliable, should record each frame's
3003 for (tloc = t->base.loc; tloc; tloc = tloc->next)
3004 if (tloc->address == regcache_read_pc (regcache))
3006 *stepping_frame_p = 0;
3010 /* If this is a stepping frame, we don't know which location
3011 triggered. The first is as good (or bad) a guess as any... */
3012 *stepping_frame_p = 1;
3016 /* Return all the actions, including default collect, of a tracepoint
3017 T. It constructs cleanups into the chain, and leaves the caller to
3018 handle them (call do_cleanups). */
3020 static struct command_line *
3021 all_tracepoint_actions_and_cleanup (struct breakpoint *t)
3023 struct command_line *actions;
3025 actions = breakpoint_commands (t);
3027 /* If there are default expressions to collect, make up a collect
3028 action and prepend to the action list to encode. Note that since
3029 validation is per-tracepoint (local var "xyz" might be valid for
3030 one tracepoint and not another, etc), we make up the action on
3031 the fly, and don't cache it. */
3032 if (*default_collect)
3034 struct command_line *default_collect_action;
3035 char *default_collect_line;
3037 default_collect_line = xstrprintf ("collect %s", default_collect);
3038 make_cleanup (xfree, default_collect_line);
3040 validate_actionline (default_collect_line, t);
3041 default_collect_action = XNEW (struct command_line);
3042 make_cleanup (xfree, default_collect_action);
3043 default_collect_action->next = actions;
3044 default_collect_action->line = default_collect_line;
3045 actions = default_collect_action;
3051 /* The tdump command. */
3054 trace_dump_command (char *args, int from_tty)
3056 int stepping_frame = 0;
3057 struct bp_location *loc;
3058 struct cleanup *old_chain;
3059 struct command_line *actions;
3061 /* This throws an error is not inspecting a trace frame. */
3062 loc = get_traceframe_location (&stepping_frame);
3064 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
3065 tracepoint_number, traceframe_number);
3067 old_chain = make_cleanup (null_cleanup, NULL);
3069 /* This command only makes sense for the current frame, not the
3071 make_cleanup_restore_current_thread ();
3072 select_frame (get_current_frame ());
3074 actions = all_tracepoint_actions_and_cleanup (loc->owner);
3076 trace_dump_actions (actions, 0, stepping_frame, from_tty);
3078 do_cleanups (old_chain);
3081 /* Encode a piece of a tracepoint's source-level definition in a form
3082 that is suitable for both protocol and saving in files. */
3083 /* This version does not do multiple encodes for long strings; it should
3084 return an offset to the next piece to encode. FIXME */
3087 encode_source_string (int tpnum, ULONGEST addr,
3088 char *srctype, const char *src, char *buf, int buf_size)
3090 if (80 + strlen (srctype) > buf_size)
3091 error (_("Buffer too small for source encoding"));
3092 sprintf (buf, "%x:%s:%s:%x:%x:",
3093 tpnum, phex_nz (addr, sizeof (addr)),
3094 srctype, 0, (int) strlen (src));
3095 if (strlen (buf) + strlen (src) * 2 >= buf_size)
3096 error (_("Source string too long for buffer"));
3097 bin2hex ((gdb_byte *) src, buf + strlen (buf), strlen (src));
3101 /* Tell the target what to do with an ongoing tracing run if GDB
3102 disconnects for some reason. */
3105 set_disconnected_tracing (char *args, int from_tty,
3106 struct cmd_list_element *c)
3108 target_set_disconnected_tracing (disconnected_tracing);
3112 set_circular_trace_buffer (char *args, int from_tty,
3113 struct cmd_list_element *c)
3115 target_set_circular_trace_buffer (circular_trace_buffer);
3119 set_trace_buffer_size (char *args, int from_tty,
3120 struct cmd_list_element *c)
3122 target_set_trace_buffer_size (trace_buffer_size);
3126 set_trace_user (char *args, int from_tty,
3127 struct cmd_list_element *c)
3131 ret = target_set_trace_notes (trace_user, NULL, NULL);
3134 warning (_("Target does not support trace notes, user ignored"));
3138 set_trace_notes (char *args, int from_tty,
3139 struct cmd_list_element *c)
3143 ret = target_set_trace_notes (NULL, trace_notes, NULL);
3146 warning (_("Target does not support trace notes, note ignored"));
3150 set_trace_stop_notes (char *args, int from_tty,
3151 struct cmd_list_element *c)
3155 ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
3158 warning (_("Target does not support trace notes, stop note ignored"));
3161 /* Convert the memory pointed to by mem into hex, placing result in buf.
3162 * Return a pointer to the last char put in buf (null)
3163 * "stolen" from sparc-stub.c
3166 static const char hexchars[] = "0123456789abcdef";
3169 mem2hex (gdb_byte *mem, char *buf, int count)
3177 *buf++ = hexchars[ch >> 4];
3178 *buf++ = hexchars[ch & 0xf];
3187 get_traceframe_number (void)
3189 return traceframe_number;
3193 get_tracepoint_number (void)
3195 return tracepoint_number;
3198 /* Make the traceframe NUM be the current trace frame. Does nothing
3199 if NUM is already current. */
3202 set_current_traceframe (int num)
3206 if (traceframe_number == num)
3208 /* Nothing to do. */
3212 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
3215 warning (_("could not change traceframe"));
3217 set_traceframe_num (newnum);
3219 /* Changing the traceframe changes our view of registers and of the
3221 registers_changed ();
3223 clear_traceframe_info ();
3226 /* A cleanup used when switching away and back from tfind mode. */
3228 struct current_traceframe_cleanup
3230 /* The traceframe we were inspecting. */
3231 int traceframe_number;
3235 do_restore_current_traceframe_cleanup (void *arg)
3237 struct current_traceframe_cleanup *old = arg;
3239 set_current_traceframe (old->traceframe_number);
3243 restore_current_traceframe_cleanup_dtor (void *arg)
3245 struct current_traceframe_cleanup *old = arg;
3251 make_cleanup_restore_current_traceframe (void)
3253 struct current_traceframe_cleanup *old =
3254 XNEW (struct current_traceframe_cleanup);
3256 old->traceframe_number = traceframe_number;
3258 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
3259 restore_current_traceframe_cleanup_dtor);
3262 /* Given a number and address, return an uploaded tracepoint with that
3263 number, creating if necessary. */
3265 struct uploaded_tp *
3266 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
3268 struct uploaded_tp *utp;
3270 for (utp = *utpp; utp; utp = utp->next)
3271 if (utp->number == num && utp->addr == addr)
3274 utp = XCNEW (struct uploaded_tp);
3277 utp->actions = NULL;
3278 utp->step_actions = NULL;
3279 utp->cmd_strings = NULL;
3287 free_uploaded_tps (struct uploaded_tp **utpp)
3289 struct uploaded_tp *next_one;
3293 next_one = (*utpp)->next;
3299 /* Given a number and address, return an uploaded tracepoint with that
3300 number, creating if necessary. */
3302 struct uploaded_tsv *
3303 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3305 struct uploaded_tsv *utsv;
3307 for (utsv = *utsvp; utsv; utsv = utsv->next)
3308 if (utsv->number == num)
3311 utsv = XCNEW (struct uploaded_tsv);
3313 utsv->next = *utsvp;
3320 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3322 struct uploaded_tsv *next_one;
3326 next_one = (*utsvp)->next;
3332 /* FIXME this function is heuristic and will miss the cases where the
3333 conditional is semantically identical but differs in whitespace,
3334 such as "x == 0" vs "x==0". */
3337 cond_string_is_same (char *str1, char *str2)
3339 if (str1 == NULL || str2 == NULL)
3340 return (str1 == str2);
3342 return (strcmp (str1, str2) == 0);
3345 /* Look for an existing tracepoint that seems similar enough to the
3346 uploaded one. Enablement isn't compared, because the user can
3347 toggle that freely, and may have done so in anticipation of the
3348 next trace run. Return the location of matched tracepoint. */
3350 static struct bp_location *
3351 find_matching_tracepoint_location (struct uploaded_tp *utp)
3353 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
3355 struct breakpoint *b;
3356 struct bp_location *loc;
3358 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
3360 struct tracepoint *t = (struct tracepoint *) b;
3362 if (b->type == utp->type
3363 && t->step_count == utp->step
3364 && t->pass_count == utp->pass
3365 && cond_string_is_same (t->base.cond_string, utp->cond_string)
3366 /* FIXME also test actions. */
3369 /* Scan the locations for an address match. */
3370 for (loc = b->loc; loc; loc = loc->next)
3372 if (loc->address == utp->addr)
3380 /* Given a list of tracepoints uploaded from a target, attempt to
3381 match them up with existing tracepoints, and create new ones if not
3385 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3387 struct uploaded_tp *utp;
3388 /* A set of tracepoints which are modified. */
3389 VEC(breakpoint_p) *modified_tp = NULL;
3391 struct breakpoint *b;
3393 /* Look for GDB tracepoints that match up with our uploaded versions. */
3394 for (utp = *uploaded_tps; utp; utp = utp->next)
3396 struct bp_location *loc;
3397 struct tracepoint *t;
3399 loc = find_matching_tracepoint_location (utp);
3404 /* Mark this location as already inserted. */
3406 t = (struct tracepoint *) loc->owner;
3407 printf_filtered (_("Assuming tracepoint %d is same "
3408 "as target's tracepoint %d at %s.\n"),
3409 loc->owner->number, utp->number,
3410 paddress (loc->gdbarch, utp->addr));
3412 /* The tracepoint LOC->owner was modified (the location LOC
3413 was marked as inserted in the target). Save it in
3414 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3415 observers will be notified later once for each tracepoint
3416 saved in MODIFIED_TP. */
3418 VEC_iterate (breakpoint_p, modified_tp, ix, b);
3420 if (b == loc->owner)
3426 VEC_safe_push (breakpoint_p, modified_tp, loc->owner);
3430 t = create_tracepoint_from_upload (utp);
3432 printf_filtered (_("Created tracepoint %d for "
3433 "target's tracepoint %d at %s.\n"),
3434 t->base.number, utp->number,
3435 paddress (get_current_arch (), utp->addr));
3437 printf_filtered (_("Failed to create tracepoint for target's "
3438 "tracepoint %d at %s, skipping it.\n"),
3440 paddress (get_current_arch (), utp->addr));
3442 /* Whether found or created, record the number used by the
3443 target, to help with mapping target tracepoints back to their
3444 counterparts here. */
3446 t->number_on_target = utp->number;
3449 /* Notify 'breakpoint-modified' observer that at least one of B's
3450 locations was changed. */
3451 for (ix = 0; VEC_iterate (breakpoint_p, modified_tp, ix, b); ix++)
3452 observer_notify_breakpoint_modified (b);
3454 VEC_free (breakpoint_p, modified_tp);
3455 free_uploaded_tps (uploaded_tps);
3458 /* Trace state variables don't have much to identify them beyond their
3459 name, so just use that to detect matches. */
3461 static struct trace_state_variable *
3462 find_matching_tsv (struct uploaded_tsv *utsv)
3467 return find_trace_state_variable (utsv->name);
3470 static struct trace_state_variable *
3471 create_tsv_from_upload (struct uploaded_tsv *utsv)
3473 const char *namebase;
3476 struct trace_state_variable *tsv;
3477 struct cleanup *old_chain;
3481 namebase = utsv->name;
3482 buf = xstrprintf ("%s", namebase);
3487 buf = xstrprintf ("%s_%d", namebase, try_num++);
3490 /* Fish for a name that is not in use. */
3491 /* (should check against all internal vars?) */
3492 while (find_trace_state_variable (buf))
3495 buf = xstrprintf ("%s_%d", namebase, try_num++);
3498 old_chain = make_cleanup (xfree, buf);
3500 /* We have an available name, create the variable. */
3501 tsv = create_trace_state_variable (buf);
3502 tsv->initial_value = utsv->initial_value;
3503 tsv->builtin = utsv->builtin;
3505 observer_notify_tsv_created (tsv);
3507 do_cleanups (old_chain);
3512 /* Given a list of uploaded trace state variables, try to match them
3513 up with existing variables, or create additional ones. */
3516 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
3519 struct uploaded_tsv *utsv;
3520 struct trace_state_variable *tsv;
3523 /* Most likely some numbers will have to be reassigned as part of
3524 the merge, so clear them all in anticipation. */
3525 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3528 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
3530 tsv = find_matching_tsv (utsv);
3534 printf_filtered (_("Assuming trace state variable $%s "
3535 "is same as target's variable %d.\n"),
3536 tsv->name, utsv->number);
3540 tsv = create_tsv_from_upload (utsv);
3542 printf_filtered (_("Created trace state variable "
3543 "$%s for target's variable %d.\n"),
3544 tsv->name, utsv->number);
3546 /* Give precedence to numberings that come from the target. */
3548 tsv->number = utsv->number;
3551 /* Renumber everything that didn't get a target-assigned number. */
3553 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3554 if (tsv->number > highest)
3555 highest = tsv->number;
3558 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3559 if (tsv->number == 0)
3560 tsv->number = highest++;
3562 free_uploaded_tsvs (uploaded_tsvs);
3565 /* Parse the part of trace status syntax that is shared between
3566 the remote protocol and the trace file reader. */
3569 parse_trace_status (char *line, struct trace_status *ts)
3571 char *p = line, *p1, *p2, *p3, *p_temp;
3575 ts->running_known = 1;
3576 ts->running = (*p++ == '1');
3577 ts->stop_reason = trace_stop_reason_unknown;
3578 xfree (ts->stop_desc);
3579 ts->stop_desc = NULL;
3580 ts->traceframe_count = -1;
3581 ts->traceframes_created = -1;
3582 ts->buffer_free = -1;
3583 ts->buffer_size = -1;
3584 ts->disconnected_tracing = 0;
3585 ts->circular_buffer = 0;
3586 xfree (ts->user_name);
3587 ts->user_name = NULL;
3590 ts->start_time = ts->stop_time = 0;
3594 p1 = strchr (p, ':');
3596 error (_("Malformed trace status, at %s\n\
3597 Status line: '%s'\n"), p, line);
3598 p3 = strchr (p, ';');
3600 p3 = p + strlen (p);
3601 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3603 p = unpack_varlen_hex (++p1, &val);
3604 ts->stop_reason = trace_buffer_full;
3606 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3608 p = unpack_varlen_hex (++p1, &val);
3609 ts->stop_reason = trace_never_run;
3611 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
3614 p = unpack_varlen_hex (++p1, &val);
3615 ts->stop_reason = tracepoint_passcount;
3616 ts->stopping_tracepoint = val;
3618 else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
3620 p2 = strchr (++p1, ':');
3628 ts->stop_desc = (char *) xmalloc (strlen (line));
3629 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
3630 ts->stop_desc[end] = '\0';
3633 ts->stop_desc = xstrdup ("");
3635 p = unpack_varlen_hex (++p2, &val);
3636 ts->stop_reason = tstop_command;
3638 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3640 p = unpack_varlen_hex (++p1, &val);
3641 ts->stop_reason = trace_disconnected;
3643 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3645 p2 = strchr (++p1, ':');
3648 ts->stop_desc = (char *) xmalloc ((p2 - p1) / 2 + 1);
3649 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
3650 ts->stop_desc[end] = '\0';
3653 ts->stop_desc = xstrdup ("");
3655 p = unpack_varlen_hex (++p2, &val);
3656 ts->stopping_tracepoint = val;
3657 ts->stop_reason = tracepoint_error;
3659 else if (strncmp (p, "tframes", p1 - p) == 0)
3661 p = unpack_varlen_hex (++p1, &val);
3662 ts->traceframe_count = val;
3664 else if (strncmp (p, "tcreated", p1 - p) == 0)
3666 p = unpack_varlen_hex (++p1, &val);
3667 ts->traceframes_created = val;
3669 else if (strncmp (p, "tfree", p1 - p) == 0)
3671 p = unpack_varlen_hex (++p1, &val);
3672 ts->buffer_free = val;
3674 else if (strncmp (p, "tsize", p1 - p) == 0)
3676 p = unpack_varlen_hex (++p1, &val);
3677 ts->buffer_size = val;
3679 else if (strncmp (p, "disconn", p1 - p) == 0)
3681 p = unpack_varlen_hex (++p1, &val);
3682 ts->disconnected_tracing = val;
3684 else if (strncmp (p, "circular", p1 - p) == 0)
3686 p = unpack_varlen_hex (++p1, &val);
3687 ts->circular_buffer = val;
3689 else if (strncmp (p, "starttime", p1 - p) == 0)
3691 p = unpack_varlen_hex (++p1, &val);
3692 ts->start_time = val;
3694 else if (strncmp (p, "stoptime", p1 - p) == 0)
3696 p = unpack_varlen_hex (++p1, &val);
3697 ts->stop_time = val;
3699 else if (strncmp (p, "username", p1 - p) == 0)
3702 ts->user_name = (char *) xmalloc (strlen (p) / 2);
3703 end = hex2bin (p1, (gdb_byte *) ts->user_name, (p3 - p1) / 2);
3704 ts->user_name[end] = '\0';
3707 else if (strncmp (p, "notes", p1 - p) == 0)
3710 ts->notes = (char *) xmalloc (strlen (p) / 2);
3711 end = hex2bin (p1, (gdb_byte *) ts->notes, (p3 - p1) / 2);
3712 ts->notes[end] = '\0';
3717 /* Silently skip unknown optional info. */
3718 p_temp = strchr (p1 + 1, ';');
3722 /* Must be at the end. */
3729 parse_tracepoint_status (char *p, struct breakpoint *bp,
3730 struct uploaded_tp *utp)
3733 struct tracepoint *tp = (struct tracepoint *) bp;
3735 p = unpack_varlen_hex (p, &uval);
3737 tp->base.hit_count += uval;
3739 utp->hit_count += uval;
3740 p = unpack_varlen_hex (p + 1, &uval);
3742 tp->traceframe_usage += uval;
3744 utp->traceframe_usage += uval;
3745 /* Ignore any extra, allowing for future extensions. */
3748 /* Given a line of text defining a part of a tracepoint, parse it into
3749 an "uploaded tracepoint". */
3752 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
3756 ULONGEST num, addr, step, pass, orig_size, xlen, start;
3759 char *cond, *srctype, *buf;
3760 struct uploaded_tp *utp = NULL;
3763 /* Both tracepoint and action definitions start with the same number
3764 and address sequence. */
3766 p = unpack_varlen_hex (p, &num);
3767 p++; /* skip a colon */
3768 p = unpack_varlen_hex (p, &addr);
3769 p++; /* skip a colon */
3772 enabled = (*p++ == 'E');
3773 p++; /* skip a colon */
3774 p = unpack_varlen_hex (p, &step);
3775 p++; /* skip a colon */
3776 p = unpack_varlen_hex (p, &pass);
3777 type = bp_tracepoint;
3779 /* Thumb through optional fields. */
3782 p++; /* skip a colon */
3785 type = bp_fast_tracepoint;
3787 p = unpack_varlen_hex (p, &orig_size);
3791 type = bp_static_tracepoint;
3797 p = unpack_varlen_hex (p, &xlen);
3798 p++; /* skip a comma */
3799 cond = (char *) xmalloc (2 * xlen + 1);
3800 strncpy (cond, p, 2 * xlen);
3801 cond[2 * xlen] = '\0';
3805 warning (_("Unrecognized char '%c' in tracepoint "
3806 "definition, skipping rest"), *p);
3808 utp = get_uploaded_tp (num, addr, utpp);
3810 utp->enabled = enabled;
3815 else if (piece == 'A')
3817 utp = get_uploaded_tp (num, addr, utpp);
3818 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
3820 else if (piece == 'S')
3822 utp = get_uploaded_tp (num, addr, utpp);
3823 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
3825 else if (piece == 'Z')
3827 /* Parse a chunk of source form definition. */
3828 utp = get_uploaded_tp (num, addr, utpp);
3830 p = strchr (p, ':');
3831 p++; /* skip a colon */
3832 p = unpack_varlen_hex (p, &start);
3833 p++; /* skip a colon */
3834 p = unpack_varlen_hex (p, &xlen);
3835 p++; /* skip a colon */
3837 buf = (char *) alloca (strlen (line));
3839 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3842 if (startswith (srctype, "at:"))
3843 utp->at_string = xstrdup (buf);
3844 else if (startswith (srctype, "cond:"))
3845 utp->cond_string = xstrdup (buf);
3846 else if (startswith (srctype, "cmd:"))
3847 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
3849 else if (piece == 'V')
3851 utp = get_uploaded_tp (num, addr, utpp);
3853 parse_tracepoint_status (p, NULL, utp);
3857 /* Don't error out, the target might be sending us optional
3858 info that we don't care about. */
3859 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
3863 /* Convert a textual description of a trace state variable into an
3867 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
3870 ULONGEST num, initval, builtin;
3872 struct uploaded_tsv *utsv = NULL;
3874 buf = (char *) alloca (strlen (line));
3877 p = unpack_varlen_hex (p, &num);
3878 p++; /* skip a colon */
3879 p = unpack_varlen_hex (p, &initval);
3880 p++; /* skip a colon */
3881 p = unpack_varlen_hex (p, &builtin);
3882 p++; /* skip a colon */
3883 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3886 utsv = get_uploaded_tsv (num, utsvp);
3887 utsv->initial_value = initval;
3888 utsv->builtin = builtin;
3889 utsv->name = xstrdup (buf);
3893 free_current_marker (void *arg)
3895 struct static_tracepoint_marker **marker_p = arg;
3897 if (*marker_p != NULL)
3899 release_static_tracepoint_marker (*marker_p);
3906 /* Given a line of text defining a static tracepoint marker, parse it
3907 into a "static tracepoint marker" object. Throws an error is
3908 parsing fails. If PP is non-null, it points to one past the end of
3909 the parsed marker definition. */
3912 parse_static_tracepoint_marker_definition (char *line, char **pp,
3913 struct static_tracepoint_marker *marker)
3920 p = unpack_varlen_hex (p, &addr);
3921 p++; /* skip a colon */
3923 marker->gdbarch = target_gdbarch ();
3924 marker->address = (CORE_ADDR) addr;
3926 endp = strchr (p, ':');
3928 error (_("bad marker definition: %s"), line);
3930 marker->str_id = (char *) xmalloc (endp - p + 1);
3931 end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
3932 marker->str_id[end] = '\0';
3935 p++; /* skip a colon */
3937 marker->extra = (char *) xmalloc (strlen (p) + 1);
3938 end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
3939 marker->extra[end] = '\0';
3945 /* Release a static tracepoint marker's contents. Note that the
3946 object itself isn't released here. There objects are usually on
3950 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
3952 xfree (marker->str_id);
3953 marker->str_id = NULL;
3956 /* Print MARKER to gdb_stdout. */
3959 print_one_static_tracepoint_marker (int count,
3960 struct static_tracepoint_marker *marker)
3962 struct command_line *l;
3965 char wrap_indent[80];
3966 char extra_field_indent[80];
3967 struct ui_out *uiout = current_uiout;
3968 struct cleanup *bkpt_chain;
3969 VEC(breakpoint_p) *tracepoints;
3971 struct symtab_and_line sal;
3975 sal.pc = marker->address;
3977 tracepoints = static_tracepoints_here (marker->address);
3979 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
3981 /* A counter field to help readability. This is not a stable
3983 ui_out_field_int (uiout, "count", count);
3985 ui_out_field_string (uiout, "marker-id", marker->str_id);
3987 ui_out_field_fmt (uiout, "enabled", "%c",
3988 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
3989 ui_out_spaces (uiout, 2);
3991 strcpy (wrap_indent, " ");
3993 if (gdbarch_addr_bit (marker->gdbarch) <= 32)
3994 strcat (wrap_indent, " ");
3996 strcat (wrap_indent, " ");
3998 strcpy (extra_field_indent, " ");
4000 ui_out_field_core_addr (uiout, "addr", marker->gdbarch, marker->address);
4002 sal = find_pc_line (marker->address, 0);
4003 sym = find_pc_sect_function (marker->address, NULL);
4006 ui_out_text (uiout, "in ");
4007 ui_out_field_string (uiout, "func",
4008 SYMBOL_PRINT_NAME (sym));
4009 ui_out_wrap_hint (uiout, wrap_indent);
4010 ui_out_text (uiout, " at ");
4013 ui_out_field_skip (uiout, "func");
4015 if (sal.symtab != NULL)
4017 ui_out_field_string (uiout, "file",
4018 symtab_to_filename_for_display (sal.symtab));
4019 ui_out_text (uiout, ":");
4021 if (ui_out_is_mi_like_p (uiout))
4023 const char *fullname = symtab_to_fullname (sal.symtab);
4025 ui_out_field_string (uiout, "fullname", fullname);
4028 ui_out_field_skip (uiout, "fullname");
4030 ui_out_field_int (uiout, "line", sal.line);
4034 ui_out_field_skip (uiout, "fullname");
4035 ui_out_field_skip (uiout, "line");
4038 ui_out_text (uiout, "\n");
4039 ui_out_text (uiout, extra_field_indent);
4040 ui_out_text (uiout, _("Data: \""));
4041 ui_out_field_string (uiout, "extra-data", marker->extra);
4042 ui_out_text (uiout, "\"\n");
4044 if (!VEC_empty (breakpoint_p, tracepoints))
4046 struct cleanup *cleanup_chain;
4048 struct breakpoint *b;
4050 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
4053 ui_out_text (uiout, extra_field_indent);
4054 ui_out_text (uiout, _("Probed by static tracepoints: "));
4055 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
4058 ui_out_text (uiout, ", ");
4059 ui_out_text (uiout, "#");
4060 ui_out_field_int (uiout, "tracepoint-id", b->number);
4063 do_cleanups (cleanup_chain);
4065 if (ui_out_is_mi_like_p (uiout))
4066 ui_out_field_int (uiout, "number-of-tracepoints",
4067 VEC_length(breakpoint_p, tracepoints));
4069 ui_out_text (uiout, "\n");
4071 VEC_free (breakpoint_p, tracepoints);
4073 do_cleanups (bkpt_chain);
4077 info_static_tracepoint_markers_command (char *arg, int from_tty)
4079 VEC(static_tracepoint_marker_p) *markers;
4080 struct cleanup *old_chain;
4081 struct static_tracepoint_marker *marker;
4082 struct ui_out *uiout = current_uiout;
4085 /* We don't have to check target_can_use_agent and agent's capability on
4086 static tracepoint here, in order to be compatible with older GDBserver.
4087 We don't check USE_AGENT is true or not, because static tracepoints
4088 don't work without in-process agent, so we don't bother users to type
4089 `set agent on' when to use static tracepoint. */
4092 = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
4093 "StaticTracepointMarkersTable");
4095 ui_out_table_header (uiout, 7, ui_left, "counter", "Cnt");
4097 ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
4099 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
4100 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
4101 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
4103 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
4104 ui_out_table_header (uiout, 40, ui_noalign, "what", "What");
4106 ui_out_table_body (uiout);
4108 markers = target_static_tracepoint_markers_by_strid (NULL);
4109 make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
4112 VEC_iterate (static_tracepoint_marker_p,
4113 markers, i, marker);
4116 print_one_static_tracepoint_marker (i + 1, marker);
4117 release_static_tracepoint_marker (marker);
4120 do_cleanups (old_chain);
4123 /* The $_sdata convenience variable is a bit special. We don't know
4124 for sure type of the value until we actually have a chance to fetch
4125 the data --- the size of the object depends on what has been
4126 collected. We solve this by making $_sdata be an internalvar that
4127 creates a new value on access. */
4129 /* Return a new value with the correct type for the sdata object of
4130 the current trace frame. Return a void value if there's no object
4133 static struct value *
4134 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
4140 /* We need to read the whole object before we know its size. */
4141 size = target_read_alloc (¤t_target,
4142 TARGET_OBJECT_STATIC_TRACE_DATA,
4149 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
4151 v = allocate_value (type);
4152 memcpy (value_contents_raw (v), buf, size);
4157 return allocate_value (builtin_type (gdbarch)->builtin_void);
4160 #if !defined(HAVE_LIBEXPAT)
4162 struct traceframe_info *
4163 parse_traceframe_info (const char *tframe_info)
4165 static int have_warned;
4170 warning (_("Can not parse XML trace frame info; XML support "
4171 "was disabled at compile time"));
4177 #else /* HAVE_LIBEXPAT */
4179 #include "xml-support.h"
4181 /* Handle the start of a <memory> element. */
4184 traceframe_info_start_memory (struct gdb_xml_parser *parser,
4185 const struct gdb_xml_element *element,
4186 void *user_data, VEC(gdb_xml_value_s) *attributes)
4188 struct traceframe_info *info = user_data;
4189 struct mem_range *r = VEC_safe_push (mem_range_s, info->memory, NULL);
4190 ULONGEST *start_p, *length_p;
4192 start_p = xml_find_attribute (attributes, "start")->value;
4193 length_p = xml_find_attribute (attributes, "length")->value;
4195 r->start = *start_p;
4196 r->length = *length_p;
4199 /* Handle the start of a <tvar> element. */
4202 traceframe_info_start_tvar (struct gdb_xml_parser *parser,
4203 const struct gdb_xml_element *element,
4205 VEC(gdb_xml_value_s) *attributes)
4207 struct traceframe_info *info = user_data;
4208 const char *id_attrib = xml_find_attribute (attributes, "id")->value;
4209 int id = gdb_xml_parse_ulongest (parser, id_attrib);
4211 VEC_safe_push (int, info->tvars, id);
4214 /* Discard the constructed trace frame info (if an error occurs). */
4217 free_result (void *p)
4219 struct traceframe_info *result = p;
4221 free_traceframe_info (result);
4224 /* The allowed elements and attributes for an XML memory map. */
4226 static const struct gdb_xml_attribute memory_attributes[] = {
4227 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4228 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4229 { NULL, GDB_XML_AF_NONE, NULL, NULL }
4232 static const struct gdb_xml_attribute tvar_attributes[] = {
4233 { "id", GDB_XML_AF_NONE, NULL, NULL },
4234 { NULL, GDB_XML_AF_NONE, NULL, NULL }
4237 static const struct gdb_xml_element traceframe_info_children[] = {
4238 { "memory", memory_attributes, NULL,
4239 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
4240 traceframe_info_start_memory, NULL },
4241 { "tvar", tvar_attributes, NULL,
4242 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
4243 traceframe_info_start_tvar, NULL },
4244 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4247 static const struct gdb_xml_element traceframe_info_elements[] = {
4248 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
4250 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4253 /* Parse a traceframe-info XML document. */
4255 struct traceframe_info *
4256 parse_traceframe_info (const char *tframe_info)
4258 struct traceframe_info *result;
4259 struct cleanup *back_to;
4261 result = XCNEW (struct traceframe_info);
4262 back_to = make_cleanup (free_result, result);
4264 if (gdb_xml_parse_quick (_("trace frame info"),
4265 "traceframe-info.dtd", traceframe_info_elements,
4266 tframe_info, result) == 0)
4268 /* Parsed successfully, keep the result. */
4269 discard_cleanups (back_to);
4274 do_cleanups (back_to);
4278 #endif /* HAVE_LIBEXPAT */
4280 /* Returns the traceframe_info object for the current traceframe.
4281 This is where we avoid re-fetching the object from the target if we
4282 already have it cached. */
4284 struct traceframe_info *
4285 get_traceframe_info (void)
4287 if (traceframe_info == NULL)
4288 traceframe_info = target_traceframe_info ();
4290 return traceframe_info;
4293 /* If the target supports the query, return in RESULT the set of
4294 collected memory in the current traceframe, found within the LEN
4295 bytes range starting at MEMADDR. Returns true if the target
4296 supports the query, otherwise returns false, and RESULT is left
4300 traceframe_available_memory (VEC(mem_range_s) **result,
4301 CORE_ADDR memaddr, ULONGEST len)
4303 struct traceframe_info *info = get_traceframe_info ();
4307 struct mem_range *r;
4312 for (i = 0; VEC_iterate (mem_range_s, info->memory, i, r); i++)
4313 if (mem_ranges_overlap (r->start, r->length, memaddr, len))
4315 ULONGEST lo1, hi1, lo2, hi2;
4316 struct mem_range *nr;
4319 hi1 = memaddr + len;
4322 hi2 = r->start + r->length;
4324 nr = VEC_safe_push (mem_range_s, *result, NULL);
4326 nr->start = max (lo1, lo2);
4327 nr->length = min (hi1, hi2) - nr->start;
4330 normalize_mem_ranges (*result);
4337 /* Implementation of `sdata' variable. */
4339 static const struct internalvar_funcs sdata_funcs =
4346 /* module initialization */
4348 _initialize_tracepoint (void)
4350 struct cmd_list_element *c;
4352 /* Explicitly create without lookup, since that tries to create a
4353 value with a void typed value, and when we get here, gdbarch
4354 isn't initialized yet. At this point, we're quite sure there
4355 isn't another convenience variable of the same name. */
4356 create_internalvar_type_lazy ("_sdata", &sdata_funcs, NULL);
4358 traceframe_number = -1;
4359 tracepoint_number = -1;
4361 add_info ("scope", scope_info,
4362 _("List the variables local to a scope"));
4364 add_cmd ("tracepoints", class_trace, NULL,
4365 _("Tracing of program execution without stopping the program."),
4368 add_com ("tdump", class_trace, trace_dump_command,
4369 _("Print everything collected at the current tracepoint."));
4371 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
4372 Define a trace state variable.\n\
4373 Argument is a $-prefixed name, optionally followed\n\
4374 by '=' and an expression that sets the initial value\n\
4375 at the start of tracing."));
4376 set_cmd_completer (c, expression_completer);
4378 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
4379 Delete one or more trace state variables.\n\
4380 Arguments are the names of the variables to delete.\n\
4381 If no arguments are supplied, delete all variables."), &deletelist);
4382 /* FIXME add a trace variable completer. */
4384 add_info ("tvariables", tvariables_info, _("\
4385 Status of trace state variables and their values.\n\
4388 add_info ("static-tracepoint-markers",
4389 info_static_tracepoint_markers_command, _("\
4390 List target static tracepoints markers.\n\
4393 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
4394 Select a trace frame;\n\
4395 No argument means forward by one frame; '-' means backward by one frame."),
4396 &tfindlist, "tfind ", 1, &cmdlist);
4398 add_cmd ("outside", class_trace, trace_find_outside_command, _("\
4399 Select a trace frame whose PC is outside the given range (exclusive).\n\
4400 Usage: tfind outside addr1, addr2"),
4403 add_cmd ("range", class_trace, trace_find_range_command, _("\
4404 Select a trace frame whose PC is in the given range (inclusive).\n\
4405 Usage: tfind range addr1,addr2"),
4408 add_cmd ("line", class_trace, trace_find_line_command, _("\
4409 Select a trace frame by source line.\n\
4410 Argument can be a line number (with optional source file),\n\
4411 a function name, or '*' followed by an address.\n\
4412 Default argument is 'the next source line that was traced'."),
4415 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
4416 Select a trace frame by tracepoint number.\n\
4417 Default is the tracepoint for the current trace frame."),
4420 add_cmd ("pc", class_trace, trace_find_pc_command, _("\
4421 Select a trace frame by PC.\n\
4422 Default is the current PC, or the PC of the current trace frame."),
4425 add_cmd ("end", class_trace, trace_find_end_command, _("\
4426 De-select any trace frame and resume 'live' debugging."),
4429 add_alias_cmd ("none", "end", class_trace, 0, &tfindlist);
4431 add_cmd ("start", class_trace, trace_find_start_command,
4432 _("Select the first trace frame in the trace buffer."),
4435 add_com ("tstatus", class_trace, trace_status_command,
4436 _("Display the status of the current trace data collection."));
4438 add_com ("tstop", class_trace, trace_stop_command, _("\
4439 Stop trace data collection.\n\
4440 Usage: tstop [ <notes> ... ]\n\
4441 Any arguments supplied are recorded with the trace as a stop reason and\n\
4442 reported by tstatus (if the target supports trace notes)."));
4444 add_com ("tstart", class_trace, trace_start_command, _("\
4445 Start trace data collection.\n\
4446 Usage: tstart [ <notes> ... ]\n\
4447 Any arguments supplied are recorded with the trace as a note and\n\
4448 reported by tstatus (if the target supports trace notes)."));
4450 add_com ("end", class_trace, end_actions_pseudocommand, _("\
4451 Ends a list of commands or actions.\n\
4452 Several GDB commands allow you to enter a list of commands or actions.\n\
4453 Entering \"end\" on a line by itself is the normal way to terminate\n\
4455 Note: the \"end\" command cannot be used at the gdb prompt."));
4457 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
4458 Specify single-stepping behavior at a tracepoint.\n\
4459 Argument is number of instructions to trace in single-step mode\n\
4460 following the tracepoint. This command is normally followed by\n\
4461 one or more \"collect\" commands, to specify what to collect\n\
4462 while single-stepping.\n\n\
4463 Note: this command can only be used in a tracepoint \"actions\" list."));
4465 add_com_alias ("ws", "while-stepping", class_alias, 0);
4466 add_com_alias ("stepping", "while-stepping", class_alias, 0);
4468 add_com ("collect", class_trace, collect_pseudocommand, _("\
4469 Specify one or more data items to be collected at a tracepoint.\n\
4470 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4471 collect all data (variables, registers) referenced by that expression.\n\
4472 Also accepts the following special arguments:\n\
4473 $regs -- all registers.\n\
4474 $args -- all function arguments.\n\
4475 $locals -- all variables local to the block/function scope.\n\
4476 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4477 Note: this command can only be used in a tracepoint \"actions\" list."));
4479 add_com ("teval", class_trace, teval_pseudocommand, _("\
4480 Specify one or more expressions to be evaluated at a tracepoint.\n\
4481 Accepts a comma-separated list of (one or more) expressions.\n\
4482 The result of each evaluation will be discarded.\n\
4483 Note: this command can only be used in a tracepoint \"actions\" list."));
4485 add_com ("actions", class_trace, trace_actions_command, _("\
4486 Specify the actions to be taken at a tracepoint.\n\
4487 Tracepoint actions may include collecting of specified data,\n\
4488 single-stepping, or enabling/disabling other tracepoints,\n\
4489 depending on target's capabilities."));
4491 default_collect = xstrdup ("");
4492 add_setshow_string_cmd ("default-collect", class_trace,
4493 &default_collect, _("\
4494 Set the list of expressions to collect by default"), _("\
4495 Show the list of expressions to collect by default"), NULL,
4497 &setlist, &showlist);
4499 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
4500 &disconnected_tracing, _("\
4501 Set whether tracing continues after GDB disconnects."), _("\
4502 Show whether tracing continues after GDB disconnects."), _("\
4503 Use this to continue a tracing run even if GDB disconnects\n\
4504 or detaches from the target. You can reconnect later and look at\n\
4505 trace data collected in the meantime."),
4506 set_disconnected_tracing,
4511 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
4512 &circular_trace_buffer, _("\
4513 Set target's use of circular trace buffer."), _("\
4514 Show target's use of circular trace buffer."), _("\
4515 Use this to make the trace buffer into a circular buffer,\n\
4516 which will discard traceframes (oldest first) instead of filling\n\
4517 up and stopping the trace run."),
4518 set_circular_trace_buffer,
4523 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class,
4524 &trace_buffer_size, _("\
4525 Set requested size of trace buffer."), _("\
4526 Show requested size of trace buffer."), _("\
4527 Use this to choose a size for the trace buffer. Some targets\n\
4528 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
4529 disables any attempt to set the buffer size and lets the target choose."),
4530 set_trace_buffer_size, NULL,
4531 &setlist, &showlist);
4533 add_setshow_string_cmd ("trace-user", class_trace,
4535 Set the user name to use for current and future trace runs"), _("\
4536 Show the user name to use for current and future trace runs"), NULL,
4537 set_trace_user, NULL,
4538 &setlist, &showlist);
4540 add_setshow_string_cmd ("trace-notes", class_trace,
4542 Set notes string to use for current and future trace runs"), _("\
4543 Show the notes string to use for current and future trace runs"), NULL,
4544 set_trace_notes, NULL,
4545 &setlist, &showlist);
4547 add_setshow_string_cmd ("trace-stop-notes", class_trace,
4548 &trace_stop_notes, _("\
4549 Set notes string to use for future tstop commands"), _("\
4550 Show the notes string to use for future tstop commands"), NULL,
4551 set_trace_stop_notes, NULL,
4552 &setlist, &showlist);