1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
25 #include "expression.h"
29 #include "target-dcache.h"
32 #include "breakpoint.h"
33 #include "tracepoint.h"
36 #include "completer.h"
38 #include "dictionary.h"
40 #include "user-regs.h"
44 #include "filenames.h"
45 #include "gdbthread.h"
52 #include "cli/cli-utils.h"
55 #include "filestuff.h"
57 #include "tracefile.h"
61 /* readline include files */
62 #include "readline/readline.h"
63 #include "readline/history.h"
65 /* readline defines this. */
70 /* Maximum length of an agent aexpression.
71 This accounts for the fact that packets are limited to 400 bytes
72 (which includes everything -- including the checksum), and assumes
73 the worst case of maximum length for each of the pieces of a
76 NOTE: expressions get mem2hex'ed otherwise this would be twice as
77 large. (400 - 31)/2 == 184 */
78 #define MAX_AGENT_EXPR_LEN 184
80 /* A hook used to notify the UI of tracepoint operations. */
82 void (*deprecated_trace_find_hook) (char *arg, int from_tty);
83 void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
88 This module defines the following debugger commands:
89 trace : set a tracepoint on a function, line, or address.
90 info trace : list all debugger-defined tracepoints.
91 delete trace : delete one or more tracepoints.
92 enable trace : enable one or more tracepoints.
93 disable trace : disable one or more tracepoints.
94 actions : specify actions to be taken at a tracepoint.
95 passcount : specify a pass count for a tracepoint.
96 tstart : start a trace experiment.
97 tstop : stop a trace experiment.
98 tstatus : query the status of a trace experiment.
99 tfind : find a trace frame in the trace buffer.
100 tdump : print everything collected at the current tracepoint.
101 save-tracepoints : write tracepoint setup into a file.
103 This module defines the following user-visible debugger variables:
104 $trace_frame : sequence number of trace frame currently being debugged.
105 $trace_line : source line of trace frame currently being debugged.
106 $trace_file : source file of trace frame currently being debugged.
107 $tracepoint : tracepoint number of trace frame currently being debugged.
111 /* ======= Important global variables: ======= */
113 /* The list of all trace state variables. We don't retain pointers to
114 any of these for any reason - API is by name or number only - so it
115 works to have a vector of objects. */
117 typedef struct trace_state_variable tsv_s;
120 static VEC(tsv_s) *tvariables;
122 /* The next integer to assign to a variable. */
124 static int next_tsv_number = 1;
126 /* Number of last traceframe collected. */
127 static int traceframe_number;
129 /* Tracepoint for last traceframe collected. */
130 static int tracepoint_number;
132 /* The traceframe info of the current traceframe. NULL if we haven't
133 yet attempted to fetch it, or if the target does not support
134 fetching this object, or if we're not inspecting a traceframe
136 static struct traceframe_info *traceframe_info;
138 /* Tracing command lists. */
139 static struct cmd_list_element *tfindlist;
141 /* List of expressions to collect by default at each tracepoint hit. */
142 char *default_collect;
144 static int disconnected_tracing;
146 /* This variable controls whether we ask the target for a linear or
147 circular trace buffer. */
149 static int circular_trace_buffer;
151 /* This variable is the requested trace buffer size, or -1 to indicate
152 that we don't care and leave it up to the target to set a size. */
154 static int trace_buffer_size = -1;
156 /* Textual notes applying to the current and/or future trace runs. */
158 char *trace_user = NULL;
160 /* Textual notes applying to the current and/or future trace runs. */
162 char *trace_notes = NULL;
164 /* Textual notes applying to the stopping of a trace. */
166 char *trace_stop_notes = NULL;
168 /* ======= Important command functions: ======= */
169 static void actions_command (char *, int);
170 static void tstart_command (char *, int);
171 static void tstop_command (char *, int);
172 static void tstatus_command (char *, int);
173 static void tfind_pc_command (char *, int);
174 static void tfind_tracepoint_command (char *, int);
175 static void tfind_line_command (char *, int);
176 static void tfind_range_command (char *, int);
177 static void tfind_outside_command (char *, int);
178 static void tdump_command (char *, int);
180 /* support routines */
182 struct collection_list;
183 static char *mem2hex (gdb_byte *, char *, int);
185 static struct command_line *
186 all_tracepoint_actions_and_cleanup (struct breakpoint *t);
188 extern void _initialize_tracepoint (void);
190 static struct trace_status trace_status;
192 const char *stop_reason_names[] = {
202 struct trace_status *
203 current_trace_status (void)
205 return &trace_status;
211 free_traceframe_info (struct traceframe_info *info)
215 VEC_free (mem_range_s, info->memory);
216 VEC_free (int, info->tvars);
222 /* Free and clear the traceframe info cache of the current
226 clear_traceframe_info (void)
228 free_traceframe_info (traceframe_info);
229 traceframe_info = NULL;
232 /* Set traceframe number to NUM. */
234 set_traceframe_num (int num)
236 traceframe_number = num;
237 set_internalvar_integer (lookup_internalvar ("trace_frame"), num);
240 /* Set tracepoint number to NUM. */
242 set_tracepoint_num (int num)
244 tracepoint_number = num;
245 set_internalvar_integer (lookup_internalvar ("tracepoint"), num);
248 /* Set externally visible debug variables for querying/printing
249 the traceframe context (line, function, file). */
252 set_traceframe_context (struct frame_info *trace_frame)
255 struct symbol *traceframe_fun;
256 struct symtab_and_line traceframe_sal;
258 /* Save as globals for internal use. */
259 if (trace_frame != NULL
260 && get_frame_pc_if_available (trace_frame, &trace_pc))
262 traceframe_sal = find_pc_line (trace_pc, 0);
263 traceframe_fun = find_pc_function (trace_pc);
265 /* Save linenumber as "$trace_line", a debugger variable visible to
267 set_internalvar_integer (lookup_internalvar ("trace_line"),
268 traceframe_sal.line);
272 init_sal (&traceframe_sal);
273 traceframe_fun = NULL;
274 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
277 /* Save func name as "$trace_func", a debugger variable visible to
279 if (traceframe_fun == NULL
280 || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
281 clear_internalvar (lookup_internalvar ("trace_func"));
283 set_internalvar_string (lookup_internalvar ("trace_func"),
284 SYMBOL_LINKAGE_NAME (traceframe_fun));
286 /* Save file name as "$trace_file", a debugger variable visible to
288 if (traceframe_sal.symtab == NULL)
289 clear_internalvar (lookup_internalvar ("trace_file"));
291 set_internalvar_string (lookup_internalvar ("trace_file"),
292 symtab_to_filename_for_display (traceframe_sal.symtab));
295 /* Create a new trace state variable with the given name. */
297 struct trace_state_variable *
298 create_trace_state_variable (const char *name)
300 struct trace_state_variable tsv;
302 memset (&tsv, 0, sizeof (tsv));
303 tsv.name = xstrdup (name);
304 tsv.number = next_tsv_number++;
305 return VEC_safe_push (tsv_s, tvariables, &tsv);
308 /* Look for a trace state variable of the given name. */
310 struct trace_state_variable *
311 find_trace_state_variable (const char *name)
313 struct trace_state_variable *tsv;
316 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
317 if (strcmp (name, tsv->name) == 0)
323 /* Look for a trace state variable of the given number. Return NULL if
326 struct trace_state_variable *
327 find_trace_state_variable_by_number (int number)
329 struct trace_state_variable *tsv;
332 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
333 if (tsv->number == number)
340 delete_trace_state_variable (const char *name)
342 struct trace_state_variable *tsv;
345 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
346 if (strcmp (name, tsv->name) == 0)
348 observer_notify_tsv_deleted (tsv);
350 xfree ((void *)tsv->name);
351 VEC_unordered_remove (tsv_s, tvariables, ix);
356 warning (_("No trace variable named \"$%s\", not deleting"), name);
359 /* Throws an error if NAME is not valid syntax for a trace state
363 validate_trace_state_variable_name (const char *name)
368 error (_("Must supply a non-empty variable name"));
370 /* All digits in the name is reserved for value history
372 for (p = name; isdigit (*p); p++)
375 error (_("$%s is not a valid trace state variable name"), name);
377 for (p = name; isalnum (*p) || *p == '_'; p++)
380 error (_("$%s is not a valid trace state variable name"), name);
383 /* The 'tvariable' command collects a name and optional expression to
384 evaluate into an initial value. */
387 trace_variable_command (char *args, int from_tty)
389 struct cleanup *old_chain;
391 struct trace_state_variable *tsv;
395 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
397 /* Only allow two syntaxes; "$name" and "$name=value". */
398 p = skip_spaces (args);
401 error (_("Name of trace variable should start with '$'"));
404 while (isalnum (*p) || *p == '_')
406 name = savestring (name, p - name);
407 old_chain = make_cleanup (xfree, name);
410 if (*p != '=' && *p != '\0')
411 error (_("Syntax must be $NAME [ = EXPR ]"));
413 validate_trace_state_variable_name (name);
416 initval = value_as_long (parse_and_eval (++p));
418 /* If the variable already exists, just change its initial value. */
419 tsv = find_trace_state_variable (name);
422 if (tsv->initial_value != initval)
424 tsv->initial_value = initval;
425 observer_notify_tsv_modified (tsv);
427 printf_filtered (_("Trace state variable $%s "
428 "now has initial value %s.\n"),
429 tsv->name, plongest (tsv->initial_value));
430 do_cleanups (old_chain);
434 /* Create a new variable. */
435 tsv = create_trace_state_variable (name);
436 tsv->initial_value = initval;
438 observer_notify_tsv_created (tsv);
440 printf_filtered (_("Trace state variable $%s "
441 "created, with initial value %s.\n"),
442 tsv->name, plongest (tsv->initial_value));
444 do_cleanups (old_chain);
448 delete_trace_variable_command (char *args, int from_tty)
452 struct cleanup *back_to;
456 if (query (_("Delete all trace state variables? ")))
457 VEC_free (tsv_s, tvariables);
459 observer_notify_tsv_deleted (NULL);
463 argv = gdb_buildargv (args);
464 back_to = make_cleanup_freeargv (argv);
466 for (ix = 0; argv[ix] != NULL; ix++)
468 if (*argv[ix] == '$')
469 delete_trace_state_variable (argv[ix] + 1);
471 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv[ix]);
474 do_cleanups (back_to);
480 tvariables_info_1 (void)
482 struct trace_state_variable *tsv;
485 struct cleanup *back_to;
486 struct ui_out *uiout = current_uiout;
488 if (VEC_length (tsv_s, tvariables) == 0 && !uiout->is_mi_like_p ())
490 printf_filtered (_("No trace state variables.\n"));
494 /* Try to acquire values from the target. */
495 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix, ++count)
496 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
499 back_to = make_cleanup_ui_out_table_begin_end (uiout, 3,
500 count, "trace-variables");
501 uiout->table_header (15, ui_left, "name", "Name");
502 uiout->table_header (11, ui_left, "initial", "Initial");
503 uiout->table_header (11, ui_left, "current", "Current");
505 uiout->table_body ();
507 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
511 ui_out_emit_tuple tuple_emitter (uiout, "variable");
513 std::string name = std::string ("$") + tsv->name;
514 uiout->field_string ("name", name.c_str ());
515 uiout->field_string ("initial", plongest (tsv->initial_value));
517 if (tsv->value_known)
518 c = plongest (tsv->value);
519 else if (uiout->is_mi_like_p ())
520 /* For MI, we prefer not to use magic string constants, but rather
521 omit the field completely. The difference between unknown and
522 undefined does not seem important enough to represent. */
524 else if (current_trace_status ()->running || traceframe_number >= 0)
525 /* The value is/was defined, but we don't have it. */
528 /* It is not meaningful to ask about the value. */
531 uiout->field_string ("current", c);
535 do_cleanups (back_to);
538 /* List all the trace state variables. */
541 tvariables_info (char *args, int from_tty)
543 tvariables_info_1 ();
546 /* Stash definitions of tsvs into the given file. */
549 save_trace_state_variables (struct ui_file *fp)
551 struct trace_state_variable *tsv;
554 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
556 fprintf_unfiltered (fp, "tvariable $%s", tsv->name);
557 if (tsv->initial_value)
558 fprintf_unfiltered (fp, " = %s", plongest (tsv->initial_value));
559 fprintf_unfiltered (fp, "\n");
563 /* ACTIONS functions: */
565 /* The three functions:
566 collect_pseudocommand,
567 while_stepping_pseudocommand, and
568 end_actions_pseudocommand
569 are placeholders for "commands" that are actually ONLY to be used
570 within a tracepoint action list. If the actual function is ever called,
571 it means that somebody issued the "command" at the top level,
572 which is always an error. */
575 end_actions_pseudocommand (char *args, int from_tty)
577 error (_("This command cannot be used at the top level."));
581 while_stepping_pseudocommand (char *args, int from_tty)
583 error (_("This command can only be used in a tracepoint actions list."));
587 collect_pseudocommand (char *args, int from_tty)
589 error (_("This command can only be used in a tracepoint actions list."));
593 teval_pseudocommand (char *args, int from_tty)
595 error (_("This command can only be used in a tracepoint actions list."));
598 /* Parse any collection options, such as /s for strings. */
601 decode_agent_options (const char *exp, int *trace_string)
603 struct value_print_options opts;
610 /* Call this to borrow the print elements default for collection
612 get_user_print_options (&opts);
617 if (target_supports_string_tracing ())
619 /* Allow an optional decimal number giving an explicit maximum
620 string length, defaulting it to the "print elements" value;
621 so "collect/s80 mystr" gets at most 80 bytes of string. */
622 *trace_string = opts.print_max;
624 if (*exp >= '0' && *exp <= '9')
625 *trace_string = atoi (exp);
626 while (*exp >= '0' && *exp <= '9')
630 error (_("Target does not support \"/s\" option for string tracing."));
633 error (_("Undefined collection format \"%c\"."), *exp);
635 exp = skip_spaces_const (exp);
640 /* Enter a list of actions for a tracepoint. */
642 actions_command (char *args, int from_tty)
644 struct tracepoint *t;
646 t = get_tracepoint_by_number (&args, NULL);
650 string_printf ("Enter actions for tracepoint %d, one per line.",
653 command_line_up l = read_command_lines (&tmpbuf[0], from_tty, 1,
654 check_tracepoint_command, t);
655 breakpoint_set_commands (t, std::move (l));
657 /* else just return */
660 /* Report the results of checking the agent expression, as errors or
664 report_agent_reqs_errors (struct agent_expr *aexpr)
666 /* All of the "flaws" are serious bytecode generation issues that
667 should never occur. */
668 if (aexpr->flaw != agent_flaw_none)
669 internal_error (__FILE__, __LINE__, _("expression is malformed"));
671 /* If analysis shows a stack underflow, GDB must have done something
672 badly wrong in its bytecode generation. */
673 if (aexpr->min_height < 0)
674 internal_error (__FILE__, __LINE__,
675 _("expression has min height < 0"));
677 /* Issue this error if the stack is predicted to get too deep. The
678 limit is rather arbitrary; a better scheme might be for the
679 target to report how much stack it will have available. The
680 depth roughly corresponds to parenthesization, so a limit of 20
681 amounts to 20 levels of expression nesting, which is actually
682 a pretty big hairy expression. */
683 if (aexpr->max_height > 20)
684 error (_("Expression is too complicated."));
687 /* worker function */
689 validate_actionline (const char *line, struct breakpoint *b)
691 struct cmd_list_element *c;
692 struct cleanup *old_chain = NULL;
695 struct bp_location *loc;
696 struct tracepoint *t = (struct tracepoint *) b;
698 /* If EOF is typed, *line is NULL. */
702 p = skip_spaces_const (line);
704 /* Symbol lookup etc. */
705 if (*p == '\0') /* empty line: just prompt for another line. */
708 if (*p == '#') /* comment line */
711 c = lookup_cmd (&p, cmdlist, "", -1, 1);
713 error (_("`%s' is not a tracepoint action, or is ambiguous."), p);
715 if (cmd_cfunc_eq (c, collect_pseudocommand))
717 int trace_string = 0;
720 p = decode_agent_options (p, &trace_string);
723 { /* Repeat over a comma-separated list. */
724 QUIT; /* Allow user to bail out with ^C. */
725 p = skip_spaces_const (p);
727 if (*p == '$') /* Look for special pseudo-symbols. */
729 if (0 == strncasecmp ("reg", p + 1, 3)
730 || 0 == strncasecmp ("arg", p + 1, 3)
731 || 0 == strncasecmp ("loc", p + 1, 3)
732 || 0 == strncasecmp ("_ret", p + 1, 4)
733 || 0 == strncasecmp ("_sdata", p + 1, 6))
738 /* else fall thru, treat p as an expression and parse it! */
741 for (loc = t->loc; loc; loc = loc->next)
744 expression_up exp = parse_exp_1 (&p, loc->address,
745 block_for_pc (loc->address), 1);
747 if (exp->elts[0].opcode == OP_VAR_VALUE)
749 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
751 error (_("constant `%s' (value %s) "
752 "will not be collected."),
753 SYMBOL_PRINT_NAME (exp->elts[2].symbol),
754 plongest (SYMBOL_VALUE (exp->elts[2].symbol)));
756 else if (SYMBOL_CLASS (exp->elts[2].symbol)
757 == LOC_OPTIMIZED_OUT)
759 error (_("`%s' is optimized away "
760 "and cannot be collected."),
761 SYMBOL_PRINT_NAME (exp->elts[2].symbol));
765 /* We have something to collect, make sure that the expr to
766 bytecode translator can handle it and that it's not too
768 agent_expr_up aexpr = gen_trace_for_expr (loc->address,
772 if (aexpr->len > MAX_AGENT_EXPR_LEN)
773 error (_("Expression is too complicated."));
775 ax_reqs (aexpr.get ());
777 report_agent_reqs_errors (aexpr.get ());
780 while (p && *p++ == ',');
783 else if (cmd_cfunc_eq (c, teval_pseudocommand))
786 { /* Repeat over a comma-separated list. */
787 QUIT; /* Allow user to bail out with ^C. */
788 p = skip_spaces_const (p);
791 for (loc = t->loc; loc; loc = loc->next)
795 /* Only expressions are allowed for this action. */
796 expression_up exp = parse_exp_1 (&p, loc->address,
797 block_for_pc (loc->address), 1);
799 /* We have something to evaluate, make sure that the expr to
800 bytecode translator can handle it and that it's not too
802 agent_expr_up aexpr = gen_eval_for_expr (loc->address, exp.get ());
804 if (aexpr->len > MAX_AGENT_EXPR_LEN)
805 error (_("Expression is too complicated."));
807 ax_reqs (aexpr.get ());
808 report_agent_reqs_errors (aexpr.get ());
811 while (p && *p++ == ',');
814 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
818 p = skip_spaces_const (p);
819 t->step_count = strtol (p, &endp, 0);
820 if (endp == p || t->step_count == 0)
821 error (_("while-stepping step count `%s' is malformed."), line);
825 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
829 error (_("`%s' is not a supported tracepoint action."), line);
833 memrange_absolute = -1
836 /* MEMRANGE functions: */
838 /* Compare memranges for std::sort. */
841 memrange_comp (const memrange &a, const memrange &b)
843 if (a.type == b.type)
845 if (a.type == memrange_absolute)
846 return (bfd_vma) a.start < (bfd_vma) b.start;
848 return a.start < b.start;
851 return a.type < b.type;
854 /* Sort the memrange list using std::sort, and merge adjacent memranges. */
857 memrange_sortmerge (std::vector<memrange> &memranges)
859 if (!memranges.empty ())
863 std::sort (memranges.begin (), memranges.end (), memrange_comp);
865 for (a = 0, b = 1; b < memranges.size (); b++)
867 /* If memrange b overlaps or is adjacent to memrange a,
869 if (memranges[a].type == memranges[b].type
870 && memranges[b].start <= memranges[a].end)
872 if (memranges[b].end > memranges[a].end)
873 memranges[a].end = memranges[b].end;
874 continue; /* next b, same a */
878 memranges[a] = memranges[b];
880 memranges.resize (a + 1);
884 /* Add a register to a collection list. */
887 collection_list::add_register (unsigned int regno)
890 printf_filtered ("collect register %d\n", regno);
891 if (regno >= (8 * sizeof (m_regs_mask)))
892 error (_("Internal: register number %d too large for tracepoint"),
894 m_regs_mask[regno / 8] |= 1 << (regno % 8);
897 /* Add a memrange to a collection list. */
900 collection_list::add_memrange (struct gdbarch *gdbarch,
901 int type, bfd_signed_vma base,
905 printf_filtered ("(%d,%s,%ld)\n", type, paddress (gdbarch, base), len);
907 /* type: memrange_absolute == memory, other n == basereg */
908 /* base: addr if memory, offset if reg relative. */
909 /* len: we actually save end (base + len) for convenience */
910 m_memranges.emplace_back (type, base, base + len);
912 if (type != memrange_absolute) /* Better collect the base register! */
916 /* Add a symbol to a collection list. */
919 collection_list::collect_symbol (struct symbol *sym,
920 struct gdbarch *gdbarch,
921 long frame_regno, long frame_offset,
927 bfd_signed_vma offset;
928 int treat_as_expr = 0;
930 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
931 switch (SYMBOL_CLASS (sym))
934 printf_filtered ("%s: don't know symbol class %d\n",
935 SYMBOL_PRINT_NAME (sym),
939 printf_filtered ("constant %s (value %s) will not be collected.\n",
940 SYMBOL_PRINT_NAME (sym), plongest (SYMBOL_VALUE (sym)));
943 offset = SYMBOL_VALUE_ADDRESS (sym);
946 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
947 SYMBOL_PRINT_NAME (sym), len,
948 paddress (gdbarch, offset));
950 /* A struct may be a C++ class with static fields, go to general
951 expression handling. */
952 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
955 add_memrange (gdbarch, memrange_absolute, offset, len);
958 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
960 printf_filtered ("LOC_REG[parm] %s: ",
961 SYMBOL_PRINT_NAME (sym));
963 /* Check for doubles stored in two registers. */
964 /* FIXME: how about larger types stored in 3 or more regs? */
965 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
966 len > register_size (gdbarch, reg))
967 add_register (reg + 1);
970 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
971 printf_filtered (" (will not collect %s)\n",
972 SYMBOL_PRINT_NAME (sym));
976 offset = frame_offset + SYMBOL_VALUE (sym);
979 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
980 " from frame ptr reg %d\n",
981 SYMBOL_PRINT_NAME (sym), len,
982 paddress (gdbarch, offset), reg);
984 add_memrange (gdbarch, reg, offset, len);
986 case LOC_REGPARM_ADDR:
987 reg = SYMBOL_VALUE (sym);
991 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset %s"
993 SYMBOL_PRINT_NAME (sym), len,
994 paddress (gdbarch, offset), reg);
996 add_memrange (gdbarch, reg, offset, len);
1000 offset = frame_offset + SYMBOL_VALUE (sym);
1003 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
1004 " from frame ptr reg %d\n",
1005 SYMBOL_PRINT_NAME (sym), len,
1006 paddress (gdbarch, offset), reg);
1008 add_memrange (gdbarch, reg, offset, len);
1011 case LOC_UNRESOLVED:
1015 case LOC_OPTIMIZED_OUT:
1016 printf_filtered ("%s has been optimized out of existence.\n",
1017 SYMBOL_PRINT_NAME (sym));
1025 /* Expressions are the most general case. */
1028 struct cleanup *old_chain1 = NULL;
1030 agent_expr_up aexpr = gen_trace_for_var (scope, gdbarch,
1033 /* It can happen that the symbol is recorded as a computed
1034 location, but it's been optimized away and doesn't actually
1035 have a location expression. */
1038 printf_filtered ("%s has been optimized out of existence.\n",
1039 SYMBOL_PRINT_NAME (sym));
1043 ax_reqs (aexpr.get ());
1045 report_agent_reqs_errors (aexpr.get ());
1047 /* Take care of the registers. */
1048 if (aexpr->reg_mask_len > 0)
1050 for (int ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1052 QUIT; /* Allow user to bail out with ^C. */
1053 if (aexpr->reg_mask[ndx1] != 0)
1055 /* Assume chars have 8 bits. */
1056 for (int ndx2 = 0; ndx2 < 8; ndx2++)
1057 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1058 /* It's used -- record it. */
1059 add_register (ndx1 * 8 + ndx2);
1064 add_aexpr (std::move (aexpr));
1068 /* Data to be passed around in the calls to the locals and args
1071 struct add_local_symbols_data
1073 struct collection_list *collect;
1074 struct gdbarch *gdbarch;
1082 /* The callback for the locals and args iterators. */
1085 do_collect_symbol (const char *print_name,
1089 struct add_local_symbols_data *p = (struct add_local_symbols_data *) cb_data;
1091 p->collect->collect_symbol (sym, p->gdbarch, p->frame_regno,
1092 p->frame_offset, p->pc, p->trace_string);
1095 p->collect->add_wholly_collected (print_name);
1099 collection_list::add_wholly_collected (const char *print_name)
1101 m_wholly_collected.push_back (print_name);
1104 /* Add all locals (or args) symbols to collection list. */
1107 collection_list::add_local_symbols (struct gdbarch *gdbarch, CORE_ADDR pc,
1108 long frame_regno, long frame_offset, int type,
1111 const struct block *block;
1112 struct add_local_symbols_data cb_data;
1114 cb_data.collect = this;
1115 cb_data.gdbarch = gdbarch;
1117 cb_data.frame_regno = frame_regno;
1118 cb_data.frame_offset = frame_offset;
1120 cb_data.trace_string = trace_string;
1124 block = block_for_pc (pc);
1127 warning (_("Can't collect locals; "
1128 "no symbol table info available.\n"));
1132 iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1133 if (cb_data.count == 0)
1134 warning (_("No locals found in scope."));
1138 pc = get_pc_function_start (pc);
1139 block = block_for_pc (pc);
1142 warning (_("Can't collect args; no symbol table info available."));
1146 iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1147 if (cb_data.count == 0)
1148 warning (_("No args found in scope."));
1153 collection_list::add_static_trace_data ()
1156 printf_filtered ("collect static trace data\n");
1157 m_strace_data = true;
1160 collection_list::collection_list ()
1162 m_strace_data (false)
1164 m_memranges.reserve (128);
1165 m_aexprs.reserve (128);
1168 /* Reduce a collection list to string form (for gdb protocol). */
1171 collection_list::stringify ()
1173 char temp_buf[2048];
1176 char *(*str_list)[];
1180 count = 1 + 1 + m_memranges.size () + m_aexprs.size () + 1;
1181 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1186 printf_filtered ("\nCollecting static trace data\n");
1189 (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
1193 for (i = sizeof (m_regs_mask) - 1; i > 0; i--)
1194 if (m_regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */
1196 if (m_regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
1199 printf_filtered ("\nCollecting registers (mask): 0x");
1204 QUIT; /* Allow user to bail out with ^C. */
1206 printf_filtered ("%02X", m_regs_mask[i]);
1207 sprintf (end, "%02X", m_regs_mask[i]);
1210 (*str_list)[ndx] = xstrdup (temp_buf);
1214 printf_filtered ("\n");
1215 if (!m_memranges.empty () && info_verbose)
1216 printf_filtered ("Collecting memranges: \n");
1217 for (i = 0, count = 0, end = temp_buf; i < m_memranges.size (); i++)
1219 QUIT; /* Allow user to bail out with ^C. */
1222 printf_filtered ("(%d, %s, %ld)\n",
1223 m_memranges[i].type,
1224 paddress (target_gdbarch (),
1225 m_memranges[i].start),
1226 (long) (m_memranges[i].end
1227 - m_memranges[i].start));
1229 if (count + 27 > MAX_AGENT_EXPR_LEN)
1231 (*str_list)[ndx] = savestring (temp_buf, count);
1238 bfd_signed_vma length
1239 = m_memranges[i].end - m_memranges[i].start;
1241 /* The "%X" conversion specifier expects an unsigned argument,
1242 so passing -1 (memrange_absolute) to it directly gives you
1243 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1245 if (m_memranges[i].type == memrange_absolute)
1246 sprintf (end, "M-1,%s,%lX", phex_nz (m_memranges[i].start, 0),
1249 sprintf (end, "M%X,%s,%lX", m_memranges[i].type,
1250 phex_nz (m_memranges[i].start, 0), (long) length);
1253 count += strlen (end);
1254 end = temp_buf + count;
1257 for (i = 0; i < m_aexprs.size (); i++)
1259 QUIT; /* Allow user to bail out with ^C. */
1260 if ((count + 10 + 2 * m_aexprs[i]->len) > MAX_AGENT_EXPR_LEN)
1262 (*str_list)[ndx] = savestring (temp_buf, count);
1267 sprintf (end, "X%08X,", m_aexprs[i]->len);
1268 end += 10; /* 'X' + 8 hex digits + ',' */
1271 end = mem2hex (m_aexprs[i]->buf, end, m_aexprs[i]->len);
1272 count += 2 * m_aexprs[i]->len;
1277 (*str_list)[ndx] = savestring (temp_buf, count);
1282 (*str_list)[ndx] = NULL;
1293 /* Add the printed expression EXP to *LIST. */
1296 collection_list::append_exp (struct expression *exp)
1298 string_file tmp_stream;
1300 print_expression (exp, &tmp_stream);
1302 m_computed.push_back (std::move (tmp_stream.string ()));
1306 collection_list::finish ()
1308 memrange_sortmerge (m_memranges);
1312 encode_actions_1 (struct command_line *action,
1313 struct bp_location *tloc,
1315 LONGEST frame_offset,
1316 struct collection_list *collect,
1317 struct collection_list *stepping_list)
1319 const char *action_exp;
1321 struct value *tempval;
1322 struct cmd_list_element *cmd;
1324 for (; action; action = action->next)
1326 QUIT; /* Allow user to bail out with ^C. */
1327 action_exp = action->line;
1328 action_exp = skip_spaces_const (action_exp);
1330 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1332 error (_("Bad action list item: %s"), action_exp);
1334 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1336 int trace_string = 0;
1338 if (*action_exp == '/')
1339 action_exp = decode_agent_options (action_exp, &trace_string);
1342 { /* Repeat over a comma-separated list. */
1343 QUIT; /* Allow user to bail out with ^C. */
1344 action_exp = skip_spaces_const (action_exp);
1346 if (0 == strncasecmp ("$reg", action_exp, 4))
1348 for (i = 0; i < gdbarch_num_regs (target_gdbarch ()); i++)
1349 collect->add_register (i);
1350 action_exp = strchr (action_exp, ','); /* more? */
1352 else if (0 == strncasecmp ("$arg", action_exp, 4))
1354 collect->add_local_symbols (target_gdbarch (),
1360 action_exp = strchr (action_exp, ','); /* more? */
1362 else if (0 == strncasecmp ("$loc", action_exp, 4))
1364 collect->add_local_symbols (target_gdbarch (),
1370 action_exp = strchr (action_exp, ','); /* more? */
1372 else if (0 == strncasecmp ("$_ret", action_exp, 5))
1375 = gen_trace_for_return_address (tloc->address,
1379 ax_reqs (aexpr.get ());
1380 report_agent_reqs_errors (aexpr.get ());
1382 /* take care of the registers */
1383 if (aexpr->reg_mask_len > 0)
1385 for (int ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1387 QUIT; /* allow user to bail out with ^C */
1388 if (aexpr->reg_mask[ndx1] != 0)
1390 /* assume chars have 8 bits */
1391 for (int ndx2 = 0; ndx2 < 8; ndx2++)
1392 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1394 /* It's used -- record it. */
1395 collect->add_register (ndx1 * 8 + ndx2);
1401 collect->add_aexpr (std::move (aexpr));
1402 action_exp = strchr (action_exp, ','); /* more? */
1404 else if (0 == strncasecmp ("$_sdata", action_exp, 7))
1406 collect->add_static_trace_data ();
1407 action_exp = strchr (action_exp, ','); /* more? */
1412 struct cleanup *old_chain1 = NULL;
1414 expression_up exp = parse_exp_1 (&action_exp, tloc->address,
1415 block_for_pc (tloc->address),
1418 switch (exp->elts[0].opcode)
1422 const char *name = &exp->elts[2].string;
1424 i = user_reg_map_name_to_regnum (target_gdbarch (),
1425 name, strlen (name));
1427 internal_error (__FILE__, __LINE__,
1428 _("Register $%s not available"),
1431 printf_filtered ("OP_REGISTER: ");
1432 collect->add_register (i);
1437 /* Safe because we know it's a simple expression. */
1438 tempval = evaluate_expression (exp.get ());
1439 addr = value_address (tempval);
1440 /* Initialize the TYPE_LENGTH if it is a typedef. */
1441 check_typedef (exp->elts[1].type);
1442 collect->add_memrange (target_gdbarch (),
1443 memrange_absolute, addr,
1444 TYPE_LENGTH (exp->elts[1].type));
1445 collect->append_exp (exp.get ());
1450 struct symbol *sym = exp->elts[2].symbol;
1451 char_ptr name = (char_ptr) SYMBOL_NATURAL_NAME (sym);
1453 collect->collect_symbol (exp->elts[2].symbol,
1459 collect->add_wholly_collected (name);
1463 default: /* Full-fledged expression. */
1464 agent_expr_up aexpr = gen_trace_for_expr (tloc->address,
1468 ax_reqs (aexpr.get ());
1470 report_agent_reqs_errors (aexpr.get ());
1472 /* Take care of the registers. */
1473 if (aexpr->reg_mask_len > 0)
1475 for (int ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1477 QUIT; /* Allow user to bail out with ^C. */
1478 if (aexpr->reg_mask[ndx1] != 0)
1480 /* Assume chars have 8 bits. */
1481 for (int ndx2 = 0; ndx2 < 8; ndx2++)
1482 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1484 /* It's used -- record it. */
1485 collect->add_register (ndx1 * 8 + ndx2);
1491 collect->add_aexpr (std::move (aexpr));
1492 collect->append_exp (exp.get ());
1497 while (action_exp && *action_exp++ == ',');
1499 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1502 { /* Repeat over a comma-separated list. */
1503 QUIT; /* Allow user to bail out with ^C. */
1504 action_exp = skip_spaces_const (action_exp);
1507 struct cleanup *old_chain1 = NULL;
1509 expression_up exp = parse_exp_1 (&action_exp, tloc->address,
1510 block_for_pc (tloc->address),
1513 agent_expr_up aexpr = gen_eval_for_expr (tloc->address,
1516 ax_reqs (aexpr.get ());
1517 report_agent_reqs_errors (aexpr.get ());
1519 /* Even though we're not officially collecting, add
1520 to the collect list anyway. */
1521 collect->add_aexpr (std::move (aexpr));
1524 while (action_exp && *action_exp++ == ',');
1526 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1528 /* We check against nested while-stepping when setting
1529 breakpoint action, so no way to run into nested
1531 gdb_assert (stepping_list);
1533 encode_actions_1 (action->body_list[0], tloc, frame_reg,
1534 frame_offset, stepping_list, NULL);
1537 error (_("Invalid tracepoint command '%s'"), action->line);
1541 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1542 and STEPPING_LIST. */
1545 encode_actions (struct bp_location *tloc,
1546 struct collection_list *tracepoint_list,
1547 struct collection_list *stepping_list)
1549 struct command_line *actions;
1551 LONGEST frame_offset;
1553 gdbarch_virtual_frame_pointer (tloc->gdbarch,
1554 tloc->address, &frame_reg, &frame_offset);
1556 actions = all_tracepoint_actions_and_cleanup (tloc->owner);
1558 encode_actions_1 (actions, tloc, frame_reg, frame_offset,
1559 tracepoint_list, stepping_list);
1561 tracepoint_list->finish ();
1562 stepping_list->finish ();
1565 /* Render all actions into gdb protocol. */
1568 encode_actions_rsp (struct bp_location *tloc, char ***tdp_actions,
1569 char ***stepping_actions)
1571 struct collection_list tracepoint_list, stepping_list;
1573 *tdp_actions = NULL;
1574 *stepping_actions = NULL;
1576 encode_actions (tloc, &tracepoint_list, &stepping_list);
1578 *tdp_actions = tracepoint_list.stringify ();
1579 *stepping_actions = stepping_list.stringify ();
1583 collection_list::add_aexpr (agent_expr_up aexpr)
1585 m_aexprs.push_back (std::move (aexpr));
1589 process_tracepoint_on_disconnect (void)
1591 VEC(breakpoint_p) *tp_vec = NULL;
1593 struct breakpoint *b;
1594 int has_pending_p = 0;
1596 /* Check whether we still have pending tracepoint. If we have, warn the
1597 user that pending tracepoint will no longer work. */
1598 tp_vec = all_tracepoints ();
1599 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1608 struct bp_location *loc1;
1610 for (loc1 = b->loc; loc1; loc1 = loc1->next)
1612 if (loc1->shlib_disabled)
1623 VEC_free (breakpoint_p, tp_vec);
1626 warning (_("Pending tracepoints will not be resolved while"
1627 " GDB is disconnected\n"));
1630 /* Reset local state of tracing. */
1633 trace_reset_local_state (void)
1635 set_traceframe_num (-1);
1636 set_tracepoint_num (-1);
1637 set_traceframe_context (NULL);
1638 clear_traceframe_info ();
1642 start_tracing (char *notes)
1644 VEC(breakpoint_p) *tp_vec = NULL;
1646 struct breakpoint *b;
1647 struct trace_state_variable *tsv;
1648 int any_enabled = 0, num_to_download = 0;
1651 tp_vec = all_tracepoints ();
1653 /* No point in tracing without any tracepoints... */
1654 if (VEC_length (breakpoint_p, tp_vec) == 0)
1656 VEC_free (breakpoint_p, tp_vec);
1657 error (_("No tracepoints defined, not starting trace"));
1660 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1662 if (b->enable_state == bp_enabled)
1665 if ((b->type == bp_fast_tracepoint
1666 ? may_insert_fast_tracepoints
1667 : may_insert_tracepoints))
1670 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1671 (b->type == bp_fast_tracepoint ? "fast " : ""), b->number);
1676 if (target_supports_enable_disable_tracepoint ())
1677 warning (_("No tracepoints enabled"));
1680 /* No point in tracing with only disabled tracepoints that
1681 cannot be re-enabled. */
1682 VEC_free (breakpoint_p, tp_vec);
1683 error (_("No tracepoints enabled, not starting trace"));
1687 if (num_to_download <= 0)
1689 VEC_free (breakpoint_p, tp_vec);
1690 error (_("No tracepoints that may be downloaded, not starting trace"));
1693 target_trace_init ();
1695 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1697 struct tracepoint *t = (struct tracepoint *) b;
1698 struct bp_location *loc;
1699 int bp_location_downloaded = 0;
1701 /* Clear `inserted' flag. */
1702 for (loc = b->loc; loc; loc = loc->next)
1705 if ((b->type == bp_fast_tracepoint
1706 ? !may_insert_fast_tracepoints
1707 : !may_insert_tracepoints))
1710 t->number_on_target = 0;
1712 for (loc = b->loc; loc; loc = loc->next)
1714 /* Since tracepoint locations are never duplicated, `inserted'
1715 flag should be zero. */
1716 gdb_assert (!loc->inserted);
1718 target_download_tracepoint (loc);
1721 bp_location_downloaded = 1;
1724 t->number_on_target = b->number;
1726 for (loc = b->loc; loc; loc = loc->next)
1727 if (loc->probe.probe != NULL
1728 && loc->probe.probe->pops->set_semaphore != NULL)
1729 loc->probe.probe->pops->set_semaphore (loc->probe.probe,
1733 if (bp_location_downloaded)
1734 observer_notify_breakpoint_modified (b);
1736 VEC_free (breakpoint_p, tp_vec);
1738 /* Send down all the trace state variables too. */
1739 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1741 target_download_trace_state_variable (tsv);
1744 /* Tell target to treat text-like sections as transparent. */
1745 target_trace_set_readonly_regions ();
1746 /* Set some mode flags. */
1747 target_set_disconnected_tracing (disconnected_tracing);
1748 target_set_circular_trace_buffer (circular_trace_buffer);
1749 target_set_trace_buffer_size (trace_buffer_size);
1752 notes = trace_notes;
1753 ret = target_set_trace_notes (trace_user, notes, NULL);
1755 if (!ret && (trace_user || notes))
1756 warning (_("Target does not support trace user/notes, info ignored"));
1758 /* Now insert traps and begin collecting data. */
1759 target_trace_start ();
1761 /* Reset our local state. */
1762 trace_reset_local_state ();
1763 current_trace_status()->running = 1;
1766 /* The tstart command requests the target to start a new trace run.
1767 The command passes any arguments it has to the target verbatim, as
1768 an optional "trace note". This is useful as for instance a warning
1769 to other users if the trace runs disconnected, and you don't want
1770 anybody else messing with the target. */
1773 tstart_command (char *args, int from_tty)
1775 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1777 if (current_trace_status ()->running)
1780 && !query (_("A trace is running already. Start a new run? ")))
1781 error (_("New trace run not started."));
1784 start_tracing (args);
1787 /* The tstop command stops the tracing run. The command passes any
1788 supplied arguments to the target verbatim as a "stop note"; if the
1789 target supports trace notes, then it will be reported back as part
1790 of the trace run's status. */
1793 tstop_command (char *args, int from_tty)
1795 if (!current_trace_status ()->running)
1796 error (_("Trace is not running."));
1798 stop_tracing (args);
1802 stop_tracing (char *note)
1805 VEC(breakpoint_p) *tp_vec = NULL;
1807 struct breakpoint *t;
1809 target_trace_stop ();
1811 tp_vec = all_tracepoints ();
1812 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1814 struct bp_location *loc;
1816 if ((t->type == bp_fast_tracepoint
1817 ? !may_insert_fast_tracepoints
1818 : !may_insert_tracepoints))
1821 for (loc = t->loc; loc; loc = loc->next)
1823 /* GDB can be totally absent in some disconnected trace scenarios,
1824 but we don't really care if this semaphore goes out of sync.
1825 That's why we are decrementing it here, but not taking care
1827 if (loc->probe.probe != NULL
1828 && loc->probe.probe->pops->clear_semaphore != NULL)
1829 loc->probe.probe->pops->clear_semaphore (loc->probe.probe,
1835 VEC_free (breakpoint_p, tp_vec);
1838 note = trace_stop_notes;
1839 ret = target_set_trace_notes (NULL, NULL, note);
1842 warning (_("Target does not support trace notes, note ignored"));
1844 /* Should change in response to reply? */
1845 current_trace_status ()->running = 0;
1848 /* tstatus command */
1850 tstatus_command (char *args, int from_tty)
1852 struct trace_status *ts = current_trace_status ();
1854 VEC(breakpoint_p) *tp_vec = NULL;
1855 struct breakpoint *t;
1857 status = target_get_trace_status (ts);
1861 if (ts->filename != NULL)
1862 printf_filtered (_("Using a trace file.\n"));
1865 printf_filtered (_("Trace can not be run on this target.\n"));
1870 if (!ts->running_known)
1872 printf_filtered (_("Run/stop status is unknown.\n"));
1874 else if (ts->running)
1876 printf_filtered (_("Trace is running on the target.\n"));
1880 switch (ts->stop_reason)
1882 case trace_never_run:
1883 printf_filtered (_("No trace has been run on the target.\n"));
1885 case trace_stop_command:
1887 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1890 printf_filtered (_("Trace stopped by a tstop command.\n"));
1892 case trace_buffer_full:
1893 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1895 case trace_disconnected:
1896 printf_filtered (_("Trace stopped because of disconnection.\n"));
1898 case tracepoint_passcount:
1899 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1900 ts->stopping_tracepoint);
1902 case tracepoint_error:
1903 if (ts->stopping_tracepoint)
1904 printf_filtered (_("Trace stopped by an "
1905 "error (%s, tracepoint %d).\n"),
1906 ts->stop_desc, ts->stopping_tracepoint);
1908 printf_filtered (_("Trace stopped by an error (%s).\n"),
1911 case trace_stop_reason_unknown:
1912 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1915 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1921 if (ts->traceframes_created >= 0
1922 && ts->traceframe_count != ts->traceframes_created)
1924 printf_filtered (_("Buffer contains %d trace "
1925 "frames (of %d created total).\n"),
1926 ts->traceframe_count, ts->traceframes_created);
1928 else if (ts->traceframe_count >= 0)
1930 printf_filtered (_("Collected %d trace frames.\n"),
1931 ts->traceframe_count);
1934 if (ts->buffer_free >= 0)
1936 if (ts->buffer_size >= 0)
1938 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1939 ts->buffer_free, ts->buffer_size);
1940 if (ts->buffer_size > 0)
1941 printf_filtered (_(" (%d%% full)"),
1942 ((int) ((((long long) (ts->buffer_size
1943 - ts->buffer_free)) * 100)
1944 / ts->buffer_size)));
1945 printf_filtered (_(".\n"));
1948 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1952 if (ts->disconnected_tracing)
1953 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1955 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1957 if (ts->circular_buffer)
1958 printf_filtered (_("Trace buffer is circular.\n"));
1960 if (ts->user_name && strlen (ts->user_name) > 0)
1961 printf_filtered (_("Trace user is %s.\n"), ts->user_name);
1963 if (ts->notes && strlen (ts->notes) > 0)
1964 printf_filtered (_("Trace notes: %s.\n"), ts->notes);
1966 /* Now report on what we're doing with tfind. */
1967 if (traceframe_number >= 0)
1968 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1969 traceframe_number, tracepoint_number);
1971 printf_filtered (_("Not looking at any trace frame.\n"));
1973 /* Report start/stop times if supplied. */
1978 LONGEST run_time = ts->stop_time - ts->start_time;
1980 /* Reporting a run time is more readable than two long numbers. */
1981 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
1982 (long int) (ts->start_time / 1000000),
1983 (long int) (ts->start_time % 1000000),
1984 (long int) (run_time / 1000000),
1985 (long int) (run_time % 1000000));
1988 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
1989 (long int) (ts->start_time / 1000000),
1990 (long int) (ts->start_time % 1000000));
1992 else if (ts->stop_time)
1993 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
1994 (long int) (ts->stop_time / 1000000),
1995 (long int) (ts->stop_time % 1000000));
1997 /* Now report any per-tracepoint status available. */
1998 tp_vec = all_tracepoints ();
2000 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
2001 target_get_tracepoint_status (t, NULL);
2003 VEC_free (breakpoint_p, tp_vec);
2006 /* Report the trace status to uiout, in a way suitable for MI, and not
2007 suitable for CLI. If ON_STOP is true, suppress a few fields that
2008 are not meaningful in the -trace-stop response.
2010 The implementation is essentially parallel to trace_status_command, but
2011 merging them will result in unreadable code. */
2013 trace_status_mi (int on_stop)
2015 struct ui_out *uiout = current_uiout;
2016 struct trace_status *ts = current_trace_status ();
2019 status = target_get_trace_status (ts);
2021 if (status == -1 && ts->filename == NULL)
2023 uiout->field_string ("supported", "0");
2027 if (ts->filename != NULL)
2028 uiout->field_string ("supported", "file");
2030 uiout->field_string ("supported", "1");
2032 if (ts->filename != NULL)
2033 uiout->field_string ("trace-file", ts->filename);
2035 gdb_assert (ts->running_known);
2039 uiout->field_string ("running", "1");
2041 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2042 Given that the frontend gets the status either on -trace-stop, or from
2043 -trace-status after re-connection, it does not seem like this
2044 information is necessary for anything. It is not necessary for either
2045 figuring the vital state of the target nor for navigation of trace
2046 frames. If the frontend wants to show the current state is some
2047 configure dialog, it can request the value when such dialog is
2048 invoked by the user. */
2052 const char *stop_reason = NULL;
2053 int stopping_tracepoint = -1;
2056 uiout->field_string ("running", "0");
2058 if (ts->stop_reason != trace_stop_reason_unknown)
2060 switch (ts->stop_reason)
2062 case trace_stop_command:
2063 stop_reason = "request";
2065 case trace_buffer_full:
2066 stop_reason = "overflow";
2068 case trace_disconnected:
2069 stop_reason = "disconnection";
2071 case tracepoint_passcount:
2072 stop_reason = "passcount";
2073 stopping_tracepoint = ts->stopping_tracepoint;
2075 case tracepoint_error:
2076 stop_reason = "error";
2077 stopping_tracepoint = ts->stopping_tracepoint;
2083 uiout->field_string ("stop-reason", stop_reason);
2084 if (stopping_tracepoint != -1)
2085 uiout->field_int ("stopping-tracepoint",
2086 stopping_tracepoint);
2087 if (ts->stop_reason == tracepoint_error)
2088 uiout->field_string ("error-description",
2094 if (ts->traceframe_count != -1)
2095 uiout->field_int ("frames", ts->traceframe_count);
2096 if (ts->traceframes_created != -1)
2097 uiout->field_int ("frames-created", ts->traceframes_created);
2098 if (ts->buffer_size != -1)
2099 uiout->field_int ("buffer-size", ts->buffer_size);
2100 if (ts->buffer_free != -1)
2101 uiout->field_int ("buffer-free", ts->buffer_free);
2103 uiout->field_int ("disconnected", ts->disconnected_tracing);
2104 uiout->field_int ("circular", ts->circular_buffer);
2106 uiout->field_string ("user-name", ts->user_name);
2107 uiout->field_string ("notes", ts->notes);
2112 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2113 (long int) (ts->start_time / 1000000),
2114 (long int) (ts->start_time % 1000000));
2115 uiout->field_string ("start-time", buf);
2116 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2117 (long int) (ts->stop_time / 1000000),
2118 (long int) (ts->stop_time % 1000000));
2119 uiout->field_string ("stop-time", buf);
2123 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2124 user if she really wants to detach. */
2127 query_if_trace_running (int from_tty)
2132 /* It can happen that the target that was tracing went away on its
2133 own, and we didn't notice. Get a status update, and if the
2134 current target doesn't even do tracing, then assume it's not
2136 if (target_get_trace_status (current_trace_status ()) < 0)
2137 current_trace_status ()->running = 0;
2139 /* If running interactively, give the user the option to cancel and
2140 then decide what to do differently with the run. Scripts are
2141 just going to disconnect and let the target deal with it,
2142 according to how it's been instructed previously via
2143 disconnected-tracing. */
2144 if (current_trace_status ()->running)
2146 process_tracepoint_on_disconnect ();
2148 if (current_trace_status ()->disconnected_tracing)
2150 if (!query (_("Trace is running and will "
2151 "continue after detach; detach anyway? ")))
2152 error (_("Not confirmed."));
2156 if (!query (_("Trace is running but will "
2157 "stop on detach; detach anyway? ")))
2158 error (_("Not confirmed."));
2163 /* This function handles the details of what to do about an ongoing
2164 tracing run if the user has asked to detach or otherwise disconnect
2168 disconnect_tracing (void)
2170 /* Also we want to be out of tfind mode, otherwise things can get
2171 confusing upon reconnection. Just use these calls instead of
2172 full tfind_1 behavior because we're in the middle of detaching,
2173 and there's no point to updating current stack frame etc. */
2174 trace_reset_local_state ();
2177 /* Worker function for the various flavors of the tfind command. */
2179 tfind_1 (enum trace_find_type type, int num,
2180 CORE_ADDR addr1, CORE_ADDR addr2,
2183 int target_frameno = -1, target_tracept = -1;
2184 struct frame_id old_frame_id = null_frame_id;
2185 struct tracepoint *tp;
2186 struct ui_out *uiout = current_uiout;
2188 /* Only try to get the current stack frame if we have a chance of
2189 succeeding. In particular, if we're trying to get a first trace
2190 frame while all threads are running, it's not going to succeed,
2191 so leave it with a default value and let the frame comparison
2192 below (correctly) decide to print out the source location of the
2194 if (!(type == tfind_number && num == -1)
2195 && (has_stack_frames () || traceframe_number >= 0))
2196 old_frame_id = get_frame_id (get_current_frame ());
2198 target_frameno = target_trace_find (type, num, addr1, addr2,
2201 if (type == tfind_number
2203 && target_frameno == -1)
2205 /* We told the target to get out of tfind mode, and it did. */
2207 else if (target_frameno == -1)
2209 /* A request for a non-existent trace frame has failed.
2210 Our response will be different, depending on FROM_TTY:
2212 If FROM_TTY is true, meaning that this command was
2213 typed interactively by the user, then give an error
2214 and DO NOT change the state of traceframe_number etc.
2216 However if FROM_TTY is false, meaning that we're either
2217 in a script, a loop, or a user-defined command, then
2218 DON'T give an error, but DO change the state of
2219 traceframe_number etc. to invalid.
2221 The rationalle is that if you typed the command, you
2222 might just have committed a typo or something, and you'd
2223 like to NOT lose your current debugging state. However
2224 if you're in a user-defined command or especially in a
2225 loop, then you need a way to detect that the command
2226 failed WITHOUT aborting. This allows you to write
2227 scripts that search thru the trace buffer until the end,
2228 and then continue on to do something else. */
2231 error (_("Target failed to find requested trace frame."));
2235 printf_filtered ("End of trace buffer.\n");
2236 #if 0 /* dubious now? */
2237 /* The following will not recurse, since it's
2239 tfind_command ("-1", from_tty);
2244 tp = get_tracepoint_by_number_on_target (target_tracept);
2246 reinit_frame_cache ();
2247 target_dcache_invalidate ();
2249 set_tracepoint_num (tp ? tp->number : target_tracept);
2251 if (target_frameno != get_traceframe_number ())
2252 observer_notify_traceframe_changed (target_frameno, tracepoint_number);
2254 set_current_traceframe (target_frameno);
2256 if (target_frameno == -1)
2257 set_traceframe_context (NULL);
2259 set_traceframe_context (get_current_frame ());
2261 if (traceframe_number >= 0)
2263 /* Use different branches for MI and CLI to make CLI messages
2265 if (uiout->is_mi_like_p ())
2267 uiout->field_string ("found", "1");
2268 uiout->field_int ("tracepoint", tracepoint_number);
2269 uiout->field_int ("traceframe", traceframe_number);
2273 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2274 traceframe_number, tracepoint_number);
2279 if (uiout->is_mi_like_p ())
2280 uiout->field_string ("found", "0");
2281 else if (type == tfind_number && num == -1)
2282 printf_unfiltered (_("No longer looking at any trace frame\n"));
2283 else /* This case may never occur, check. */
2284 printf_unfiltered (_("No trace frame found\n"));
2287 /* If we're in nonstop mode and getting out of looking at trace
2288 frames, there won't be any current frame to go back to and
2291 && (has_stack_frames () || traceframe_number >= 0))
2293 enum print_what print_what;
2295 /* NOTE: in imitation of the step command, try to determine
2296 whether we have made a transition from one function to
2297 another. If so, we'll print the "stack frame" (ie. the new
2298 function and it's arguments) -- otherwise we'll just show the
2301 if (frame_id_eq (old_frame_id,
2302 get_frame_id (get_current_frame ())))
2303 print_what = SRC_LINE;
2305 print_what = SRC_AND_LOC;
2307 print_stack_frame (get_selected_frame (NULL), 1, print_what, 1);
2312 /* Error on looking at traceframes while trace is running. */
2315 check_trace_running (struct trace_status *status)
2317 if (status->running && status->filename == NULL)
2318 error (_("May not look at trace frames while trace is running."));
2321 /* trace_find_command takes a trace frame number n,
2322 sends "QTFrame:<n>" to the target,
2323 and accepts a reply that may contain several optional pieces
2324 of information: a frame number, a tracepoint number, and an
2325 indication of whether this is a trap frame or a stepping frame.
2327 The minimal response is just "OK" (which indicates that the
2328 target does not give us a frame number or a tracepoint number).
2329 Instead of that, the target may send us a string containing
2331 F<hexnum> (gives the selected frame number)
2332 T<hexnum> (gives the selected tracepoint number)
2337 tfind_command_1 (const char *args, int from_tty)
2338 { /* This should only be called with a numeric argument. */
2341 check_trace_running (current_trace_status ());
2343 if (args == 0 || *args == 0)
2344 { /* TFIND with no args means find NEXT trace frame. */
2345 if (traceframe_number == -1)
2346 frameno = 0; /* "next" is first one. */
2348 frameno = traceframe_number + 1;
2350 else if (0 == strcmp (args, "-"))
2352 if (traceframe_number == -1)
2353 error (_("not debugging trace buffer"));
2354 else if (from_tty && traceframe_number == 0)
2355 error (_("already at start of trace buffer"));
2357 frameno = traceframe_number - 1;
2359 /* A hack to work around eval's need for fp to have been collected. */
2360 else if (0 == strcmp (args, "-1"))
2363 frameno = parse_and_eval_long (args);
2366 error (_("invalid input (%d is less than zero)"), frameno);
2368 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2372 tfind_command (char *args, int from_tty)
2374 tfind_command_1 (const_cast<char *> (args), from_tty);
2379 tfind_end_command (char *args, int from_tty)
2381 tfind_command_1 ("-1", from_tty);
2386 tfind_start_command (char *args, int from_tty)
2388 tfind_command_1 ("0", from_tty);
2391 /* tfind pc command */
2393 tfind_pc_command (char *args, int from_tty)
2397 check_trace_running (current_trace_status ());
2399 if (args == 0 || *args == 0)
2400 pc = regcache_read_pc (get_current_regcache ());
2402 pc = parse_and_eval_address (args);
2404 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2407 /* tfind tracepoint command */
2409 tfind_tracepoint_command (char *args, int from_tty)
2412 struct tracepoint *tp;
2414 check_trace_running (current_trace_status ());
2416 if (args == 0 || *args == 0)
2418 if (tracepoint_number == -1)
2419 error (_("No current tracepoint -- please supply an argument."));
2421 tdp = tracepoint_number; /* Default is current TDP. */
2424 tdp = parse_and_eval_long (args);
2426 /* If we have the tracepoint on hand, use the number that the
2427 target knows about (which may be different if we disconnected
2428 and reconnected). */
2429 tp = get_tracepoint (tdp);
2431 tdp = tp->number_on_target;
2433 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2436 /* TFIND LINE command:
2438 This command will take a sourceline for argument, just like BREAK
2439 or TRACE (ie. anything that "decode_line_1" can handle).
2441 With no argument, this command will find the next trace frame
2442 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2445 tfind_line_command (char *args, int from_tty)
2447 static CORE_ADDR start_pc, end_pc;
2448 struct symtabs_and_lines sals;
2449 struct symtab_and_line sal;
2450 struct cleanup *old_chain;
2452 check_trace_running (current_trace_status ());
2454 if (args == 0 || *args == 0)
2456 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2458 sals.sals = XNEW (struct symtab_and_line);
2463 sals = decode_line_with_current_source (args, DECODE_LINE_FUNFIRSTLINE);
2467 old_chain = make_cleanup (xfree, sals.sals);
2468 if (sal.symtab == 0)
2469 error (_("No line number information available."));
2471 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2473 if (start_pc == end_pc)
2475 printf_filtered ("Line %d of \"%s\"",
2477 symtab_to_filename_for_display (sal.symtab));
2479 printf_filtered (" is at address ");
2480 print_address (get_current_arch (), start_pc, gdb_stdout);
2482 printf_filtered (" but contains no code.\n");
2483 sal = find_pc_line (start_pc, 0);
2485 && find_line_pc_range (sal, &start_pc, &end_pc)
2486 && start_pc != end_pc)
2487 printf_filtered ("Attempting to find line %d instead.\n",
2490 error (_("Cannot find a good line."));
2494 /* Is there any case in which we get here, and have an address
2495 which the user would want to see? If we have debugging
2496 symbols and no line numbers? */
2497 error (_("Line number %d is out of range for \"%s\"."),
2498 sal.line, symtab_to_filename_for_display (sal.symtab));
2500 /* Find within range of stated line. */
2502 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2504 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2505 do_cleanups (old_chain);
2508 /* tfind range command */
2510 tfind_range_command (char *args, int from_tty)
2512 static CORE_ADDR start, stop;
2515 check_trace_running (current_trace_status ());
2517 if (args == 0 || *args == 0)
2518 { /* XXX FIXME: what should default behavior be? */
2519 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2523 if (0 != (tmp = strchr (args, ',')))
2525 *tmp++ = '\0'; /* Terminate start address. */
2526 tmp = skip_spaces (tmp);
2527 start = parse_and_eval_address (args);
2528 stop = parse_and_eval_address (tmp);
2531 { /* No explicit end address? */
2532 start = parse_and_eval_address (args);
2533 stop = start + 1; /* ??? */
2536 tfind_1 (tfind_range, 0, start, stop, from_tty);
2539 /* tfind outside command */
2541 tfind_outside_command (char *args, int from_tty)
2543 CORE_ADDR start, stop;
2546 if (current_trace_status ()->running
2547 && current_trace_status ()->filename == NULL)
2548 error (_("May not look at trace frames while trace is running."));
2550 if (args == 0 || *args == 0)
2551 { /* XXX FIXME: what should default behavior be? */
2552 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2556 if (0 != (tmp = strchr (args, ',')))
2558 *tmp++ = '\0'; /* Terminate start address. */
2559 tmp = skip_spaces (tmp);
2560 start = parse_and_eval_address (args);
2561 stop = parse_and_eval_address (tmp);
2564 { /* No explicit end address? */
2565 start = parse_and_eval_address (args);
2566 stop = start + 1; /* ??? */
2569 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2572 /* info scope command: list the locals for a scope. */
2574 scope_info (char *args, int from_tty)
2576 struct symtabs_and_lines sals;
2578 struct bound_minimal_symbol msym;
2579 const struct block *block;
2580 const char *symname;
2581 char *save_args = args;
2582 struct block_iterator iter;
2584 struct gdbarch *gdbarch;
2587 if (args == 0 || *args == 0)
2588 error (_("requires an argument (function, "
2589 "line or *addr) to define a scope"));
2591 event_location_up location = string_to_event_location (&args,
2593 sals = decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE,
2595 if (sals.nelts == 0)
2597 /* Presumably decode_line_1 has already warned. */
2601 /* Resolve line numbers to PC. */
2602 resolve_sal_pc (&sals.sals[0]);
2603 block = block_for_pc (sals.sals[0].pc);
2607 QUIT; /* Allow user to bail out with ^C. */
2608 ALL_BLOCK_SYMBOLS (block, iter, sym)
2610 QUIT; /* Allow user to bail out with ^C. */
2612 printf_filtered ("Scope for %s:\n", save_args);
2615 symname = SYMBOL_PRINT_NAME (sym);
2616 if (symname == NULL || *symname == '\0')
2617 continue; /* Probably botched, certainly useless. */
2619 gdbarch = symbol_arch (sym);
2621 printf_filtered ("Symbol %s is ", symname);
2623 if (SYMBOL_COMPUTED_OPS (sym) != NULL)
2624 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2625 BLOCK_START (block),
2629 switch (SYMBOL_CLASS (sym))
2632 case LOC_UNDEF: /* Messed up symbol? */
2633 printf_filtered ("a bogus symbol, class %d.\n",
2634 SYMBOL_CLASS (sym));
2635 count--; /* Don't count this one. */
2638 printf_filtered ("a constant with value %s (%s)",
2639 plongest (SYMBOL_VALUE (sym)),
2640 hex_string (SYMBOL_VALUE (sym)));
2642 case LOC_CONST_BYTES:
2643 printf_filtered ("constant bytes: ");
2644 if (SYMBOL_TYPE (sym))
2645 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2646 fprintf_filtered (gdb_stdout, " %02x",
2647 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2650 printf_filtered ("in static storage at address ");
2651 printf_filtered ("%s", paddress (gdbarch,
2652 SYMBOL_VALUE_ADDRESS (sym)));
2655 /* GDBARCH is the architecture associated with the objfile
2656 the symbol is defined in; the target architecture may be
2657 different, and may provide additional registers. However,
2658 we do not know the target architecture at this point.
2659 We assume the objfile architecture will contain all the
2660 standard registers that occur in debug info in that
2662 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2665 if (SYMBOL_IS_ARGUMENT (sym))
2666 printf_filtered ("an argument in register $%s",
2667 gdbarch_register_name (gdbarch, regno));
2669 printf_filtered ("a local variable in register $%s",
2670 gdbarch_register_name (gdbarch, regno));
2673 printf_filtered ("an argument at stack/frame offset %s",
2674 plongest (SYMBOL_VALUE (sym)));
2677 printf_filtered ("a local variable at frame offset %s",
2678 plongest (SYMBOL_VALUE (sym)));
2681 printf_filtered ("a reference argument at offset %s",
2682 plongest (SYMBOL_VALUE (sym)));
2684 case LOC_REGPARM_ADDR:
2685 /* Note comment at LOC_REGISTER. */
2686 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2688 printf_filtered ("the address of an argument, in register $%s",
2689 gdbarch_register_name (gdbarch, regno));
2692 printf_filtered ("a typedef.\n");
2695 printf_filtered ("a label at address ");
2696 printf_filtered ("%s", paddress (gdbarch,
2697 SYMBOL_VALUE_ADDRESS (sym)));
2700 printf_filtered ("a function at address ");
2701 printf_filtered ("%s",
2702 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2704 case LOC_UNRESOLVED:
2705 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2707 if (msym.minsym == NULL)
2708 printf_filtered ("Unresolved Static");
2711 printf_filtered ("static storage at address ");
2712 printf_filtered ("%s",
2714 BMSYMBOL_VALUE_ADDRESS (msym)));
2717 case LOC_OPTIMIZED_OUT:
2718 printf_filtered ("optimized out.\n");
2721 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2724 if (SYMBOL_TYPE (sym))
2725 printf_filtered (", length %d.\n",
2726 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2728 if (BLOCK_FUNCTION (block))
2731 block = BLOCK_SUPERBLOCK (block);
2734 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2738 /* Helper for trace_dump_command. Dump the action list starting at
2739 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2740 actions of the body of a while-stepping action. STEPPING_FRAME is
2741 set if the current traceframe was determined to be a while-stepping
2745 trace_dump_actions (struct command_line *action,
2746 int stepping_actions, int stepping_frame,
2749 const char *action_exp, *next_comma;
2751 for (; action != NULL; action = action->next)
2753 struct cmd_list_element *cmd;
2755 QUIT; /* Allow user to bail out with ^C. */
2756 action_exp = action->line;
2757 action_exp = skip_spaces_const (action_exp);
2759 /* The collection actions to be done while stepping are
2760 bracketed by the commands "while-stepping" and "end". */
2762 if (*action_exp == '#') /* comment line */
2765 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2767 error (_("Bad action list item: %s"), action_exp);
2769 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2773 for (i = 0; i < action->body_count; ++i)
2774 trace_dump_actions (action->body_list[i],
2775 1, stepping_frame, from_tty);
2777 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2779 /* Display the collected data.
2780 For the trap frame, display only what was collected at
2781 the trap. Likewise for stepping frames, display only
2782 what was collected while stepping. This means that the
2783 two boolean variables, STEPPING_FRAME and
2784 STEPPING_ACTIONS should be equal. */
2785 if (stepping_frame == stepping_actions)
2788 struct cleanup *old_chain
2789 = make_cleanup (free_current_contents, &cmd);
2790 int trace_string = 0;
2792 if (*action_exp == '/')
2793 action_exp = decode_agent_options (action_exp, &trace_string);
2796 { /* Repeat over a comma-separated list. */
2797 QUIT; /* Allow user to bail out with ^C. */
2798 if (*action_exp == ',')
2800 action_exp = skip_spaces_const (action_exp);
2802 next_comma = strchr (action_exp, ',');
2804 if (0 == strncasecmp (action_exp, "$reg", 4))
2805 registers_info (NULL, from_tty);
2806 else if (0 == strncasecmp (action_exp, "$_ret", 5))
2808 else if (0 == strncasecmp (action_exp, "$loc", 4))
2809 locals_info (NULL, from_tty);
2810 else if (0 == strncasecmp (action_exp, "$arg", 4))
2811 args_info (NULL, from_tty);
2814 if (next_comma != NULL)
2816 size_t len = next_comma - action_exp;
2818 cmd = (char *) xrealloc (cmd, len + 1);
2819 memcpy (cmd, action_exp, len);
2824 size_t len = strlen (action_exp);
2826 cmd = (char *) xrealloc (cmd, len + 1);
2827 memcpy (cmd, action_exp, len + 1);
2830 printf_filtered ("%s = ", cmd);
2831 output_command_const (cmd, from_tty);
2832 printf_filtered ("\n");
2834 action_exp = next_comma;
2836 while (action_exp && *action_exp == ',');
2838 do_cleanups (old_chain);
2844 /* Return bp_location of the tracepoint associated with the current
2845 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2846 is a stepping traceframe. */
2848 struct bp_location *
2849 get_traceframe_location (int *stepping_frame_p)
2851 struct tracepoint *t;
2852 struct bp_location *tloc;
2853 struct regcache *regcache;
2855 if (tracepoint_number == -1)
2856 error (_("No current trace frame."));
2858 t = get_tracepoint (tracepoint_number);
2861 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2864 /* The current frame is a trap frame if the frame PC is equal to the
2865 tracepoint PC. If not, then the current frame was collected
2866 during single-stepping. */
2867 regcache = get_current_regcache ();
2869 /* If the traceframe's address matches any of the tracepoint's
2870 locations, assume it is a direct hit rather than a while-stepping
2871 frame. (FIXME this is not reliable, should record each frame's
2873 for (tloc = t->loc; tloc; tloc = tloc->next)
2874 if (tloc->address == regcache_read_pc (regcache))
2876 *stepping_frame_p = 0;
2880 /* If this is a stepping frame, we don't know which location
2881 triggered. The first is as good (or bad) a guess as any... */
2882 *stepping_frame_p = 1;
2886 /* Return all the actions, including default collect, of a tracepoint
2887 T. It constructs cleanups into the chain, and leaves the caller to
2888 handle them (call do_cleanups). */
2890 static struct command_line *
2891 all_tracepoint_actions_and_cleanup (struct breakpoint *t)
2893 struct command_line *actions;
2895 actions = breakpoint_commands (t);
2897 /* If there are default expressions to collect, make up a collect
2898 action and prepend to the action list to encode. Note that since
2899 validation is per-tracepoint (local var "xyz" might be valid for
2900 one tracepoint and not another, etc), we make up the action on
2901 the fly, and don't cache it. */
2902 if (*default_collect)
2904 struct command_line *default_collect_action;
2905 char *default_collect_line;
2907 default_collect_line = xstrprintf ("collect %s", default_collect);
2908 make_cleanup (xfree, default_collect_line);
2910 validate_actionline (default_collect_line, t);
2911 default_collect_action = XNEW (struct command_line);
2912 make_cleanup (xfree, default_collect_action);
2913 default_collect_action->next = actions;
2914 default_collect_action->line = default_collect_line;
2915 actions = default_collect_action;
2921 /* The tdump command. */
2924 tdump_command (char *args, int from_tty)
2926 int stepping_frame = 0;
2927 struct bp_location *loc;
2928 struct command_line *actions;
2930 /* This throws an error is not inspecting a trace frame. */
2931 loc = get_traceframe_location (&stepping_frame);
2933 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2934 tracepoint_number, traceframe_number);
2936 /* This command only makes sense for the current frame, not the
2938 scoped_restore_current_thread restore_thread;
2940 select_frame (get_current_frame ());
2942 actions = all_tracepoint_actions_and_cleanup (loc->owner);
2944 trace_dump_actions (actions, 0, stepping_frame, from_tty);
2947 /* Encode a piece of a tracepoint's source-level definition in a form
2948 that is suitable for both protocol and saving in files. */
2949 /* This version does not do multiple encodes for long strings; it should
2950 return an offset to the next piece to encode. FIXME */
2953 encode_source_string (int tpnum, ULONGEST addr,
2954 const char *srctype, const char *src,
2955 char *buf, int buf_size)
2957 if (80 + strlen (srctype) > buf_size)
2958 error (_("Buffer too small for source encoding"));
2959 sprintf (buf, "%x:%s:%s:%x:%x:",
2960 tpnum, phex_nz (addr, sizeof (addr)),
2961 srctype, 0, (int) strlen (src));
2962 if (strlen (buf) + strlen (src) * 2 >= buf_size)
2963 error (_("Source string too long for buffer"));
2964 bin2hex ((gdb_byte *) src, buf + strlen (buf), strlen (src));
2968 /* Tell the target what to do with an ongoing tracing run if GDB
2969 disconnects for some reason. */
2972 set_disconnected_tracing (char *args, int from_tty,
2973 struct cmd_list_element *c)
2975 target_set_disconnected_tracing (disconnected_tracing);
2979 set_circular_trace_buffer (char *args, int from_tty,
2980 struct cmd_list_element *c)
2982 target_set_circular_trace_buffer (circular_trace_buffer);
2986 set_trace_buffer_size (char *args, int from_tty,
2987 struct cmd_list_element *c)
2989 target_set_trace_buffer_size (trace_buffer_size);
2993 set_trace_user (char *args, int from_tty,
2994 struct cmd_list_element *c)
2998 ret = target_set_trace_notes (trace_user, NULL, NULL);
3001 warning (_("Target does not support trace notes, user ignored"));
3005 set_trace_notes (char *args, int from_tty,
3006 struct cmd_list_element *c)
3010 ret = target_set_trace_notes (NULL, trace_notes, NULL);
3013 warning (_("Target does not support trace notes, note ignored"));
3017 set_trace_stop_notes (char *args, int from_tty,
3018 struct cmd_list_element *c)
3022 ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
3025 warning (_("Target does not support trace notes, stop note ignored"));
3028 /* Convert the memory pointed to by mem into hex, placing result in buf.
3029 * Return a pointer to the last char put in buf (null)
3030 * "stolen" from sparc-stub.c
3033 static const char hexchars[] = "0123456789abcdef";
3036 mem2hex (gdb_byte *mem, char *buf, int count)
3044 *buf++ = hexchars[ch >> 4];
3045 *buf++ = hexchars[ch & 0xf];
3054 get_traceframe_number (void)
3056 return traceframe_number;
3060 get_tracepoint_number (void)
3062 return tracepoint_number;
3065 /* Make the traceframe NUM be the current trace frame. Does nothing
3066 if NUM is already current. */
3069 set_current_traceframe (int num)
3073 if (traceframe_number == num)
3075 /* Nothing to do. */
3079 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
3082 warning (_("could not change traceframe"));
3084 set_traceframe_num (newnum);
3086 /* Changing the traceframe changes our view of registers and of the
3088 registers_changed ();
3090 clear_traceframe_info ();
3093 /* A cleanup used when switching away and back from tfind mode. */
3095 struct current_traceframe_cleanup
3097 /* The traceframe we were inspecting. */
3098 int traceframe_number;
3102 do_restore_current_traceframe_cleanup (void *arg)
3104 struct current_traceframe_cleanup *old
3105 = (struct current_traceframe_cleanup *) arg;
3107 set_current_traceframe (old->traceframe_number);
3111 restore_current_traceframe_cleanup_dtor (void *arg)
3113 struct current_traceframe_cleanup *old
3114 = (struct current_traceframe_cleanup *) arg;
3120 make_cleanup_restore_current_traceframe (void)
3122 struct current_traceframe_cleanup *old =
3123 XNEW (struct current_traceframe_cleanup);
3125 old->traceframe_number = traceframe_number;
3127 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
3128 restore_current_traceframe_cleanup_dtor);
3131 /* Given a number and address, return an uploaded tracepoint with that
3132 number, creating if necessary. */
3134 struct uploaded_tp *
3135 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
3137 struct uploaded_tp *utp;
3139 for (utp = *utpp; utp; utp = utp->next)
3140 if (utp->number == num && utp->addr == addr)
3143 utp = XCNEW (struct uploaded_tp);
3146 utp->actions = NULL;
3147 utp->step_actions = NULL;
3148 utp->cmd_strings = NULL;
3156 free_uploaded_tps (struct uploaded_tp **utpp)
3158 struct uploaded_tp *next_one;
3162 next_one = (*utpp)->next;
3168 /* Given a number and address, return an uploaded tracepoint with that
3169 number, creating if necessary. */
3171 struct uploaded_tsv *
3172 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3174 struct uploaded_tsv *utsv;
3176 for (utsv = *utsvp; utsv; utsv = utsv->next)
3177 if (utsv->number == num)
3180 utsv = XCNEW (struct uploaded_tsv);
3182 utsv->next = *utsvp;
3189 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3191 struct uploaded_tsv *next_one;
3195 next_one = (*utsvp)->next;
3201 /* FIXME this function is heuristic and will miss the cases where the
3202 conditional is semantically identical but differs in whitespace,
3203 such as "x == 0" vs "x==0". */
3206 cond_string_is_same (char *str1, char *str2)
3208 if (str1 == NULL || str2 == NULL)
3209 return (str1 == str2);
3211 return (strcmp (str1, str2) == 0);
3214 /* Look for an existing tracepoint that seems similar enough to the
3215 uploaded one. Enablement isn't compared, because the user can
3216 toggle that freely, and may have done so in anticipation of the
3217 next trace run. Return the location of matched tracepoint. */
3219 static struct bp_location *
3220 find_matching_tracepoint_location (struct uploaded_tp *utp)
3222 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
3224 struct breakpoint *b;
3225 struct bp_location *loc;
3227 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
3229 struct tracepoint *t = (struct tracepoint *) b;
3231 if (b->type == utp->type
3232 && t->step_count == utp->step
3233 && t->pass_count == utp->pass
3234 && cond_string_is_same (t->cond_string, utp->cond_string)
3235 /* FIXME also test actions. */
3238 /* Scan the locations for an address match. */
3239 for (loc = b->loc; loc; loc = loc->next)
3241 if (loc->address == utp->addr)
3249 /* Given a list of tracepoints uploaded from a target, attempt to
3250 match them up with existing tracepoints, and create new ones if not
3254 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3256 struct uploaded_tp *utp;
3257 /* A set of tracepoints which are modified. */
3258 VEC(breakpoint_p) *modified_tp = NULL;
3260 struct breakpoint *b;
3262 /* Look for GDB tracepoints that match up with our uploaded versions. */
3263 for (utp = *uploaded_tps; utp; utp = utp->next)
3265 struct bp_location *loc;
3266 struct tracepoint *t;
3268 loc = find_matching_tracepoint_location (utp);
3273 /* Mark this location as already inserted. */
3275 t = (struct tracepoint *) loc->owner;
3276 printf_filtered (_("Assuming tracepoint %d is same "
3277 "as target's tracepoint %d at %s.\n"),
3278 loc->owner->number, utp->number,
3279 paddress (loc->gdbarch, utp->addr));
3281 /* The tracepoint LOC->owner was modified (the location LOC
3282 was marked as inserted in the target). Save it in
3283 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3284 observers will be notified later once for each tracepoint
3285 saved in MODIFIED_TP. */
3287 VEC_iterate (breakpoint_p, modified_tp, ix, b);
3289 if (b == loc->owner)
3295 VEC_safe_push (breakpoint_p, modified_tp, loc->owner);
3299 t = create_tracepoint_from_upload (utp);
3301 printf_filtered (_("Created tracepoint %d for "
3302 "target's tracepoint %d at %s.\n"),
3303 t->number, utp->number,
3304 paddress (get_current_arch (), utp->addr));
3306 printf_filtered (_("Failed to create tracepoint for target's "
3307 "tracepoint %d at %s, skipping it.\n"),
3309 paddress (get_current_arch (), utp->addr));
3311 /* Whether found or created, record the number used by the
3312 target, to help with mapping target tracepoints back to their
3313 counterparts here. */
3315 t->number_on_target = utp->number;
3318 /* Notify 'breakpoint-modified' observer that at least one of B's
3319 locations was changed. */
3320 for (ix = 0; VEC_iterate (breakpoint_p, modified_tp, ix, b); ix++)
3321 observer_notify_breakpoint_modified (b);
3323 VEC_free (breakpoint_p, modified_tp);
3324 free_uploaded_tps (uploaded_tps);
3327 /* Trace state variables don't have much to identify them beyond their
3328 name, so just use that to detect matches. */
3330 static struct trace_state_variable *
3331 find_matching_tsv (struct uploaded_tsv *utsv)
3336 return find_trace_state_variable (utsv->name);
3339 static struct trace_state_variable *
3340 create_tsv_from_upload (struct uploaded_tsv *utsv)
3342 const char *namebase;
3345 struct trace_state_variable *tsv;
3346 struct cleanup *old_chain;
3350 namebase = utsv->name;
3351 buf = xstrprintf ("%s", namebase);
3356 buf = xstrprintf ("%s_%d", namebase, try_num++);
3359 /* Fish for a name that is not in use. */
3360 /* (should check against all internal vars?) */
3361 while (find_trace_state_variable (buf))
3364 buf = xstrprintf ("%s_%d", namebase, try_num++);
3367 old_chain = make_cleanup (xfree, buf);
3369 /* We have an available name, create the variable. */
3370 tsv = create_trace_state_variable (buf);
3371 tsv->initial_value = utsv->initial_value;
3372 tsv->builtin = utsv->builtin;
3374 observer_notify_tsv_created (tsv);
3376 do_cleanups (old_chain);
3381 /* Given a list of uploaded trace state variables, try to match them
3382 up with existing variables, or create additional ones. */
3385 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
3388 struct uploaded_tsv *utsv;
3389 struct trace_state_variable *tsv;
3392 /* Most likely some numbers will have to be reassigned as part of
3393 the merge, so clear them all in anticipation. */
3394 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3397 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
3399 tsv = find_matching_tsv (utsv);
3403 printf_filtered (_("Assuming trace state variable $%s "
3404 "is same as target's variable %d.\n"),
3405 tsv->name, utsv->number);
3409 tsv = create_tsv_from_upload (utsv);
3411 printf_filtered (_("Created trace state variable "
3412 "$%s for target's variable %d.\n"),
3413 tsv->name, utsv->number);
3415 /* Give precedence to numberings that come from the target. */
3417 tsv->number = utsv->number;
3420 /* Renumber everything that didn't get a target-assigned number. */
3422 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3423 if (tsv->number > highest)
3424 highest = tsv->number;
3427 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3428 if (tsv->number == 0)
3429 tsv->number = highest++;
3431 free_uploaded_tsvs (uploaded_tsvs);
3434 /* Parse the part of trace status syntax that is shared between
3435 the remote protocol and the trace file reader. */
3438 parse_trace_status (char *line, struct trace_status *ts)
3440 char *p = line, *p1, *p2, *p3, *p_temp;
3444 ts->running_known = 1;
3445 ts->running = (*p++ == '1');
3446 ts->stop_reason = trace_stop_reason_unknown;
3447 xfree (ts->stop_desc);
3448 ts->stop_desc = NULL;
3449 ts->traceframe_count = -1;
3450 ts->traceframes_created = -1;
3451 ts->buffer_free = -1;
3452 ts->buffer_size = -1;
3453 ts->disconnected_tracing = 0;
3454 ts->circular_buffer = 0;
3455 xfree (ts->user_name);
3456 ts->user_name = NULL;
3459 ts->start_time = ts->stop_time = 0;
3463 p1 = strchr (p, ':');
3465 error (_("Malformed trace status, at %s\n\
3466 Status line: '%s'\n"), p, line);
3467 p3 = strchr (p, ';');
3469 p3 = p + strlen (p);
3470 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3472 p = unpack_varlen_hex (++p1, &val);
3473 ts->stop_reason = trace_buffer_full;
3475 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3477 p = unpack_varlen_hex (++p1, &val);
3478 ts->stop_reason = trace_never_run;
3480 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
3483 p = unpack_varlen_hex (++p1, &val);
3484 ts->stop_reason = tracepoint_passcount;
3485 ts->stopping_tracepoint = val;
3487 else if (strncmp (p, stop_reason_names[trace_stop_command], p1 - p) == 0)
3489 p2 = strchr (++p1, ':');
3497 ts->stop_desc = (char *) xmalloc (strlen (line));
3498 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
3499 ts->stop_desc[end] = '\0';
3502 ts->stop_desc = xstrdup ("");
3504 p = unpack_varlen_hex (++p2, &val);
3505 ts->stop_reason = trace_stop_command;
3507 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3509 p = unpack_varlen_hex (++p1, &val);
3510 ts->stop_reason = trace_disconnected;
3512 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3514 p2 = strchr (++p1, ':');
3517 ts->stop_desc = (char *) xmalloc ((p2 - p1) / 2 + 1);
3518 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
3519 ts->stop_desc[end] = '\0';
3522 ts->stop_desc = xstrdup ("");
3524 p = unpack_varlen_hex (++p2, &val);
3525 ts->stopping_tracepoint = val;
3526 ts->stop_reason = tracepoint_error;
3528 else if (strncmp (p, "tframes", p1 - p) == 0)
3530 p = unpack_varlen_hex (++p1, &val);
3531 ts->traceframe_count = val;
3533 else if (strncmp (p, "tcreated", p1 - p) == 0)
3535 p = unpack_varlen_hex (++p1, &val);
3536 ts->traceframes_created = val;
3538 else if (strncmp (p, "tfree", p1 - p) == 0)
3540 p = unpack_varlen_hex (++p1, &val);
3541 ts->buffer_free = val;
3543 else if (strncmp (p, "tsize", p1 - p) == 0)
3545 p = unpack_varlen_hex (++p1, &val);
3546 ts->buffer_size = val;
3548 else if (strncmp (p, "disconn", p1 - p) == 0)
3550 p = unpack_varlen_hex (++p1, &val);
3551 ts->disconnected_tracing = val;
3553 else if (strncmp (p, "circular", p1 - p) == 0)
3555 p = unpack_varlen_hex (++p1, &val);
3556 ts->circular_buffer = val;
3558 else if (strncmp (p, "starttime", p1 - p) == 0)
3560 p = unpack_varlen_hex (++p1, &val);
3561 ts->start_time = val;
3563 else if (strncmp (p, "stoptime", p1 - p) == 0)
3565 p = unpack_varlen_hex (++p1, &val);
3566 ts->stop_time = val;
3568 else if (strncmp (p, "username", p1 - p) == 0)
3571 ts->user_name = (char *) xmalloc (strlen (p) / 2);
3572 end = hex2bin (p1, (gdb_byte *) ts->user_name, (p3 - p1) / 2);
3573 ts->user_name[end] = '\0';
3576 else if (strncmp (p, "notes", p1 - p) == 0)
3579 ts->notes = (char *) xmalloc (strlen (p) / 2);
3580 end = hex2bin (p1, (gdb_byte *) ts->notes, (p3 - p1) / 2);
3581 ts->notes[end] = '\0';
3586 /* Silently skip unknown optional info. */
3587 p_temp = strchr (p1 + 1, ';');
3591 /* Must be at the end. */
3598 parse_tracepoint_status (char *p, struct breakpoint *bp,
3599 struct uploaded_tp *utp)
3602 struct tracepoint *tp = (struct tracepoint *) bp;
3604 p = unpack_varlen_hex (p, &uval);
3606 tp->hit_count += uval;
3608 utp->hit_count += uval;
3609 p = unpack_varlen_hex (p + 1, &uval);
3611 tp->traceframe_usage += uval;
3613 utp->traceframe_usage += uval;
3614 /* Ignore any extra, allowing for future extensions. */
3617 /* Given a line of text defining a part of a tracepoint, parse it into
3618 an "uploaded tracepoint". */
3621 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
3625 ULONGEST num, addr, step, pass, orig_size, xlen, start;
3628 char *cond, *srctype, *buf;
3629 struct uploaded_tp *utp = NULL;
3632 /* Both tracepoint and action definitions start with the same number
3633 and address sequence. */
3635 p = unpack_varlen_hex (p, &num);
3636 p++; /* skip a colon */
3637 p = unpack_varlen_hex (p, &addr);
3638 p++; /* skip a colon */
3641 enabled = (*p++ == 'E');
3642 p++; /* skip a colon */
3643 p = unpack_varlen_hex (p, &step);
3644 p++; /* skip a colon */
3645 p = unpack_varlen_hex (p, &pass);
3646 type = bp_tracepoint;
3648 /* Thumb through optional fields. */
3651 p++; /* skip a colon */
3654 type = bp_fast_tracepoint;
3656 p = unpack_varlen_hex (p, &orig_size);
3660 type = bp_static_tracepoint;
3666 p = unpack_varlen_hex (p, &xlen);
3667 p++; /* skip a comma */
3668 cond = (char *) xmalloc (2 * xlen + 1);
3669 strncpy (cond, p, 2 * xlen);
3670 cond[2 * xlen] = '\0';
3674 warning (_("Unrecognized char '%c' in tracepoint "
3675 "definition, skipping rest"), *p);
3677 utp = get_uploaded_tp (num, addr, utpp);
3679 utp->enabled = enabled;
3684 else if (piece == 'A')
3686 utp = get_uploaded_tp (num, addr, utpp);
3687 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
3689 else if (piece == 'S')
3691 utp = get_uploaded_tp (num, addr, utpp);
3692 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
3694 else if (piece == 'Z')
3696 /* Parse a chunk of source form definition. */
3697 utp = get_uploaded_tp (num, addr, utpp);
3699 p = strchr (p, ':');
3700 p++; /* skip a colon */
3701 p = unpack_varlen_hex (p, &start);
3702 p++; /* skip a colon */
3703 p = unpack_varlen_hex (p, &xlen);
3704 p++; /* skip a colon */
3706 buf = (char *) alloca (strlen (line));
3708 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3711 if (startswith (srctype, "at:"))
3712 utp->at_string = xstrdup (buf);
3713 else if (startswith (srctype, "cond:"))
3714 utp->cond_string = xstrdup (buf);
3715 else if (startswith (srctype, "cmd:"))
3716 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
3718 else if (piece == 'V')
3720 utp = get_uploaded_tp (num, addr, utpp);
3722 parse_tracepoint_status (p, NULL, utp);
3726 /* Don't error out, the target might be sending us optional
3727 info that we don't care about. */
3728 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
3732 /* Convert a textual description of a trace state variable into an
3736 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
3739 ULONGEST num, initval, builtin;
3741 struct uploaded_tsv *utsv = NULL;
3743 buf = (char *) alloca (strlen (line));
3746 p = unpack_varlen_hex (p, &num);
3747 p++; /* skip a colon */
3748 p = unpack_varlen_hex (p, &initval);
3749 p++; /* skip a colon */
3750 p = unpack_varlen_hex (p, &builtin);
3751 p++; /* skip a colon */
3752 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3755 utsv = get_uploaded_tsv (num, utsvp);
3756 utsv->initial_value = initval;
3757 utsv->builtin = builtin;
3758 utsv->name = xstrdup (buf);
3762 free_current_marker (void *arg)
3764 struct static_tracepoint_marker **marker_p
3765 = (struct static_tracepoint_marker **) arg;
3767 if (*marker_p != NULL)
3769 release_static_tracepoint_marker (*marker_p);
3776 /* Given a line of text defining a static tracepoint marker, parse it
3777 into a "static tracepoint marker" object. Throws an error is
3778 parsing fails. If PP is non-null, it points to one past the end of
3779 the parsed marker definition. */
3782 parse_static_tracepoint_marker_definition (char *line, char **pp,
3783 struct static_tracepoint_marker *marker)
3790 p = unpack_varlen_hex (p, &addr);
3791 p++; /* skip a colon */
3793 marker->gdbarch = target_gdbarch ();
3794 marker->address = (CORE_ADDR) addr;
3796 endp = strchr (p, ':');
3798 error (_("bad marker definition: %s"), line);
3800 marker->str_id = (char *) xmalloc (endp - p + 1);
3801 end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
3802 marker->str_id[end] = '\0';
3805 p++; /* skip a colon */
3807 marker->extra = (char *) xmalloc (strlen (p) + 1);
3808 end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
3809 marker->extra[end] = '\0';
3815 /* Release a static tracepoint marker's contents. Note that the
3816 object itself isn't released here. There objects are usually on
3820 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
3822 xfree (marker->str_id);
3823 marker->str_id = NULL;
3826 /* Print MARKER to gdb_stdout. */
3829 print_one_static_tracepoint_marker (int count,
3830 struct static_tracepoint_marker *marker)
3834 char wrap_indent[80];
3835 char extra_field_indent[80];
3836 struct ui_out *uiout = current_uiout;
3837 VEC(breakpoint_p) *tracepoints;
3839 struct symtab_and_line sal;
3843 sal.pc = marker->address;
3845 tracepoints = static_tracepoints_here (marker->address);
3847 ui_out_emit_tuple tuple_emitter (uiout, "marker");
3849 /* A counter field to help readability. This is not a stable
3851 uiout->field_int ("count", count);
3853 uiout->field_string ("marker-id", marker->str_id);
3855 uiout->field_fmt ("enabled", "%c",
3856 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
3859 strcpy (wrap_indent, " ");
3861 if (gdbarch_addr_bit (marker->gdbarch) <= 32)
3862 strcat (wrap_indent, " ");
3864 strcat (wrap_indent, " ");
3866 strcpy (extra_field_indent, " ");
3868 uiout->field_core_addr ("addr", marker->gdbarch, marker->address);
3870 sal = find_pc_line (marker->address, 0);
3871 sym = find_pc_sect_function (marker->address, NULL);
3874 uiout->text ("in ");
3875 uiout->field_string ("func",
3876 SYMBOL_PRINT_NAME (sym));
3877 uiout->wrap_hint (wrap_indent);
3878 uiout->text (" at ");
3881 uiout->field_skip ("func");
3883 if (sal.symtab != NULL)
3885 uiout->field_string ("file",
3886 symtab_to_filename_for_display (sal.symtab));
3889 if (uiout->is_mi_like_p ())
3891 const char *fullname = symtab_to_fullname (sal.symtab);
3893 uiout->field_string ("fullname", fullname);
3896 uiout->field_skip ("fullname");
3898 uiout->field_int ("line", sal.line);
3902 uiout->field_skip ("fullname");
3903 uiout->field_skip ("line");
3907 uiout->text (extra_field_indent);
3908 uiout->text (_("Data: \""));
3909 uiout->field_string ("extra-data", marker->extra);
3910 uiout->text ("\"\n");
3912 if (!VEC_empty (breakpoint_p, tracepoints))
3915 struct breakpoint *b;
3918 ui_out_emit_tuple tuple_emitter (uiout, "tracepoints-at");
3920 uiout->text (extra_field_indent);
3921 uiout->text (_("Probed by static tracepoints: "));
3922 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
3927 uiout->field_int ("tracepoint-id", b->number);
3931 if (uiout->is_mi_like_p ())
3932 uiout->field_int ("number-of-tracepoints",
3933 VEC_length(breakpoint_p, tracepoints));
3937 VEC_free (breakpoint_p, tracepoints);
3941 info_static_tracepoint_markers_command (char *arg, int from_tty)
3943 VEC(static_tracepoint_marker_p) *markers;
3944 struct cleanup *old_chain;
3945 struct static_tracepoint_marker *marker;
3946 struct ui_out *uiout = current_uiout;
3949 /* We don't have to check target_can_use_agent and agent's capability on
3950 static tracepoint here, in order to be compatible with older GDBserver.
3951 We don't check USE_AGENT is true or not, because static tracepoints
3952 don't work without in-process agent, so we don't bother users to type
3953 `set agent on' when to use static tracepoint. */
3956 = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
3957 "StaticTracepointMarkersTable");
3959 uiout->table_header (7, ui_left, "counter", "Cnt");
3961 uiout->table_header (40, ui_left, "marker-id", "ID");
3963 uiout->table_header (3, ui_left, "enabled", "Enb");
3964 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
3965 uiout->table_header (10, ui_left, "addr", "Address");
3967 uiout->table_header (18, ui_left, "addr", "Address");
3968 uiout->table_header (40, ui_noalign, "what", "What");
3970 uiout->table_body ();
3972 markers = target_static_tracepoint_markers_by_strid (NULL);
3973 make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
3976 VEC_iterate (static_tracepoint_marker_p,
3977 markers, i, marker);
3980 print_one_static_tracepoint_marker (i + 1, marker);
3981 release_static_tracepoint_marker (marker);
3984 do_cleanups (old_chain);
3987 /* The $_sdata convenience variable is a bit special. We don't know
3988 for sure type of the value until we actually have a chance to fetch
3989 the data --- the size of the object depends on what has been
3990 collected. We solve this by making $_sdata be an internalvar that
3991 creates a new value on access. */
3993 /* Return a new value with the correct type for the sdata object of
3994 the current trace frame. Return a void value if there's no object
3997 static struct value *
3998 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
4004 /* We need to read the whole object before we know its size. */
4005 size = target_read_alloc (¤t_target,
4006 TARGET_OBJECT_STATIC_TRACE_DATA,
4013 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
4015 v = allocate_value (type);
4016 memcpy (value_contents_raw (v), buf, size);
4021 return allocate_value (builtin_type (gdbarch)->builtin_void);
4024 #if !defined(HAVE_LIBEXPAT)
4026 struct traceframe_info *
4027 parse_traceframe_info (const char *tframe_info)
4029 static int have_warned;
4034 warning (_("Can not parse XML trace frame info; XML support "
4035 "was disabled at compile time"));
4041 #else /* HAVE_LIBEXPAT */
4043 #include "xml-support.h"
4045 /* Handle the start of a <memory> element. */
4048 traceframe_info_start_memory (struct gdb_xml_parser *parser,
4049 const struct gdb_xml_element *element,
4050 void *user_data, VEC(gdb_xml_value_s) *attributes)
4052 struct traceframe_info *info = (struct traceframe_info *) user_data;
4053 struct mem_range *r = VEC_safe_push (mem_range_s, info->memory, NULL);
4054 ULONGEST *start_p, *length_p;
4057 = (ULONGEST *) xml_find_attribute (attributes, "start")->value;
4059 = (ULONGEST *) xml_find_attribute (attributes, "length")->value;
4061 r->start = *start_p;
4062 r->length = *length_p;
4065 /* Handle the start of a <tvar> element. */
4068 traceframe_info_start_tvar (struct gdb_xml_parser *parser,
4069 const struct gdb_xml_element *element,
4071 VEC(gdb_xml_value_s) *attributes)
4073 struct traceframe_info *info = (struct traceframe_info *) user_data;
4074 const char *id_attrib
4075 = (const char *) xml_find_attribute (attributes, "id")->value;
4076 int id = gdb_xml_parse_ulongest (parser, id_attrib);
4078 VEC_safe_push (int, info->tvars, id);
4081 /* Discard the constructed trace frame info (if an error occurs). */
4084 free_result (void *p)
4086 struct traceframe_info *result = (struct traceframe_info *) p;
4088 free_traceframe_info (result);
4091 /* The allowed elements and attributes for an XML memory map. */
4093 static const struct gdb_xml_attribute memory_attributes[] = {
4094 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4095 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4096 { NULL, GDB_XML_AF_NONE, NULL, NULL }
4099 static const struct gdb_xml_attribute tvar_attributes[] = {
4100 { "id", GDB_XML_AF_NONE, NULL, NULL },
4101 { NULL, GDB_XML_AF_NONE, NULL, NULL }
4104 static const struct gdb_xml_element traceframe_info_children[] = {
4105 { "memory", memory_attributes, NULL,
4106 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
4107 traceframe_info_start_memory, NULL },
4108 { "tvar", tvar_attributes, NULL,
4109 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
4110 traceframe_info_start_tvar, NULL },
4111 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4114 static const struct gdb_xml_element traceframe_info_elements[] = {
4115 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
4117 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4120 /* Parse a traceframe-info XML document. */
4122 struct traceframe_info *
4123 parse_traceframe_info (const char *tframe_info)
4125 struct traceframe_info *result;
4126 struct cleanup *back_to;
4128 result = XCNEW (struct traceframe_info);
4129 back_to = make_cleanup (free_result, result);
4131 if (gdb_xml_parse_quick (_("trace frame info"),
4132 "traceframe-info.dtd", traceframe_info_elements,
4133 tframe_info, result) == 0)
4135 /* Parsed successfully, keep the result. */
4136 discard_cleanups (back_to);
4141 do_cleanups (back_to);
4145 #endif /* HAVE_LIBEXPAT */
4147 /* Returns the traceframe_info object for the current traceframe.
4148 This is where we avoid re-fetching the object from the target if we
4149 already have it cached. */
4151 struct traceframe_info *
4152 get_traceframe_info (void)
4154 if (traceframe_info == NULL)
4155 traceframe_info = target_traceframe_info ();
4157 return traceframe_info;
4160 /* If the target supports the query, return in RESULT the set of
4161 collected memory in the current traceframe, found within the LEN
4162 bytes range starting at MEMADDR. Returns true if the target
4163 supports the query, otherwise returns false, and RESULT is left
4167 traceframe_available_memory (VEC(mem_range_s) **result,
4168 CORE_ADDR memaddr, ULONGEST len)
4170 struct traceframe_info *info = get_traceframe_info ();
4174 struct mem_range *r;
4179 for (i = 0; VEC_iterate (mem_range_s, info->memory, i, r); i++)
4180 if (mem_ranges_overlap (r->start, r->length, memaddr, len))
4182 ULONGEST lo1, hi1, lo2, hi2;
4183 struct mem_range *nr;
4186 hi1 = memaddr + len;
4189 hi2 = r->start + r->length;
4191 nr = VEC_safe_push (mem_range_s, *result, NULL);
4193 nr->start = std::max (lo1, lo2);
4194 nr->length = std::min (hi1, hi2) - nr->start;
4197 normalize_mem_ranges (*result);
4204 /* Implementation of `sdata' variable. */
4206 static const struct internalvar_funcs sdata_funcs =
4213 /* module initialization */
4215 _initialize_tracepoint (void)
4217 struct cmd_list_element *c;
4219 /* Explicitly create without lookup, since that tries to create a
4220 value with a void typed value, and when we get here, gdbarch
4221 isn't initialized yet. At this point, we're quite sure there
4222 isn't another convenience variable of the same name. */
4223 create_internalvar_type_lazy ("_sdata", &sdata_funcs, NULL);
4225 traceframe_number = -1;
4226 tracepoint_number = -1;
4228 add_info ("scope", scope_info,
4229 _("List the variables local to a scope"));
4231 add_cmd ("tracepoints", class_trace, NULL,
4232 _("Tracing of program execution without stopping the program."),
4235 add_com ("tdump", class_trace, tdump_command,
4236 _("Print everything collected at the current tracepoint."));
4238 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
4239 Define a trace state variable.\n\
4240 Argument is a $-prefixed name, optionally followed\n\
4241 by '=' and an expression that sets the initial value\n\
4242 at the start of tracing."));
4243 set_cmd_completer (c, expression_completer);
4245 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
4246 Delete one or more trace state variables.\n\
4247 Arguments are the names of the variables to delete.\n\
4248 If no arguments are supplied, delete all variables."), &deletelist);
4249 /* FIXME add a trace variable completer. */
4251 add_info ("tvariables", tvariables_info, _("\
4252 Status of trace state variables and their values.\n\
4255 add_info ("static-tracepoint-markers",
4256 info_static_tracepoint_markers_command, _("\
4257 List target static tracepoints markers.\n\
4260 add_prefix_cmd ("tfind", class_trace, tfind_command, _("\
4261 Select a trace frame;\n\
4262 No argument means forward by one frame; '-' means backward by one frame."),
4263 &tfindlist, "tfind ", 1, &cmdlist);
4265 add_cmd ("outside", class_trace, tfind_outside_command, _("\
4266 Select a trace frame whose PC is outside the given range (exclusive).\n\
4267 Usage: tfind outside addr1, addr2"),
4270 add_cmd ("range", class_trace, tfind_range_command, _("\
4271 Select a trace frame whose PC is in the given range (inclusive).\n\
4272 Usage: tfind range addr1,addr2"),
4275 add_cmd ("line", class_trace, tfind_line_command, _("\
4276 Select a trace frame by source line.\n\
4277 Argument can be a line number (with optional source file),\n\
4278 a function name, or '*' followed by an address.\n\
4279 Default argument is 'the next source line that was traced'."),
4282 add_cmd ("tracepoint", class_trace, tfind_tracepoint_command, _("\
4283 Select a trace frame by tracepoint number.\n\
4284 Default is the tracepoint for the current trace frame."),
4287 add_cmd ("pc", class_trace, tfind_pc_command, _("\
4288 Select a trace frame by PC.\n\
4289 Default is the current PC, or the PC of the current trace frame."),
4292 add_cmd ("end", class_trace, tfind_end_command, _("\
4293 De-select any trace frame and resume 'live' debugging."),
4296 add_alias_cmd ("none", "end", class_trace, 0, &tfindlist);
4298 add_cmd ("start", class_trace, tfind_start_command,
4299 _("Select the first trace frame in the trace buffer."),
4302 add_com ("tstatus", class_trace, tstatus_command,
4303 _("Display the status of the current trace data collection."));
4305 add_com ("tstop", class_trace, tstop_command, _("\
4306 Stop trace data collection.\n\
4307 Usage: tstop [ <notes> ... ]\n\
4308 Any arguments supplied are recorded with the trace as a stop reason and\n\
4309 reported by tstatus (if the target supports trace notes)."));
4311 add_com ("tstart", class_trace, tstart_command, _("\
4312 Start trace data collection.\n\
4313 Usage: tstart [ <notes> ... ]\n\
4314 Any arguments supplied are recorded with the trace as a note and\n\
4315 reported by tstatus (if the target supports trace notes)."));
4317 add_com ("end", class_trace, end_actions_pseudocommand, _("\
4318 Ends a list of commands or actions.\n\
4319 Several GDB commands allow you to enter a list of commands or actions.\n\
4320 Entering \"end\" on a line by itself is the normal way to terminate\n\
4322 Note: the \"end\" command cannot be used at the gdb prompt."));
4324 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
4325 Specify single-stepping behavior at a tracepoint.\n\
4326 Argument is number of instructions to trace in single-step mode\n\
4327 following the tracepoint. This command is normally followed by\n\
4328 one or more \"collect\" commands, to specify what to collect\n\
4329 while single-stepping.\n\n\
4330 Note: this command can only be used in a tracepoint \"actions\" list."));
4332 add_com_alias ("ws", "while-stepping", class_alias, 0);
4333 add_com_alias ("stepping", "while-stepping", class_alias, 0);
4335 add_com ("collect", class_trace, collect_pseudocommand, _("\
4336 Specify one or more data items to be collected at a tracepoint.\n\
4337 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4338 collect all data (variables, registers) referenced by that expression.\n\
4339 Also accepts the following special arguments:\n\
4340 $regs -- all registers.\n\
4341 $args -- all function arguments.\n\
4342 $locals -- all variables local to the block/function scope.\n\
4343 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4344 Note: this command can only be used in a tracepoint \"actions\" list."));
4346 add_com ("teval", class_trace, teval_pseudocommand, _("\
4347 Specify one or more expressions to be evaluated at a tracepoint.\n\
4348 Accepts a comma-separated list of (one or more) expressions.\n\
4349 The result of each evaluation will be discarded.\n\
4350 Note: this command can only be used in a tracepoint \"actions\" list."));
4352 add_com ("actions", class_trace, actions_command, _("\
4353 Specify the actions to be taken at a tracepoint.\n\
4354 Tracepoint actions may include collecting of specified data,\n\
4355 single-stepping, or enabling/disabling other tracepoints,\n\
4356 depending on target's capabilities."));
4358 default_collect = xstrdup ("");
4359 add_setshow_string_cmd ("default-collect", class_trace,
4360 &default_collect, _("\
4361 Set the list of expressions to collect by default"), _("\
4362 Show the list of expressions to collect by default"), NULL,
4364 &setlist, &showlist);
4366 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
4367 &disconnected_tracing, _("\
4368 Set whether tracing continues after GDB disconnects."), _("\
4369 Show whether tracing continues after GDB disconnects."), _("\
4370 Use this to continue a tracing run even if GDB disconnects\n\
4371 or detaches from the target. You can reconnect later and look at\n\
4372 trace data collected in the meantime."),
4373 set_disconnected_tracing,
4378 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
4379 &circular_trace_buffer, _("\
4380 Set target's use of circular trace buffer."), _("\
4381 Show target's use of circular trace buffer."), _("\
4382 Use this to make the trace buffer into a circular buffer,\n\
4383 which will discard traceframes (oldest first) instead of filling\n\
4384 up and stopping the trace run."),
4385 set_circular_trace_buffer,
4390 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class,
4391 &trace_buffer_size, _("\
4392 Set requested size of trace buffer."), _("\
4393 Show requested size of trace buffer."), _("\
4394 Use this to choose a size for the trace buffer. Some targets\n\
4395 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
4396 disables any attempt to set the buffer size and lets the target choose."),
4397 set_trace_buffer_size, NULL,
4398 &setlist, &showlist);
4400 add_setshow_string_cmd ("trace-user", class_trace,
4402 Set the user name to use for current and future trace runs"), _("\
4403 Show the user name to use for current and future trace runs"), NULL,
4404 set_trace_user, NULL,
4405 &setlist, &showlist);
4407 add_setshow_string_cmd ("trace-notes", class_trace,
4409 Set notes string to use for current and future trace runs"), _("\
4410 Show the notes string to use for current and future trace runs"), NULL,
4411 set_trace_notes, NULL,
4412 &setlist, &showlist);
4414 add_setshow_string_cmd ("trace-stop-notes", class_trace,
4415 &trace_stop_notes, _("\
4416 Set notes string to use for future tstop commands"), _("\
4417 Show the notes string to use for future tstop commands"), NULL,
4418 set_trace_stop_notes, NULL,
4419 &setlist, &showlist);