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 traceframe_info_up current_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 /* support routines */
170 struct collection_list;
171 static char *mem2hex (gdb_byte *, char *, int);
173 static struct command_line *
174 all_tracepoint_actions_and_cleanup (struct breakpoint *t);
176 static struct trace_status trace_status;
178 const char *stop_reason_names[] = {
188 struct trace_status *
189 current_trace_status (void)
191 return &trace_status;
194 /* Free and clear the traceframe info cache of the current
198 clear_traceframe_info (void)
200 current_traceframe_info = NULL;
203 /* Set traceframe number to NUM. */
205 set_traceframe_num (int num)
207 traceframe_number = num;
208 set_internalvar_integer (lookup_internalvar ("trace_frame"), num);
211 /* Set tracepoint number to NUM. */
213 set_tracepoint_num (int num)
215 tracepoint_number = num;
216 set_internalvar_integer (lookup_internalvar ("tracepoint"), num);
219 /* Set externally visible debug variables for querying/printing
220 the traceframe context (line, function, file). */
223 set_traceframe_context (struct frame_info *trace_frame)
226 struct symbol *traceframe_fun;
227 symtab_and_line traceframe_sal;
229 /* Save as globals for internal use. */
230 if (trace_frame != NULL
231 && get_frame_pc_if_available (trace_frame, &trace_pc))
233 traceframe_sal = find_pc_line (trace_pc, 0);
234 traceframe_fun = find_pc_function (trace_pc);
236 /* Save linenumber as "$trace_line", a debugger variable visible to
238 set_internalvar_integer (lookup_internalvar ("trace_line"),
239 traceframe_sal.line);
243 traceframe_fun = NULL;
244 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
247 /* Save func name as "$trace_func", a debugger variable visible to
249 if (traceframe_fun == NULL
250 || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
251 clear_internalvar (lookup_internalvar ("trace_func"));
253 set_internalvar_string (lookup_internalvar ("trace_func"),
254 SYMBOL_LINKAGE_NAME (traceframe_fun));
256 /* Save file name as "$trace_file", a debugger variable visible to
258 if (traceframe_sal.symtab == NULL)
259 clear_internalvar (lookup_internalvar ("trace_file"));
261 set_internalvar_string (lookup_internalvar ("trace_file"),
262 symtab_to_filename_for_display (traceframe_sal.symtab));
265 /* Create a new trace state variable with the given name. */
267 struct trace_state_variable *
268 create_trace_state_variable (const char *name)
270 struct trace_state_variable tsv;
272 memset (&tsv, 0, sizeof (tsv));
273 tsv.name = xstrdup (name);
274 tsv.number = next_tsv_number++;
275 return VEC_safe_push (tsv_s, tvariables, &tsv);
278 /* Look for a trace state variable of the given name. */
280 struct trace_state_variable *
281 find_trace_state_variable (const char *name)
283 struct trace_state_variable *tsv;
286 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
287 if (strcmp (name, tsv->name) == 0)
293 /* Look for a trace state variable of the given number. Return NULL if
296 struct trace_state_variable *
297 find_trace_state_variable_by_number (int number)
299 struct trace_state_variable *tsv;
302 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
303 if (tsv->number == number)
310 delete_trace_state_variable (const char *name)
312 struct trace_state_variable *tsv;
315 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
316 if (strcmp (name, tsv->name) == 0)
318 observer_notify_tsv_deleted (tsv);
320 xfree ((void *)tsv->name);
321 VEC_unordered_remove (tsv_s, tvariables, ix);
326 warning (_("No trace variable named \"$%s\", not deleting"), name);
329 /* Throws an error if NAME is not valid syntax for a trace state
333 validate_trace_state_variable_name (const char *name)
338 error (_("Must supply a non-empty variable name"));
340 /* All digits in the name is reserved for value history
342 for (p = name; isdigit (*p); p++)
345 error (_("$%s is not a valid trace state variable name"), name);
347 for (p = name; isalnum (*p) || *p == '_'; p++)
350 error (_("$%s is not a valid trace state variable name"), name);
353 /* The 'tvariable' command collects a name and optional expression to
354 evaluate into an initial value. */
357 trace_variable_command (const char *args, int from_tty)
360 struct trace_state_variable *tsv;
361 const char *name_start, *p;
364 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
366 /* Only allow two syntaxes; "$name" and "$name=value". */
367 p = skip_spaces (args);
370 error (_("Name of trace variable should start with '$'"));
373 while (isalnum (*p) || *p == '_')
375 std::string name (name_start, p - name_start);
378 if (*p != '=' && *p != '\0')
379 error (_("Syntax must be $NAME [ = EXPR ]"));
381 validate_trace_state_variable_name (name.c_str ());
384 initval = value_as_long (parse_and_eval (++p));
386 /* If the variable already exists, just change its initial value. */
387 tsv = find_trace_state_variable (name.c_str ());
390 if (tsv->initial_value != initval)
392 tsv->initial_value = initval;
393 observer_notify_tsv_modified (tsv);
395 printf_filtered (_("Trace state variable $%s "
396 "now has initial value %s.\n"),
397 tsv->name, plongest (tsv->initial_value));
401 /* Create a new variable. */
402 tsv = create_trace_state_variable (name.c_str ());
403 tsv->initial_value = initval;
405 observer_notify_tsv_created (tsv);
407 printf_filtered (_("Trace state variable $%s "
408 "created, with initial value %s.\n"),
409 tsv->name, plongest (tsv->initial_value));
413 delete_trace_variable_command (const char *args, int from_tty)
417 if (query (_("Delete all trace state variables? ")))
418 VEC_free (tsv_s, tvariables);
420 observer_notify_tsv_deleted (NULL);
424 gdb_argv argv (args);
426 for (char *arg : argv)
429 delete_trace_state_variable (arg + 1);
431 warning (_("Name \"%s\" not prefixed with '$', ignoring"), arg);
438 tvariables_info_1 (void)
440 struct trace_state_variable *tsv;
443 struct ui_out *uiout = current_uiout;
445 if (VEC_length (tsv_s, tvariables) == 0 && !uiout->is_mi_like_p ())
447 printf_filtered (_("No trace state variables.\n"));
451 /* Try to acquire values from the target. */
452 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix, ++count)
453 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
456 ui_out_emit_table table_emitter (uiout, 3, count, "trace-variables");
457 uiout->table_header (15, ui_left, "name", "Name");
458 uiout->table_header (11, ui_left, "initial", "Initial");
459 uiout->table_header (11, ui_left, "current", "Current");
461 uiout->table_body ();
463 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
467 ui_out_emit_tuple tuple_emitter (uiout, "variable");
469 std::string name = std::string ("$") + tsv->name;
470 uiout->field_string ("name", name.c_str ());
471 uiout->field_string ("initial", plongest (tsv->initial_value));
473 if (tsv->value_known)
474 c = plongest (tsv->value);
475 else if (uiout->is_mi_like_p ())
476 /* For MI, we prefer not to use magic string constants, but rather
477 omit the field completely. The difference between unknown and
478 undefined does not seem important enough to represent. */
480 else if (current_trace_status ()->running || traceframe_number >= 0)
481 /* The value is/was defined, but we don't have it. */
484 /* It is not meaningful to ask about the value. */
487 uiout->field_string ("current", c);
492 /* List all the trace state variables. */
495 info_tvariables_command (const char *args, int from_tty)
497 tvariables_info_1 ();
500 /* Stash definitions of tsvs into the given file. */
503 save_trace_state_variables (struct ui_file *fp)
505 struct trace_state_variable *tsv;
508 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
510 fprintf_unfiltered (fp, "tvariable $%s", tsv->name);
511 if (tsv->initial_value)
512 fprintf_unfiltered (fp, " = %s", plongest (tsv->initial_value));
513 fprintf_unfiltered (fp, "\n");
517 /* ACTIONS functions: */
519 /* The three functions:
520 collect_pseudocommand,
521 while_stepping_pseudocommand, and
522 end_actions_pseudocommand
523 are placeholders for "commands" that are actually ONLY to be used
524 within a tracepoint action list. If the actual function is ever called,
525 it means that somebody issued the "command" at the top level,
526 which is always an error. */
529 end_actions_pseudocommand (const char *args, int from_tty)
531 error (_("This command cannot be used at the top level."));
535 while_stepping_pseudocommand (const char *args, int from_tty)
537 error (_("This command can only be used in a tracepoint actions list."));
541 collect_pseudocommand (const char *args, int from_tty)
543 error (_("This command can only be used in a tracepoint actions list."));
547 teval_pseudocommand (const char *args, int from_tty)
549 error (_("This command can only be used in a tracepoint actions list."));
552 /* Parse any collection options, such as /s for strings. */
555 decode_agent_options (const char *exp, int *trace_string)
557 struct value_print_options opts;
564 /* Call this to borrow the print elements default for collection
566 get_user_print_options (&opts);
571 if (target_supports_string_tracing ())
573 /* Allow an optional decimal number giving an explicit maximum
574 string length, defaulting it to the "print elements" value;
575 so "collect/s80 mystr" gets at most 80 bytes of string. */
576 *trace_string = opts.print_max;
578 if (*exp >= '0' && *exp <= '9')
579 *trace_string = atoi (exp);
580 while (*exp >= '0' && *exp <= '9')
584 error (_("Target does not support \"/s\" option for string tracing."));
587 error (_("Undefined collection format \"%c\"."), *exp);
589 exp = skip_spaces (exp);
594 /* Enter a list of actions for a tracepoint. */
596 actions_command (const char *args, int from_tty)
598 struct tracepoint *t;
600 t = get_tracepoint_by_number (&args, NULL);
604 string_printf ("Enter actions for tracepoint %d, one per line.",
607 command_line_up l = read_command_lines (&tmpbuf[0], from_tty, 1,
608 check_tracepoint_command, t);
609 breakpoint_set_commands (t, std::move (l));
611 /* else just return */
614 /* Report the results of checking the agent expression, as errors or
618 report_agent_reqs_errors (struct agent_expr *aexpr)
620 /* All of the "flaws" are serious bytecode generation issues that
621 should never occur. */
622 if (aexpr->flaw != agent_flaw_none)
623 internal_error (__FILE__, __LINE__, _("expression is malformed"));
625 /* If analysis shows a stack underflow, GDB must have done something
626 badly wrong in its bytecode generation. */
627 if (aexpr->min_height < 0)
628 internal_error (__FILE__, __LINE__,
629 _("expression has min height < 0"));
631 /* Issue this error if the stack is predicted to get too deep. The
632 limit is rather arbitrary; a better scheme might be for the
633 target to report how much stack it will have available. The
634 depth roughly corresponds to parenthesization, so a limit of 20
635 amounts to 20 levels of expression nesting, which is actually
636 a pretty big hairy expression. */
637 if (aexpr->max_height > 20)
638 error (_("Expression is too complicated."));
641 /* worker function */
643 validate_actionline (const char *line, struct breakpoint *b)
645 struct cmd_list_element *c;
648 struct bp_location *loc;
649 struct tracepoint *t = (struct tracepoint *) b;
651 /* If EOF is typed, *line is NULL. */
655 p = skip_spaces (line);
657 /* Symbol lookup etc. */
658 if (*p == '\0') /* empty line: just prompt for another line. */
661 if (*p == '#') /* comment line */
664 c = lookup_cmd (&p, cmdlist, "", -1, 1);
666 error (_("`%s' is not a tracepoint action, or is ambiguous."), p);
668 if (cmd_cfunc_eq (c, collect_pseudocommand))
670 int trace_string = 0;
673 p = decode_agent_options (p, &trace_string);
676 { /* Repeat over a comma-separated list. */
677 QUIT; /* Allow user to bail out with ^C. */
680 if (*p == '$') /* Look for special pseudo-symbols. */
682 if (0 == strncasecmp ("reg", p + 1, 3)
683 || 0 == strncasecmp ("arg", p + 1, 3)
684 || 0 == strncasecmp ("loc", p + 1, 3)
685 || 0 == strncasecmp ("_ret", p + 1, 4)
686 || 0 == strncasecmp ("_sdata", p + 1, 6))
691 /* else fall thru, treat p as an expression and parse it! */
694 for (loc = t->loc; loc; loc = loc->next)
697 expression_up exp = parse_exp_1 (&p, loc->address,
698 block_for_pc (loc->address), 1);
700 if (exp->elts[0].opcode == OP_VAR_VALUE)
702 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
704 error (_("constant `%s' (value %s) "
705 "will not be collected."),
706 SYMBOL_PRINT_NAME (exp->elts[2].symbol),
707 plongest (SYMBOL_VALUE (exp->elts[2].symbol)));
709 else if (SYMBOL_CLASS (exp->elts[2].symbol)
710 == LOC_OPTIMIZED_OUT)
712 error (_("`%s' is optimized away "
713 "and cannot be collected."),
714 SYMBOL_PRINT_NAME (exp->elts[2].symbol));
718 /* We have something to collect, make sure that the expr to
719 bytecode translator can handle it and that it's not too
721 agent_expr_up aexpr = gen_trace_for_expr (loc->address,
725 if (aexpr->len > MAX_AGENT_EXPR_LEN)
726 error (_("Expression is too complicated."));
728 ax_reqs (aexpr.get ());
730 report_agent_reqs_errors (aexpr.get ());
733 while (p && *p++ == ',');
736 else if (cmd_cfunc_eq (c, teval_pseudocommand))
739 { /* Repeat over a comma-separated list. */
740 QUIT; /* Allow user to bail out with ^C. */
744 for (loc = t->loc; loc; loc = loc->next)
748 /* Only expressions are allowed for this action. */
749 expression_up exp = parse_exp_1 (&p, loc->address,
750 block_for_pc (loc->address), 1);
752 /* We have something to evaluate, make sure that the expr to
753 bytecode translator can handle it and that it's not too
755 agent_expr_up aexpr = gen_eval_for_expr (loc->address, exp.get ());
757 if (aexpr->len > MAX_AGENT_EXPR_LEN)
758 error (_("Expression is too complicated."));
760 ax_reqs (aexpr.get ());
761 report_agent_reqs_errors (aexpr.get ());
764 while (p && *p++ == ',');
767 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
772 t->step_count = strtol (p, &endp, 0);
773 if (endp == p || t->step_count == 0)
774 error (_("while-stepping step count `%s' is malformed."), line);
778 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
782 error (_("`%s' is not a supported tracepoint action."), line);
786 memrange_absolute = -1
789 /* MEMRANGE functions: */
791 /* Compare memranges for std::sort. */
794 memrange_comp (const memrange &a, const memrange &b)
796 if (a.type == b.type)
798 if (a.type == memrange_absolute)
799 return (bfd_vma) a.start < (bfd_vma) b.start;
801 return a.start < b.start;
804 return a.type < b.type;
807 /* Sort the memrange list using std::sort, and merge adjacent memranges. */
810 memrange_sortmerge (std::vector<memrange> &memranges)
812 if (!memranges.empty ())
816 std::sort (memranges.begin (), memranges.end (), memrange_comp);
818 for (a = 0, b = 1; b < memranges.size (); b++)
820 /* If memrange b overlaps or is adjacent to memrange a,
822 if (memranges[a].type == memranges[b].type
823 && memranges[b].start <= memranges[a].end)
825 if (memranges[b].end > memranges[a].end)
826 memranges[a].end = memranges[b].end;
827 continue; /* next b, same a */
831 memranges[a] = memranges[b];
833 memranges.resize (a + 1);
837 /* Add a register to a collection list. */
840 collection_list::add_register (unsigned int regno)
843 printf_filtered ("collect register %d\n", regno);
844 if (regno >= (8 * sizeof (m_regs_mask)))
845 error (_("Internal: register number %d too large for tracepoint"),
847 m_regs_mask[regno / 8] |= 1 << (regno % 8);
850 /* Add a memrange to a collection list. */
853 collection_list::add_memrange (struct gdbarch *gdbarch,
854 int type, bfd_signed_vma base,
858 printf_filtered ("(%d,%s,%ld)\n", type, paddress (gdbarch, base), len);
860 /* type: memrange_absolute == memory, other n == basereg */
861 /* base: addr if memory, offset if reg relative. */
862 /* len: we actually save end (base + len) for convenience */
863 m_memranges.emplace_back (type, base, base + len);
865 if (type != memrange_absolute) /* Better collect the base register! */
869 /* Add a symbol to a collection list. */
872 collection_list::collect_symbol (struct symbol *sym,
873 struct gdbarch *gdbarch,
874 long frame_regno, long frame_offset,
880 bfd_signed_vma offset;
881 int treat_as_expr = 0;
883 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
884 switch (SYMBOL_CLASS (sym))
887 printf_filtered ("%s: don't know symbol class %d\n",
888 SYMBOL_PRINT_NAME (sym),
892 printf_filtered ("constant %s (value %s) will not be collected.\n",
893 SYMBOL_PRINT_NAME (sym), plongest (SYMBOL_VALUE (sym)));
896 offset = SYMBOL_VALUE_ADDRESS (sym);
899 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
900 SYMBOL_PRINT_NAME (sym), len,
901 paddress (gdbarch, offset));
903 /* A struct may be a C++ class with static fields, go to general
904 expression handling. */
905 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
908 add_memrange (gdbarch, memrange_absolute, offset, len);
911 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
913 printf_filtered ("LOC_REG[parm] %s: ",
914 SYMBOL_PRINT_NAME (sym));
916 /* Check for doubles stored in two registers. */
917 /* FIXME: how about larger types stored in 3 or more regs? */
918 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
919 len > register_size (gdbarch, reg))
920 add_register (reg + 1);
923 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
924 printf_filtered (" (will not collect %s)\n",
925 SYMBOL_PRINT_NAME (sym));
929 offset = frame_offset + SYMBOL_VALUE (sym);
932 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
933 " from frame ptr reg %d\n",
934 SYMBOL_PRINT_NAME (sym), len,
935 paddress (gdbarch, offset), reg);
937 add_memrange (gdbarch, reg, offset, len);
939 case LOC_REGPARM_ADDR:
940 reg = SYMBOL_VALUE (sym);
944 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset %s"
946 SYMBOL_PRINT_NAME (sym), len,
947 paddress (gdbarch, offset), reg);
949 add_memrange (gdbarch, reg, offset, len);
953 offset = frame_offset + SYMBOL_VALUE (sym);
956 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
957 " from frame ptr reg %d\n",
958 SYMBOL_PRINT_NAME (sym), len,
959 paddress (gdbarch, offset), reg);
961 add_memrange (gdbarch, reg, offset, len);
968 case LOC_OPTIMIZED_OUT:
969 printf_filtered ("%s has been optimized out of existence.\n",
970 SYMBOL_PRINT_NAME (sym));
978 /* Expressions are the most general case. */
981 agent_expr_up aexpr = gen_trace_for_var (scope, gdbarch,
984 /* It can happen that the symbol is recorded as a computed
985 location, but it's been optimized away and doesn't actually
986 have a location expression. */
989 printf_filtered ("%s has been optimized out of existence.\n",
990 SYMBOL_PRINT_NAME (sym));
994 ax_reqs (aexpr.get ());
996 report_agent_reqs_errors (aexpr.get ());
998 /* Take care of the registers. */
999 if (aexpr->reg_mask_len > 0)
1001 for (int ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1003 QUIT; /* Allow user to bail out with ^C. */
1004 if (aexpr->reg_mask[ndx1] != 0)
1006 /* Assume chars have 8 bits. */
1007 for (int ndx2 = 0; ndx2 < 8; ndx2++)
1008 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1009 /* It's used -- record it. */
1010 add_register (ndx1 * 8 + ndx2);
1015 add_aexpr (std::move (aexpr));
1019 /* Data to be passed around in the calls to the locals and args
1022 struct add_local_symbols_data
1024 struct collection_list *collect;
1025 struct gdbarch *gdbarch;
1033 /* The callback for the locals and args iterators. */
1036 do_collect_symbol (const char *print_name,
1040 struct add_local_symbols_data *p = (struct add_local_symbols_data *) cb_data;
1042 p->collect->collect_symbol (sym, p->gdbarch, p->frame_regno,
1043 p->frame_offset, p->pc, p->trace_string);
1046 p->collect->add_wholly_collected (print_name);
1050 collection_list::add_wholly_collected (const char *print_name)
1052 m_wholly_collected.push_back (print_name);
1055 /* Add all locals (or args) symbols to collection list. */
1058 collection_list::add_local_symbols (struct gdbarch *gdbarch, CORE_ADDR pc,
1059 long frame_regno, long frame_offset, int type,
1062 const struct block *block;
1063 struct add_local_symbols_data cb_data;
1065 cb_data.collect = this;
1066 cb_data.gdbarch = gdbarch;
1068 cb_data.frame_regno = frame_regno;
1069 cb_data.frame_offset = frame_offset;
1071 cb_data.trace_string = trace_string;
1075 block = block_for_pc (pc);
1078 warning (_("Can't collect locals; "
1079 "no symbol table info available.\n"));
1083 iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1084 if (cb_data.count == 0)
1085 warning (_("No locals found in scope."));
1089 pc = get_pc_function_start (pc);
1090 block = block_for_pc (pc);
1093 warning (_("Can't collect args; no symbol table info available."));
1097 iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1098 if (cb_data.count == 0)
1099 warning (_("No args found in scope."));
1104 collection_list::add_static_trace_data ()
1107 printf_filtered ("collect static trace data\n");
1108 m_strace_data = true;
1111 collection_list::collection_list ()
1113 m_strace_data (false)
1115 m_memranges.reserve (128);
1116 m_aexprs.reserve (128);
1119 /* Reduce a collection list to string form (for gdb protocol). */
1121 std::vector<std::string>
1122 collection_list::stringify ()
1124 char temp_buf[2048];
1128 std::vector<std::string> str_list;
1133 printf_filtered ("\nCollecting static trace data\n");
1136 str_list.emplace_back (temp_buf, end - temp_buf);
1139 for (i = sizeof (m_regs_mask) - 1; i > 0; i--)
1140 if (m_regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */
1142 if (m_regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
1145 printf_filtered ("\nCollecting registers (mask): 0x");
1150 QUIT; /* Allow user to bail out with ^C. */
1152 printf_filtered ("%02X", m_regs_mask[i]);
1153 sprintf (end, "%02X", m_regs_mask[i]);
1156 str_list.emplace_back (temp_buf);
1159 printf_filtered ("\n");
1160 if (!m_memranges.empty () && info_verbose)
1161 printf_filtered ("Collecting memranges: \n");
1162 for (i = 0, count = 0, end = temp_buf; i < m_memranges.size (); i++)
1164 QUIT; /* Allow user to bail out with ^C. */
1167 printf_filtered ("(%d, %s, %ld)\n",
1168 m_memranges[i].type,
1169 paddress (target_gdbarch (),
1170 m_memranges[i].start),
1171 (long) (m_memranges[i].end
1172 - m_memranges[i].start));
1174 if (count + 27 > MAX_AGENT_EXPR_LEN)
1176 str_list.emplace_back (temp_buf, count);
1182 bfd_signed_vma length
1183 = m_memranges[i].end - m_memranges[i].start;
1185 /* The "%X" conversion specifier expects an unsigned argument,
1186 so passing -1 (memrange_absolute) to it directly gives you
1187 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1189 if (m_memranges[i].type == memrange_absolute)
1190 sprintf (end, "M-1,%s,%lX", phex_nz (m_memranges[i].start, 0),
1193 sprintf (end, "M%X,%s,%lX", m_memranges[i].type,
1194 phex_nz (m_memranges[i].start, 0), (long) length);
1197 count += strlen (end);
1198 end = temp_buf + count;
1201 for (i = 0; i < m_aexprs.size (); i++)
1203 QUIT; /* Allow user to bail out with ^C. */
1204 if ((count + 10 + 2 * m_aexprs[i]->len) > MAX_AGENT_EXPR_LEN)
1206 str_list.emplace_back (temp_buf, count);
1210 sprintf (end, "X%08X,", m_aexprs[i]->len);
1211 end += 10; /* 'X' + 8 hex digits + ',' */
1214 end = mem2hex (m_aexprs[i]->buf, end, m_aexprs[i]->len);
1215 count += 2 * m_aexprs[i]->len;
1220 str_list.emplace_back (temp_buf, count);
1228 /* Add the printed expression EXP to *LIST. */
1231 collection_list::append_exp (struct expression *exp)
1233 string_file tmp_stream;
1235 print_expression (exp, &tmp_stream);
1237 m_computed.push_back (std::move (tmp_stream.string ()));
1241 collection_list::finish ()
1243 memrange_sortmerge (m_memranges);
1247 encode_actions_1 (struct command_line *action,
1248 struct bp_location *tloc,
1250 LONGEST frame_offset,
1251 struct collection_list *collect,
1252 struct collection_list *stepping_list)
1254 const char *action_exp;
1256 struct value *tempval;
1257 struct cmd_list_element *cmd;
1259 for (; action; action = action->next)
1261 QUIT; /* Allow user to bail out with ^C. */
1262 action_exp = action->line;
1263 action_exp = skip_spaces (action_exp);
1265 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1267 error (_("Bad action list item: %s"), action_exp);
1269 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1271 int trace_string = 0;
1273 if (*action_exp == '/')
1274 action_exp = decode_agent_options (action_exp, &trace_string);
1277 { /* Repeat over a comma-separated list. */
1278 QUIT; /* Allow user to bail out with ^C. */
1279 action_exp = skip_spaces (action_exp);
1281 if (0 == strncasecmp ("$reg", action_exp, 4))
1283 for (i = 0; i < gdbarch_num_regs (target_gdbarch ()); i++)
1284 collect->add_register (i);
1285 action_exp = strchr (action_exp, ','); /* more? */
1287 else if (0 == strncasecmp ("$arg", action_exp, 4))
1289 collect->add_local_symbols (target_gdbarch (),
1295 action_exp = strchr (action_exp, ','); /* more? */
1297 else if (0 == strncasecmp ("$loc", action_exp, 4))
1299 collect->add_local_symbols (target_gdbarch (),
1305 action_exp = strchr (action_exp, ','); /* more? */
1307 else if (0 == strncasecmp ("$_ret", action_exp, 5))
1310 = gen_trace_for_return_address (tloc->address,
1314 ax_reqs (aexpr.get ());
1315 report_agent_reqs_errors (aexpr.get ());
1317 /* take care of the registers */
1318 if (aexpr->reg_mask_len > 0)
1320 for (int ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1322 QUIT; /* allow user to bail out with ^C */
1323 if (aexpr->reg_mask[ndx1] != 0)
1325 /* assume chars have 8 bits */
1326 for (int ndx2 = 0; ndx2 < 8; ndx2++)
1327 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1329 /* It's used -- record it. */
1330 collect->add_register (ndx1 * 8 + ndx2);
1336 collect->add_aexpr (std::move (aexpr));
1337 action_exp = strchr (action_exp, ','); /* more? */
1339 else if (0 == strncasecmp ("$_sdata", action_exp, 7))
1341 collect->add_static_trace_data ();
1342 action_exp = strchr (action_exp, ','); /* more? */
1348 expression_up exp = parse_exp_1 (&action_exp, tloc->address,
1349 block_for_pc (tloc->address),
1352 switch (exp->elts[0].opcode)
1356 const char *name = &exp->elts[2].string;
1358 i = user_reg_map_name_to_regnum (target_gdbarch (),
1359 name, strlen (name));
1361 internal_error (__FILE__, __LINE__,
1362 _("Register $%s not available"),
1365 printf_filtered ("OP_REGISTER: ");
1366 collect->add_register (i);
1371 /* Safe because we know it's a simple expression. */
1372 tempval = evaluate_expression (exp.get ());
1373 addr = value_address (tempval);
1374 /* Initialize the TYPE_LENGTH if it is a typedef. */
1375 check_typedef (exp->elts[1].type);
1376 collect->add_memrange (target_gdbarch (),
1377 memrange_absolute, addr,
1378 TYPE_LENGTH (exp->elts[1].type));
1379 collect->append_exp (exp.get ());
1384 struct symbol *sym = exp->elts[2].symbol;
1385 char_ptr name = (char_ptr) SYMBOL_NATURAL_NAME (sym);
1387 collect->collect_symbol (exp->elts[2].symbol,
1393 collect->add_wholly_collected (name);
1397 default: /* Full-fledged expression. */
1398 agent_expr_up aexpr = gen_trace_for_expr (tloc->address,
1402 ax_reqs (aexpr.get ());
1404 report_agent_reqs_errors (aexpr.get ());
1406 /* Take care of the registers. */
1407 if (aexpr->reg_mask_len > 0)
1409 for (int ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1411 QUIT; /* Allow user to bail out with ^C. */
1412 if (aexpr->reg_mask[ndx1] != 0)
1414 /* Assume chars have 8 bits. */
1415 for (int ndx2 = 0; ndx2 < 8; ndx2++)
1416 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1418 /* It's used -- record it. */
1419 collect->add_register (ndx1 * 8 + ndx2);
1425 collect->add_aexpr (std::move (aexpr));
1426 collect->append_exp (exp.get ());
1431 while (action_exp && *action_exp++ == ',');
1433 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1436 { /* Repeat over a comma-separated list. */
1437 QUIT; /* Allow user to bail out with ^C. */
1438 action_exp = skip_spaces (action_exp);
1441 expression_up exp = parse_exp_1 (&action_exp, tloc->address,
1442 block_for_pc (tloc->address),
1445 agent_expr_up aexpr = gen_eval_for_expr (tloc->address,
1448 ax_reqs (aexpr.get ());
1449 report_agent_reqs_errors (aexpr.get ());
1451 /* Even though we're not officially collecting, add
1452 to the collect list anyway. */
1453 collect->add_aexpr (std::move (aexpr));
1456 while (action_exp && *action_exp++ == ',');
1458 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1460 /* We check against nested while-stepping when setting
1461 breakpoint action, so no way to run into nested
1463 gdb_assert (stepping_list);
1465 encode_actions_1 (action->body_list[0], tloc, frame_reg,
1466 frame_offset, stepping_list, NULL);
1469 error (_("Invalid tracepoint command '%s'"), action->line);
1473 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1474 and STEPPING_LIST. */
1477 encode_actions (struct bp_location *tloc,
1478 struct collection_list *tracepoint_list,
1479 struct collection_list *stepping_list)
1481 struct command_line *actions;
1483 LONGEST frame_offset;
1485 gdbarch_virtual_frame_pointer (tloc->gdbarch,
1486 tloc->address, &frame_reg, &frame_offset);
1488 actions = all_tracepoint_actions_and_cleanup (tloc->owner);
1490 encode_actions_1 (actions, tloc, frame_reg, frame_offset,
1491 tracepoint_list, stepping_list);
1493 tracepoint_list->finish ();
1494 stepping_list->finish ();
1497 /* Render all actions into gdb protocol. */
1500 encode_actions_rsp (struct bp_location *tloc,
1501 std::vector<std::string> *tdp_actions,
1502 std::vector<std::string> *stepping_actions)
1504 struct collection_list tracepoint_list, stepping_list;
1506 encode_actions (tloc, &tracepoint_list, &stepping_list);
1508 *tdp_actions = tracepoint_list.stringify ();
1509 *stepping_actions = stepping_list.stringify ();
1513 collection_list::add_aexpr (agent_expr_up aexpr)
1515 m_aexprs.push_back (std::move (aexpr));
1519 process_tracepoint_on_disconnect (void)
1521 VEC(breakpoint_p) *tp_vec = NULL;
1523 struct breakpoint *b;
1524 int has_pending_p = 0;
1526 /* Check whether we still have pending tracepoint. If we have, warn the
1527 user that pending tracepoint will no longer work. */
1528 tp_vec = all_tracepoints ();
1529 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1538 struct bp_location *loc1;
1540 for (loc1 = b->loc; loc1; loc1 = loc1->next)
1542 if (loc1->shlib_disabled)
1553 VEC_free (breakpoint_p, tp_vec);
1556 warning (_("Pending tracepoints will not be resolved while"
1557 " GDB is disconnected\n"));
1560 /* Reset local state of tracing. */
1563 trace_reset_local_state (void)
1565 set_traceframe_num (-1);
1566 set_tracepoint_num (-1);
1567 set_traceframe_context (NULL);
1568 clear_traceframe_info ();
1572 start_tracing (const char *notes)
1574 VEC(breakpoint_p) *tp_vec = NULL;
1576 struct breakpoint *b;
1577 struct trace_state_variable *tsv;
1578 int any_enabled = 0, num_to_download = 0;
1581 tp_vec = all_tracepoints ();
1583 /* No point in tracing without any tracepoints... */
1584 if (VEC_length (breakpoint_p, tp_vec) == 0)
1586 VEC_free (breakpoint_p, tp_vec);
1587 error (_("No tracepoints defined, not starting trace"));
1590 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1592 if (b->enable_state == bp_enabled)
1595 if ((b->type == bp_fast_tracepoint
1596 ? may_insert_fast_tracepoints
1597 : may_insert_tracepoints))
1600 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1601 (b->type == bp_fast_tracepoint ? "fast " : ""), b->number);
1606 if (target_supports_enable_disable_tracepoint ())
1607 warning (_("No tracepoints enabled"));
1610 /* No point in tracing with only disabled tracepoints that
1611 cannot be re-enabled. */
1612 VEC_free (breakpoint_p, tp_vec);
1613 error (_("No tracepoints enabled, not starting trace"));
1617 if (num_to_download <= 0)
1619 VEC_free (breakpoint_p, tp_vec);
1620 error (_("No tracepoints that may be downloaded, not starting trace"));
1623 target_trace_init ();
1625 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1627 struct tracepoint *t = (struct tracepoint *) b;
1628 struct bp_location *loc;
1629 int bp_location_downloaded = 0;
1631 /* Clear `inserted' flag. */
1632 for (loc = b->loc; loc; loc = loc->next)
1635 if ((b->type == bp_fast_tracepoint
1636 ? !may_insert_fast_tracepoints
1637 : !may_insert_tracepoints))
1640 t->number_on_target = 0;
1642 for (loc = b->loc; loc; loc = loc->next)
1644 /* Since tracepoint locations are never duplicated, `inserted'
1645 flag should be zero. */
1646 gdb_assert (!loc->inserted);
1648 target_download_tracepoint (loc);
1651 bp_location_downloaded = 1;
1654 t->number_on_target = b->number;
1656 for (loc = b->loc; loc; loc = loc->next)
1657 if (loc->probe.probe != NULL
1658 && loc->probe.probe->pops->set_semaphore != NULL)
1659 loc->probe.probe->pops->set_semaphore (loc->probe.probe,
1663 if (bp_location_downloaded)
1664 observer_notify_breakpoint_modified (b);
1666 VEC_free (breakpoint_p, tp_vec);
1668 /* Send down all the trace state variables too. */
1669 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1671 target_download_trace_state_variable (tsv);
1674 /* Tell target to treat text-like sections as transparent. */
1675 target_trace_set_readonly_regions ();
1676 /* Set some mode flags. */
1677 target_set_disconnected_tracing (disconnected_tracing);
1678 target_set_circular_trace_buffer (circular_trace_buffer);
1679 target_set_trace_buffer_size (trace_buffer_size);
1682 notes = trace_notes;
1683 ret = target_set_trace_notes (trace_user, notes, NULL);
1685 if (!ret && (trace_user || notes))
1686 warning (_("Target does not support trace user/notes, info ignored"));
1688 /* Now insert traps and begin collecting data. */
1689 target_trace_start ();
1691 /* Reset our local state. */
1692 trace_reset_local_state ();
1693 current_trace_status()->running = 1;
1696 /* The tstart command requests the target to start a new trace run.
1697 The command passes any arguments it has to the target verbatim, as
1698 an optional "trace note". This is useful as for instance a warning
1699 to other users if the trace runs disconnected, and you don't want
1700 anybody else messing with the target. */
1703 tstart_command (const char *args, int from_tty)
1705 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1707 if (current_trace_status ()->running)
1710 && !query (_("A trace is running already. Start a new run? ")))
1711 error (_("New trace run not started."));
1714 start_tracing (args);
1717 /* The tstop command stops the tracing run. The command passes any
1718 supplied arguments to the target verbatim as a "stop note"; if the
1719 target supports trace notes, then it will be reported back as part
1720 of the trace run's status. */
1723 tstop_command (const char *args, int from_tty)
1725 if (!current_trace_status ()->running)
1726 error (_("Trace is not running."));
1728 stop_tracing (args);
1732 stop_tracing (const char *note)
1735 VEC(breakpoint_p) *tp_vec = NULL;
1737 struct breakpoint *t;
1739 target_trace_stop ();
1741 tp_vec = all_tracepoints ();
1742 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1744 struct bp_location *loc;
1746 if ((t->type == bp_fast_tracepoint
1747 ? !may_insert_fast_tracepoints
1748 : !may_insert_tracepoints))
1751 for (loc = t->loc; loc; loc = loc->next)
1753 /* GDB can be totally absent in some disconnected trace scenarios,
1754 but we don't really care if this semaphore goes out of sync.
1755 That's why we are decrementing it here, but not taking care
1757 if (loc->probe.probe != NULL
1758 && loc->probe.probe->pops->clear_semaphore != NULL)
1759 loc->probe.probe->pops->clear_semaphore (loc->probe.probe,
1765 VEC_free (breakpoint_p, tp_vec);
1768 note = trace_stop_notes;
1769 ret = target_set_trace_notes (NULL, NULL, note);
1772 warning (_("Target does not support trace notes, note ignored"));
1774 /* Should change in response to reply? */
1775 current_trace_status ()->running = 0;
1778 /* tstatus command */
1780 tstatus_command (const char *args, int from_tty)
1782 struct trace_status *ts = current_trace_status ();
1784 VEC(breakpoint_p) *tp_vec = NULL;
1785 struct breakpoint *t;
1787 status = target_get_trace_status (ts);
1791 if (ts->filename != NULL)
1792 printf_filtered (_("Using a trace file.\n"));
1795 printf_filtered (_("Trace can not be run on this target.\n"));
1800 if (!ts->running_known)
1802 printf_filtered (_("Run/stop status is unknown.\n"));
1804 else if (ts->running)
1806 printf_filtered (_("Trace is running on the target.\n"));
1810 switch (ts->stop_reason)
1812 case trace_never_run:
1813 printf_filtered (_("No trace has been run on the target.\n"));
1815 case trace_stop_command:
1817 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1820 printf_filtered (_("Trace stopped by a tstop command.\n"));
1822 case trace_buffer_full:
1823 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1825 case trace_disconnected:
1826 printf_filtered (_("Trace stopped because of disconnection.\n"));
1828 case tracepoint_passcount:
1829 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1830 ts->stopping_tracepoint);
1832 case tracepoint_error:
1833 if (ts->stopping_tracepoint)
1834 printf_filtered (_("Trace stopped by an "
1835 "error (%s, tracepoint %d).\n"),
1836 ts->stop_desc, ts->stopping_tracepoint);
1838 printf_filtered (_("Trace stopped by an error (%s).\n"),
1841 case trace_stop_reason_unknown:
1842 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1845 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1851 if (ts->traceframes_created >= 0
1852 && ts->traceframe_count != ts->traceframes_created)
1854 printf_filtered (_("Buffer contains %d trace "
1855 "frames (of %d created total).\n"),
1856 ts->traceframe_count, ts->traceframes_created);
1858 else if (ts->traceframe_count >= 0)
1860 printf_filtered (_("Collected %d trace frames.\n"),
1861 ts->traceframe_count);
1864 if (ts->buffer_free >= 0)
1866 if (ts->buffer_size >= 0)
1868 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1869 ts->buffer_free, ts->buffer_size);
1870 if (ts->buffer_size > 0)
1871 printf_filtered (_(" (%d%% full)"),
1872 ((int) ((((long long) (ts->buffer_size
1873 - ts->buffer_free)) * 100)
1874 / ts->buffer_size)));
1875 printf_filtered (_(".\n"));
1878 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1882 if (ts->disconnected_tracing)
1883 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1885 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1887 if (ts->circular_buffer)
1888 printf_filtered (_("Trace buffer is circular.\n"));
1890 if (ts->user_name && strlen (ts->user_name) > 0)
1891 printf_filtered (_("Trace user is %s.\n"), ts->user_name);
1893 if (ts->notes && strlen (ts->notes) > 0)
1894 printf_filtered (_("Trace notes: %s.\n"), ts->notes);
1896 /* Now report on what we're doing with tfind. */
1897 if (traceframe_number >= 0)
1898 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1899 traceframe_number, tracepoint_number);
1901 printf_filtered (_("Not looking at any trace frame.\n"));
1903 /* Report start/stop times if supplied. */
1908 LONGEST run_time = ts->stop_time - ts->start_time;
1910 /* Reporting a run time is more readable than two long numbers. */
1911 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
1912 (long int) (ts->start_time / 1000000),
1913 (long int) (ts->start_time % 1000000),
1914 (long int) (run_time / 1000000),
1915 (long int) (run_time % 1000000));
1918 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
1919 (long int) (ts->start_time / 1000000),
1920 (long int) (ts->start_time % 1000000));
1922 else if (ts->stop_time)
1923 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
1924 (long int) (ts->stop_time / 1000000),
1925 (long int) (ts->stop_time % 1000000));
1927 /* Now report any per-tracepoint status available. */
1928 tp_vec = all_tracepoints ();
1930 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1931 target_get_tracepoint_status (t, NULL);
1933 VEC_free (breakpoint_p, tp_vec);
1936 /* Report the trace status to uiout, in a way suitable for MI, and not
1937 suitable for CLI. If ON_STOP is true, suppress a few fields that
1938 are not meaningful in the -trace-stop response.
1940 The implementation is essentially parallel to trace_status_command, but
1941 merging them will result in unreadable code. */
1943 trace_status_mi (int on_stop)
1945 struct ui_out *uiout = current_uiout;
1946 struct trace_status *ts = current_trace_status ();
1949 status = target_get_trace_status (ts);
1951 if (status == -1 && ts->filename == NULL)
1953 uiout->field_string ("supported", "0");
1957 if (ts->filename != NULL)
1958 uiout->field_string ("supported", "file");
1960 uiout->field_string ("supported", "1");
1962 if (ts->filename != NULL)
1963 uiout->field_string ("trace-file", ts->filename);
1965 gdb_assert (ts->running_known);
1969 uiout->field_string ("running", "1");
1971 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1972 Given that the frontend gets the status either on -trace-stop, or from
1973 -trace-status after re-connection, it does not seem like this
1974 information is necessary for anything. It is not necessary for either
1975 figuring the vital state of the target nor for navigation of trace
1976 frames. If the frontend wants to show the current state is some
1977 configure dialog, it can request the value when such dialog is
1978 invoked by the user. */
1982 const char *stop_reason = NULL;
1983 int stopping_tracepoint = -1;
1986 uiout->field_string ("running", "0");
1988 if (ts->stop_reason != trace_stop_reason_unknown)
1990 switch (ts->stop_reason)
1992 case trace_stop_command:
1993 stop_reason = "request";
1995 case trace_buffer_full:
1996 stop_reason = "overflow";
1998 case trace_disconnected:
1999 stop_reason = "disconnection";
2001 case tracepoint_passcount:
2002 stop_reason = "passcount";
2003 stopping_tracepoint = ts->stopping_tracepoint;
2005 case tracepoint_error:
2006 stop_reason = "error";
2007 stopping_tracepoint = ts->stopping_tracepoint;
2013 uiout->field_string ("stop-reason", stop_reason);
2014 if (stopping_tracepoint != -1)
2015 uiout->field_int ("stopping-tracepoint",
2016 stopping_tracepoint);
2017 if (ts->stop_reason == tracepoint_error)
2018 uiout->field_string ("error-description",
2024 if (ts->traceframe_count != -1)
2025 uiout->field_int ("frames", ts->traceframe_count);
2026 if (ts->traceframes_created != -1)
2027 uiout->field_int ("frames-created", ts->traceframes_created);
2028 if (ts->buffer_size != -1)
2029 uiout->field_int ("buffer-size", ts->buffer_size);
2030 if (ts->buffer_free != -1)
2031 uiout->field_int ("buffer-free", ts->buffer_free);
2033 uiout->field_int ("disconnected", ts->disconnected_tracing);
2034 uiout->field_int ("circular", ts->circular_buffer);
2036 uiout->field_string ("user-name", ts->user_name);
2037 uiout->field_string ("notes", ts->notes);
2042 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2043 (long int) (ts->start_time / 1000000),
2044 (long int) (ts->start_time % 1000000));
2045 uiout->field_string ("start-time", buf);
2046 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2047 (long int) (ts->stop_time / 1000000),
2048 (long int) (ts->stop_time % 1000000));
2049 uiout->field_string ("stop-time", buf);
2053 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2054 user if she really wants to detach. */
2057 query_if_trace_running (int from_tty)
2062 /* It can happen that the target that was tracing went away on its
2063 own, and we didn't notice. Get a status update, and if the
2064 current target doesn't even do tracing, then assume it's not
2066 if (target_get_trace_status (current_trace_status ()) < 0)
2067 current_trace_status ()->running = 0;
2069 /* If running interactively, give the user the option to cancel and
2070 then decide what to do differently with the run. Scripts are
2071 just going to disconnect and let the target deal with it,
2072 according to how it's been instructed previously via
2073 disconnected-tracing. */
2074 if (current_trace_status ()->running)
2076 process_tracepoint_on_disconnect ();
2078 if (current_trace_status ()->disconnected_tracing)
2080 if (!query (_("Trace is running and will "
2081 "continue after detach; detach anyway? ")))
2082 error (_("Not confirmed."));
2086 if (!query (_("Trace is running but will "
2087 "stop on detach; detach anyway? ")))
2088 error (_("Not confirmed."));
2093 /* This function handles the details of what to do about an ongoing
2094 tracing run if the user has asked to detach or otherwise disconnect
2098 disconnect_tracing (void)
2100 /* Also we want to be out of tfind mode, otherwise things can get
2101 confusing upon reconnection. Just use these calls instead of
2102 full tfind_1 behavior because we're in the middle of detaching,
2103 and there's no point to updating current stack frame etc. */
2104 trace_reset_local_state ();
2107 /* Worker function for the various flavors of the tfind command. */
2109 tfind_1 (enum trace_find_type type, int num,
2110 CORE_ADDR addr1, CORE_ADDR addr2,
2113 int target_frameno = -1, target_tracept = -1;
2114 struct frame_id old_frame_id = null_frame_id;
2115 struct tracepoint *tp;
2116 struct ui_out *uiout = current_uiout;
2118 /* Only try to get the current stack frame if we have a chance of
2119 succeeding. In particular, if we're trying to get a first trace
2120 frame while all threads are running, it's not going to succeed,
2121 so leave it with a default value and let the frame comparison
2122 below (correctly) decide to print out the source location of the
2124 if (!(type == tfind_number && num == -1)
2125 && (has_stack_frames () || traceframe_number >= 0))
2126 old_frame_id = get_frame_id (get_current_frame ());
2128 target_frameno = target_trace_find (type, num, addr1, addr2,
2131 if (type == tfind_number
2133 && target_frameno == -1)
2135 /* We told the target to get out of tfind mode, and it did. */
2137 else if (target_frameno == -1)
2139 /* A request for a non-existent trace frame has failed.
2140 Our response will be different, depending on FROM_TTY:
2142 If FROM_TTY is true, meaning that this command was
2143 typed interactively by the user, then give an error
2144 and DO NOT change the state of traceframe_number etc.
2146 However if FROM_TTY is false, meaning that we're either
2147 in a script, a loop, or a user-defined command, then
2148 DON'T give an error, but DO change the state of
2149 traceframe_number etc. to invalid.
2151 The rationalle is that if you typed the command, you
2152 might just have committed a typo or something, and you'd
2153 like to NOT lose your current debugging state. However
2154 if you're in a user-defined command or especially in a
2155 loop, then you need a way to detect that the command
2156 failed WITHOUT aborting. This allows you to write
2157 scripts that search thru the trace buffer until the end,
2158 and then continue on to do something else. */
2161 error (_("Target failed to find requested trace frame."));
2165 printf_filtered ("End of trace buffer.\n");
2166 #if 0 /* dubious now? */
2167 /* The following will not recurse, since it's
2169 tfind_command ("-1", from_tty);
2174 tp = get_tracepoint_by_number_on_target (target_tracept);
2176 reinit_frame_cache ();
2177 target_dcache_invalidate ();
2179 set_tracepoint_num (tp ? tp->number : target_tracept);
2181 if (target_frameno != get_traceframe_number ())
2182 observer_notify_traceframe_changed (target_frameno, tracepoint_number);
2184 set_current_traceframe (target_frameno);
2186 if (target_frameno == -1)
2187 set_traceframe_context (NULL);
2189 set_traceframe_context (get_current_frame ());
2191 if (traceframe_number >= 0)
2193 /* Use different branches for MI and CLI to make CLI messages
2195 if (uiout->is_mi_like_p ())
2197 uiout->field_string ("found", "1");
2198 uiout->field_int ("tracepoint", tracepoint_number);
2199 uiout->field_int ("traceframe", traceframe_number);
2203 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2204 traceframe_number, tracepoint_number);
2209 if (uiout->is_mi_like_p ())
2210 uiout->field_string ("found", "0");
2211 else if (type == tfind_number && num == -1)
2212 printf_unfiltered (_("No longer looking at any trace frame\n"));
2213 else /* This case may never occur, check. */
2214 printf_unfiltered (_("No trace frame found\n"));
2217 /* If we're in nonstop mode and getting out of looking at trace
2218 frames, there won't be any current frame to go back to and
2221 && (has_stack_frames () || traceframe_number >= 0))
2223 enum print_what print_what;
2225 /* NOTE: in imitation of the step command, try to determine
2226 whether we have made a transition from one function to
2227 another. If so, we'll print the "stack frame" (ie. the new
2228 function and it's arguments) -- otherwise we'll just show the
2231 if (frame_id_eq (old_frame_id,
2232 get_frame_id (get_current_frame ())))
2233 print_what = SRC_LINE;
2235 print_what = SRC_AND_LOC;
2237 print_stack_frame (get_selected_frame (NULL), 1, print_what, 1);
2242 /* Error on looking at traceframes while trace is running. */
2245 check_trace_running (struct trace_status *status)
2247 if (status->running && status->filename == NULL)
2248 error (_("May not look at trace frames while trace is running."));
2251 /* trace_find_command takes a trace frame number n,
2252 sends "QTFrame:<n>" to the target,
2253 and accepts a reply that may contain several optional pieces
2254 of information: a frame number, a tracepoint number, and an
2255 indication of whether this is a trap frame or a stepping frame.
2257 The minimal response is just "OK" (which indicates that the
2258 target does not give us a frame number or a tracepoint number).
2259 Instead of that, the target may send us a string containing
2261 F<hexnum> (gives the selected frame number)
2262 T<hexnum> (gives the selected tracepoint number)
2267 tfind_command_1 (const char *args, int from_tty)
2268 { /* This should only be called with a numeric argument. */
2271 check_trace_running (current_trace_status ());
2273 if (args == 0 || *args == 0)
2274 { /* TFIND with no args means find NEXT trace frame. */
2275 if (traceframe_number == -1)
2276 frameno = 0; /* "next" is first one. */
2278 frameno = traceframe_number + 1;
2280 else if (0 == strcmp (args, "-"))
2282 if (traceframe_number == -1)
2283 error (_("not debugging trace buffer"));
2284 else if (from_tty && traceframe_number == 0)
2285 error (_("already at start of trace buffer"));
2287 frameno = traceframe_number - 1;
2289 /* A hack to work around eval's need for fp to have been collected. */
2290 else if (0 == strcmp (args, "-1"))
2293 frameno = parse_and_eval_long (args);
2296 error (_("invalid input (%d is less than zero)"), frameno);
2298 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2302 tfind_command (const char *args, int from_tty)
2304 tfind_command_1 (args, from_tty);
2309 tfind_end_command (const char *args, int from_tty)
2311 tfind_command_1 ("-1", from_tty);
2316 tfind_start_command (const char *args, int from_tty)
2318 tfind_command_1 ("0", from_tty);
2321 /* tfind pc command */
2323 tfind_pc_command (const char *args, int from_tty)
2327 check_trace_running (current_trace_status ());
2329 if (args == 0 || *args == 0)
2330 pc = regcache_read_pc (get_current_regcache ());
2332 pc = parse_and_eval_address (args);
2334 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2337 /* tfind tracepoint command */
2339 tfind_tracepoint_command (const char *args, int from_tty)
2342 struct tracepoint *tp;
2344 check_trace_running (current_trace_status ());
2346 if (args == 0 || *args == 0)
2348 if (tracepoint_number == -1)
2349 error (_("No current tracepoint -- please supply an argument."));
2351 tdp = tracepoint_number; /* Default is current TDP. */
2354 tdp = parse_and_eval_long (args);
2356 /* If we have the tracepoint on hand, use the number that the
2357 target knows about (which may be different if we disconnected
2358 and reconnected). */
2359 tp = get_tracepoint (tdp);
2361 tdp = tp->number_on_target;
2363 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2366 /* TFIND LINE command:
2368 This command will take a sourceline for argument, just like BREAK
2369 or TRACE (ie. anything that "decode_line_1" can handle).
2371 With no argument, this command will find the next trace frame
2372 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2375 tfind_line_command (const char *args, int from_tty)
2377 check_trace_running (current_trace_status ());
2379 symtab_and_line sal;
2380 if (args == 0 || *args == 0)
2382 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2386 std::vector<symtab_and_line> sals
2387 = decode_line_with_current_source (args, DECODE_LINE_FUNFIRSTLINE);
2391 if (sal.symtab == 0)
2392 error (_("No line number information available."));
2394 CORE_ADDR start_pc, end_pc;
2395 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2397 if (start_pc == end_pc)
2399 printf_filtered ("Line %d of \"%s\"",
2401 symtab_to_filename_for_display (sal.symtab));
2403 printf_filtered (" is at address ");
2404 print_address (get_current_arch (), start_pc, gdb_stdout);
2406 printf_filtered (" but contains no code.\n");
2407 sal = find_pc_line (start_pc, 0);
2409 && find_line_pc_range (sal, &start_pc, &end_pc)
2410 && start_pc != end_pc)
2411 printf_filtered ("Attempting to find line %d instead.\n",
2414 error (_("Cannot find a good line."));
2418 /* Is there any case in which we get here, and have an address
2419 which the user would want to see? If we have debugging
2420 symbols and no line numbers? */
2421 error (_("Line number %d is out of range for \"%s\"."),
2422 sal.line, symtab_to_filename_for_display (sal.symtab));
2424 /* Find within range of stated line. */
2426 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2428 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2431 /* tfind range command */
2433 tfind_range_command (const char *args, int from_tty)
2435 static CORE_ADDR start, stop;
2438 check_trace_running (current_trace_status ());
2440 if (args == 0 || *args == 0)
2441 { /* XXX FIXME: what should default behavior be? */
2442 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2446 if (0 != (tmp = strchr (args, ',')))
2448 std::string start_addr (args, tmp);
2450 tmp = skip_spaces (tmp);
2451 start = parse_and_eval_address (start_addr.c_str ());
2452 stop = parse_and_eval_address (tmp);
2455 { /* No explicit end address? */
2456 start = parse_and_eval_address (args);
2457 stop = start + 1; /* ??? */
2460 tfind_1 (tfind_range, 0, start, stop, from_tty);
2463 /* tfind outside command */
2465 tfind_outside_command (const char *args, int from_tty)
2467 CORE_ADDR start, stop;
2470 if (current_trace_status ()->running
2471 && current_trace_status ()->filename == NULL)
2472 error (_("May not look at trace frames while trace is running."));
2474 if (args == 0 || *args == 0)
2475 { /* XXX FIXME: what should default behavior be? */
2476 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2480 if (0 != (tmp = strchr (args, ',')))
2482 std::string start_addr (args, tmp);
2484 tmp = skip_spaces (tmp);
2485 start = parse_and_eval_address (start_addr.c_str ());
2486 stop = parse_and_eval_address (tmp);
2489 { /* No explicit end address? */
2490 start = parse_and_eval_address (args);
2491 stop = start + 1; /* ??? */
2494 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2497 /* info scope command: list the locals for a scope. */
2499 info_scope_command (const char *args_in, int from_tty)
2502 struct bound_minimal_symbol msym;
2503 const struct block *block;
2504 const char *symname;
2505 const char *save_args = args_in;
2506 struct block_iterator iter;
2508 struct gdbarch *gdbarch;
2510 const char *args = args_in;
2512 if (args == 0 || *args == 0)
2513 error (_("requires an argument (function, "
2514 "line or *addr) to define a scope"));
2516 event_location_up location = string_to_event_location (&args,
2518 std::vector<symtab_and_line> sals
2519 = decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE,
2523 /* Presumably decode_line_1 has already warned. */
2527 /* Resolve line numbers to PC. */
2528 resolve_sal_pc (&sals[0]);
2529 block = block_for_pc (sals[0].pc);
2533 QUIT; /* Allow user to bail out with ^C. */
2534 ALL_BLOCK_SYMBOLS (block, iter, sym)
2536 QUIT; /* Allow user to bail out with ^C. */
2538 printf_filtered ("Scope for %s:\n", save_args);
2541 symname = SYMBOL_PRINT_NAME (sym);
2542 if (symname == NULL || *symname == '\0')
2543 continue; /* Probably botched, certainly useless. */
2545 gdbarch = symbol_arch (sym);
2547 printf_filtered ("Symbol %s is ", symname);
2549 if (SYMBOL_COMPUTED_OPS (sym) != NULL)
2550 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2551 BLOCK_START (block),
2555 switch (SYMBOL_CLASS (sym))
2558 case LOC_UNDEF: /* Messed up symbol? */
2559 printf_filtered ("a bogus symbol, class %d.\n",
2560 SYMBOL_CLASS (sym));
2561 count--; /* Don't count this one. */
2564 printf_filtered ("a constant with value %s (%s)",
2565 plongest (SYMBOL_VALUE (sym)),
2566 hex_string (SYMBOL_VALUE (sym)));
2568 case LOC_CONST_BYTES:
2569 printf_filtered ("constant bytes: ");
2570 if (SYMBOL_TYPE (sym))
2571 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2572 fprintf_filtered (gdb_stdout, " %02x",
2573 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2576 printf_filtered ("in static storage at address ");
2577 printf_filtered ("%s", paddress (gdbarch,
2578 SYMBOL_VALUE_ADDRESS (sym)));
2581 /* GDBARCH is the architecture associated with the objfile
2582 the symbol is defined in; the target architecture may be
2583 different, and may provide additional registers. However,
2584 we do not know the target architecture at this point.
2585 We assume the objfile architecture will contain all the
2586 standard registers that occur in debug info in that
2588 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2591 if (SYMBOL_IS_ARGUMENT (sym))
2592 printf_filtered ("an argument in register $%s",
2593 gdbarch_register_name (gdbarch, regno));
2595 printf_filtered ("a local variable in register $%s",
2596 gdbarch_register_name (gdbarch, regno));
2599 printf_filtered ("an argument at stack/frame offset %s",
2600 plongest (SYMBOL_VALUE (sym)));
2603 printf_filtered ("a local variable at frame offset %s",
2604 plongest (SYMBOL_VALUE (sym)));
2607 printf_filtered ("a reference argument at offset %s",
2608 plongest (SYMBOL_VALUE (sym)));
2610 case LOC_REGPARM_ADDR:
2611 /* Note comment at LOC_REGISTER. */
2612 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2614 printf_filtered ("the address of an argument, in register $%s",
2615 gdbarch_register_name (gdbarch, regno));
2618 printf_filtered ("a typedef.\n");
2621 printf_filtered ("a label at address ");
2622 printf_filtered ("%s", paddress (gdbarch,
2623 SYMBOL_VALUE_ADDRESS (sym)));
2626 printf_filtered ("a function at address ");
2627 printf_filtered ("%s",
2628 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2630 case LOC_UNRESOLVED:
2631 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2633 if (msym.minsym == NULL)
2634 printf_filtered ("Unresolved Static");
2637 printf_filtered ("static storage at address ");
2638 printf_filtered ("%s",
2640 BMSYMBOL_VALUE_ADDRESS (msym)));
2643 case LOC_OPTIMIZED_OUT:
2644 printf_filtered ("optimized out.\n");
2647 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2650 if (SYMBOL_TYPE (sym))
2651 printf_filtered (", length %d.\n",
2652 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2654 if (BLOCK_FUNCTION (block))
2657 block = BLOCK_SUPERBLOCK (block);
2660 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2664 /* Helper for trace_dump_command. Dump the action list starting at
2665 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2666 actions of the body of a while-stepping action. STEPPING_FRAME is
2667 set if the current traceframe was determined to be a while-stepping
2671 trace_dump_actions (struct command_line *action,
2672 int stepping_actions, int stepping_frame,
2675 const char *action_exp, *next_comma;
2677 for (; action != NULL; action = action->next)
2679 struct cmd_list_element *cmd;
2681 QUIT; /* Allow user to bail out with ^C. */
2682 action_exp = action->line;
2683 action_exp = skip_spaces (action_exp);
2685 /* The collection actions to be done while stepping are
2686 bracketed by the commands "while-stepping" and "end". */
2688 if (*action_exp == '#') /* comment line */
2691 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2693 error (_("Bad action list item: %s"), action_exp);
2695 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2699 for (i = 0; i < action->body_count; ++i)
2700 trace_dump_actions (action->body_list[i],
2701 1, stepping_frame, from_tty);
2703 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2705 /* Display the collected data.
2706 For the trap frame, display only what was collected at
2707 the trap. Likewise for stepping frames, display only
2708 what was collected while stepping. This means that the
2709 two boolean variables, STEPPING_FRAME and
2710 STEPPING_ACTIONS should be equal. */
2711 if (stepping_frame == stepping_actions)
2714 struct cleanup *old_chain
2715 = make_cleanup (free_current_contents, &cmd);
2716 int trace_string = 0;
2718 if (*action_exp == '/')
2719 action_exp = decode_agent_options (action_exp, &trace_string);
2722 { /* Repeat over a comma-separated list. */
2723 QUIT; /* Allow user to bail out with ^C. */
2724 if (*action_exp == ',')
2726 action_exp = skip_spaces (action_exp);
2728 next_comma = strchr (action_exp, ',');
2730 if (0 == strncasecmp (action_exp, "$reg", 4))
2731 registers_info (NULL, from_tty);
2732 else if (0 == strncasecmp (action_exp, "$_ret", 5))
2734 else if (0 == strncasecmp (action_exp, "$loc", 4))
2735 info_locals_command (NULL, from_tty);
2736 else if (0 == strncasecmp (action_exp, "$arg", 4))
2737 info_args_command (NULL, from_tty);
2740 if (next_comma != NULL)
2742 size_t len = next_comma - action_exp;
2744 cmd = (char *) xrealloc (cmd, len + 1);
2745 memcpy (cmd, action_exp, len);
2750 size_t len = strlen (action_exp);
2752 cmd = (char *) xrealloc (cmd, len + 1);
2753 memcpy (cmd, action_exp, len + 1);
2756 printf_filtered ("%s = ", cmd);
2757 output_command_const (cmd, from_tty);
2758 printf_filtered ("\n");
2760 action_exp = next_comma;
2762 while (action_exp && *action_exp == ',');
2764 do_cleanups (old_chain);
2770 /* Return bp_location of the tracepoint associated with the current
2771 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2772 is a stepping traceframe. */
2774 struct bp_location *
2775 get_traceframe_location (int *stepping_frame_p)
2777 struct tracepoint *t;
2778 struct bp_location *tloc;
2779 struct regcache *regcache;
2781 if (tracepoint_number == -1)
2782 error (_("No current trace frame."));
2784 t = get_tracepoint (tracepoint_number);
2787 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2790 /* The current frame is a trap frame if the frame PC is equal to the
2791 tracepoint PC. If not, then the current frame was collected
2792 during single-stepping. */
2793 regcache = get_current_regcache ();
2795 /* If the traceframe's address matches any of the tracepoint's
2796 locations, assume it is a direct hit rather than a while-stepping
2797 frame. (FIXME this is not reliable, should record each frame's
2799 for (tloc = t->loc; tloc; tloc = tloc->next)
2800 if (tloc->address == regcache_read_pc (regcache))
2802 *stepping_frame_p = 0;
2806 /* If this is a stepping frame, we don't know which location
2807 triggered. The first is as good (or bad) a guess as any... */
2808 *stepping_frame_p = 1;
2812 /* Return all the actions, including default collect, of a tracepoint
2813 T. It constructs cleanups into the chain, and leaves the caller to
2814 handle them (call do_cleanups). */
2816 static struct command_line *
2817 all_tracepoint_actions_and_cleanup (struct breakpoint *t)
2819 struct command_line *actions;
2821 actions = breakpoint_commands (t);
2823 /* If there are default expressions to collect, make up a collect
2824 action and prepend to the action list to encode. Note that since
2825 validation is per-tracepoint (local var "xyz" might be valid for
2826 one tracepoint and not another, etc), we make up the action on
2827 the fly, and don't cache it. */
2828 if (*default_collect)
2830 struct command_line *default_collect_action;
2831 char *default_collect_line;
2833 default_collect_line = xstrprintf ("collect %s", default_collect);
2834 make_cleanup (xfree, default_collect_line);
2836 validate_actionline (default_collect_line, t);
2837 default_collect_action = XNEW (struct command_line);
2838 make_cleanup (xfree, default_collect_action);
2839 default_collect_action->next = actions;
2840 default_collect_action->line = default_collect_line;
2841 actions = default_collect_action;
2847 /* The tdump command. */
2850 tdump_command (const char *args, int from_tty)
2852 int stepping_frame = 0;
2853 struct bp_location *loc;
2854 struct command_line *actions;
2856 /* This throws an error is not inspecting a trace frame. */
2857 loc = get_traceframe_location (&stepping_frame);
2859 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2860 tracepoint_number, traceframe_number);
2862 /* This command only makes sense for the current frame, not the
2864 scoped_restore_current_thread restore_thread;
2866 select_frame (get_current_frame ());
2868 actions = all_tracepoint_actions_and_cleanup (loc->owner);
2870 trace_dump_actions (actions, 0, stepping_frame, from_tty);
2873 /* Encode a piece of a tracepoint's source-level definition in a form
2874 that is suitable for both protocol and saving in files. */
2875 /* This version does not do multiple encodes for long strings; it should
2876 return an offset to the next piece to encode. FIXME */
2879 encode_source_string (int tpnum, ULONGEST addr,
2880 const char *srctype, const char *src,
2881 char *buf, int buf_size)
2883 if (80 + strlen (srctype) > buf_size)
2884 error (_("Buffer too small for source encoding"));
2885 sprintf (buf, "%x:%s:%s:%x:%x:",
2886 tpnum, phex_nz (addr, sizeof (addr)),
2887 srctype, 0, (int) strlen (src));
2888 if (strlen (buf) + strlen (src) * 2 >= buf_size)
2889 error (_("Source string too long for buffer"));
2890 bin2hex ((gdb_byte *) src, buf + strlen (buf), strlen (src));
2894 /* Tell the target what to do with an ongoing tracing run if GDB
2895 disconnects for some reason. */
2898 set_disconnected_tracing (const char *args, int from_tty,
2899 struct cmd_list_element *c)
2901 target_set_disconnected_tracing (disconnected_tracing);
2905 set_circular_trace_buffer (const char *args, int from_tty,
2906 struct cmd_list_element *c)
2908 target_set_circular_trace_buffer (circular_trace_buffer);
2912 set_trace_buffer_size (const char *args, int from_tty,
2913 struct cmd_list_element *c)
2915 target_set_trace_buffer_size (trace_buffer_size);
2919 set_trace_user (const char *args, int from_tty,
2920 struct cmd_list_element *c)
2924 ret = target_set_trace_notes (trace_user, NULL, NULL);
2927 warning (_("Target does not support trace notes, user ignored"));
2931 set_trace_notes (const char *args, int from_tty,
2932 struct cmd_list_element *c)
2936 ret = target_set_trace_notes (NULL, trace_notes, NULL);
2939 warning (_("Target does not support trace notes, note ignored"));
2943 set_trace_stop_notes (const char *args, int from_tty,
2944 struct cmd_list_element *c)
2948 ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
2951 warning (_("Target does not support trace notes, stop note ignored"));
2954 /* Convert the memory pointed to by mem into hex, placing result in buf.
2955 * Return a pointer to the last char put in buf (null)
2956 * "stolen" from sparc-stub.c
2959 static const char hexchars[] = "0123456789abcdef";
2962 mem2hex (gdb_byte *mem, char *buf, int count)
2970 *buf++ = hexchars[ch >> 4];
2971 *buf++ = hexchars[ch & 0xf];
2980 get_traceframe_number (void)
2982 return traceframe_number;
2986 get_tracepoint_number (void)
2988 return tracepoint_number;
2991 /* Make the traceframe NUM be the current trace frame. Does nothing
2992 if NUM is already current. */
2995 set_current_traceframe (int num)
2999 if (traceframe_number == num)
3001 /* Nothing to do. */
3005 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
3008 warning (_("could not change traceframe"));
3010 set_traceframe_num (newnum);
3012 /* Changing the traceframe changes our view of registers and of the
3014 registers_changed ();
3016 clear_traceframe_info ();
3019 /* A cleanup used when switching away and back from tfind mode. */
3021 struct current_traceframe_cleanup
3023 /* The traceframe we were inspecting. */
3024 int traceframe_number;
3028 do_restore_current_traceframe_cleanup (void *arg)
3030 struct current_traceframe_cleanup *old
3031 = (struct current_traceframe_cleanup *) arg;
3033 set_current_traceframe (old->traceframe_number);
3037 restore_current_traceframe_cleanup_dtor (void *arg)
3039 struct current_traceframe_cleanup *old
3040 = (struct current_traceframe_cleanup *) arg;
3046 make_cleanup_restore_current_traceframe (void)
3048 struct current_traceframe_cleanup *old =
3049 XNEW (struct current_traceframe_cleanup);
3051 old->traceframe_number = traceframe_number;
3053 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
3054 restore_current_traceframe_cleanup_dtor);
3057 /* Given a number and address, return an uploaded tracepoint with that
3058 number, creating if necessary. */
3060 struct uploaded_tp *
3061 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
3063 struct uploaded_tp *utp;
3065 for (utp = *utpp; utp; utp = utp->next)
3066 if (utp->number == num && utp->addr == addr)
3069 utp = XCNEW (struct uploaded_tp);
3072 utp->actions = NULL;
3073 utp->step_actions = NULL;
3074 utp->cmd_strings = NULL;
3082 free_uploaded_tps (struct uploaded_tp **utpp)
3084 struct uploaded_tp *next_one;
3088 next_one = (*utpp)->next;
3094 /* Given a number and address, return an uploaded tracepoint with that
3095 number, creating if necessary. */
3097 struct uploaded_tsv *
3098 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3100 struct uploaded_tsv *utsv;
3102 for (utsv = *utsvp; utsv; utsv = utsv->next)
3103 if (utsv->number == num)
3106 utsv = XCNEW (struct uploaded_tsv);
3108 utsv->next = *utsvp;
3115 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3117 struct uploaded_tsv *next_one;
3121 next_one = (*utsvp)->next;
3127 /* FIXME this function is heuristic and will miss the cases where the
3128 conditional is semantically identical but differs in whitespace,
3129 such as "x == 0" vs "x==0". */
3132 cond_string_is_same (char *str1, char *str2)
3134 if (str1 == NULL || str2 == NULL)
3135 return (str1 == str2);
3137 return (strcmp (str1, str2) == 0);
3140 /* Look for an existing tracepoint that seems similar enough to the
3141 uploaded one. Enablement isn't compared, because the user can
3142 toggle that freely, and may have done so in anticipation of the
3143 next trace run. Return the location of matched tracepoint. */
3145 static struct bp_location *
3146 find_matching_tracepoint_location (struct uploaded_tp *utp)
3148 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
3150 struct breakpoint *b;
3151 struct bp_location *loc;
3153 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
3155 struct tracepoint *t = (struct tracepoint *) b;
3157 if (b->type == utp->type
3158 && t->step_count == utp->step
3159 && t->pass_count == utp->pass
3160 && cond_string_is_same (t->cond_string, utp->cond_string)
3161 /* FIXME also test actions. */
3164 /* Scan the locations for an address match. */
3165 for (loc = b->loc; loc; loc = loc->next)
3167 if (loc->address == utp->addr)
3175 /* Given a list of tracepoints uploaded from a target, attempt to
3176 match them up with existing tracepoints, and create new ones if not
3180 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3182 struct uploaded_tp *utp;
3183 /* A set of tracepoints which are modified. */
3184 VEC(breakpoint_p) *modified_tp = NULL;
3186 struct breakpoint *b;
3188 /* Look for GDB tracepoints that match up with our uploaded versions. */
3189 for (utp = *uploaded_tps; utp; utp = utp->next)
3191 struct bp_location *loc;
3192 struct tracepoint *t;
3194 loc = find_matching_tracepoint_location (utp);
3199 /* Mark this location as already inserted. */
3201 t = (struct tracepoint *) loc->owner;
3202 printf_filtered (_("Assuming tracepoint %d is same "
3203 "as target's tracepoint %d at %s.\n"),
3204 loc->owner->number, utp->number,
3205 paddress (loc->gdbarch, utp->addr));
3207 /* The tracepoint LOC->owner was modified (the location LOC
3208 was marked as inserted in the target). Save it in
3209 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3210 observers will be notified later once for each tracepoint
3211 saved in MODIFIED_TP. */
3213 VEC_iterate (breakpoint_p, modified_tp, ix, b);
3215 if (b == loc->owner)
3221 VEC_safe_push (breakpoint_p, modified_tp, loc->owner);
3225 t = create_tracepoint_from_upload (utp);
3227 printf_filtered (_("Created tracepoint %d for "
3228 "target's tracepoint %d at %s.\n"),
3229 t->number, utp->number,
3230 paddress (get_current_arch (), utp->addr));
3232 printf_filtered (_("Failed to create tracepoint for target's "
3233 "tracepoint %d at %s, skipping it.\n"),
3235 paddress (get_current_arch (), utp->addr));
3237 /* Whether found or created, record the number used by the
3238 target, to help with mapping target tracepoints back to their
3239 counterparts here. */
3241 t->number_on_target = utp->number;
3244 /* Notify 'breakpoint-modified' observer that at least one of B's
3245 locations was changed. */
3246 for (ix = 0; VEC_iterate (breakpoint_p, modified_tp, ix, b); ix++)
3247 observer_notify_breakpoint_modified (b);
3249 VEC_free (breakpoint_p, modified_tp);
3250 free_uploaded_tps (uploaded_tps);
3253 /* Trace state variables don't have much to identify them beyond their
3254 name, so just use that to detect matches. */
3256 static struct trace_state_variable *
3257 find_matching_tsv (struct uploaded_tsv *utsv)
3262 return find_trace_state_variable (utsv->name);
3265 static struct trace_state_variable *
3266 create_tsv_from_upload (struct uploaded_tsv *utsv)
3268 const char *namebase;
3271 struct trace_state_variable *tsv;
3272 struct cleanup *old_chain;
3276 namebase = utsv->name;
3282 buf = string_printf ("%s_%d", namebase, try_num++);
3285 /* Fish for a name that is not in use. */
3286 /* (should check against all internal vars?) */
3287 while (find_trace_state_variable (buf.c_str ()))
3288 buf = string_printf ("%s_%d", namebase, try_num++);
3290 /* We have an available name, create the variable. */
3291 tsv = create_trace_state_variable (buf.c_str ());
3292 tsv->initial_value = utsv->initial_value;
3293 tsv->builtin = utsv->builtin;
3295 observer_notify_tsv_created (tsv);
3300 /* Given a list of uploaded trace state variables, try to match them
3301 up with existing variables, or create additional ones. */
3304 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
3307 struct uploaded_tsv *utsv;
3308 struct trace_state_variable *tsv;
3311 /* Most likely some numbers will have to be reassigned as part of
3312 the merge, so clear them all in anticipation. */
3313 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3316 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
3318 tsv = find_matching_tsv (utsv);
3322 printf_filtered (_("Assuming trace state variable $%s "
3323 "is same as target's variable %d.\n"),
3324 tsv->name, utsv->number);
3328 tsv = create_tsv_from_upload (utsv);
3330 printf_filtered (_("Created trace state variable "
3331 "$%s for target's variable %d.\n"),
3332 tsv->name, utsv->number);
3334 /* Give precedence to numberings that come from the target. */
3336 tsv->number = utsv->number;
3339 /* Renumber everything that didn't get a target-assigned number. */
3341 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3342 if (tsv->number > highest)
3343 highest = tsv->number;
3346 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3347 if (tsv->number == 0)
3348 tsv->number = highest++;
3350 free_uploaded_tsvs (uploaded_tsvs);
3353 /* Parse the part of trace status syntax that is shared between
3354 the remote protocol and the trace file reader. */
3357 parse_trace_status (const char *line, struct trace_status *ts)
3359 const char *p = line, *p1, *p2, *p3, *p_temp;
3363 ts->running_known = 1;
3364 ts->running = (*p++ == '1');
3365 ts->stop_reason = trace_stop_reason_unknown;
3366 xfree (ts->stop_desc);
3367 ts->stop_desc = NULL;
3368 ts->traceframe_count = -1;
3369 ts->traceframes_created = -1;
3370 ts->buffer_free = -1;
3371 ts->buffer_size = -1;
3372 ts->disconnected_tracing = 0;
3373 ts->circular_buffer = 0;
3374 xfree (ts->user_name);
3375 ts->user_name = NULL;
3378 ts->start_time = ts->stop_time = 0;
3382 p1 = strchr (p, ':');
3384 error (_("Malformed trace status, at %s\n\
3385 Status line: '%s'\n"), p, line);
3386 p3 = strchr (p, ';');
3388 p3 = p + strlen (p);
3389 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3391 p = unpack_varlen_hex (++p1, &val);
3392 ts->stop_reason = trace_buffer_full;
3394 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3396 p = unpack_varlen_hex (++p1, &val);
3397 ts->stop_reason = trace_never_run;
3399 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
3402 p = unpack_varlen_hex (++p1, &val);
3403 ts->stop_reason = tracepoint_passcount;
3404 ts->stopping_tracepoint = val;
3406 else if (strncmp (p, stop_reason_names[trace_stop_command], p1 - p) == 0)
3408 p2 = strchr (++p1, ':');
3416 ts->stop_desc = (char *) xmalloc (strlen (line));
3417 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
3418 ts->stop_desc[end] = '\0';
3421 ts->stop_desc = xstrdup ("");
3423 p = unpack_varlen_hex (++p2, &val);
3424 ts->stop_reason = trace_stop_command;
3426 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3428 p = unpack_varlen_hex (++p1, &val);
3429 ts->stop_reason = trace_disconnected;
3431 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3433 p2 = strchr (++p1, ':');
3436 ts->stop_desc = (char *) xmalloc ((p2 - p1) / 2 + 1);
3437 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
3438 ts->stop_desc[end] = '\0';
3441 ts->stop_desc = xstrdup ("");
3443 p = unpack_varlen_hex (++p2, &val);
3444 ts->stopping_tracepoint = val;
3445 ts->stop_reason = tracepoint_error;
3447 else if (strncmp (p, "tframes", p1 - p) == 0)
3449 p = unpack_varlen_hex (++p1, &val);
3450 ts->traceframe_count = val;
3452 else if (strncmp (p, "tcreated", p1 - p) == 0)
3454 p = unpack_varlen_hex (++p1, &val);
3455 ts->traceframes_created = val;
3457 else if (strncmp (p, "tfree", p1 - p) == 0)
3459 p = unpack_varlen_hex (++p1, &val);
3460 ts->buffer_free = val;
3462 else if (strncmp (p, "tsize", p1 - p) == 0)
3464 p = unpack_varlen_hex (++p1, &val);
3465 ts->buffer_size = val;
3467 else if (strncmp (p, "disconn", p1 - p) == 0)
3469 p = unpack_varlen_hex (++p1, &val);
3470 ts->disconnected_tracing = val;
3472 else if (strncmp (p, "circular", p1 - p) == 0)
3474 p = unpack_varlen_hex (++p1, &val);
3475 ts->circular_buffer = val;
3477 else if (strncmp (p, "starttime", p1 - p) == 0)
3479 p = unpack_varlen_hex (++p1, &val);
3480 ts->start_time = val;
3482 else if (strncmp (p, "stoptime", p1 - p) == 0)
3484 p = unpack_varlen_hex (++p1, &val);
3485 ts->stop_time = val;
3487 else if (strncmp (p, "username", p1 - p) == 0)
3490 ts->user_name = (char *) xmalloc (strlen (p) / 2);
3491 end = hex2bin (p1, (gdb_byte *) ts->user_name, (p3 - p1) / 2);
3492 ts->user_name[end] = '\0';
3495 else if (strncmp (p, "notes", p1 - p) == 0)
3498 ts->notes = (char *) xmalloc (strlen (p) / 2);
3499 end = hex2bin (p1, (gdb_byte *) ts->notes, (p3 - p1) / 2);
3500 ts->notes[end] = '\0';
3505 /* Silently skip unknown optional info. */
3506 p_temp = strchr (p1 + 1, ';');
3510 /* Must be at the end. */
3517 parse_tracepoint_status (const char *p, struct breakpoint *bp,
3518 struct uploaded_tp *utp)
3521 struct tracepoint *tp = (struct tracepoint *) bp;
3523 p = unpack_varlen_hex (p, &uval);
3525 tp->hit_count += uval;
3527 utp->hit_count += uval;
3528 p = unpack_varlen_hex (p + 1, &uval);
3530 tp->traceframe_usage += uval;
3532 utp->traceframe_usage += uval;
3533 /* Ignore any extra, allowing for future extensions. */
3536 /* Given a line of text defining a part of a tracepoint, parse it into
3537 an "uploaded tracepoint". */
3540 parse_tracepoint_definition (const char *line, struct uploaded_tp **utpp)
3544 ULONGEST num, addr, step, pass, orig_size, xlen, start;
3547 const char *srctype;
3549 struct uploaded_tp *utp = NULL;
3552 /* Both tracepoint and action definitions start with the same number
3553 and address sequence. */
3555 p = unpack_varlen_hex (p, &num);
3556 p++; /* skip a colon */
3557 p = unpack_varlen_hex (p, &addr);
3558 p++; /* skip a colon */
3561 enabled = (*p++ == 'E');
3562 p++; /* skip a colon */
3563 p = unpack_varlen_hex (p, &step);
3564 p++; /* skip a colon */
3565 p = unpack_varlen_hex (p, &pass);
3566 type = bp_tracepoint;
3568 /* Thumb through optional fields. */
3571 p++; /* skip a colon */
3574 type = bp_fast_tracepoint;
3576 p = unpack_varlen_hex (p, &orig_size);
3580 type = bp_static_tracepoint;
3586 p = unpack_varlen_hex (p, &xlen);
3587 p++; /* skip a comma */
3588 cond = (char *) xmalloc (2 * xlen + 1);
3589 strncpy (cond, p, 2 * xlen);
3590 cond[2 * xlen] = '\0';
3594 warning (_("Unrecognized char '%c' in tracepoint "
3595 "definition, skipping rest"), *p);
3597 utp = get_uploaded_tp (num, addr, utpp);
3599 utp->enabled = enabled;
3604 else if (piece == 'A')
3606 utp = get_uploaded_tp (num, addr, utpp);
3607 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
3609 else if (piece == 'S')
3611 utp = get_uploaded_tp (num, addr, utpp);
3612 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
3614 else if (piece == 'Z')
3616 /* Parse a chunk of source form definition. */
3617 utp = get_uploaded_tp (num, addr, utpp);
3619 p = strchr (p, ':');
3620 p++; /* skip a colon */
3621 p = unpack_varlen_hex (p, &start);
3622 p++; /* skip a colon */
3623 p = unpack_varlen_hex (p, &xlen);
3624 p++; /* skip a colon */
3626 buf = (char *) alloca (strlen (line));
3628 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3631 if (startswith (srctype, "at:"))
3632 utp->at_string = xstrdup (buf);
3633 else if (startswith (srctype, "cond:"))
3634 utp->cond_string = xstrdup (buf);
3635 else if (startswith (srctype, "cmd:"))
3636 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
3638 else if (piece == 'V')
3640 utp = get_uploaded_tp (num, addr, utpp);
3642 parse_tracepoint_status (p, NULL, utp);
3646 /* Don't error out, the target might be sending us optional
3647 info that we don't care about. */
3648 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
3652 /* Convert a textual description of a trace state variable into an
3656 parse_tsv_definition (const char *line, struct uploaded_tsv **utsvp)
3660 ULONGEST num, initval, builtin;
3662 struct uploaded_tsv *utsv = NULL;
3664 buf = (char *) alloca (strlen (line));
3667 p = unpack_varlen_hex (p, &num);
3668 p++; /* skip a colon */
3669 p = unpack_varlen_hex (p, &initval);
3670 p++; /* skip a colon */
3671 p = unpack_varlen_hex (p, &builtin);
3672 p++; /* skip a colon */
3673 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3676 utsv = get_uploaded_tsv (num, utsvp);
3677 utsv->initial_value = initval;
3678 utsv->builtin = builtin;
3679 utsv->name = xstrdup (buf);
3683 free_current_marker (void *arg)
3685 struct static_tracepoint_marker **marker_p
3686 = (struct static_tracepoint_marker **) arg;
3688 if (*marker_p != NULL)
3690 release_static_tracepoint_marker (*marker_p);
3697 /* Given a line of text defining a static tracepoint marker, parse it
3698 into a "static tracepoint marker" object. Throws an error is
3699 parsing fails. If PP is non-null, it points to one past the end of
3700 the parsed marker definition. */
3703 parse_static_tracepoint_marker_definition (const char *line, const char **pp,
3704 struct static_tracepoint_marker *marker)
3706 const char *p, *endp;
3711 p = unpack_varlen_hex (p, &addr);
3712 p++; /* skip a colon */
3714 marker->gdbarch = target_gdbarch ();
3715 marker->address = (CORE_ADDR) addr;
3717 endp = strchr (p, ':');
3719 error (_("bad marker definition: %s"), line);
3721 marker->str_id = (char *) xmalloc (endp - p + 1);
3722 end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
3723 marker->str_id[end] = '\0';
3726 p++; /* skip a colon */
3728 marker->extra = (char *) xmalloc (strlen (p) + 1);
3729 end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
3730 marker->extra[end] = '\0';
3736 /* Release a static tracepoint marker's contents. Note that the
3737 object itself isn't released here. There objects are usually on
3741 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
3743 xfree (marker->str_id);
3744 marker->str_id = NULL;
3747 /* Print MARKER to gdb_stdout. */
3750 print_one_static_tracepoint_marker (int count,
3751 struct static_tracepoint_marker *marker)
3755 char wrap_indent[80];
3756 char extra_field_indent[80];
3757 struct ui_out *uiout = current_uiout;
3758 VEC(breakpoint_p) *tracepoints;
3760 symtab_and_line sal;
3761 sal.pc = marker->address;
3763 tracepoints = static_tracepoints_here (marker->address);
3765 ui_out_emit_tuple tuple_emitter (uiout, "marker");
3767 /* A counter field to help readability. This is not a stable
3769 uiout->field_int ("count", count);
3771 uiout->field_string ("marker-id", marker->str_id);
3773 uiout->field_fmt ("enabled", "%c",
3774 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
3777 strcpy (wrap_indent, " ");
3779 if (gdbarch_addr_bit (marker->gdbarch) <= 32)
3780 strcat (wrap_indent, " ");
3782 strcat (wrap_indent, " ");
3784 strcpy (extra_field_indent, " ");
3786 uiout->field_core_addr ("addr", marker->gdbarch, marker->address);
3788 sal = find_pc_line (marker->address, 0);
3789 sym = find_pc_sect_function (marker->address, NULL);
3792 uiout->text ("in ");
3793 uiout->field_string ("func",
3794 SYMBOL_PRINT_NAME (sym));
3795 uiout->wrap_hint (wrap_indent);
3796 uiout->text (" at ");
3799 uiout->field_skip ("func");
3801 if (sal.symtab != NULL)
3803 uiout->field_string ("file",
3804 symtab_to_filename_for_display (sal.symtab));
3807 if (uiout->is_mi_like_p ())
3809 const char *fullname = symtab_to_fullname (sal.symtab);
3811 uiout->field_string ("fullname", fullname);
3814 uiout->field_skip ("fullname");
3816 uiout->field_int ("line", sal.line);
3820 uiout->field_skip ("fullname");
3821 uiout->field_skip ("line");
3825 uiout->text (extra_field_indent);
3826 uiout->text (_("Data: \""));
3827 uiout->field_string ("extra-data", marker->extra);
3828 uiout->text ("\"\n");
3830 if (!VEC_empty (breakpoint_p, tracepoints))
3833 struct breakpoint *b;
3836 ui_out_emit_tuple tuple_emitter (uiout, "tracepoints-at");
3838 uiout->text (extra_field_indent);
3839 uiout->text (_("Probed by static tracepoints: "));
3840 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
3845 uiout->field_int ("tracepoint-id", b->number);
3849 if (uiout->is_mi_like_p ())
3850 uiout->field_int ("number-of-tracepoints",
3851 VEC_length(breakpoint_p, tracepoints));
3855 VEC_free (breakpoint_p, tracepoints);
3859 info_static_tracepoint_markers_command (const char *arg, int from_tty)
3861 VEC(static_tracepoint_marker_p) *markers;
3862 struct cleanup *old_chain;
3863 struct static_tracepoint_marker *marker;
3864 struct ui_out *uiout = current_uiout;
3867 /* We don't have to check target_can_use_agent and agent's capability on
3868 static tracepoint here, in order to be compatible with older GDBserver.
3869 We don't check USE_AGENT is true or not, because static tracepoints
3870 don't work without in-process agent, so we don't bother users to type
3871 `set agent on' when to use static tracepoint. */
3873 ui_out_emit_table table_emitter (uiout, 5, -1,
3874 "StaticTracepointMarkersTable");
3876 uiout->table_header (7, ui_left, "counter", "Cnt");
3878 uiout->table_header (40, ui_left, "marker-id", "ID");
3880 uiout->table_header (3, ui_left, "enabled", "Enb");
3881 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
3882 uiout->table_header (10, ui_left, "addr", "Address");
3884 uiout->table_header (18, ui_left, "addr", "Address");
3885 uiout->table_header (40, ui_noalign, "what", "What");
3887 uiout->table_body ();
3889 markers = target_static_tracepoint_markers_by_strid (NULL);
3890 old_chain = make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
3893 VEC_iterate (static_tracepoint_marker_p,
3894 markers, i, marker);
3897 print_one_static_tracepoint_marker (i + 1, marker);
3898 release_static_tracepoint_marker (marker);
3901 do_cleanups (old_chain);
3904 /* The $_sdata convenience variable is a bit special. We don't know
3905 for sure type of the value until we actually have a chance to fetch
3906 the data --- the size of the object depends on what has been
3907 collected. We solve this by making $_sdata be an internalvar that
3908 creates a new value on access. */
3910 /* Return a new value with the correct type for the sdata object of
3911 the current trace frame. Return a void value if there's no object
3914 static struct value *
3915 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
3921 /* We need to read the whole object before we know its size. */
3922 size = target_read_alloc (¤t_target,
3923 TARGET_OBJECT_STATIC_TRACE_DATA,
3930 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
3932 v = allocate_value (type);
3933 memcpy (value_contents_raw (v), buf, size);
3938 return allocate_value (builtin_type (gdbarch)->builtin_void);
3941 #if !defined(HAVE_LIBEXPAT)
3943 struct std::unique_ptr<traceframe_info>
3944 parse_traceframe_info (const char *tframe_info)
3946 static int have_warned;
3951 warning (_("Can not parse XML trace frame info; XML support "
3952 "was disabled at compile time"));
3958 #else /* HAVE_LIBEXPAT */
3960 #include "xml-support.h"
3962 /* Handle the start of a <memory> element. */
3965 traceframe_info_start_memory (struct gdb_xml_parser *parser,
3966 const struct gdb_xml_element *element,
3967 void *user_data, VEC(gdb_xml_value_s) *attributes)
3969 struct traceframe_info *info = (struct traceframe_info *) user_data;
3970 ULONGEST *start_p, *length_p;
3973 = (ULONGEST *) xml_find_attribute (attributes, "start")->value;
3975 = (ULONGEST *) xml_find_attribute (attributes, "length")->value;
3977 info->memory.emplace_back (*start_p, *length_p);
3980 /* Handle the start of a <tvar> element. */
3983 traceframe_info_start_tvar (struct gdb_xml_parser *parser,
3984 const struct gdb_xml_element *element,
3986 VEC(gdb_xml_value_s) *attributes)
3988 struct traceframe_info *info = (struct traceframe_info *) user_data;
3989 const char *id_attrib
3990 = (const char *) xml_find_attribute (attributes, "id")->value;
3991 int id = gdb_xml_parse_ulongest (parser, id_attrib);
3993 info->tvars.push_back (id);
3996 /* The allowed elements and attributes for an XML memory map. */
3998 static const struct gdb_xml_attribute memory_attributes[] = {
3999 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4000 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4001 { NULL, GDB_XML_AF_NONE, NULL, NULL }
4004 static const struct gdb_xml_attribute tvar_attributes[] = {
4005 { "id", GDB_XML_AF_NONE, NULL, NULL },
4006 { NULL, GDB_XML_AF_NONE, NULL, NULL }
4009 static const struct gdb_xml_element traceframe_info_children[] = {
4010 { "memory", memory_attributes, NULL,
4011 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
4012 traceframe_info_start_memory, NULL },
4013 { "tvar", tvar_attributes, NULL,
4014 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
4015 traceframe_info_start_tvar, NULL },
4016 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4019 static const struct gdb_xml_element traceframe_info_elements[] = {
4020 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
4022 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4025 /* Parse a traceframe-info XML document. */
4028 parse_traceframe_info (const char *tframe_info)
4030 traceframe_info_up result (new traceframe_info);
4032 if (gdb_xml_parse_quick (_("trace frame info"),
4033 "traceframe-info.dtd", traceframe_info_elements,
4034 tframe_info, result.get ()) == 0)
4040 #endif /* HAVE_LIBEXPAT */
4042 /* Returns the traceframe_info object for the current traceframe.
4043 This is where we avoid re-fetching the object from the target if we
4044 already have it cached. */
4046 struct traceframe_info *
4047 get_traceframe_info (void)
4049 if (current_traceframe_info == NULL)
4050 current_traceframe_info = target_traceframe_info ();
4052 return current_traceframe_info.get ();
4055 /* If the target supports the query, return in RESULT the set of
4056 collected memory in the current traceframe, found within the LEN
4057 bytes range starting at MEMADDR. Returns true if the target
4058 supports the query, otherwise returns false, and RESULT is left
4062 traceframe_available_memory (std::vector<mem_range> *result,
4063 CORE_ADDR memaddr, ULONGEST len)
4065 struct traceframe_info *info = get_traceframe_info ();
4071 for (mem_range &r : info->memory)
4072 if (mem_ranges_overlap (r.start, r.length, memaddr, len))
4074 ULONGEST lo1, hi1, lo2, hi2;
4077 hi1 = memaddr + len;
4080 hi2 = r.start + r.length;
4082 CORE_ADDR start = std::max (lo1, lo2);
4083 int length = std::min (hi1, hi2) - start;
4085 result->emplace_back (start, length);
4088 normalize_mem_ranges (result);
4095 /* Implementation of `sdata' variable. */
4097 static const struct internalvar_funcs sdata_funcs =
4104 /* module initialization */
4106 _initialize_tracepoint (void)
4108 struct cmd_list_element *c;
4110 /* Explicitly create without lookup, since that tries to create a
4111 value with a void typed value, and when we get here, gdbarch
4112 isn't initialized yet. At this point, we're quite sure there
4113 isn't another convenience variable of the same name. */
4114 create_internalvar_type_lazy ("_sdata", &sdata_funcs, NULL);
4116 traceframe_number = -1;
4117 tracepoint_number = -1;
4119 add_info ("scope", info_scope_command,
4120 _("List the variables local to a scope"));
4122 add_cmd ("tracepoints", class_trace,
4123 _("Tracing of program execution without stopping the program."),
4126 add_com ("tdump", class_trace, tdump_command,
4127 _("Print everything collected at the current tracepoint."));
4129 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
4130 Define a trace state variable.\n\
4131 Argument is a $-prefixed name, optionally followed\n\
4132 by '=' and an expression that sets the initial value\n\
4133 at the start of tracing."));
4134 set_cmd_completer (c, expression_completer);
4136 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
4137 Delete one or more trace state variables.\n\
4138 Arguments are the names of the variables to delete.\n\
4139 If no arguments are supplied, delete all variables."), &deletelist);
4140 /* FIXME add a trace variable completer. */
4142 add_info ("tvariables", info_tvariables_command, _("\
4143 Status of trace state variables and their values.\n\
4146 add_info ("static-tracepoint-markers",
4147 info_static_tracepoint_markers_command, _("\
4148 List target static tracepoints markers.\n\
4151 add_prefix_cmd ("tfind", class_trace, tfind_command, _("\
4152 Select a trace frame;\n\
4153 No argument means forward by one frame; '-' means backward by one frame."),
4154 &tfindlist, "tfind ", 1, &cmdlist);
4156 add_cmd ("outside", class_trace, tfind_outside_command, _("\
4157 Select a trace frame whose PC is outside the given range (exclusive).\n\
4158 Usage: tfind outside addr1, addr2"),
4161 add_cmd ("range", class_trace, tfind_range_command, _("\
4162 Select a trace frame whose PC is in the given range (inclusive).\n\
4163 Usage: tfind range addr1,addr2"),
4166 add_cmd ("line", class_trace, tfind_line_command, _("\
4167 Select a trace frame by source line.\n\
4168 Argument can be a line number (with optional source file),\n\
4169 a function name, or '*' followed by an address.\n\
4170 Default argument is 'the next source line that was traced'."),
4173 add_cmd ("tracepoint", class_trace, tfind_tracepoint_command, _("\
4174 Select a trace frame by tracepoint number.\n\
4175 Default is the tracepoint for the current trace frame."),
4178 add_cmd ("pc", class_trace, tfind_pc_command, _("\
4179 Select a trace frame by PC.\n\
4180 Default is the current PC, or the PC of the current trace frame."),
4183 add_cmd ("end", class_trace, tfind_end_command, _("\
4184 De-select any trace frame and resume 'live' debugging."),
4187 add_alias_cmd ("none", "end", class_trace, 0, &tfindlist);
4189 add_cmd ("start", class_trace, tfind_start_command,
4190 _("Select the first trace frame in the trace buffer."),
4193 add_com ("tstatus", class_trace, tstatus_command,
4194 _("Display the status of the current trace data collection."));
4196 add_com ("tstop", class_trace, tstop_command, _("\
4197 Stop trace data collection.\n\
4198 Usage: tstop [ <notes> ... ]\n\
4199 Any arguments supplied are recorded with the trace as a stop reason and\n\
4200 reported by tstatus (if the target supports trace notes)."));
4202 add_com ("tstart", class_trace, tstart_command, _("\
4203 Start trace data collection.\n\
4204 Usage: tstart [ <notes> ... ]\n\
4205 Any arguments supplied are recorded with the trace as a note and\n\
4206 reported by tstatus (if the target supports trace notes)."));
4208 add_com ("end", class_trace, end_actions_pseudocommand, _("\
4209 Ends a list of commands or actions.\n\
4210 Several GDB commands allow you to enter a list of commands or actions.\n\
4211 Entering \"end\" on a line by itself is the normal way to terminate\n\
4213 Note: the \"end\" command cannot be used at the gdb prompt."));
4215 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
4216 Specify single-stepping behavior at a tracepoint.\n\
4217 Argument is number of instructions to trace in single-step mode\n\
4218 following the tracepoint. This command is normally followed by\n\
4219 one or more \"collect\" commands, to specify what to collect\n\
4220 while single-stepping.\n\n\
4221 Note: this command can only be used in a tracepoint \"actions\" list."));
4223 add_com_alias ("ws", "while-stepping", class_alias, 0);
4224 add_com_alias ("stepping", "while-stepping", class_alias, 0);
4226 add_com ("collect", class_trace, collect_pseudocommand, _("\
4227 Specify one or more data items to be collected at a tracepoint.\n\
4228 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4229 collect all data (variables, registers) referenced by that expression.\n\
4230 Also accepts the following special arguments:\n\
4231 $regs -- all registers.\n\
4232 $args -- all function arguments.\n\
4233 $locals -- all variables local to the block/function scope.\n\
4234 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4235 Note: this command can only be used in a tracepoint \"actions\" list."));
4237 add_com ("teval", class_trace, teval_pseudocommand, _("\
4238 Specify one or more expressions to be evaluated at a tracepoint.\n\
4239 Accepts a comma-separated list of (one or more) expressions.\n\
4240 The result of each evaluation will be discarded.\n\
4241 Note: this command can only be used in a tracepoint \"actions\" list."));
4243 add_com ("actions", class_trace, actions_command, _("\
4244 Specify the actions to be taken at a tracepoint.\n\
4245 Tracepoint actions may include collecting of specified data,\n\
4246 single-stepping, or enabling/disabling other tracepoints,\n\
4247 depending on target's capabilities."));
4249 default_collect = xstrdup ("");
4250 add_setshow_string_cmd ("default-collect", class_trace,
4251 &default_collect, _("\
4252 Set the list of expressions to collect by default"), _("\
4253 Show the list of expressions to collect by default"), NULL,
4255 &setlist, &showlist);
4257 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
4258 &disconnected_tracing, _("\
4259 Set whether tracing continues after GDB disconnects."), _("\
4260 Show whether tracing continues after GDB disconnects."), _("\
4261 Use this to continue a tracing run even if GDB disconnects\n\
4262 or detaches from the target. You can reconnect later and look at\n\
4263 trace data collected in the meantime."),
4264 set_disconnected_tracing,
4269 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
4270 &circular_trace_buffer, _("\
4271 Set target's use of circular trace buffer."), _("\
4272 Show target's use of circular trace buffer."), _("\
4273 Use this to make the trace buffer into a circular buffer,\n\
4274 which will discard traceframes (oldest first) instead of filling\n\
4275 up and stopping the trace run."),
4276 set_circular_trace_buffer,
4281 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class,
4282 &trace_buffer_size, _("\
4283 Set requested size of trace buffer."), _("\
4284 Show requested size of trace buffer."), _("\
4285 Use this to choose a size for the trace buffer. Some targets\n\
4286 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
4287 disables any attempt to set the buffer size and lets the target choose."),
4288 set_trace_buffer_size, NULL,
4289 &setlist, &showlist);
4291 add_setshow_string_cmd ("trace-user", class_trace,
4293 Set the user name to use for current and future trace runs"), _("\
4294 Show the user name to use for current and future trace runs"), NULL,
4295 set_trace_user, NULL,
4296 &setlist, &showlist);
4298 add_setshow_string_cmd ("trace-notes", class_trace,
4300 Set notes string to use for current and future trace runs"), _("\
4301 Show the notes string to use for current and future trace runs"), NULL,
4302 set_trace_notes, NULL,
4303 &setlist, &showlist);
4305 add_setshow_string_cmd ("trace-stop-notes", class_trace,
4306 &trace_stop_notes, _("\
4307 Set notes string to use for future tstop commands"), _("\
4308 Show the notes string to use for future tstop commands"), NULL,
4309 set_trace_stop_notes, NULL,
4310 &setlist, &showlist);