1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
25 #include "expression.h"
29 #include "target-dcache.h"
32 #include "breakpoint.h"
33 #include "tracepoint.h"
36 #include "completer.h"
38 #include "dictionary.h"
40 #include "user-regs.h"
44 #include "filenames.h"
45 #include "gdbthread.h"
52 #include "cli/cli-utils.h"
55 #include "filestuff.h"
57 #include "tracefile.h"
61 /* readline include files */
62 #include "readline/readline.h"
63 #include "readline/history.h"
65 /* readline defines this. */
70 /* Maximum length of an agent aexpression.
71 This accounts for the fact that packets are limited to 400 bytes
72 (which includes everything -- including the checksum), and assumes
73 the worst case of maximum length for each of the pieces of a
76 NOTE: expressions get mem2hex'ed otherwise this would be twice as
77 large. (400 - 31)/2 == 184 */
78 #define MAX_AGENT_EXPR_LEN 184
80 /* A hook used to notify the UI of tracepoint operations. */
82 void (*deprecated_trace_find_hook) (char *arg, int from_tty);
83 void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
88 This module defines the following debugger commands:
89 trace : set a tracepoint on a function, line, or address.
90 info trace : list all debugger-defined tracepoints.
91 delete trace : delete one or more tracepoints.
92 enable trace : enable one or more tracepoints.
93 disable trace : disable one or more tracepoints.
94 actions : specify actions to be taken at a tracepoint.
95 passcount : specify a pass count for a tracepoint.
96 tstart : start a trace experiment.
97 tstop : stop a trace experiment.
98 tstatus : query the status of a trace experiment.
99 tfind : find a trace frame in the trace buffer.
100 tdump : print everything collected at the current tracepoint.
101 save-tracepoints : write tracepoint setup into a file.
103 This module defines the following user-visible debugger variables:
104 $trace_frame : sequence number of trace frame currently being debugged.
105 $trace_line : source line of trace frame currently being debugged.
106 $trace_file : source file of trace frame currently being debugged.
107 $tracepoint : tracepoint number of trace frame currently being debugged.
111 /* ======= Important global variables: ======= */
113 /* The list of all trace state variables. We don't retain pointers to
114 any of these for any reason - API is by name or number only - so it
115 works to have a vector of objects. */
117 typedef struct trace_state_variable tsv_s;
120 static VEC(tsv_s) *tvariables;
122 /* The next integer to assign to a variable. */
124 static int next_tsv_number = 1;
126 /* Number of last traceframe collected. */
127 static int traceframe_number;
129 /* Tracepoint for last traceframe collected. */
130 static int tracepoint_number;
132 /* The traceframe info of the current traceframe. NULL if we haven't
133 yet attempted to fetch it, or if the target does not support
134 fetching this object, or if we're not inspecting a traceframe
136 static struct traceframe_info *traceframe_info;
138 /* Tracing command lists. */
139 static struct cmd_list_element *tfindlist;
141 /* List of expressions to collect by default at each tracepoint hit. */
142 char *default_collect;
144 static int disconnected_tracing;
146 /* This variable controls whether we ask the target for a linear or
147 circular trace buffer. */
149 static int circular_trace_buffer;
151 /* This variable is the requested trace buffer size, or -1 to indicate
152 that we don't care and leave it up to the target to set a size. */
154 static int trace_buffer_size = -1;
156 /* Textual notes applying to the current and/or future trace runs. */
158 char *trace_user = NULL;
160 /* Textual notes applying to the current and/or future trace runs. */
162 char *trace_notes = NULL;
164 /* Textual notes applying to the stopping of a trace. */
166 char *trace_stop_notes = NULL;
168 /* ======= Important command functions: ======= */
169 static void actions_command (char *, int);
170 static void tstart_command (char *, int);
171 static void tstop_command (char *, int);
172 static void tstatus_command (char *, int);
173 static void tfind_pc_command (char *, int);
174 static void tfind_tracepoint_command (char *, int);
175 static void tfind_line_command (char *, int);
176 static void tfind_range_command (char *, int);
177 static void tfind_outside_command (char *, int);
178 static void tdump_command (char *, int);
180 /* support routines */
182 struct collection_list;
183 static char *mem2hex (gdb_byte *, char *, int);
185 static struct command_line *
186 all_tracepoint_actions_and_cleanup (struct breakpoint *t);
188 static struct trace_status trace_status;
190 const char *stop_reason_names[] = {
200 struct trace_status *
201 current_trace_status (void)
203 return &trace_status;
209 free_traceframe_info (struct traceframe_info *info)
213 VEC_free (mem_range_s, info->memory);
214 VEC_free (int, info->tvars);
220 /* Free and clear the traceframe info cache of the current
224 clear_traceframe_info (void)
226 free_traceframe_info (traceframe_info);
227 traceframe_info = NULL;
230 /* Set traceframe number to NUM. */
232 set_traceframe_num (int num)
234 traceframe_number = num;
235 set_internalvar_integer (lookup_internalvar ("trace_frame"), num);
238 /* Set tracepoint number to NUM. */
240 set_tracepoint_num (int num)
242 tracepoint_number = num;
243 set_internalvar_integer (lookup_internalvar ("tracepoint"), num);
246 /* Set externally visible debug variables for querying/printing
247 the traceframe context (line, function, file). */
250 set_traceframe_context (struct frame_info *trace_frame)
253 struct symbol *traceframe_fun;
254 symtab_and_line traceframe_sal;
256 /* Save as globals for internal use. */
257 if (trace_frame != NULL
258 && get_frame_pc_if_available (trace_frame, &trace_pc))
260 traceframe_sal = find_pc_line (trace_pc, 0);
261 traceframe_fun = find_pc_function (trace_pc);
263 /* Save linenumber as "$trace_line", a debugger variable visible to
265 set_internalvar_integer (lookup_internalvar ("trace_line"),
266 traceframe_sal.line);
270 traceframe_fun = NULL;
271 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
274 /* Save func name as "$trace_func", a debugger variable visible to
276 if (traceframe_fun == NULL
277 || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
278 clear_internalvar (lookup_internalvar ("trace_func"));
280 set_internalvar_string (lookup_internalvar ("trace_func"),
281 SYMBOL_LINKAGE_NAME (traceframe_fun));
283 /* Save file name as "$trace_file", a debugger variable visible to
285 if (traceframe_sal.symtab == NULL)
286 clear_internalvar (lookup_internalvar ("trace_file"));
288 set_internalvar_string (lookup_internalvar ("trace_file"),
289 symtab_to_filename_for_display (traceframe_sal.symtab));
292 /* Create a new trace state variable with the given name. */
294 struct trace_state_variable *
295 create_trace_state_variable (const char *name)
297 struct trace_state_variable tsv;
299 memset (&tsv, 0, sizeof (tsv));
300 tsv.name = xstrdup (name);
301 tsv.number = next_tsv_number++;
302 return VEC_safe_push (tsv_s, tvariables, &tsv);
305 /* Look for a trace state variable of the given name. */
307 struct trace_state_variable *
308 find_trace_state_variable (const char *name)
310 struct trace_state_variable *tsv;
313 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
314 if (strcmp (name, tsv->name) == 0)
320 /* Look for a trace state variable of the given number. Return NULL if
323 struct trace_state_variable *
324 find_trace_state_variable_by_number (int number)
326 struct trace_state_variable *tsv;
329 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
330 if (tsv->number == number)
337 delete_trace_state_variable (const char *name)
339 struct trace_state_variable *tsv;
342 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
343 if (strcmp (name, tsv->name) == 0)
345 observer_notify_tsv_deleted (tsv);
347 xfree ((void *)tsv->name);
348 VEC_unordered_remove (tsv_s, tvariables, ix);
353 warning (_("No trace variable named \"$%s\", not deleting"), name);
356 /* Throws an error if NAME is not valid syntax for a trace state
360 validate_trace_state_variable_name (const char *name)
365 error (_("Must supply a non-empty variable name"));
367 /* All digits in the name is reserved for value history
369 for (p = name; isdigit (*p); p++)
372 error (_("$%s is not a valid trace state variable name"), name);
374 for (p = name; isalnum (*p) || *p == '_'; p++)
377 error (_("$%s is not a valid trace state variable name"), name);
380 /* The 'tvariable' command collects a name and optional expression to
381 evaluate into an initial value. */
384 trace_variable_command (char *args, int from_tty)
386 struct cleanup *old_chain;
388 struct trace_state_variable *tsv;
392 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
394 /* Only allow two syntaxes; "$name" and "$name=value". */
395 p = skip_spaces (args);
398 error (_("Name of trace variable should start with '$'"));
401 while (isalnum (*p) || *p == '_')
403 name = savestring (name, p - name);
404 old_chain = make_cleanup (xfree, name);
407 if (*p != '=' && *p != '\0')
408 error (_("Syntax must be $NAME [ = EXPR ]"));
410 validate_trace_state_variable_name (name);
413 initval = value_as_long (parse_and_eval (++p));
415 /* If the variable already exists, just change its initial value. */
416 tsv = find_trace_state_variable (name);
419 if (tsv->initial_value != initval)
421 tsv->initial_value = initval;
422 observer_notify_tsv_modified (tsv);
424 printf_filtered (_("Trace state variable $%s "
425 "now has initial value %s.\n"),
426 tsv->name, plongest (tsv->initial_value));
427 do_cleanups (old_chain);
431 /* Create a new variable. */
432 tsv = create_trace_state_variable (name);
433 tsv->initial_value = initval;
435 observer_notify_tsv_created (tsv);
437 printf_filtered (_("Trace state variable $%s "
438 "created, with initial value %s.\n"),
439 tsv->name, plongest (tsv->initial_value));
441 do_cleanups (old_chain);
445 delete_trace_variable_command (char *args, int from_tty)
449 if (query (_("Delete all trace state variables? ")))
450 VEC_free (tsv_s, tvariables);
452 observer_notify_tsv_deleted (NULL);
456 gdb_argv argv (args);
458 for (char *arg : argv)
461 delete_trace_state_variable (arg + 1);
463 warning (_("Name \"%s\" not prefixed with '$', ignoring"), arg);
470 tvariables_info_1 (void)
472 struct trace_state_variable *tsv;
475 struct ui_out *uiout = current_uiout;
477 if (VEC_length (tsv_s, tvariables) == 0 && !uiout->is_mi_like_p ())
479 printf_filtered (_("No trace state variables.\n"));
483 /* Try to acquire values from the target. */
484 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix, ++count)
485 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
488 ui_out_emit_table table_emitter (uiout, 3, count, "trace-variables");
489 uiout->table_header (15, ui_left, "name", "Name");
490 uiout->table_header (11, ui_left, "initial", "Initial");
491 uiout->table_header (11, ui_left, "current", "Current");
493 uiout->table_body ();
495 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
499 ui_out_emit_tuple tuple_emitter (uiout, "variable");
501 std::string name = std::string ("$") + tsv->name;
502 uiout->field_string ("name", name.c_str ());
503 uiout->field_string ("initial", plongest (tsv->initial_value));
505 if (tsv->value_known)
506 c = plongest (tsv->value);
507 else if (uiout->is_mi_like_p ())
508 /* For MI, we prefer not to use magic string constants, but rather
509 omit the field completely. The difference between unknown and
510 undefined does not seem important enough to represent. */
512 else if (current_trace_status ()->running || traceframe_number >= 0)
513 /* The value is/was defined, but we don't have it. */
516 /* It is not meaningful to ask about the value. */
519 uiout->field_string ("current", c);
524 /* List all the trace state variables. */
527 info_tvariables_command (char *args, int from_tty)
529 tvariables_info_1 ();
532 /* Stash definitions of tsvs into the given file. */
535 save_trace_state_variables (struct ui_file *fp)
537 struct trace_state_variable *tsv;
540 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
542 fprintf_unfiltered (fp, "tvariable $%s", tsv->name);
543 if (tsv->initial_value)
544 fprintf_unfiltered (fp, " = %s", plongest (tsv->initial_value));
545 fprintf_unfiltered (fp, "\n");
549 /* ACTIONS functions: */
551 /* The three functions:
552 collect_pseudocommand,
553 while_stepping_pseudocommand, and
554 end_actions_pseudocommand
555 are placeholders for "commands" that are actually ONLY to be used
556 within a tracepoint action list. If the actual function is ever called,
557 it means that somebody issued the "command" at the top level,
558 which is always an error. */
561 end_actions_pseudocommand (char *args, int from_tty)
563 error (_("This command cannot be used at the top level."));
567 while_stepping_pseudocommand (char *args, int from_tty)
569 error (_("This command can only be used in a tracepoint actions list."));
573 collect_pseudocommand (char *args, int from_tty)
575 error (_("This command can only be used in a tracepoint actions list."));
579 teval_pseudocommand (char *args, int from_tty)
581 error (_("This command can only be used in a tracepoint actions list."));
584 /* Parse any collection options, such as /s for strings. */
587 decode_agent_options (const char *exp, int *trace_string)
589 struct value_print_options opts;
596 /* Call this to borrow the print elements default for collection
598 get_user_print_options (&opts);
603 if (target_supports_string_tracing ())
605 /* Allow an optional decimal number giving an explicit maximum
606 string length, defaulting it to the "print elements" value;
607 so "collect/s80 mystr" gets at most 80 bytes of string. */
608 *trace_string = opts.print_max;
610 if (*exp >= '0' && *exp <= '9')
611 *trace_string = atoi (exp);
612 while (*exp >= '0' && *exp <= '9')
616 error (_("Target does not support \"/s\" option for string tracing."));
619 error (_("Undefined collection format \"%c\"."), *exp);
621 exp = skip_spaces (exp);
626 /* Enter a list of actions for a tracepoint. */
628 actions_command (char *args, int from_tty)
630 struct tracepoint *t;
632 t = get_tracepoint_by_number (&args, NULL);
636 string_printf ("Enter actions for tracepoint %d, one per line.",
639 command_line_up l = read_command_lines (&tmpbuf[0], from_tty, 1,
640 check_tracepoint_command, t);
641 breakpoint_set_commands (t, std::move (l));
643 /* else just return */
646 /* Report the results of checking the agent expression, as errors or
650 report_agent_reqs_errors (struct agent_expr *aexpr)
652 /* All of the "flaws" are serious bytecode generation issues that
653 should never occur. */
654 if (aexpr->flaw != agent_flaw_none)
655 internal_error (__FILE__, __LINE__, _("expression is malformed"));
657 /* If analysis shows a stack underflow, GDB must have done something
658 badly wrong in its bytecode generation. */
659 if (aexpr->min_height < 0)
660 internal_error (__FILE__, __LINE__,
661 _("expression has min height < 0"));
663 /* Issue this error if the stack is predicted to get too deep. The
664 limit is rather arbitrary; a better scheme might be for the
665 target to report how much stack it will have available. The
666 depth roughly corresponds to parenthesization, so a limit of 20
667 amounts to 20 levels of expression nesting, which is actually
668 a pretty big hairy expression. */
669 if (aexpr->max_height > 20)
670 error (_("Expression is too complicated."));
673 /* worker function */
675 validate_actionline (const char *line, struct breakpoint *b)
677 struct cmd_list_element *c;
678 struct cleanup *old_chain = NULL;
681 struct bp_location *loc;
682 struct tracepoint *t = (struct tracepoint *) b;
684 /* If EOF is typed, *line is NULL. */
688 p = skip_spaces (line);
690 /* Symbol lookup etc. */
691 if (*p == '\0') /* empty line: just prompt for another line. */
694 if (*p == '#') /* comment line */
697 c = lookup_cmd (&p, cmdlist, "", -1, 1);
699 error (_("`%s' is not a tracepoint action, or is ambiguous."), p);
701 if (cmd_cfunc_eq (c, collect_pseudocommand))
703 int trace_string = 0;
706 p = decode_agent_options (p, &trace_string);
709 { /* Repeat over a comma-separated list. */
710 QUIT; /* Allow user to bail out with ^C. */
713 if (*p == '$') /* Look for special pseudo-symbols. */
715 if (0 == strncasecmp ("reg", p + 1, 3)
716 || 0 == strncasecmp ("arg", p + 1, 3)
717 || 0 == strncasecmp ("loc", p + 1, 3)
718 || 0 == strncasecmp ("_ret", p + 1, 4)
719 || 0 == strncasecmp ("_sdata", p + 1, 6))
724 /* else fall thru, treat p as an expression and parse it! */
727 for (loc = t->loc; loc; loc = loc->next)
730 expression_up exp = parse_exp_1 (&p, loc->address,
731 block_for_pc (loc->address), 1);
733 if (exp->elts[0].opcode == OP_VAR_VALUE)
735 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
737 error (_("constant `%s' (value %s) "
738 "will not be collected."),
739 SYMBOL_PRINT_NAME (exp->elts[2].symbol),
740 plongest (SYMBOL_VALUE (exp->elts[2].symbol)));
742 else if (SYMBOL_CLASS (exp->elts[2].symbol)
743 == LOC_OPTIMIZED_OUT)
745 error (_("`%s' is optimized away "
746 "and cannot be collected."),
747 SYMBOL_PRINT_NAME (exp->elts[2].symbol));
751 /* We have something to collect, make sure that the expr to
752 bytecode translator can handle it and that it's not too
754 agent_expr_up aexpr = gen_trace_for_expr (loc->address,
758 if (aexpr->len > MAX_AGENT_EXPR_LEN)
759 error (_("Expression is too complicated."));
761 ax_reqs (aexpr.get ());
763 report_agent_reqs_errors (aexpr.get ());
766 while (p && *p++ == ',');
769 else if (cmd_cfunc_eq (c, teval_pseudocommand))
772 { /* Repeat over a comma-separated list. */
773 QUIT; /* Allow user to bail out with ^C. */
777 for (loc = t->loc; loc; loc = loc->next)
781 /* Only expressions are allowed for this action. */
782 expression_up exp = parse_exp_1 (&p, loc->address,
783 block_for_pc (loc->address), 1);
785 /* We have something to evaluate, make sure that the expr to
786 bytecode translator can handle it and that it's not too
788 agent_expr_up aexpr = gen_eval_for_expr (loc->address, exp.get ());
790 if (aexpr->len > MAX_AGENT_EXPR_LEN)
791 error (_("Expression is too complicated."));
793 ax_reqs (aexpr.get ());
794 report_agent_reqs_errors (aexpr.get ());
797 while (p && *p++ == ',');
800 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
805 t->step_count = strtol (p, &endp, 0);
806 if (endp == p || t->step_count == 0)
807 error (_("while-stepping step count `%s' is malformed."), line);
811 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
815 error (_("`%s' is not a supported tracepoint action."), line);
819 memrange_absolute = -1
822 /* MEMRANGE functions: */
824 /* Compare memranges for std::sort. */
827 memrange_comp (const memrange &a, const memrange &b)
829 if (a.type == b.type)
831 if (a.type == memrange_absolute)
832 return (bfd_vma) a.start < (bfd_vma) b.start;
834 return a.start < b.start;
837 return a.type < b.type;
840 /* Sort the memrange list using std::sort, and merge adjacent memranges. */
843 memrange_sortmerge (std::vector<memrange> &memranges)
845 if (!memranges.empty ())
849 std::sort (memranges.begin (), memranges.end (), memrange_comp);
851 for (a = 0, b = 1; b < memranges.size (); b++)
853 /* If memrange b overlaps or is adjacent to memrange a,
855 if (memranges[a].type == memranges[b].type
856 && memranges[b].start <= memranges[a].end)
858 if (memranges[b].end > memranges[a].end)
859 memranges[a].end = memranges[b].end;
860 continue; /* next b, same a */
864 memranges[a] = memranges[b];
866 memranges.resize (a + 1);
870 /* Add a register to a collection list. */
873 collection_list::add_register (unsigned int regno)
876 printf_filtered ("collect register %d\n", regno);
877 if (regno >= (8 * sizeof (m_regs_mask)))
878 error (_("Internal: register number %d too large for tracepoint"),
880 m_regs_mask[regno / 8] |= 1 << (regno % 8);
883 /* Add a memrange to a collection list. */
886 collection_list::add_memrange (struct gdbarch *gdbarch,
887 int type, bfd_signed_vma base,
891 printf_filtered ("(%d,%s,%ld)\n", type, paddress (gdbarch, base), len);
893 /* type: memrange_absolute == memory, other n == basereg */
894 /* base: addr if memory, offset if reg relative. */
895 /* len: we actually save end (base + len) for convenience */
896 m_memranges.emplace_back (type, base, base + len);
898 if (type != memrange_absolute) /* Better collect the base register! */
902 /* Add a symbol to a collection list. */
905 collection_list::collect_symbol (struct symbol *sym,
906 struct gdbarch *gdbarch,
907 long frame_regno, long frame_offset,
913 bfd_signed_vma offset;
914 int treat_as_expr = 0;
916 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
917 switch (SYMBOL_CLASS (sym))
920 printf_filtered ("%s: don't know symbol class %d\n",
921 SYMBOL_PRINT_NAME (sym),
925 printf_filtered ("constant %s (value %s) will not be collected.\n",
926 SYMBOL_PRINT_NAME (sym), plongest (SYMBOL_VALUE (sym)));
929 offset = SYMBOL_VALUE_ADDRESS (sym);
932 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
933 SYMBOL_PRINT_NAME (sym), len,
934 paddress (gdbarch, offset));
936 /* A struct may be a C++ class with static fields, go to general
937 expression handling. */
938 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
941 add_memrange (gdbarch, memrange_absolute, offset, len);
944 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
946 printf_filtered ("LOC_REG[parm] %s: ",
947 SYMBOL_PRINT_NAME (sym));
949 /* Check for doubles stored in two registers. */
950 /* FIXME: how about larger types stored in 3 or more regs? */
951 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
952 len > register_size (gdbarch, reg))
953 add_register (reg + 1);
956 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
957 printf_filtered (" (will not collect %s)\n",
958 SYMBOL_PRINT_NAME (sym));
962 offset = frame_offset + SYMBOL_VALUE (sym);
965 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
966 " from frame ptr reg %d\n",
967 SYMBOL_PRINT_NAME (sym), len,
968 paddress (gdbarch, offset), reg);
970 add_memrange (gdbarch, reg, offset, len);
972 case LOC_REGPARM_ADDR:
973 reg = SYMBOL_VALUE (sym);
977 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset %s"
979 SYMBOL_PRINT_NAME (sym), len,
980 paddress (gdbarch, offset), reg);
982 add_memrange (gdbarch, reg, offset, len);
986 offset = frame_offset + SYMBOL_VALUE (sym);
989 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
990 " from frame ptr reg %d\n",
991 SYMBOL_PRINT_NAME (sym), len,
992 paddress (gdbarch, offset), reg);
994 add_memrange (gdbarch, reg, offset, len);
1001 case LOC_OPTIMIZED_OUT:
1002 printf_filtered ("%s has been optimized out of existence.\n",
1003 SYMBOL_PRINT_NAME (sym));
1011 /* Expressions are the most general case. */
1014 struct cleanup *old_chain1 = NULL;
1016 agent_expr_up aexpr = gen_trace_for_var (scope, gdbarch,
1019 /* It can happen that the symbol is recorded as a computed
1020 location, but it's been optimized away and doesn't actually
1021 have a location expression. */
1024 printf_filtered ("%s has been optimized out of existence.\n",
1025 SYMBOL_PRINT_NAME (sym));
1029 ax_reqs (aexpr.get ());
1031 report_agent_reqs_errors (aexpr.get ());
1033 /* Take care of the registers. */
1034 if (aexpr->reg_mask_len > 0)
1036 for (int ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1038 QUIT; /* Allow user to bail out with ^C. */
1039 if (aexpr->reg_mask[ndx1] != 0)
1041 /* Assume chars have 8 bits. */
1042 for (int ndx2 = 0; ndx2 < 8; ndx2++)
1043 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1044 /* It's used -- record it. */
1045 add_register (ndx1 * 8 + ndx2);
1050 add_aexpr (std::move (aexpr));
1054 /* Data to be passed around in the calls to the locals and args
1057 struct add_local_symbols_data
1059 struct collection_list *collect;
1060 struct gdbarch *gdbarch;
1068 /* The callback for the locals and args iterators. */
1071 do_collect_symbol (const char *print_name,
1075 struct add_local_symbols_data *p = (struct add_local_symbols_data *) cb_data;
1077 p->collect->collect_symbol (sym, p->gdbarch, p->frame_regno,
1078 p->frame_offset, p->pc, p->trace_string);
1081 p->collect->add_wholly_collected (print_name);
1085 collection_list::add_wholly_collected (const char *print_name)
1087 m_wholly_collected.push_back (print_name);
1090 /* Add all locals (or args) symbols to collection list. */
1093 collection_list::add_local_symbols (struct gdbarch *gdbarch, CORE_ADDR pc,
1094 long frame_regno, long frame_offset, int type,
1097 const struct block *block;
1098 struct add_local_symbols_data cb_data;
1100 cb_data.collect = this;
1101 cb_data.gdbarch = gdbarch;
1103 cb_data.frame_regno = frame_regno;
1104 cb_data.frame_offset = frame_offset;
1106 cb_data.trace_string = trace_string;
1110 block = block_for_pc (pc);
1113 warning (_("Can't collect locals; "
1114 "no symbol table info available.\n"));
1118 iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1119 if (cb_data.count == 0)
1120 warning (_("No locals found in scope."));
1124 pc = get_pc_function_start (pc);
1125 block = block_for_pc (pc);
1128 warning (_("Can't collect args; no symbol table info available."));
1132 iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1133 if (cb_data.count == 0)
1134 warning (_("No args found in scope."));
1139 collection_list::add_static_trace_data ()
1142 printf_filtered ("collect static trace data\n");
1143 m_strace_data = true;
1146 collection_list::collection_list ()
1148 m_strace_data (false)
1150 m_memranges.reserve (128);
1151 m_aexprs.reserve (128);
1154 /* Reduce a collection list to string form (for gdb protocol). */
1157 collection_list::stringify ()
1159 char temp_buf[2048];
1162 char *(*str_list)[];
1166 count = 1 + 1 + m_memranges.size () + m_aexprs.size () + 1;
1167 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1172 printf_filtered ("\nCollecting static trace data\n");
1175 (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
1179 for (i = sizeof (m_regs_mask) - 1; i > 0; i--)
1180 if (m_regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */
1182 if (m_regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
1185 printf_filtered ("\nCollecting registers (mask): 0x");
1190 QUIT; /* Allow user to bail out with ^C. */
1192 printf_filtered ("%02X", m_regs_mask[i]);
1193 sprintf (end, "%02X", m_regs_mask[i]);
1196 (*str_list)[ndx] = xstrdup (temp_buf);
1200 printf_filtered ("\n");
1201 if (!m_memranges.empty () && info_verbose)
1202 printf_filtered ("Collecting memranges: \n");
1203 for (i = 0, count = 0, end = temp_buf; i < m_memranges.size (); i++)
1205 QUIT; /* Allow user to bail out with ^C. */
1208 printf_filtered ("(%d, %s, %ld)\n",
1209 m_memranges[i].type,
1210 paddress (target_gdbarch (),
1211 m_memranges[i].start),
1212 (long) (m_memranges[i].end
1213 - m_memranges[i].start));
1215 if (count + 27 > MAX_AGENT_EXPR_LEN)
1217 (*str_list)[ndx] = savestring (temp_buf, count);
1224 bfd_signed_vma length
1225 = m_memranges[i].end - m_memranges[i].start;
1227 /* The "%X" conversion specifier expects an unsigned argument,
1228 so passing -1 (memrange_absolute) to it directly gives you
1229 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1231 if (m_memranges[i].type == memrange_absolute)
1232 sprintf (end, "M-1,%s,%lX", phex_nz (m_memranges[i].start, 0),
1235 sprintf (end, "M%X,%s,%lX", m_memranges[i].type,
1236 phex_nz (m_memranges[i].start, 0), (long) length);
1239 count += strlen (end);
1240 end = temp_buf + count;
1243 for (i = 0; i < m_aexprs.size (); i++)
1245 QUIT; /* Allow user to bail out with ^C. */
1246 if ((count + 10 + 2 * m_aexprs[i]->len) > MAX_AGENT_EXPR_LEN)
1248 (*str_list)[ndx] = savestring (temp_buf, count);
1253 sprintf (end, "X%08X,", m_aexprs[i]->len);
1254 end += 10; /* 'X' + 8 hex digits + ',' */
1257 end = mem2hex (m_aexprs[i]->buf, end, m_aexprs[i]->len);
1258 count += 2 * m_aexprs[i]->len;
1263 (*str_list)[ndx] = savestring (temp_buf, count);
1268 (*str_list)[ndx] = NULL;
1279 /* Add the printed expression EXP to *LIST. */
1282 collection_list::append_exp (struct expression *exp)
1284 string_file tmp_stream;
1286 print_expression (exp, &tmp_stream);
1288 m_computed.push_back (std::move (tmp_stream.string ()));
1292 collection_list::finish ()
1294 memrange_sortmerge (m_memranges);
1298 encode_actions_1 (struct command_line *action,
1299 struct bp_location *tloc,
1301 LONGEST frame_offset,
1302 struct collection_list *collect,
1303 struct collection_list *stepping_list)
1305 const char *action_exp;
1307 struct value *tempval;
1308 struct cmd_list_element *cmd;
1310 for (; action; action = action->next)
1312 QUIT; /* Allow user to bail out with ^C. */
1313 action_exp = action->line;
1314 action_exp = skip_spaces (action_exp);
1316 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1318 error (_("Bad action list item: %s"), action_exp);
1320 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1322 int trace_string = 0;
1324 if (*action_exp == '/')
1325 action_exp = decode_agent_options (action_exp, &trace_string);
1328 { /* Repeat over a comma-separated list. */
1329 QUIT; /* Allow user to bail out with ^C. */
1330 action_exp = skip_spaces (action_exp);
1332 if (0 == strncasecmp ("$reg", action_exp, 4))
1334 for (i = 0; i < gdbarch_num_regs (target_gdbarch ()); i++)
1335 collect->add_register (i);
1336 action_exp = strchr (action_exp, ','); /* more? */
1338 else if (0 == strncasecmp ("$arg", action_exp, 4))
1340 collect->add_local_symbols (target_gdbarch (),
1346 action_exp = strchr (action_exp, ','); /* more? */
1348 else if (0 == strncasecmp ("$loc", action_exp, 4))
1350 collect->add_local_symbols (target_gdbarch (),
1356 action_exp = strchr (action_exp, ','); /* more? */
1358 else if (0 == strncasecmp ("$_ret", action_exp, 5))
1361 = gen_trace_for_return_address (tloc->address,
1365 ax_reqs (aexpr.get ());
1366 report_agent_reqs_errors (aexpr.get ());
1368 /* take care of the registers */
1369 if (aexpr->reg_mask_len > 0)
1371 for (int ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1373 QUIT; /* allow user to bail out with ^C */
1374 if (aexpr->reg_mask[ndx1] != 0)
1376 /* assume chars have 8 bits */
1377 for (int ndx2 = 0; ndx2 < 8; ndx2++)
1378 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1380 /* It's used -- record it. */
1381 collect->add_register (ndx1 * 8 + ndx2);
1387 collect->add_aexpr (std::move (aexpr));
1388 action_exp = strchr (action_exp, ','); /* more? */
1390 else if (0 == strncasecmp ("$_sdata", action_exp, 7))
1392 collect->add_static_trace_data ();
1393 action_exp = strchr (action_exp, ','); /* more? */
1398 struct cleanup *old_chain1 = NULL;
1400 expression_up exp = parse_exp_1 (&action_exp, tloc->address,
1401 block_for_pc (tloc->address),
1404 switch (exp->elts[0].opcode)
1408 const char *name = &exp->elts[2].string;
1410 i = user_reg_map_name_to_regnum (target_gdbarch (),
1411 name, strlen (name));
1413 internal_error (__FILE__, __LINE__,
1414 _("Register $%s not available"),
1417 printf_filtered ("OP_REGISTER: ");
1418 collect->add_register (i);
1423 /* Safe because we know it's a simple expression. */
1424 tempval = evaluate_expression (exp.get ());
1425 addr = value_address (tempval);
1426 /* Initialize the TYPE_LENGTH if it is a typedef. */
1427 check_typedef (exp->elts[1].type);
1428 collect->add_memrange (target_gdbarch (),
1429 memrange_absolute, addr,
1430 TYPE_LENGTH (exp->elts[1].type));
1431 collect->append_exp (exp.get ());
1436 struct symbol *sym = exp->elts[2].symbol;
1437 char_ptr name = (char_ptr) SYMBOL_NATURAL_NAME (sym);
1439 collect->collect_symbol (exp->elts[2].symbol,
1445 collect->add_wholly_collected (name);
1449 default: /* Full-fledged expression. */
1450 agent_expr_up aexpr = gen_trace_for_expr (tloc->address,
1454 ax_reqs (aexpr.get ());
1456 report_agent_reqs_errors (aexpr.get ());
1458 /* Take care of the registers. */
1459 if (aexpr->reg_mask_len > 0)
1461 for (int ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1463 QUIT; /* Allow user to bail out with ^C. */
1464 if (aexpr->reg_mask[ndx1] != 0)
1466 /* Assume chars have 8 bits. */
1467 for (int ndx2 = 0; ndx2 < 8; ndx2++)
1468 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1470 /* It's used -- record it. */
1471 collect->add_register (ndx1 * 8 + ndx2);
1477 collect->add_aexpr (std::move (aexpr));
1478 collect->append_exp (exp.get ());
1483 while (action_exp && *action_exp++ == ',');
1485 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1488 { /* Repeat over a comma-separated list. */
1489 QUIT; /* Allow user to bail out with ^C. */
1490 action_exp = skip_spaces (action_exp);
1493 struct cleanup *old_chain1 = NULL;
1495 expression_up exp = parse_exp_1 (&action_exp, tloc->address,
1496 block_for_pc (tloc->address),
1499 agent_expr_up aexpr = gen_eval_for_expr (tloc->address,
1502 ax_reqs (aexpr.get ());
1503 report_agent_reqs_errors (aexpr.get ());
1505 /* Even though we're not officially collecting, add
1506 to the collect list anyway. */
1507 collect->add_aexpr (std::move (aexpr));
1510 while (action_exp && *action_exp++ == ',');
1512 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1514 /* We check against nested while-stepping when setting
1515 breakpoint action, so no way to run into nested
1517 gdb_assert (stepping_list);
1519 encode_actions_1 (action->body_list[0], tloc, frame_reg,
1520 frame_offset, stepping_list, NULL);
1523 error (_("Invalid tracepoint command '%s'"), action->line);
1527 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1528 and STEPPING_LIST. */
1531 encode_actions (struct bp_location *tloc,
1532 struct collection_list *tracepoint_list,
1533 struct collection_list *stepping_list)
1535 struct command_line *actions;
1537 LONGEST frame_offset;
1539 gdbarch_virtual_frame_pointer (tloc->gdbarch,
1540 tloc->address, &frame_reg, &frame_offset);
1542 actions = all_tracepoint_actions_and_cleanup (tloc->owner);
1544 encode_actions_1 (actions, tloc, frame_reg, frame_offset,
1545 tracepoint_list, stepping_list);
1547 tracepoint_list->finish ();
1548 stepping_list->finish ();
1551 /* Render all actions into gdb protocol. */
1554 encode_actions_rsp (struct bp_location *tloc, char ***tdp_actions,
1555 char ***stepping_actions)
1557 struct collection_list tracepoint_list, stepping_list;
1559 *tdp_actions = NULL;
1560 *stepping_actions = NULL;
1562 encode_actions (tloc, &tracepoint_list, &stepping_list);
1564 *tdp_actions = tracepoint_list.stringify ();
1565 *stepping_actions = stepping_list.stringify ();
1569 collection_list::add_aexpr (agent_expr_up aexpr)
1571 m_aexprs.push_back (std::move (aexpr));
1575 process_tracepoint_on_disconnect (void)
1577 VEC(breakpoint_p) *tp_vec = NULL;
1579 struct breakpoint *b;
1580 int has_pending_p = 0;
1582 /* Check whether we still have pending tracepoint. If we have, warn the
1583 user that pending tracepoint will no longer work. */
1584 tp_vec = all_tracepoints ();
1585 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1594 struct bp_location *loc1;
1596 for (loc1 = b->loc; loc1; loc1 = loc1->next)
1598 if (loc1->shlib_disabled)
1609 VEC_free (breakpoint_p, tp_vec);
1612 warning (_("Pending tracepoints will not be resolved while"
1613 " GDB is disconnected\n"));
1616 /* Reset local state of tracing. */
1619 trace_reset_local_state (void)
1621 set_traceframe_num (-1);
1622 set_tracepoint_num (-1);
1623 set_traceframe_context (NULL);
1624 clear_traceframe_info ();
1628 start_tracing (char *notes)
1630 VEC(breakpoint_p) *tp_vec = NULL;
1632 struct breakpoint *b;
1633 struct trace_state_variable *tsv;
1634 int any_enabled = 0, num_to_download = 0;
1637 tp_vec = all_tracepoints ();
1639 /* No point in tracing without any tracepoints... */
1640 if (VEC_length (breakpoint_p, tp_vec) == 0)
1642 VEC_free (breakpoint_p, tp_vec);
1643 error (_("No tracepoints defined, not starting trace"));
1646 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1648 if (b->enable_state == bp_enabled)
1651 if ((b->type == bp_fast_tracepoint
1652 ? may_insert_fast_tracepoints
1653 : may_insert_tracepoints))
1656 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1657 (b->type == bp_fast_tracepoint ? "fast " : ""), b->number);
1662 if (target_supports_enable_disable_tracepoint ())
1663 warning (_("No tracepoints enabled"));
1666 /* No point in tracing with only disabled tracepoints that
1667 cannot be re-enabled. */
1668 VEC_free (breakpoint_p, tp_vec);
1669 error (_("No tracepoints enabled, not starting trace"));
1673 if (num_to_download <= 0)
1675 VEC_free (breakpoint_p, tp_vec);
1676 error (_("No tracepoints that may be downloaded, not starting trace"));
1679 target_trace_init ();
1681 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1683 struct tracepoint *t = (struct tracepoint *) b;
1684 struct bp_location *loc;
1685 int bp_location_downloaded = 0;
1687 /* Clear `inserted' flag. */
1688 for (loc = b->loc; loc; loc = loc->next)
1691 if ((b->type == bp_fast_tracepoint
1692 ? !may_insert_fast_tracepoints
1693 : !may_insert_tracepoints))
1696 t->number_on_target = 0;
1698 for (loc = b->loc; loc; loc = loc->next)
1700 /* Since tracepoint locations are never duplicated, `inserted'
1701 flag should be zero. */
1702 gdb_assert (!loc->inserted);
1704 target_download_tracepoint (loc);
1707 bp_location_downloaded = 1;
1710 t->number_on_target = b->number;
1712 for (loc = b->loc; loc; loc = loc->next)
1713 if (loc->probe.probe != NULL
1714 && loc->probe.probe->pops->set_semaphore != NULL)
1715 loc->probe.probe->pops->set_semaphore (loc->probe.probe,
1719 if (bp_location_downloaded)
1720 observer_notify_breakpoint_modified (b);
1722 VEC_free (breakpoint_p, tp_vec);
1724 /* Send down all the trace state variables too. */
1725 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1727 target_download_trace_state_variable (tsv);
1730 /* Tell target to treat text-like sections as transparent. */
1731 target_trace_set_readonly_regions ();
1732 /* Set some mode flags. */
1733 target_set_disconnected_tracing (disconnected_tracing);
1734 target_set_circular_trace_buffer (circular_trace_buffer);
1735 target_set_trace_buffer_size (trace_buffer_size);
1738 notes = trace_notes;
1739 ret = target_set_trace_notes (trace_user, notes, NULL);
1741 if (!ret && (trace_user || notes))
1742 warning (_("Target does not support trace user/notes, info ignored"));
1744 /* Now insert traps and begin collecting data. */
1745 target_trace_start ();
1747 /* Reset our local state. */
1748 trace_reset_local_state ();
1749 current_trace_status()->running = 1;
1752 /* The tstart command requests the target to start a new trace run.
1753 The command passes any arguments it has to the target verbatim, as
1754 an optional "trace note". This is useful as for instance a warning
1755 to other users if the trace runs disconnected, and you don't want
1756 anybody else messing with the target. */
1759 tstart_command (char *args, int from_tty)
1761 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1763 if (current_trace_status ()->running)
1766 && !query (_("A trace is running already. Start a new run? ")))
1767 error (_("New trace run not started."));
1770 start_tracing (args);
1773 /* The tstop command stops the tracing run. The command passes any
1774 supplied arguments to the target verbatim as a "stop note"; if the
1775 target supports trace notes, then it will be reported back as part
1776 of the trace run's status. */
1779 tstop_command (char *args, int from_tty)
1781 if (!current_trace_status ()->running)
1782 error (_("Trace is not running."));
1784 stop_tracing (args);
1788 stop_tracing (char *note)
1791 VEC(breakpoint_p) *tp_vec = NULL;
1793 struct breakpoint *t;
1795 target_trace_stop ();
1797 tp_vec = all_tracepoints ();
1798 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1800 struct bp_location *loc;
1802 if ((t->type == bp_fast_tracepoint
1803 ? !may_insert_fast_tracepoints
1804 : !may_insert_tracepoints))
1807 for (loc = t->loc; loc; loc = loc->next)
1809 /* GDB can be totally absent in some disconnected trace scenarios,
1810 but we don't really care if this semaphore goes out of sync.
1811 That's why we are decrementing it here, but not taking care
1813 if (loc->probe.probe != NULL
1814 && loc->probe.probe->pops->clear_semaphore != NULL)
1815 loc->probe.probe->pops->clear_semaphore (loc->probe.probe,
1821 VEC_free (breakpoint_p, tp_vec);
1824 note = trace_stop_notes;
1825 ret = target_set_trace_notes (NULL, NULL, note);
1828 warning (_("Target does not support trace notes, note ignored"));
1830 /* Should change in response to reply? */
1831 current_trace_status ()->running = 0;
1834 /* tstatus command */
1836 tstatus_command (char *args, int from_tty)
1838 struct trace_status *ts = current_trace_status ();
1840 VEC(breakpoint_p) *tp_vec = NULL;
1841 struct breakpoint *t;
1843 status = target_get_trace_status (ts);
1847 if (ts->filename != NULL)
1848 printf_filtered (_("Using a trace file.\n"));
1851 printf_filtered (_("Trace can not be run on this target.\n"));
1856 if (!ts->running_known)
1858 printf_filtered (_("Run/stop status is unknown.\n"));
1860 else if (ts->running)
1862 printf_filtered (_("Trace is running on the target.\n"));
1866 switch (ts->stop_reason)
1868 case trace_never_run:
1869 printf_filtered (_("No trace has been run on the target.\n"));
1871 case trace_stop_command:
1873 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1876 printf_filtered (_("Trace stopped by a tstop command.\n"));
1878 case trace_buffer_full:
1879 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1881 case trace_disconnected:
1882 printf_filtered (_("Trace stopped because of disconnection.\n"));
1884 case tracepoint_passcount:
1885 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1886 ts->stopping_tracepoint);
1888 case tracepoint_error:
1889 if (ts->stopping_tracepoint)
1890 printf_filtered (_("Trace stopped by an "
1891 "error (%s, tracepoint %d).\n"),
1892 ts->stop_desc, ts->stopping_tracepoint);
1894 printf_filtered (_("Trace stopped by an error (%s).\n"),
1897 case trace_stop_reason_unknown:
1898 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1901 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1907 if (ts->traceframes_created >= 0
1908 && ts->traceframe_count != ts->traceframes_created)
1910 printf_filtered (_("Buffer contains %d trace "
1911 "frames (of %d created total).\n"),
1912 ts->traceframe_count, ts->traceframes_created);
1914 else if (ts->traceframe_count >= 0)
1916 printf_filtered (_("Collected %d trace frames.\n"),
1917 ts->traceframe_count);
1920 if (ts->buffer_free >= 0)
1922 if (ts->buffer_size >= 0)
1924 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1925 ts->buffer_free, ts->buffer_size);
1926 if (ts->buffer_size > 0)
1927 printf_filtered (_(" (%d%% full)"),
1928 ((int) ((((long long) (ts->buffer_size
1929 - ts->buffer_free)) * 100)
1930 / ts->buffer_size)));
1931 printf_filtered (_(".\n"));
1934 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1938 if (ts->disconnected_tracing)
1939 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1941 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1943 if (ts->circular_buffer)
1944 printf_filtered (_("Trace buffer is circular.\n"));
1946 if (ts->user_name && strlen (ts->user_name) > 0)
1947 printf_filtered (_("Trace user is %s.\n"), ts->user_name);
1949 if (ts->notes && strlen (ts->notes) > 0)
1950 printf_filtered (_("Trace notes: %s.\n"), ts->notes);
1952 /* Now report on what we're doing with tfind. */
1953 if (traceframe_number >= 0)
1954 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1955 traceframe_number, tracepoint_number);
1957 printf_filtered (_("Not looking at any trace frame.\n"));
1959 /* Report start/stop times if supplied. */
1964 LONGEST run_time = ts->stop_time - ts->start_time;
1966 /* Reporting a run time is more readable than two long numbers. */
1967 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
1968 (long int) (ts->start_time / 1000000),
1969 (long int) (ts->start_time % 1000000),
1970 (long int) (run_time / 1000000),
1971 (long int) (run_time % 1000000));
1974 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
1975 (long int) (ts->start_time / 1000000),
1976 (long int) (ts->start_time % 1000000));
1978 else if (ts->stop_time)
1979 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
1980 (long int) (ts->stop_time / 1000000),
1981 (long int) (ts->stop_time % 1000000));
1983 /* Now report any per-tracepoint status available. */
1984 tp_vec = all_tracepoints ();
1986 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1987 target_get_tracepoint_status (t, NULL);
1989 VEC_free (breakpoint_p, tp_vec);
1992 /* Report the trace status to uiout, in a way suitable for MI, and not
1993 suitable for CLI. If ON_STOP is true, suppress a few fields that
1994 are not meaningful in the -trace-stop response.
1996 The implementation is essentially parallel to trace_status_command, but
1997 merging them will result in unreadable code. */
1999 trace_status_mi (int on_stop)
2001 struct ui_out *uiout = current_uiout;
2002 struct trace_status *ts = current_trace_status ();
2005 status = target_get_trace_status (ts);
2007 if (status == -1 && ts->filename == NULL)
2009 uiout->field_string ("supported", "0");
2013 if (ts->filename != NULL)
2014 uiout->field_string ("supported", "file");
2016 uiout->field_string ("supported", "1");
2018 if (ts->filename != NULL)
2019 uiout->field_string ("trace-file", ts->filename);
2021 gdb_assert (ts->running_known);
2025 uiout->field_string ("running", "1");
2027 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2028 Given that the frontend gets the status either on -trace-stop, or from
2029 -trace-status after re-connection, it does not seem like this
2030 information is necessary for anything. It is not necessary for either
2031 figuring the vital state of the target nor for navigation of trace
2032 frames. If the frontend wants to show the current state is some
2033 configure dialog, it can request the value when such dialog is
2034 invoked by the user. */
2038 const char *stop_reason = NULL;
2039 int stopping_tracepoint = -1;
2042 uiout->field_string ("running", "0");
2044 if (ts->stop_reason != trace_stop_reason_unknown)
2046 switch (ts->stop_reason)
2048 case trace_stop_command:
2049 stop_reason = "request";
2051 case trace_buffer_full:
2052 stop_reason = "overflow";
2054 case trace_disconnected:
2055 stop_reason = "disconnection";
2057 case tracepoint_passcount:
2058 stop_reason = "passcount";
2059 stopping_tracepoint = ts->stopping_tracepoint;
2061 case tracepoint_error:
2062 stop_reason = "error";
2063 stopping_tracepoint = ts->stopping_tracepoint;
2069 uiout->field_string ("stop-reason", stop_reason);
2070 if (stopping_tracepoint != -1)
2071 uiout->field_int ("stopping-tracepoint",
2072 stopping_tracepoint);
2073 if (ts->stop_reason == tracepoint_error)
2074 uiout->field_string ("error-description",
2080 if (ts->traceframe_count != -1)
2081 uiout->field_int ("frames", ts->traceframe_count);
2082 if (ts->traceframes_created != -1)
2083 uiout->field_int ("frames-created", ts->traceframes_created);
2084 if (ts->buffer_size != -1)
2085 uiout->field_int ("buffer-size", ts->buffer_size);
2086 if (ts->buffer_free != -1)
2087 uiout->field_int ("buffer-free", ts->buffer_free);
2089 uiout->field_int ("disconnected", ts->disconnected_tracing);
2090 uiout->field_int ("circular", ts->circular_buffer);
2092 uiout->field_string ("user-name", ts->user_name);
2093 uiout->field_string ("notes", ts->notes);
2098 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2099 (long int) (ts->start_time / 1000000),
2100 (long int) (ts->start_time % 1000000));
2101 uiout->field_string ("start-time", buf);
2102 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2103 (long int) (ts->stop_time / 1000000),
2104 (long int) (ts->stop_time % 1000000));
2105 uiout->field_string ("stop-time", buf);
2109 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2110 user if she really wants to detach. */
2113 query_if_trace_running (int from_tty)
2118 /* It can happen that the target that was tracing went away on its
2119 own, and we didn't notice. Get a status update, and if the
2120 current target doesn't even do tracing, then assume it's not
2122 if (target_get_trace_status (current_trace_status ()) < 0)
2123 current_trace_status ()->running = 0;
2125 /* If running interactively, give the user the option to cancel and
2126 then decide what to do differently with the run. Scripts are
2127 just going to disconnect and let the target deal with it,
2128 according to how it's been instructed previously via
2129 disconnected-tracing. */
2130 if (current_trace_status ()->running)
2132 process_tracepoint_on_disconnect ();
2134 if (current_trace_status ()->disconnected_tracing)
2136 if (!query (_("Trace is running and will "
2137 "continue after detach; detach anyway? ")))
2138 error (_("Not confirmed."));
2142 if (!query (_("Trace is running but will "
2143 "stop on detach; detach anyway? ")))
2144 error (_("Not confirmed."));
2149 /* This function handles the details of what to do about an ongoing
2150 tracing run if the user has asked to detach or otherwise disconnect
2154 disconnect_tracing (void)
2156 /* Also we want to be out of tfind mode, otherwise things can get
2157 confusing upon reconnection. Just use these calls instead of
2158 full tfind_1 behavior because we're in the middle of detaching,
2159 and there's no point to updating current stack frame etc. */
2160 trace_reset_local_state ();
2163 /* Worker function for the various flavors of the tfind command. */
2165 tfind_1 (enum trace_find_type type, int num,
2166 CORE_ADDR addr1, CORE_ADDR addr2,
2169 int target_frameno = -1, target_tracept = -1;
2170 struct frame_id old_frame_id = null_frame_id;
2171 struct tracepoint *tp;
2172 struct ui_out *uiout = current_uiout;
2174 /* Only try to get the current stack frame if we have a chance of
2175 succeeding. In particular, if we're trying to get a first trace
2176 frame while all threads are running, it's not going to succeed,
2177 so leave it with a default value and let the frame comparison
2178 below (correctly) decide to print out the source location of the
2180 if (!(type == tfind_number && num == -1)
2181 && (has_stack_frames () || traceframe_number >= 0))
2182 old_frame_id = get_frame_id (get_current_frame ());
2184 target_frameno = target_trace_find (type, num, addr1, addr2,
2187 if (type == tfind_number
2189 && target_frameno == -1)
2191 /* We told the target to get out of tfind mode, and it did. */
2193 else if (target_frameno == -1)
2195 /* A request for a non-existent trace frame has failed.
2196 Our response will be different, depending on FROM_TTY:
2198 If FROM_TTY is true, meaning that this command was
2199 typed interactively by the user, then give an error
2200 and DO NOT change the state of traceframe_number etc.
2202 However if FROM_TTY is false, meaning that we're either
2203 in a script, a loop, or a user-defined command, then
2204 DON'T give an error, but DO change the state of
2205 traceframe_number etc. to invalid.
2207 The rationalle is that if you typed the command, you
2208 might just have committed a typo or something, and you'd
2209 like to NOT lose your current debugging state. However
2210 if you're in a user-defined command or especially in a
2211 loop, then you need a way to detect that the command
2212 failed WITHOUT aborting. This allows you to write
2213 scripts that search thru the trace buffer until the end,
2214 and then continue on to do something else. */
2217 error (_("Target failed to find requested trace frame."));
2221 printf_filtered ("End of trace buffer.\n");
2222 #if 0 /* dubious now? */
2223 /* The following will not recurse, since it's
2225 tfind_command ("-1", from_tty);
2230 tp = get_tracepoint_by_number_on_target (target_tracept);
2232 reinit_frame_cache ();
2233 target_dcache_invalidate ();
2235 set_tracepoint_num (tp ? tp->number : target_tracept);
2237 if (target_frameno != get_traceframe_number ())
2238 observer_notify_traceframe_changed (target_frameno, tracepoint_number);
2240 set_current_traceframe (target_frameno);
2242 if (target_frameno == -1)
2243 set_traceframe_context (NULL);
2245 set_traceframe_context (get_current_frame ());
2247 if (traceframe_number >= 0)
2249 /* Use different branches for MI and CLI to make CLI messages
2251 if (uiout->is_mi_like_p ())
2253 uiout->field_string ("found", "1");
2254 uiout->field_int ("tracepoint", tracepoint_number);
2255 uiout->field_int ("traceframe", traceframe_number);
2259 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2260 traceframe_number, tracepoint_number);
2265 if (uiout->is_mi_like_p ())
2266 uiout->field_string ("found", "0");
2267 else if (type == tfind_number && num == -1)
2268 printf_unfiltered (_("No longer looking at any trace frame\n"));
2269 else /* This case may never occur, check. */
2270 printf_unfiltered (_("No trace frame found\n"));
2273 /* If we're in nonstop mode and getting out of looking at trace
2274 frames, there won't be any current frame to go back to and
2277 && (has_stack_frames () || traceframe_number >= 0))
2279 enum print_what print_what;
2281 /* NOTE: in imitation of the step command, try to determine
2282 whether we have made a transition from one function to
2283 another. If so, we'll print the "stack frame" (ie. the new
2284 function and it's arguments) -- otherwise we'll just show the
2287 if (frame_id_eq (old_frame_id,
2288 get_frame_id (get_current_frame ())))
2289 print_what = SRC_LINE;
2291 print_what = SRC_AND_LOC;
2293 print_stack_frame (get_selected_frame (NULL), 1, print_what, 1);
2298 /* Error on looking at traceframes while trace is running. */
2301 check_trace_running (struct trace_status *status)
2303 if (status->running && status->filename == NULL)
2304 error (_("May not look at trace frames while trace is running."));
2307 /* trace_find_command takes a trace frame number n,
2308 sends "QTFrame:<n>" to the target,
2309 and accepts a reply that may contain several optional pieces
2310 of information: a frame number, a tracepoint number, and an
2311 indication of whether this is a trap frame or a stepping frame.
2313 The minimal response is just "OK" (which indicates that the
2314 target does not give us a frame number or a tracepoint number).
2315 Instead of that, the target may send us a string containing
2317 F<hexnum> (gives the selected frame number)
2318 T<hexnum> (gives the selected tracepoint number)
2323 tfind_command_1 (const char *args, int from_tty)
2324 { /* This should only be called with a numeric argument. */
2327 check_trace_running (current_trace_status ());
2329 if (args == 0 || *args == 0)
2330 { /* TFIND with no args means find NEXT trace frame. */
2331 if (traceframe_number == -1)
2332 frameno = 0; /* "next" is first one. */
2334 frameno = traceframe_number + 1;
2336 else if (0 == strcmp (args, "-"))
2338 if (traceframe_number == -1)
2339 error (_("not debugging trace buffer"));
2340 else if (from_tty && traceframe_number == 0)
2341 error (_("already at start of trace buffer"));
2343 frameno = traceframe_number - 1;
2345 /* A hack to work around eval's need for fp to have been collected. */
2346 else if (0 == strcmp (args, "-1"))
2349 frameno = parse_and_eval_long (args);
2352 error (_("invalid input (%d is less than zero)"), frameno);
2354 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2358 tfind_command (char *args, int from_tty)
2360 tfind_command_1 (const_cast<char *> (args), from_tty);
2365 tfind_end_command (char *args, int from_tty)
2367 tfind_command_1 ("-1", from_tty);
2372 tfind_start_command (char *args, int from_tty)
2374 tfind_command_1 ("0", from_tty);
2377 /* tfind pc command */
2379 tfind_pc_command (char *args, int from_tty)
2383 check_trace_running (current_trace_status ());
2385 if (args == 0 || *args == 0)
2386 pc = regcache_read_pc (get_current_regcache ());
2388 pc = parse_and_eval_address (args);
2390 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2393 /* tfind tracepoint command */
2395 tfind_tracepoint_command (char *args, int from_tty)
2398 struct tracepoint *tp;
2400 check_trace_running (current_trace_status ());
2402 if (args == 0 || *args == 0)
2404 if (tracepoint_number == -1)
2405 error (_("No current tracepoint -- please supply an argument."));
2407 tdp = tracepoint_number; /* Default is current TDP. */
2410 tdp = parse_and_eval_long (args);
2412 /* If we have the tracepoint on hand, use the number that the
2413 target knows about (which may be different if we disconnected
2414 and reconnected). */
2415 tp = get_tracepoint (tdp);
2417 tdp = tp->number_on_target;
2419 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2422 /* TFIND LINE command:
2424 This command will take a sourceline for argument, just like BREAK
2425 or TRACE (ie. anything that "decode_line_1" can handle).
2427 With no argument, this command will find the next trace frame
2428 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2431 tfind_line_command (char *args, int from_tty)
2433 check_trace_running (current_trace_status ());
2435 symtab_and_line sal;
2436 if (args == 0 || *args == 0)
2438 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2442 std::vector<symtab_and_line> sals
2443 = decode_line_with_current_source (args, DECODE_LINE_FUNFIRSTLINE);
2447 if (sal.symtab == 0)
2448 error (_("No line number information available."));
2450 CORE_ADDR start_pc, end_pc;
2451 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2453 if (start_pc == end_pc)
2455 printf_filtered ("Line %d of \"%s\"",
2457 symtab_to_filename_for_display (sal.symtab));
2459 printf_filtered (" is at address ");
2460 print_address (get_current_arch (), start_pc, gdb_stdout);
2462 printf_filtered (" but contains no code.\n");
2463 sal = find_pc_line (start_pc, 0);
2465 && find_line_pc_range (sal, &start_pc, &end_pc)
2466 && start_pc != end_pc)
2467 printf_filtered ("Attempting to find line %d instead.\n",
2470 error (_("Cannot find a good line."));
2474 /* Is there any case in which we get here, and have an address
2475 which the user would want to see? If we have debugging
2476 symbols and no line numbers? */
2477 error (_("Line number %d is out of range for \"%s\"."),
2478 sal.line, symtab_to_filename_for_display (sal.symtab));
2480 /* Find within range of stated line. */
2482 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2484 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2487 /* tfind range command */
2489 tfind_range_command (char *args, int from_tty)
2491 static CORE_ADDR start, stop;
2494 check_trace_running (current_trace_status ());
2496 if (args == 0 || *args == 0)
2497 { /* XXX FIXME: what should default behavior be? */
2498 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2502 if (0 != (tmp = strchr (args, ',')))
2504 *tmp++ = '\0'; /* Terminate start address. */
2505 tmp = skip_spaces (tmp);
2506 start = parse_and_eval_address (args);
2507 stop = parse_and_eval_address (tmp);
2510 { /* No explicit end address? */
2511 start = parse_and_eval_address (args);
2512 stop = start + 1; /* ??? */
2515 tfind_1 (tfind_range, 0, start, stop, from_tty);
2518 /* tfind outside command */
2520 tfind_outside_command (char *args, int from_tty)
2522 CORE_ADDR start, stop;
2525 if (current_trace_status ()->running
2526 && current_trace_status ()->filename == NULL)
2527 error (_("May not look at trace frames while trace is running."));
2529 if (args == 0 || *args == 0)
2530 { /* XXX FIXME: what should default behavior be? */
2531 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2535 if (0 != (tmp = strchr (args, ',')))
2537 *tmp++ = '\0'; /* Terminate start address. */
2538 tmp = skip_spaces (tmp);
2539 start = parse_and_eval_address (args);
2540 stop = parse_and_eval_address (tmp);
2543 { /* No explicit end address? */
2544 start = parse_and_eval_address (args);
2545 stop = start + 1; /* ??? */
2548 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2551 /* info scope command: list the locals for a scope. */
2553 info_scope_command (char *args, int from_tty)
2556 struct bound_minimal_symbol msym;
2557 const struct block *block;
2558 const char *symname;
2559 char *save_args = args;
2560 struct block_iterator iter;
2562 struct gdbarch *gdbarch;
2565 if (args == 0 || *args == 0)
2566 error (_("requires an argument (function, "
2567 "line or *addr) to define a scope"));
2569 event_location_up location = string_to_event_location (&args,
2571 std::vector<symtab_and_line> sals
2572 = decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE,
2576 /* Presumably decode_line_1 has already warned. */
2580 /* Resolve line numbers to PC. */
2581 resolve_sal_pc (&sals[0]);
2582 block = block_for_pc (sals[0].pc);
2586 QUIT; /* Allow user to bail out with ^C. */
2587 ALL_BLOCK_SYMBOLS (block, iter, sym)
2589 QUIT; /* Allow user to bail out with ^C. */
2591 printf_filtered ("Scope for %s:\n", save_args);
2594 symname = SYMBOL_PRINT_NAME (sym);
2595 if (symname == NULL || *symname == '\0')
2596 continue; /* Probably botched, certainly useless. */
2598 gdbarch = symbol_arch (sym);
2600 printf_filtered ("Symbol %s is ", symname);
2602 if (SYMBOL_COMPUTED_OPS (sym) != NULL)
2603 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2604 BLOCK_START (block),
2608 switch (SYMBOL_CLASS (sym))
2611 case LOC_UNDEF: /* Messed up symbol? */
2612 printf_filtered ("a bogus symbol, class %d.\n",
2613 SYMBOL_CLASS (sym));
2614 count--; /* Don't count this one. */
2617 printf_filtered ("a constant with value %s (%s)",
2618 plongest (SYMBOL_VALUE (sym)),
2619 hex_string (SYMBOL_VALUE (sym)));
2621 case LOC_CONST_BYTES:
2622 printf_filtered ("constant bytes: ");
2623 if (SYMBOL_TYPE (sym))
2624 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2625 fprintf_filtered (gdb_stdout, " %02x",
2626 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2629 printf_filtered ("in static storage at address ");
2630 printf_filtered ("%s", paddress (gdbarch,
2631 SYMBOL_VALUE_ADDRESS (sym)));
2634 /* GDBARCH is the architecture associated with the objfile
2635 the symbol is defined in; the target architecture may be
2636 different, and may provide additional registers. However,
2637 we do not know the target architecture at this point.
2638 We assume the objfile architecture will contain all the
2639 standard registers that occur in debug info in that
2641 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2644 if (SYMBOL_IS_ARGUMENT (sym))
2645 printf_filtered ("an argument in register $%s",
2646 gdbarch_register_name (gdbarch, regno));
2648 printf_filtered ("a local variable in register $%s",
2649 gdbarch_register_name (gdbarch, regno));
2652 printf_filtered ("an argument at stack/frame offset %s",
2653 plongest (SYMBOL_VALUE (sym)));
2656 printf_filtered ("a local variable at frame offset %s",
2657 plongest (SYMBOL_VALUE (sym)));
2660 printf_filtered ("a reference argument at offset %s",
2661 plongest (SYMBOL_VALUE (sym)));
2663 case LOC_REGPARM_ADDR:
2664 /* Note comment at LOC_REGISTER. */
2665 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2667 printf_filtered ("the address of an argument, in register $%s",
2668 gdbarch_register_name (gdbarch, regno));
2671 printf_filtered ("a typedef.\n");
2674 printf_filtered ("a label at address ");
2675 printf_filtered ("%s", paddress (gdbarch,
2676 SYMBOL_VALUE_ADDRESS (sym)));
2679 printf_filtered ("a function at address ");
2680 printf_filtered ("%s",
2681 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2683 case LOC_UNRESOLVED:
2684 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2686 if (msym.minsym == NULL)
2687 printf_filtered ("Unresolved Static");
2690 printf_filtered ("static storage at address ");
2691 printf_filtered ("%s",
2693 BMSYMBOL_VALUE_ADDRESS (msym)));
2696 case LOC_OPTIMIZED_OUT:
2697 printf_filtered ("optimized out.\n");
2700 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2703 if (SYMBOL_TYPE (sym))
2704 printf_filtered (", length %d.\n",
2705 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2707 if (BLOCK_FUNCTION (block))
2710 block = BLOCK_SUPERBLOCK (block);
2713 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2717 /* Helper for trace_dump_command. Dump the action list starting at
2718 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2719 actions of the body of a while-stepping action. STEPPING_FRAME is
2720 set if the current traceframe was determined to be a while-stepping
2724 trace_dump_actions (struct command_line *action,
2725 int stepping_actions, int stepping_frame,
2728 const char *action_exp, *next_comma;
2730 for (; action != NULL; action = action->next)
2732 struct cmd_list_element *cmd;
2734 QUIT; /* Allow user to bail out with ^C. */
2735 action_exp = action->line;
2736 action_exp = skip_spaces (action_exp);
2738 /* The collection actions to be done while stepping are
2739 bracketed by the commands "while-stepping" and "end". */
2741 if (*action_exp == '#') /* comment line */
2744 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2746 error (_("Bad action list item: %s"), action_exp);
2748 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2752 for (i = 0; i < action->body_count; ++i)
2753 trace_dump_actions (action->body_list[i],
2754 1, stepping_frame, from_tty);
2756 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2758 /* Display the collected data.
2759 For the trap frame, display only what was collected at
2760 the trap. Likewise for stepping frames, display only
2761 what was collected while stepping. This means that the
2762 two boolean variables, STEPPING_FRAME and
2763 STEPPING_ACTIONS should be equal. */
2764 if (stepping_frame == stepping_actions)
2767 struct cleanup *old_chain
2768 = make_cleanup (free_current_contents, &cmd);
2769 int trace_string = 0;
2771 if (*action_exp == '/')
2772 action_exp = decode_agent_options (action_exp, &trace_string);
2775 { /* Repeat over a comma-separated list. */
2776 QUIT; /* Allow user to bail out with ^C. */
2777 if (*action_exp == ',')
2779 action_exp = skip_spaces (action_exp);
2781 next_comma = strchr (action_exp, ',');
2783 if (0 == strncasecmp (action_exp, "$reg", 4))
2784 registers_info (NULL, from_tty);
2785 else if (0 == strncasecmp (action_exp, "$_ret", 5))
2787 else if (0 == strncasecmp (action_exp, "$loc", 4))
2788 info_locals_command (NULL, from_tty);
2789 else if (0 == strncasecmp (action_exp, "$arg", 4))
2790 info_args_command (NULL, from_tty);
2793 if (next_comma != NULL)
2795 size_t len = next_comma - action_exp;
2797 cmd = (char *) xrealloc (cmd, len + 1);
2798 memcpy (cmd, action_exp, len);
2803 size_t len = strlen (action_exp);
2805 cmd = (char *) xrealloc (cmd, len + 1);
2806 memcpy (cmd, action_exp, len + 1);
2809 printf_filtered ("%s = ", cmd);
2810 output_command_const (cmd, from_tty);
2811 printf_filtered ("\n");
2813 action_exp = next_comma;
2815 while (action_exp && *action_exp == ',');
2817 do_cleanups (old_chain);
2823 /* Return bp_location of the tracepoint associated with the current
2824 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2825 is a stepping traceframe. */
2827 struct bp_location *
2828 get_traceframe_location (int *stepping_frame_p)
2830 struct tracepoint *t;
2831 struct bp_location *tloc;
2832 struct regcache *regcache;
2834 if (tracepoint_number == -1)
2835 error (_("No current trace frame."));
2837 t = get_tracepoint (tracepoint_number);
2840 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2843 /* The current frame is a trap frame if the frame PC is equal to the
2844 tracepoint PC. If not, then the current frame was collected
2845 during single-stepping. */
2846 regcache = get_current_regcache ();
2848 /* If the traceframe's address matches any of the tracepoint's
2849 locations, assume it is a direct hit rather than a while-stepping
2850 frame. (FIXME this is not reliable, should record each frame's
2852 for (tloc = t->loc; tloc; tloc = tloc->next)
2853 if (tloc->address == regcache_read_pc (regcache))
2855 *stepping_frame_p = 0;
2859 /* If this is a stepping frame, we don't know which location
2860 triggered. The first is as good (or bad) a guess as any... */
2861 *stepping_frame_p = 1;
2865 /* Return all the actions, including default collect, of a tracepoint
2866 T. It constructs cleanups into the chain, and leaves the caller to
2867 handle them (call do_cleanups). */
2869 static struct command_line *
2870 all_tracepoint_actions_and_cleanup (struct breakpoint *t)
2872 struct command_line *actions;
2874 actions = breakpoint_commands (t);
2876 /* If there are default expressions to collect, make up a collect
2877 action and prepend to the action list to encode. Note that since
2878 validation is per-tracepoint (local var "xyz" might be valid for
2879 one tracepoint and not another, etc), we make up the action on
2880 the fly, and don't cache it. */
2881 if (*default_collect)
2883 struct command_line *default_collect_action;
2884 char *default_collect_line;
2886 default_collect_line = xstrprintf ("collect %s", default_collect);
2887 make_cleanup (xfree, default_collect_line);
2889 validate_actionline (default_collect_line, t);
2890 default_collect_action = XNEW (struct command_line);
2891 make_cleanup (xfree, default_collect_action);
2892 default_collect_action->next = actions;
2893 default_collect_action->line = default_collect_line;
2894 actions = default_collect_action;
2900 /* The tdump command. */
2903 tdump_command (char *args, int from_tty)
2905 int stepping_frame = 0;
2906 struct bp_location *loc;
2907 struct command_line *actions;
2909 /* This throws an error is not inspecting a trace frame. */
2910 loc = get_traceframe_location (&stepping_frame);
2912 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2913 tracepoint_number, traceframe_number);
2915 /* This command only makes sense for the current frame, not the
2917 scoped_restore_current_thread restore_thread;
2919 select_frame (get_current_frame ());
2921 actions = all_tracepoint_actions_and_cleanup (loc->owner);
2923 trace_dump_actions (actions, 0, stepping_frame, from_tty);
2926 /* Encode a piece of a tracepoint's source-level definition in a form
2927 that is suitable for both protocol and saving in files. */
2928 /* This version does not do multiple encodes for long strings; it should
2929 return an offset to the next piece to encode. FIXME */
2932 encode_source_string (int tpnum, ULONGEST addr,
2933 const char *srctype, const char *src,
2934 char *buf, int buf_size)
2936 if (80 + strlen (srctype) > buf_size)
2937 error (_("Buffer too small for source encoding"));
2938 sprintf (buf, "%x:%s:%s:%x:%x:",
2939 tpnum, phex_nz (addr, sizeof (addr)),
2940 srctype, 0, (int) strlen (src));
2941 if (strlen (buf) + strlen (src) * 2 >= buf_size)
2942 error (_("Source string too long for buffer"));
2943 bin2hex ((gdb_byte *) src, buf + strlen (buf), strlen (src));
2947 /* Tell the target what to do with an ongoing tracing run if GDB
2948 disconnects for some reason. */
2951 set_disconnected_tracing (char *args, int from_tty,
2952 struct cmd_list_element *c)
2954 target_set_disconnected_tracing (disconnected_tracing);
2958 set_circular_trace_buffer (char *args, int from_tty,
2959 struct cmd_list_element *c)
2961 target_set_circular_trace_buffer (circular_trace_buffer);
2965 set_trace_buffer_size (char *args, int from_tty,
2966 struct cmd_list_element *c)
2968 target_set_trace_buffer_size (trace_buffer_size);
2972 set_trace_user (char *args, int from_tty,
2973 struct cmd_list_element *c)
2977 ret = target_set_trace_notes (trace_user, NULL, NULL);
2980 warning (_("Target does not support trace notes, user ignored"));
2984 set_trace_notes (char *args, int from_tty,
2985 struct cmd_list_element *c)
2989 ret = target_set_trace_notes (NULL, trace_notes, NULL);
2992 warning (_("Target does not support trace notes, note ignored"));
2996 set_trace_stop_notes (char *args, int from_tty,
2997 struct cmd_list_element *c)
3001 ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
3004 warning (_("Target does not support trace notes, stop note ignored"));
3007 /* Convert the memory pointed to by mem into hex, placing result in buf.
3008 * Return a pointer to the last char put in buf (null)
3009 * "stolen" from sparc-stub.c
3012 static const char hexchars[] = "0123456789abcdef";
3015 mem2hex (gdb_byte *mem, char *buf, int count)
3023 *buf++ = hexchars[ch >> 4];
3024 *buf++ = hexchars[ch & 0xf];
3033 get_traceframe_number (void)
3035 return traceframe_number;
3039 get_tracepoint_number (void)
3041 return tracepoint_number;
3044 /* Make the traceframe NUM be the current trace frame. Does nothing
3045 if NUM is already current. */
3048 set_current_traceframe (int num)
3052 if (traceframe_number == num)
3054 /* Nothing to do. */
3058 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
3061 warning (_("could not change traceframe"));
3063 set_traceframe_num (newnum);
3065 /* Changing the traceframe changes our view of registers and of the
3067 registers_changed ();
3069 clear_traceframe_info ();
3072 /* A cleanup used when switching away and back from tfind mode. */
3074 struct current_traceframe_cleanup
3076 /* The traceframe we were inspecting. */
3077 int traceframe_number;
3081 do_restore_current_traceframe_cleanup (void *arg)
3083 struct current_traceframe_cleanup *old
3084 = (struct current_traceframe_cleanup *) arg;
3086 set_current_traceframe (old->traceframe_number);
3090 restore_current_traceframe_cleanup_dtor (void *arg)
3092 struct current_traceframe_cleanup *old
3093 = (struct current_traceframe_cleanup *) arg;
3099 make_cleanup_restore_current_traceframe (void)
3101 struct current_traceframe_cleanup *old =
3102 XNEW (struct current_traceframe_cleanup);
3104 old->traceframe_number = traceframe_number;
3106 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
3107 restore_current_traceframe_cleanup_dtor);
3110 /* Given a number and address, return an uploaded tracepoint with that
3111 number, creating if necessary. */
3113 struct uploaded_tp *
3114 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
3116 struct uploaded_tp *utp;
3118 for (utp = *utpp; utp; utp = utp->next)
3119 if (utp->number == num && utp->addr == addr)
3122 utp = XCNEW (struct uploaded_tp);
3125 utp->actions = NULL;
3126 utp->step_actions = NULL;
3127 utp->cmd_strings = NULL;
3135 free_uploaded_tps (struct uploaded_tp **utpp)
3137 struct uploaded_tp *next_one;
3141 next_one = (*utpp)->next;
3147 /* Given a number and address, return an uploaded tracepoint with that
3148 number, creating if necessary. */
3150 struct uploaded_tsv *
3151 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3153 struct uploaded_tsv *utsv;
3155 for (utsv = *utsvp; utsv; utsv = utsv->next)
3156 if (utsv->number == num)
3159 utsv = XCNEW (struct uploaded_tsv);
3161 utsv->next = *utsvp;
3168 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3170 struct uploaded_tsv *next_one;
3174 next_one = (*utsvp)->next;
3180 /* FIXME this function is heuristic and will miss the cases where the
3181 conditional is semantically identical but differs in whitespace,
3182 such as "x == 0" vs "x==0". */
3185 cond_string_is_same (char *str1, char *str2)
3187 if (str1 == NULL || str2 == NULL)
3188 return (str1 == str2);
3190 return (strcmp (str1, str2) == 0);
3193 /* Look for an existing tracepoint that seems similar enough to the
3194 uploaded one. Enablement isn't compared, because the user can
3195 toggle that freely, and may have done so in anticipation of the
3196 next trace run. Return the location of matched tracepoint. */
3198 static struct bp_location *
3199 find_matching_tracepoint_location (struct uploaded_tp *utp)
3201 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
3203 struct breakpoint *b;
3204 struct bp_location *loc;
3206 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
3208 struct tracepoint *t = (struct tracepoint *) b;
3210 if (b->type == utp->type
3211 && t->step_count == utp->step
3212 && t->pass_count == utp->pass
3213 && cond_string_is_same (t->cond_string, utp->cond_string)
3214 /* FIXME also test actions. */
3217 /* Scan the locations for an address match. */
3218 for (loc = b->loc; loc; loc = loc->next)
3220 if (loc->address == utp->addr)
3228 /* Given a list of tracepoints uploaded from a target, attempt to
3229 match them up with existing tracepoints, and create new ones if not
3233 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3235 struct uploaded_tp *utp;
3236 /* A set of tracepoints which are modified. */
3237 VEC(breakpoint_p) *modified_tp = NULL;
3239 struct breakpoint *b;
3241 /* Look for GDB tracepoints that match up with our uploaded versions. */
3242 for (utp = *uploaded_tps; utp; utp = utp->next)
3244 struct bp_location *loc;
3245 struct tracepoint *t;
3247 loc = find_matching_tracepoint_location (utp);
3252 /* Mark this location as already inserted. */
3254 t = (struct tracepoint *) loc->owner;
3255 printf_filtered (_("Assuming tracepoint %d is same "
3256 "as target's tracepoint %d at %s.\n"),
3257 loc->owner->number, utp->number,
3258 paddress (loc->gdbarch, utp->addr));
3260 /* The tracepoint LOC->owner was modified (the location LOC
3261 was marked as inserted in the target). Save it in
3262 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3263 observers will be notified later once for each tracepoint
3264 saved in MODIFIED_TP. */
3266 VEC_iterate (breakpoint_p, modified_tp, ix, b);
3268 if (b == loc->owner)
3274 VEC_safe_push (breakpoint_p, modified_tp, loc->owner);
3278 t = create_tracepoint_from_upload (utp);
3280 printf_filtered (_("Created tracepoint %d for "
3281 "target's tracepoint %d at %s.\n"),
3282 t->number, utp->number,
3283 paddress (get_current_arch (), utp->addr));
3285 printf_filtered (_("Failed to create tracepoint for target's "
3286 "tracepoint %d at %s, skipping it.\n"),
3288 paddress (get_current_arch (), utp->addr));
3290 /* Whether found or created, record the number used by the
3291 target, to help with mapping target tracepoints back to their
3292 counterparts here. */
3294 t->number_on_target = utp->number;
3297 /* Notify 'breakpoint-modified' observer that at least one of B's
3298 locations was changed. */
3299 for (ix = 0; VEC_iterate (breakpoint_p, modified_tp, ix, b); ix++)
3300 observer_notify_breakpoint_modified (b);
3302 VEC_free (breakpoint_p, modified_tp);
3303 free_uploaded_tps (uploaded_tps);
3306 /* Trace state variables don't have much to identify them beyond their
3307 name, so just use that to detect matches. */
3309 static struct trace_state_variable *
3310 find_matching_tsv (struct uploaded_tsv *utsv)
3315 return find_trace_state_variable (utsv->name);
3318 static struct trace_state_variable *
3319 create_tsv_from_upload (struct uploaded_tsv *utsv)
3321 const char *namebase;
3324 struct trace_state_variable *tsv;
3325 struct cleanup *old_chain;
3329 namebase = utsv->name;
3330 buf = xstrprintf ("%s", namebase);
3335 buf = xstrprintf ("%s_%d", namebase, try_num++);
3338 /* Fish for a name that is not in use. */
3339 /* (should check against all internal vars?) */
3340 while (find_trace_state_variable (buf))
3343 buf = xstrprintf ("%s_%d", namebase, try_num++);
3346 old_chain = make_cleanup (xfree, buf);
3348 /* We have an available name, create the variable. */
3349 tsv = create_trace_state_variable (buf);
3350 tsv->initial_value = utsv->initial_value;
3351 tsv->builtin = utsv->builtin;
3353 observer_notify_tsv_created (tsv);
3355 do_cleanups (old_chain);
3360 /* Given a list of uploaded trace state variables, try to match them
3361 up with existing variables, or create additional ones. */
3364 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
3367 struct uploaded_tsv *utsv;
3368 struct trace_state_variable *tsv;
3371 /* Most likely some numbers will have to be reassigned as part of
3372 the merge, so clear them all in anticipation. */
3373 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3376 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
3378 tsv = find_matching_tsv (utsv);
3382 printf_filtered (_("Assuming trace state variable $%s "
3383 "is same as target's variable %d.\n"),
3384 tsv->name, utsv->number);
3388 tsv = create_tsv_from_upload (utsv);
3390 printf_filtered (_("Created trace state variable "
3391 "$%s for target's variable %d.\n"),
3392 tsv->name, utsv->number);
3394 /* Give precedence to numberings that come from the target. */
3396 tsv->number = utsv->number;
3399 /* Renumber everything that didn't get a target-assigned number. */
3401 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3402 if (tsv->number > highest)
3403 highest = tsv->number;
3406 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3407 if (tsv->number == 0)
3408 tsv->number = highest++;
3410 free_uploaded_tsvs (uploaded_tsvs);
3413 /* Parse the part of trace status syntax that is shared between
3414 the remote protocol and the trace file reader. */
3417 parse_trace_status (char *line, struct trace_status *ts)
3419 char *p = line, *p1, *p2, *p3, *p_temp;
3423 ts->running_known = 1;
3424 ts->running = (*p++ == '1');
3425 ts->stop_reason = trace_stop_reason_unknown;
3426 xfree (ts->stop_desc);
3427 ts->stop_desc = NULL;
3428 ts->traceframe_count = -1;
3429 ts->traceframes_created = -1;
3430 ts->buffer_free = -1;
3431 ts->buffer_size = -1;
3432 ts->disconnected_tracing = 0;
3433 ts->circular_buffer = 0;
3434 xfree (ts->user_name);
3435 ts->user_name = NULL;
3438 ts->start_time = ts->stop_time = 0;
3442 p1 = strchr (p, ':');
3444 error (_("Malformed trace status, at %s\n\
3445 Status line: '%s'\n"), p, line);
3446 p3 = strchr (p, ';');
3448 p3 = p + strlen (p);
3449 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3451 p = unpack_varlen_hex (++p1, &val);
3452 ts->stop_reason = trace_buffer_full;
3454 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3456 p = unpack_varlen_hex (++p1, &val);
3457 ts->stop_reason = trace_never_run;
3459 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
3462 p = unpack_varlen_hex (++p1, &val);
3463 ts->stop_reason = tracepoint_passcount;
3464 ts->stopping_tracepoint = val;
3466 else if (strncmp (p, stop_reason_names[trace_stop_command], p1 - p) == 0)
3468 p2 = strchr (++p1, ':');
3476 ts->stop_desc = (char *) xmalloc (strlen (line));
3477 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
3478 ts->stop_desc[end] = '\0';
3481 ts->stop_desc = xstrdup ("");
3483 p = unpack_varlen_hex (++p2, &val);
3484 ts->stop_reason = trace_stop_command;
3486 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3488 p = unpack_varlen_hex (++p1, &val);
3489 ts->stop_reason = trace_disconnected;
3491 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3493 p2 = strchr (++p1, ':');
3496 ts->stop_desc = (char *) xmalloc ((p2 - p1) / 2 + 1);
3497 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
3498 ts->stop_desc[end] = '\0';
3501 ts->stop_desc = xstrdup ("");
3503 p = unpack_varlen_hex (++p2, &val);
3504 ts->stopping_tracepoint = val;
3505 ts->stop_reason = tracepoint_error;
3507 else if (strncmp (p, "tframes", p1 - p) == 0)
3509 p = unpack_varlen_hex (++p1, &val);
3510 ts->traceframe_count = val;
3512 else if (strncmp (p, "tcreated", p1 - p) == 0)
3514 p = unpack_varlen_hex (++p1, &val);
3515 ts->traceframes_created = val;
3517 else if (strncmp (p, "tfree", p1 - p) == 0)
3519 p = unpack_varlen_hex (++p1, &val);
3520 ts->buffer_free = val;
3522 else if (strncmp (p, "tsize", p1 - p) == 0)
3524 p = unpack_varlen_hex (++p1, &val);
3525 ts->buffer_size = val;
3527 else if (strncmp (p, "disconn", p1 - p) == 0)
3529 p = unpack_varlen_hex (++p1, &val);
3530 ts->disconnected_tracing = val;
3532 else if (strncmp (p, "circular", p1 - p) == 0)
3534 p = unpack_varlen_hex (++p1, &val);
3535 ts->circular_buffer = val;
3537 else if (strncmp (p, "starttime", p1 - p) == 0)
3539 p = unpack_varlen_hex (++p1, &val);
3540 ts->start_time = val;
3542 else if (strncmp (p, "stoptime", p1 - p) == 0)
3544 p = unpack_varlen_hex (++p1, &val);
3545 ts->stop_time = val;
3547 else if (strncmp (p, "username", p1 - p) == 0)
3550 ts->user_name = (char *) xmalloc (strlen (p) / 2);
3551 end = hex2bin (p1, (gdb_byte *) ts->user_name, (p3 - p1) / 2);
3552 ts->user_name[end] = '\0';
3555 else if (strncmp (p, "notes", p1 - p) == 0)
3558 ts->notes = (char *) xmalloc (strlen (p) / 2);
3559 end = hex2bin (p1, (gdb_byte *) ts->notes, (p3 - p1) / 2);
3560 ts->notes[end] = '\0';
3565 /* Silently skip unknown optional info. */
3566 p_temp = strchr (p1 + 1, ';');
3570 /* Must be at the end. */
3577 parse_tracepoint_status (char *p, struct breakpoint *bp,
3578 struct uploaded_tp *utp)
3581 struct tracepoint *tp = (struct tracepoint *) bp;
3583 p = unpack_varlen_hex (p, &uval);
3585 tp->hit_count += uval;
3587 utp->hit_count += uval;
3588 p = unpack_varlen_hex (p + 1, &uval);
3590 tp->traceframe_usage += uval;
3592 utp->traceframe_usage += uval;
3593 /* Ignore any extra, allowing for future extensions. */
3596 /* Given a line of text defining a part of a tracepoint, parse it into
3597 an "uploaded tracepoint". */
3600 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
3604 ULONGEST num, addr, step, pass, orig_size, xlen, start;
3607 char *cond, *srctype, *buf;
3608 struct uploaded_tp *utp = NULL;
3611 /* Both tracepoint and action definitions start with the same number
3612 and address sequence. */
3614 p = unpack_varlen_hex (p, &num);
3615 p++; /* skip a colon */
3616 p = unpack_varlen_hex (p, &addr);
3617 p++; /* skip a colon */
3620 enabled = (*p++ == 'E');
3621 p++; /* skip a colon */
3622 p = unpack_varlen_hex (p, &step);
3623 p++; /* skip a colon */
3624 p = unpack_varlen_hex (p, &pass);
3625 type = bp_tracepoint;
3627 /* Thumb through optional fields. */
3630 p++; /* skip a colon */
3633 type = bp_fast_tracepoint;
3635 p = unpack_varlen_hex (p, &orig_size);
3639 type = bp_static_tracepoint;
3645 p = unpack_varlen_hex (p, &xlen);
3646 p++; /* skip a comma */
3647 cond = (char *) xmalloc (2 * xlen + 1);
3648 strncpy (cond, p, 2 * xlen);
3649 cond[2 * xlen] = '\0';
3653 warning (_("Unrecognized char '%c' in tracepoint "
3654 "definition, skipping rest"), *p);
3656 utp = get_uploaded_tp (num, addr, utpp);
3658 utp->enabled = enabled;
3663 else if (piece == 'A')
3665 utp = get_uploaded_tp (num, addr, utpp);
3666 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
3668 else if (piece == 'S')
3670 utp = get_uploaded_tp (num, addr, utpp);
3671 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
3673 else if (piece == 'Z')
3675 /* Parse a chunk of source form definition. */
3676 utp = get_uploaded_tp (num, addr, utpp);
3678 p = strchr (p, ':');
3679 p++; /* skip a colon */
3680 p = unpack_varlen_hex (p, &start);
3681 p++; /* skip a colon */
3682 p = unpack_varlen_hex (p, &xlen);
3683 p++; /* skip a colon */
3685 buf = (char *) alloca (strlen (line));
3687 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3690 if (startswith (srctype, "at:"))
3691 utp->at_string = xstrdup (buf);
3692 else if (startswith (srctype, "cond:"))
3693 utp->cond_string = xstrdup (buf);
3694 else if (startswith (srctype, "cmd:"))
3695 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
3697 else if (piece == 'V')
3699 utp = get_uploaded_tp (num, addr, utpp);
3701 parse_tracepoint_status (p, NULL, utp);
3705 /* Don't error out, the target might be sending us optional
3706 info that we don't care about. */
3707 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
3711 /* Convert a textual description of a trace state variable into an
3715 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
3718 ULONGEST num, initval, builtin;
3720 struct uploaded_tsv *utsv = NULL;
3722 buf = (char *) alloca (strlen (line));
3725 p = unpack_varlen_hex (p, &num);
3726 p++; /* skip a colon */
3727 p = unpack_varlen_hex (p, &initval);
3728 p++; /* skip a colon */
3729 p = unpack_varlen_hex (p, &builtin);
3730 p++; /* skip a colon */
3731 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3734 utsv = get_uploaded_tsv (num, utsvp);
3735 utsv->initial_value = initval;
3736 utsv->builtin = builtin;
3737 utsv->name = xstrdup (buf);
3741 free_current_marker (void *arg)
3743 struct static_tracepoint_marker **marker_p
3744 = (struct static_tracepoint_marker **) arg;
3746 if (*marker_p != NULL)
3748 release_static_tracepoint_marker (*marker_p);
3755 /* Given a line of text defining a static tracepoint marker, parse it
3756 into a "static tracepoint marker" object. Throws an error is
3757 parsing fails. If PP is non-null, it points to one past the end of
3758 the parsed marker definition. */
3761 parse_static_tracepoint_marker_definition (char *line, char **pp,
3762 struct static_tracepoint_marker *marker)
3769 p = unpack_varlen_hex (p, &addr);
3770 p++; /* skip a colon */
3772 marker->gdbarch = target_gdbarch ();
3773 marker->address = (CORE_ADDR) addr;
3775 endp = strchr (p, ':');
3777 error (_("bad marker definition: %s"), line);
3779 marker->str_id = (char *) xmalloc (endp - p + 1);
3780 end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
3781 marker->str_id[end] = '\0';
3784 p++; /* skip a colon */
3786 marker->extra = (char *) xmalloc (strlen (p) + 1);
3787 end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
3788 marker->extra[end] = '\0';
3794 /* Release a static tracepoint marker's contents. Note that the
3795 object itself isn't released here. There objects are usually on
3799 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
3801 xfree (marker->str_id);
3802 marker->str_id = NULL;
3805 /* Print MARKER to gdb_stdout. */
3808 print_one_static_tracepoint_marker (int count,
3809 struct static_tracepoint_marker *marker)
3813 char wrap_indent[80];
3814 char extra_field_indent[80];
3815 struct ui_out *uiout = current_uiout;
3816 VEC(breakpoint_p) *tracepoints;
3818 symtab_and_line sal;
3819 sal.pc = marker->address;
3821 tracepoints = static_tracepoints_here (marker->address);
3823 ui_out_emit_tuple tuple_emitter (uiout, "marker");
3825 /* A counter field to help readability. This is not a stable
3827 uiout->field_int ("count", count);
3829 uiout->field_string ("marker-id", marker->str_id);
3831 uiout->field_fmt ("enabled", "%c",
3832 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
3835 strcpy (wrap_indent, " ");
3837 if (gdbarch_addr_bit (marker->gdbarch) <= 32)
3838 strcat (wrap_indent, " ");
3840 strcat (wrap_indent, " ");
3842 strcpy (extra_field_indent, " ");
3844 uiout->field_core_addr ("addr", marker->gdbarch, marker->address);
3846 sal = find_pc_line (marker->address, 0);
3847 sym = find_pc_sect_function (marker->address, NULL);
3850 uiout->text ("in ");
3851 uiout->field_string ("func",
3852 SYMBOL_PRINT_NAME (sym));
3853 uiout->wrap_hint (wrap_indent);
3854 uiout->text (" at ");
3857 uiout->field_skip ("func");
3859 if (sal.symtab != NULL)
3861 uiout->field_string ("file",
3862 symtab_to_filename_for_display (sal.symtab));
3865 if (uiout->is_mi_like_p ())
3867 const char *fullname = symtab_to_fullname (sal.symtab);
3869 uiout->field_string ("fullname", fullname);
3872 uiout->field_skip ("fullname");
3874 uiout->field_int ("line", sal.line);
3878 uiout->field_skip ("fullname");
3879 uiout->field_skip ("line");
3883 uiout->text (extra_field_indent);
3884 uiout->text (_("Data: \""));
3885 uiout->field_string ("extra-data", marker->extra);
3886 uiout->text ("\"\n");
3888 if (!VEC_empty (breakpoint_p, tracepoints))
3891 struct breakpoint *b;
3894 ui_out_emit_tuple tuple_emitter (uiout, "tracepoints-at");
3896 uiout->text (extra_field_indent);
3897 uiout->text (_("Probed by static tracepoints: "));
3898 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
3903 uiout->field_int ("tracepoint-id", b->number);
3907 if (uiout->is_mi_like_p ())
3908 uiout->field_int ("number-of-tracepoints",
3909 VEC_length(breakpoint_p, tracepoints));
3913 VEC_free (breakpoint_p, tracepoints);
3917 info_static_tracepoint_markers_command (char *arg, int from_tty)
3919 VEC(static_tracepoint_marker_p) *markers;
3920 struct cleanup *old_chain;
3921 struct static_tracepoint_marker *marker;
3922 struct ui_out *uiout = current_uiout;
3925 /* We don't have to check target_can_use_agent and agent's capability on
3926 static tracepoint here, in order to be compatible with older GDBserver.
3927 We don't check USE_AGENT is true or not, because static tracepoints
3928 don't work without in-process agent, so we don't bother users to type
3929 `set agent on' when to use static tracepoint. */
3931 ui_out_emit_table table_emitter (uiout, 5, -1,
3932 "StaticTracepointMarkersTable");
3934 uiout->table_header (7, ui_left, "counter", "Cnt");
3936 uiout->table_header (40, ui_left, "marker-id", "ID");
3938 uiout->table_header (3, ui_left, "enabled", "Enb");
3939 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
3940 uiout->table_header (10, ui_left, "addr", "Address");
3942 uiout->table_header (18, ui_left, "addr", "Address");
3943 uiout->table_header (40, ui_noalign, "what", "What");
3945 uiout->table_body ();
3947 markers = target_static_tracepoint_markers_by_strid (NULL);
3948 old_chain = make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
3951 VEC_iterate (static_tracepoint_marker_p,
3952 markers, i, marker);
3955 print_one_static_tracepoint_marker (i + 1, marker);
3956 release_static_tracepoint_marker (marker);
3959 do_cleanups (old_chain);
3962 /* The $_sdata convenience variable is a bit special. We don't know
3963 for sure type of the value until we actually have a chance to fetch
3964 the data --- the size of the object depends on what has been
3965 collected. We solve this by making $_sdata be an internalvar that
3966 creates a new value on access. */
3968 /* Return a new value with the correct type for the sdata object of
3969 the current trace frame. Return a void value if there's no object
3972 static struct value *
3973 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
3979 /* We need to read the whole object before we know its size. */
3980 size = target_read_alloc (¤t_target,
3981 TARGET_OBJECT_STATIC_TRACE_DATA,
3988 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
3990 v = allocate_value (type);
3991 memcpy (value_contents_raw (v), buf, size);
3996 return allocate_value (builtin_type (gdbarch)->builtin_void);
3999 #if !defined(HAVE_LIBEXPAT)
4001 struct traceframe_info *
4002 parse_traceframe_info (const char *tframe_info)
4004 static int have_warned;
4009 warning (_("Can not parse XML trace frame info; XML support "
4010 "was disabled at compile time"));
4016 #else /* HAVE_LIBEXPAT */
4018 #include "xml-support.h"
4020 /* Handle the start of a <memory> element. */
4023 traceframe_info_start_memory (struct gdb_xml_parser *parser,
4024 const struct gdb_xml_element *element,
4025 void *user_data, VEC(gdb_xml_value_s) *attributes)
4027 struct traceframe_info *info = (struct traceframe_info *) user_data;
4028 struct mem_range *r = VEC_safe_push (mem_range_s, info->memory, NULL);
4029 ULONGEST *start_p, *length_p;
4032 = (ULONGEST *) xml_find_attribute (attributes, "start")->value;
4034 = (ULONGEST *) xml_find_attribute (attributes, "length")->value;
4036 r->start = *start_p;
4037 r->length = *length_p;
4040 /* Handle the start of a <tvar> element. */
4043 traceframe_info_start_tvar (struct gdb_xml_parser *parser,
4044 const struct gdb_xml_element *element,
4046 VEC(gdb_xml_value_s) *attributes)
4048 struct traceframe_info *info = (struct traceframe_info *) user_data;
4049 const char *id_attrib
4050 = (const char *) xml_find_attribute (attributes, "id")->value;
4051 int id = gdb_xml_parse_ulongest (parser, id_attrib);
4053 VEC_safe_push (int, info->tvars, id);
4056 /* Discard the constructed trace frame info (if an error occurs). */
4059 free_result (void *p)
4061 struct traceframe_info *result = (struct traceframe_info *) p;
4063 free_traceframe_info (result);
4066 /* The allowed elements and attributes for an XML memory map. */
4068 static const struct gdb_xml_attribute memory_attributes[] = {
4069 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4070 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4071 { NULL, GDB_XML_AF_NONE, NULL, NULL }
4074 static const struct gdb_xml_attribute tvar_attributes[] = {
4075 { "id", GDB_XML_AF_NONE, NULL, NULL },
4076 { NULL, GDB_XML_AF_NONE, NULL, NULL }
4079 static const struct gdb_xml_element traceframe_info_children[] = {
4080 { "memory", memory_attributes, NULL,
4081 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
4082 traceframe_info_start_memory, NULL },
4083 { "tvar", tvar_attributes, NULL,
4084 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
4085 traceframe_info_start_tvar, NULL },
4086 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4089 static const struct gdb_xml_element traceframe_info_elements[] = {
4090 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
4092 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4095 /* Parse a traceframe-info XML document. */
4097 struct traceframe_info *
4098 parse_traceframe_info (const char *tframe_info)
4100 struct traceframe_info *result;
4101 struct cleanup *back_to;
4103 result = XCNEW (struct traceframe_info);
4104 back_to = make_cleanup (free_result, result);
4106 if (gdb_xml_parse_quick (_("trace frame info"),
4107 "traceframe-info.dtd", traceframe_info_elements,
4108 tframe_info, result) == 0)
4110 /* Parsed successfully, keep the result. */
4111 discard_cleanups (back_to);
4116 do_cleanups (back_to);
4120 #endif /* HAVE_LIBEXPAT */
4122 /* Returns the traceframe_info object for the current traceframe.
4123 This is where we avoid re-fetching the object from the target if we
4124 already have it cached. */
4126 struct traceframe_info *
4127 get_traceframe_info (void)
4129 if (traceframe_info == NULL)
4130 traceframe_info = target_traceframe_info ();
4132 return traceframe_info;
4135 /* If the target supports the query, return in RESULT the set of
4136 collected memory in the current traceframe, found within the LEN
4137 bytes range starting at MEMADDR. Returns true if the target
4138 supports the query, otherwise returns false, and RESULT is left
4142 traceframe_available_memory (VEC(mem_range_s) **result,
4143 CORE_ADDR memaddr, ULONGEST len)
4145 struct traceframe_info *info = get_traceframe_info ();
4149 struct mem_range *r;
4154 for (i = 0; VEC_iterate (mem_range_s, info->memory, i, r); i++)
4155 if (mem_ranges_overlap (r->start, r->length, memaddr, len))
4157 ULONGEST lo1, hi1, lo2, hi2;
4158 struct mem_range *nr;
4161 hi1 = memaddr + len;
4164 hi2 = r->start + r->length;
4166 nr = VEC_safe_push (mem_range_s, *result, NULL);
4168 nr->start = std::max (lo1, lo2);
4169 nr->length = std::min (hi1, hi2) - nr->start;
4172 normalize_mem_ranges (*result);
4179 /* Implementation of `sdata' variable. */
4181 static const struct internalvar_funcs sdata_funcs =
4188 /* module initialization */
4190 _initialize_tracepoint (void)
4192 struct cmd_list_element *c;
4194 /* Explicitly create without lookup, since that tries to create a
4195 value with a void typed value, and when we get here, gdbarch
4196 isn't initialized yet. At this point, we're quite sure there
4197 isn't another convenience variable of the same name. */
4198 create_internalvar_type_lazy ("_sdata", &sdata_funcs, NULL);
4200 traceframe_number = -1;
4201 tracepoint_number = -1;
4203 add_info ("scope", info_scope_command,
4204 _("List the variables local to a scope"));
4206 add_cmd ("tracepoints", class_trace,
4207 _("Tracing of program execution without stopping the program."),
4210 add_com ("tdump", class_trace, tdump_command,
4211 _("Print everything collected at the current tracepoint."));
4213 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
4214 Define a trace state variable.\n\
4215 Argument is a $-prefixed name, optionally followed\n\
4216 by '=' and an expression that sets the initial value\n\
4217 at the start of tracing."));
4218 set_cmd_completer (c, expression_completer);
4220 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
4221 Delete one or more trace state variables.\n\
4222 Arguments are the names of the variables to delete.\n\
4223 If no arguments are supplied, delete all variables."), &deletelist);
4224 /* FIXME add a trace variable completer. */
4226 add_info ("tvariables", info_tvariables_command, _("\
4227 Status of trace state variables and their values.\n\
4230 add_info ("static-tracepoint-markers",
4231 info_static_tracepoint_markers_command, _("\
4232 List target static tracepoints markers.\n\
4235 add_prefix_cmd ("tfind", class_trace, tfind_command, _("\
4236 Select a trace frame;\n\
4237 No argument means forward by one frame; '-' means backward by one frame."),
4238 &tfindlist, "tfind ", 1, &cmdlist);
4240 add_cmd ("outside", class_trace, tfind_outside_command, _("\
4241 Select a trace frame whose PC is outside the given range (exclusive).\n\
4242 Usage: tfind outside addr1, addr2"),
4245 add_cmd ("range", class_trace, tfind_range_command, _("\
4246 Select a trace frame whose PC is in the given range (inclusive).\n\
4247 Usage: tfind range addr1,addr2"),
4250 add_cmd ("line", class_trace, tfind_line_command, _("\
4251 Select a trace frame by source line.\n\
4252 Argument can be a line number (with optional source file),\n\
4253 a function name, or '*' followed by an address.\n\
4254 Default argument is 'the next source line that was traced'."),
4257 add_cmd ("tracepoint", class_trace, tfind_tracepoint_command, _("\
4258 Select a trace frame by tracepoint number.\n\
4259 Default is the tracepoint for the current trace frame."),
4262 add_cmd ("pc", class_trace, tfind_pc_command, _("\
4263 Select a trace frame by PC.\n\
4264 Default is the current PC, or the PC of the current trace frame."),
4267 add_cmd ("end", class_trace, tfind_end_command, _("\
4268 De-select any trace frame and resume 'live' debugging."),
4271 add_alias_cmd ("none", "end", class_trace, 0, &tfindlist);
4273 add_cmd ("start", class_trace, tfind_start_command,
4274 _("Select the first trace frame in the trace buffer."),
4277 add_com ("tstatus", class_trace, tstatus_command,
4278 _("Display the status of the current trace data collection."));
4280 add_com ("tstop", class_trace, tstop_command, _("\
4281 Stop trace data collection.\n\
4282 Usage: tstop [ <notes> ... ]\n\
4283 Any arguments supplied are recorded with the trace as a stop reason and\n\
4284 reported by tstatus (if the target supports trace notes)."));
4286 add_com ("tstart", class_trace, tstart_command, _("\
4287 Start trace data collection.\n\
4288 Usage: tstart [ <notes> ... ]\n\
4289 Any arguments supplied are recorded with the trace as a note and\n\
4290 reported by tstatus (if the target supports trace notes)."));
4292 add_com ("end", class_trace, end_actions_pseudocommand, _("\
4293 Ends a list of commands or actions.\n\
4294 Several GDB commands allow you to enter a list of commands or actions.\n\
4295 Entering \"end\" on a line by itself is the normal way to terminate\n\
4297 Note: the \"end\" command cannot be used at the gdb prompt."));
4299 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
4300 Specify single-stepping behavior at a tracepoint.\n\
4301 Argument is number of instructions to trace in single-step mode\n\
4302 following the tracepoint. This command is normally followed by\n\
4303 one or more \"collect\" commands, to specify what to collect\n\
4304 while single-stepping.\n\n\
4305 Note: this command can only be used in a tracepoint \"actions\" list."));
4307 add_com_alias ("ws", "while-stepping", class_alias, 0);
4308 add_com_alias ("stepping", "while-stepping", class_alias, 0);
4310 add_com ("collect", class_trace, collect_pseudocommand, _("\
4311 Specify one or more data items to be collected at a tracepoint.\n\
4312 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4313 collect all data (variables, registers) referenced by that expression.\n\
4314 Also accepts the following special arguments:\n\
4315 $regs -- all registers.\n\
4316 $args -- all function arguments.\n\
4317 $locals -- all variables local to the block/function scope.\n\
4318 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4319 Note: this command can only be used in a tracepoint \"actions\" list."));
4321 add_com ("teval", class_trace, teval_pseudocommand, _("\
4322 Specify one or more expressions to be evaluated at a tracepoint.\n\
4323 Accepts a comma-separated list of (one or more) expressions.\n\
4324 The result of each evaluation will be discarded.\n\
4325 Note: this command can only be used in a tracepoint \"actions\" list."));
4327 add_com ("actions", class_trace, actions_command, _("\
4328 Specify the actions to be taken at a tracepoint.\n\
4329 Tracepoint actions may include collecting of specified data,\n\
4330 single-stepping, or enabling/disabling other tracepoints,\n\
4331 depending on target's capabilities."));
4333 default_collect = xstrdup ("");
4334 add_setshow_string_cmd ("default-collect", class_trace,
4335 &default_collect, _("\
4336 Set the list of expressions to collect by default"), _("\
4337 Show the list of expressions to collect by default"), NULL,
4339 &setlist, &showlist);
4341 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
4342 &disconnected_tracing, _("\
4343 Set whether tracing continues after GDB disconnects."), _("\
4344 Show whether tracing continues after GDB disconnects."), _("\
4345 Use this to continue a tracing run even if GDB disconnects\n\
4346 or detaches from the target. You can reconnect later and look at\n\
4347 trace data collected in the meantime."),
4348 set_disconnected_tracing,
4353 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
4354 &circular_trace_buffer, _("\
4355 Set target's use of circular trace buffer."), _("\
4356 Show target's use of circular trace buffer."), _("\
4357 Use this to make the trace buffer into a circular buffer,\n\
4358 which will discard traceframes (oldest first) instead of filling\n\
4359 up and stopping the trace run."),
4360 set_circular_trace_buffer,
4365 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class,
4366 &trace_buffer_size, _("\
4367 Set requested size of trace buffer."), _("\
4368 Show requested size of trace buffer."), _("\
4369 Use this to choose a size for the trace buffer. Some targets\n\
4370 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
4371 disables any attempt to set the buffer size and lets the target choose."),
4372 set_trace_buffer_size, NULL,
4373 &setlist, &showlist);
4375 add_setshow_string_cmd ("trace-user", class_trace,
4377 Set the user name to use for current and future trace runs"), _("\
4378 Show the user name to use for current and future trace runs"), NULL,
4379 set_trace_user, NULL,
4380 &setlist, &showlist);
4382 add_setshow_string_cmd ("trace-notes", class_trace,
4384 Set notes string to use for current and future trace runs"), _("\
4385 Show the notes string to use for current and future trace runs"), NULL,
4386 set_trace_notes, NULL,
4387 &setlist, &showlist);
4389 add_setshow_string_cmd ("trace-stop-notes", class_trace,
4390 &trace_stop_notes, _("\
4391 Set notes string to use for future tstop commands"), _("\
4392 Show the notes string to use for future tstop commands"), NULL,
4393 set_trace_stop_notes, NULL,
4394 &setlist, &showlist);