1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2018 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"
39 #include "observable.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 static std::vector<trace_state_variable> tvariables;
119 /* The next integer to assign to a variable. */
121 static int next_tsv_number = 1;
123 /* Number of last traceframe collected. */
124 static int traceframe_number;
126 /* Tracepoint for last traceframe collected. */
127 static int tracepoint_number;
129 /* The traceframe info of the current traceframe. NULL if we haven't
130 yet attempted to fetch it, or if the target does not support
131 fetching this object, or if we're not inspecting a traceframe
133 static traceframe_info_up current_traceframe_info;
135 /* Tracing command lists. */
136 static struct cmd_list_element *tfindlist;
138 /* List of expressions to collect by default at each tracepoint hit. */
139 char *default_collect;
141 static int disconnected_tracing;
143 /* This variable controls whether we ask the target for a linear or
144 circular trace buffer. */
146 static int circular_trace_buffer;
148 /* This variable is the requested trace buffer size, or -1 to indicate
149 that we don't care and leave it up to the target to set a size. */
151 static int trace_buffer_size = -1;
153 /* Textual notes applying to the current and/or future trace runs. */
155 char *trace_user = NULL;
157 /* Textual notes applying to the current and/or future trace runs. */
159 char *trace_notes = NULL;
161 /* Textual notes applying to the stopping of a trace. */
163 char *trace_stop_notes = NULL;
165 /* support routines */
167 struct collection_list;
168 static char *mem2hex (gdb_byte *, char *, int);
170 static counted_command_line all_tracepoint_actions (struct breakpoint *);
172 static struct trace_status trace_status;
174 const char *stop_reason_names[] = {
184 struct trace_status *
185 current_trace_status (void)
187 return &trace_status;
190 /* Free and clear the traceframe info cache of the current
194 clear_traceframe_info (void)
196 current_traceframe_info = NULL;
199 /* Set traceframe number to NUM. */
201 set_traceframe_num (int num)
203 traceframe_number = num;
204 set_internalvar_integer (lookup_internalvar ("trace_frame"), num);
207 /* Set tracepoint number to NUM. */
209 set_tracepoint_num (int num)
211 tracepoint_number = num;
212 set_internalvar_integer (lookup_internalvar ("tracepoint"), num);
215 /* Set externally visible debug variables for querying/printing
216 the traceframe context (line, function, file). */
219 set_traceframe_context (struct frame_info *trace_frame)
222 struct symbol *traceframe_fun;
223 symtab_and_line traceframe_sal;
225 /* Save as globals for internal use. */
226 if (trace_frame != NULL
227 && get_frame_pc_if_available (trace_frame, &trace_pc))
229 traceframe_sal = find_pc_line (trace_pc, 0);
230 traceframe_fun = find_pc_function (trace_pc);
232 /* Save linenumber as "$trace_line", a debugger variable visible to
234 set_internalvar_integer (lookup_internalvar ("trace_line"),
235 traceframe_sal.line);
239 traceframe_fun = NULL;
240 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
243 /* Save func name as "$trace_func", a debugger variable visible to
245 if (traceframe_fun == NULL
246 || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
247 clear_internalvar (lookup_internalvar ("trace_func"));
249 set_internalvar_string (lookup_internalvar ("trace_func"),
250 SYMBOL_LINKAGE_NAME (traceframe_fun));
252 /* Save file name as "$trace_file", a debugger variable visible to
254 if (traceframe_sal.symtab == NULL)
255 clear_internalvar (lookup_internalvar ("trace_file"));
257 set_internalvar_string (lookup_internalvar ("trace_file"),
258 symtab_to_filename_for_display (traceframe_sal.symtab));
261 /* Create a new trace state variable with the given name. */
263 struct trace_state_variable *
264 create_trace_state_variable (const char *name)
266 tvariables.emplace_back (name, next_tsv_number++);
267 return &tvariables.back ();
270 /* Look for a trace state variable of the given name. */
272 struct trace_state_variable *
273 find_trace_state_variable (const char *name)
275 for (trace_state_variable &tsv : tvariables)
276 if (tsv.name == name)
282 /* Look for a trace state variable of the given number. Return NULL if
285 struct trace_state_variable *
286 find_trace_state_variable_by_number (int number)
288 for (trace_state_variable &tsv : tvariables)
289 if (tsv.number == number)
296 delete_trace_state_variable (const char *name)
298 for (auto it = tvariables.begin (); it != tvariables.end (); it++)
299 if (it->name == name)
301 gdb::observers::tsv_deleted.notify (&*it);
302 tvariables.erase (it);
306 warning (_("No trace variable named \"$%s\", not deleting"), name);
309 /* Throws an error if NAME is not valid syntax for a trace state
313 validate_trace_state_variable_name (const char *name)
318 error (_("Must supply a non-empty variable name"));
320 /* All digits in the name is reserved for value history
322 for (p = name; isdigit (*p); p++)
325 error (_("$%s is not a valid trace state variable name"), name);
327 for (p = name; isalnum (*p) || *p == '_'; p++)
330 error (_("$%s is not a valid trace state variable name"), name);
333 /* The 'tvariable' command collects a name and optional expression to
334 evaluate into an initial value. */
337 trace_variable_command (const char *args, int from_tty)
340 struct trace_state_variable *tsv;
341 const char *name_start, *p;
344 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
346 /* Only allow two syntaxes; "$name" and "$name=value". */
347 p = skip_spaces (args);
350 error (_("Name of trace variable should start with '$'"));
353 while (isalnum (*p) || *p == '_')
355 std::string name (name_start, p - name_start);
358 if (*p != '=' && *p != '\0')
359 error (_("Syntax must be $NAME [ = EXPR ]"));
361 validate_trace_state_variable_name (name.c_str ());
364 initval = value_as_long (parse_and_eval (++p));
366 /* If the variable already exists, just change its initial value. */
367 tsv = find_trace_state_variable (name.c_str ());
370 if (tsv->initial_value != initval)
372 tsv->initial_value = initval;
373 gdb::observers::tsv_modified.notify (tsv);
375 printf_filtered (_("Trace state variable $%s "
376 "now has initial value %s.\n"),
377 tsv->name.c_str (), plongest (tsv->initial_value));
381 /* Create a new variable. */
382 tsv = create_trace_state_variable (name.c_str ());
383 tsv->initial_value = initval;
385 gdb::observers::tsv_created.notify (tsv);
387 printf_filtered (_("Trace state variable $%s "
388 "created, with initial value %s.\n"),
389 tsv->name.c_str (), plongest (tsv->initial_value));
393 delete_trace_variable_command (const char *args, int from_tty)
397 if (query (_("Delete all trace state variables? ")))
400 gdb::observers::tsv_deleted.notify (NULL);
404 gdb_argv argv (args);
406 for (char *arg : argv)
409 delete_trace_state_variable (arg + 1);
411 warning (_("Name \"%s\" not prefixed with '$', ignoring"), arg);
418 tvariables_info_1 (void)
420 struct ui_out *uiout = current_uiout;
422 /* Try to acquire values from the target. */
423 for (trace_state_variable &tsv : tvariables)
425 = target_get_trace_state_variable_value (tsv.number, &tsv.value);
428 ui_out_emit_table table_emitter (uiout, 3, tvariables.size (),
430 uiout->table_header (15, ui_left, "name", "Name");
431 uiout->table_header (11, ui_left, "initial", "Initial");
432 uiout->table_header (11, ui_left, "current", "Current");
434 uiout->table_body ();
436 for (const trace_state_variable &tsv : tvariables)
440 ui_out_emit_tuple tuple_emitter (uiout, "variable");
442 uiout->field_string ("name", std::string ("$") + tsv.name);
443 uiout->field_string ("initial", plongest (tsv.initial_value));
446 c = plongest (tsv.value);
447 else if (uiout->is_mi_like_p ())
448 /* For MI, we prefer not to use magic string constants, but rather
449 omit the field completely. The difference between unknown and
450 undefined does not seem important enough to represent. */
452 else if (current_trace_status ()->running || traceframe_number >= 0)
453 /* The value is/was defined, but we don't have it. */
456 /* It is not meaningful to ask about the value. */
459 uiout->field_string ("current", c);
464 if (tvariables.empty ())
465 uiout->text (_("No trace state variables.\n"));
468 /* List all the trace state variables. */
471 info_tvariables_command (const char *args, int from_tty)
473 tvariables_info_1 ();
476 /* Stash definitions of tsvs into the given file. */
479 save_trace_state_variables (struct ui_file *fp)
481 for (const trace_state_variable &tsv : tvariables)
483 fprintf_unfiltered (fp, "tvariable $%s", tsv.name.c_str ());
484 if (tsv.initial_value)
485 fprintf_unfiltered (fp, " = %s", plongest (tsv.initial_value));
486 fprintf_unfiltered (fp, "\n");
490 /* ACTIONS functions: */
492 /* The three functions:
493 collect_pseudocommand,
494 while_stepping_pseudocommand, and
495 end_actions_pseudocommand
496 are placeholders for "commands" that are actually ONLY to be used
497 within a tracepoint action list. If the actual function is ever called,
498 it means that somebody issued the "command" at the top level,
499 which is always an error. */
502 end_actions_pseudocommand (const char *args, int from_tty)
504 error (_("This command cannot be used at the top level."));
508 while_stepping_pseudocommand (const char *args, int from_tty)
510 error (_("This command can only be used in a tracepoint actions list."));
514 collect_pseudocommand (const char *args, int from_tty)
516 error (_("This command can only be used in a tracepoint actions list."));
520 teval_pseudocommand (const char *args, int from_tty)
522 error (_("This command can only be used in a tracepoint actions list."));
525 /* Parse any collection options, such as /s for strings. */
528 decode_agent_options (const char *exp, int *trace_string)
530 struct value_print_options opts;
537 /* Call this to borrow the print elements default for collection
539 get_user_print_options (&opts);
544 if (target_supports_string_tracing ())
546 /* Allow an optional decimal number giving an explicit maximum
547 string length, defaulting it to the "print elements" value;
548 so "collect/s80 mystr" gets at most 80 bytes of string. */
549 *trace_string = opts.print_max;
551 if (*exp >= '0' && *exp <= '9')
552 *trace_string = atoi (exp);
553 while (*exp >= '0' && *exp <= '9')
557 error (_("Target does not support \"/s\" option for string tracing."));
560 error (_("Undefined collection format \"%c\"."), *exp);
562 exp = skip_spaces (exp);
567 /* Enter a list of actions for a tracepoint. */
569 actions_command (const char *args, int from_tty)
571 struct tracepoint *t;
573 t = get_tracepoint_by_number (&args, NULL);
577 string_printf ("Enter actions for tracepoint %d, one per line.",
580 counted_command_line l = read_command_lines (tmpbuf.c_str (),
582 [=] (const char *line)
584 validate_actionline (line, t);
586 breakpoint_set_commands (t, std::move (l));
588 /* else just return */
591 /* Report the results of checking the agent expression, as errors or
595 report_agent_reqs_errors (struct agent_expr *aexpr)
597 /* All of the "flaws" are serious bytecode generation issues that
598 should never occur. */
599 if (aexpr->flaw != agent_flaw_none)
600 internal_error (__FILE__, __LINE__, _("expression is malformed"));
602 /* If analysis shows a stack underflow, GDB must have done something
603 badly wrong in its bytecode generation. */
604 if (aexpr->min_height < 0)
605 internal_error (__FILE__, __LINE__,
606 _("expression has min height < 0"));
608 /* Issue this error if the stack is predicted to get too deep. The
609 limit is rather arbitrary; a better scheme might be for the
610 target to report how much stack it will have available. The
611 depth roughly corresponds to parenthesization, so a limit of 20
612 amounts to 20 levels of expression nesting, which is actually
613 a pretty big hairy expression. */
614 if (aexpr->max_height > 20)
615 error (_("Expression is too complicated."));
618 /* worker function */
620 validate_actionline (const char *line, struct breakpoint *b)
622 struct cmd_list_element *c;
625 struct bp_location *loc;
626 struct tracepoint *t = (struct tracepoint *) b;
628 /* If EOF is typed, *line is NULL. */
632 p = skip_spaces (line);
634 /* Symbol lookup etc. */
635 if (*p == '\0') /* empty line: just prompt for another line. */
638 if (*p == '#') /* comment line */
641 c = lookup_cmd (&p, cmdlist, "", -1, 1);
643 error (_("`%s' is not a tracepoint action, or is ambiguous."), p);
645 if (cmd_cfunc_eq (c, collect_pseudocommand))
647 int trace_string = 0;
650 p = decode_agent_options (p, &trace_string);
653 { /* Repeat over a comma-separated list. */
654 QUIT; /* Allow user to bail out with ^C. */
657 if (*p == '$') /* Look for special pseudo-symbols. */
659 if (0 == strncasecmp ("reg", p + 1, 3)
660 || 0 == strncasecmp ("arg", p + 1, 3)
661 || 0 == strncasecmp ("loc", p + 1, 3)
662 || 0 == strncasecmp ("_ret", p + 1, 4)
663 || 0 == strncasecmp ("_sdata", p + 1, 6))
668 /* else fall thru, treat p as an expression and parse it! */
671 for (loc = t->loc; loc; loc = loc->next)
674 expression_up exp = parse_exp_1 (&p, loc->address,
675 block_for_pc (loc->address), 1);
677 if (exp->elts[0].opcode == OP_VAR_VALUE)
679 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
681 error (_("constant `%s' (value %s) "
682 "will not be collected."),
683 SYMBOL_PRINT_NAME (exp->elts[2].symbol),
684 plongest (SYMBOL_VALUE (exp->elts[2].symbol)));
686 else if (SYMBOL_CLASS (exp->elts[2].symbol)
687 == LOC_OPTIMIZED_OUT)
689 error (_("`%s' is optimized away "
690 "and cannot be collected."),
691 SYMBOL_PRINT_NAME (exp->elts[2].symbol));
695 /* We have something to collect, make sure that the expr to
696 bytecode translator can handle it and that it's not too
698 agent_expr_up aexpr = gen_trace_for_expr (loc->address,
702 if (aexpr->len > MAX_AGENT_EXPR_LEN)
703 error (_("Expression is too complicated."));
705 ax_reqs (aexpr.get ());
707 report_agent_reqs_errors (aexpr.get ());
710 while (p && *p++ == ',');
713 else if (cmd_cfunc_eq (c, teval_pseudocommand))
716 { /* Repeat over a comma-separated list. */
717 QUIT; /* Allow user to bail out with ^C. */
721 for (loc = t->loc; loc; loc = loc->next)
725 /* Only expressions are allowed for this action. */
726 expression_up exp = parse_exp_1 (&p, loc->address,
727 block_for_pc (loc->address), 1);
729 /* We have something to evaluate, make sure that the expr to
730 bytecode translator can handle it and that it's not too
732 agent_expr_up aexpr = gen_eval_for_expr (loc->address, exp.get ());
734 if (aexpr->len > MAX_AGENT_EXPR_LEN)
735 error (_("Expression is too complicated."));
737 ax_reqs (aexpr.get ());
738 report_agent_reqs_errors (aexpr.get ());
741 while (p && *p++ == ',');
744 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
749 t->step_count = strtol (p, &endp, 0);
750 if (endp == p || t->step_count == 0)
751 error (_("while-stepping step count `%s' is malformed."), line);
755 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
759 error (_("`%s' is not a supported tracepoint action."), line);
763 memrange_absolute = -1
766 /* MEMRANGE functions: */
768 /* Compare memranges for std::sort. */
771 memrange_comp (const memrange &a, const memrange &b)
773 if (a.type == b.type)
775 if (a.type == memrange_absolute)
776 return (bfd_vma) a.start < (bfd_vma) b.start;
778 return a.start < b.start;
781 return a.type < b.type;
784 /* Sort the memrange list using std::sort, and merge adjacent memranges. */
787 memrange_sortmerge (std::vector<memrange> &memranges)
789 if (!memranges.empty ())
793 std::sort (memranges.begin (), memranges.end (), memrange_comp);
795 for (a = 0, b = 1; b < memranges.size (); b++)
797 /* If memrange b overlaps or is adjacent to memrange a,
799 if (memranges[a].type == memranges[b].type
800 && memranges[b].start <= memranges[a].end)
802 if (memranges[b].end > memranges[a].end)
803 memranges[a].end = memranges[b].end;
804 continue; /* next b, same a */
808 memranges[a] = memranges[b];
810 memranges.resize (a + 1);
814 /* Add a register to a collection list. */
817 collection_list::add_register (unsigned int regno)
820 printf_filtered ("collect register %d\n", regno);
821 if (regno >= (8 * sizeof (m_regs_mask)))
822 error (_("Internal: register number %d too large for tracepoint"),
824 m_regs_mask[regno / 8] |= 1 << (regno % 8);
827 /* Add a memrange to a collection list. */
830 collection_list::add_memrange (struct gdbarch *gdbarch,
831 int type, bfd_signed_vma base,
835 printf_filtered ("(%d,%s,%ld)\n", type, paddress (gdbarch, base), len);
837 /* type: memrange_absolute == memory, other n == basereg */
838 /* base: addr if memory, offset if reg relative. */
839 /* len: we actually save end (base + len) for convenience */
840 m_memranges.emplace_back (type, base, base + len);
842 if (type != memrange_absolute) /* Better collect the base register! */
846 /* Add a symbol to a collection list. */
849 collection_list::collect_symbol (struct symbol *sym,
850 struct gdbarch *gdbarch,
851 long frame_regno, long frame_offset,
857 bfd_signed_vma offset;
858 int treat_as_expr = 0;
860 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
861 switch (SYMBOL_CLASS (sym))
864 printf_filtered ("%s: don't know symbol class %d\n",
865 SYMBOL_PRINT_NAME (sym),
869 printf_filtered ("constant %s (value %s) will not be collected.\n",
870 SYMBOL_PRINT_NAME (sym), plongest (SYMBOL_VALUE (sym)));
873 offset = SYMBOL_VALUE_ADDRESS (sym);
876 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
877 SYMBOL_PRINT_NAME (sym), len,
878 paddress (gdbarch, offset));
880 /* A struct may be a C++ class with static fields, go to general
881 expression handling. */
882 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
885 add_memrange (gdbarch, memrange_absolute, offset, len);
888 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
890 printf_filtered ("LOC_REG[parm] %s: ",
891 SYMBOL_PRINT_NAME (sym));
893 /* Check for doubles stored in two registers. */
894 /* FIXME: how about larger types stored in 3 or more regs? */
895 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
896 len > register_size (gdbarch, reg))
897 add_register (reg + 1);
900 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
901 printf_filtered (" (will not collect %s)\n",
902 SYMBOL_PRINT_NAME (sym));
906 offset = frame_offset + SYMBOL_VALUE (sym);
909 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
910 " from frame ptr reg %d\n",
911 SYMBOL_PRINT_NAME (sym), len,
912 paddress (gdbarch, offset), reg);
914 add_memrange (gdbarch, reg, offset, len);
916 case LOC_REGPARM_ADDR:
917 reg = SYMBOL_VALUE (sym);
921 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset %s"
923 SYMBOL_PRINT_NAME (sym), len,
924 paddress (gdbarch, offset), reg);
926 add_memrange (gdbarch, reg, offset, len);
930 offset = frame_offset + SYMBOL_VALUE (sym);
933 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
934 " from frame ptr reg %d\n",
935 SYMBOL_PRINT_NAME (sym), len,
936 paddress (gdbarch, offset), reg);
938 add_memrange (gdbarch, reg, offset, len);
945 case LOC_OPTIMIZED_OUT:
946 printf_filtered ("%s has been optimized out of existence.\n",
947 SYMBOL_PRINT_NAME (sym));
955 /* Expressions are the most general case. */
958 agent_expr_up aexpr = gen_trace_for_var (scope, gdbarch,
961 /* It can happen that the symbol is recorded as a computed
962 location, but it's been optimized away and doesn't actually
963 have a location expression. */
966 printf_filtered ("%s has been optimized out of existence.\n",
967 SYMBOL_PRINT_NAME (sym));
971 ax_reqs (aexpr.get ());
973 report_agent_reqs_errors (aexpr.get ());
975 /* Take care of the registers. */
976 if (aexpr->reg_mask_len > 0)
978 for (int ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
980 QUIT; /* Allow user to bail out with ^C. */
981 if (aexpr->reg_mask[ndx1] != 0)
983 /* Assume chars have 8 bits. */
984 for (int ndx2 = 0; ndx2 < 8; ndx2++)
985 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
986 /* It's used -- record it. */
987 add_register (ndx1 * 8 + ndx2);
992 add_aexpr (std::move (aexpr));
996 /* Data to be passed around in the calls to the locals and args
999 struct add_local_symbols_data
1001 struct collection_list *collect;
1002 struct gdbarch *gdbarch;
1010 /* The callback for the locals and args iterators. */
1013 do_collect_symbol (const char *print_name,
1017 struct add_local_symbols_data *p = (struct add_local_symbols_data *) cb_data;
1019 p->collect->collect_symbol (sym, p->gdbarch, p->frame_regno,
1020 p->frame_offset, p->pc, p->trace_string);
1023 p->collect->add_wholly_collected (print_name);
1027 collection_list::add_wholly_collected (const char *print_name)
1029 m_wholly_collected.push_back (print_name);
1032 /* Add all locals (or args) symbols to collection list. */
1035 collection_list::add_local_symbols (struct gdbarch *gdbarch, CORE_ADDR pc,
1036 long frame_regno, long frame_offset, int type,
1039 const struct block *block;
1040 struct add_local_symbols_data cb_data;
1042 cb_data.collect = this;
1043 cb_data.gdbarch = gdbarch;
1045 cb_data.frame_regno = frame_regno;
1046 cb_data.frame_offset = frame_offset;
1048 cb_data.trace_string = trace_string;
1052 block = block_for_pc (pc);
1055 warning (_("Can't collect locals; "
1056 "no symbol table info available.\n"));
1060 iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1061 if (cb_data.count == 0)
1062 warning (_("No locals found in scope."));
1066 pc = get_pc_function_start (pc);
1067 block = block_for_pc (pc);
1070 warning (_("Can't collect args; no symbol table info available."));
1074 iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1075 if (cb_data.count == 0)
1076 warning (_("No args found in scope."));
1081 collection_list::add_static_trace_data ()
1084 printf_filtered ("collect static trace data\n");
1085 m_strace_data = true;
1088 collection_list::collection_list ()
1090 m_strace_data (false)
1092 m_memranges.reserve (128);
1093 m_aexprs.reserve (128);
1096 /* Reduce a collection list to string form (for gdb protocol). */
1098 std::vector<std::string>
1099 collection_list::stringify ()
1101 char temp_buf[2048];
1105 std::vector<std::string> str_list;
1110 printf_filtered ("\nCollecting static trace data\n");
1113 str_list.emplace_back (temp_buf, end - temp_buf);
1116 for (i = sizeof (m_regs_mask) - 1; i > 0; i--)
1117 if (m_regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */
1119 if (m_regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
1122 printf_filtered ("\nCollecting registers (mask): 0x");
1127 QUIT; /* Allow user to bail out with ^C. */
1129 printf_filtered ("%02X", m_regs_mask[i]);
1130 sprintf (end, "%02X", m_regs_mask[i]);
1133 str_list.emplace_back (temp_buf);
1136 printf_filtered ("\n");
1137 if (!m_memranges.empty () && info_verbose)
1138 printf_filtered ("Collecting memranges: \n");
1139 for (i = 0, count = 0, end = temp_buf; i < m_memranges.size (); i++)
1141 QUIT; /* Allow user to bail out with ^C. */
1144 printf_filtered ("(%d, %s, %ld)\n",
1145 m_memranges[i].type,
1146 paddress (target_gdbarch (),
1147 m_memranges[i].start),
1148 (long) (m_memranges[i].end
1149 - m_memranges[i].start));
1151 if (count + 27 > MAX_AGENT_EXPR_LEN)
1153 str_list.emplace_back (temp_buf, count);
1159 bfd_signed_vma length
1160 = m_memranges[i].end - m_memranges[i].start;
1162 /* The "%X" conversion specifier expects an unsigned argument,
1163 so passing -1 (memrange_absolute) to it directly gives you
1164 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1166 if (m_memranges[i].type == memrange_absolute)
1167 sprintf (end, "M-1,%s,%lX", phex_nz (m_memranges[i].start, 0),
1170 sprintf (end, "M%X,%s,%lX", m_memranges[i].type,
1171 phex_nz (m_memranges[i].start, 0), (long) length);
1174 count += strlen (end);
1175 end = temp_buf + count;
1178 for (i = 0; i < m_aexprs.size (); i++)
1180 QUIT; /* Allow user to bail out with ^C. */
1181 if ((count + 10 + 2 * m_aexprs[i]->len) > MAX_AGENT_EXPR_LEN)
1183 str_list.emplace_back (temp_buf, count);
1187 sprintf (end, "X%08X,", m_aexprs[i]->len);
1188 end += 10; /* 'X' + 8 hex digits + ',' */
1191 end = mem2hex (m_aexprs[i]->buf, end, m_aexprs[i]->len);
1192 count += 2 * m_aexprs[i]->len;
1197 str_list.emplace_back (temp_buf, count);
1205 /* Add the printed expression EXP to *LIST. */
1208 collection_list::append_exp (struct expression *exp)
1210 string_file tmp_stream;
1212 print_expression (exp, &tmp_stream);
1214 m_computed.push_back (std::move (tmp_stream.string ()));
1218 collection_list::finish ()
1220 memrange_sortmerge (m_memranges);
1224 encode_actions_1 (struct command_line *action,
1225 struct bp_location *tloc,
1227 LONGEST frame_offset,
1228 struct collection_list *collect,
1229 struct collection_list *stepping_list)
1231 const char *action_exp;
1233 struct value *tempval;
1234 struct cmd_list_element *cmd;
1236 for (; action; action = action->next)
1238 QUIT; /* Allow user to bail out with ^C. */
1239 action_exp = action->line;
1240 action_exp = skip_spaces (action_exp);
1242 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1244 error (_("Bad action list item: %s"), action_exp);
1246 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1248 int trace_string = 0;
1250 if (*action_exp == '/')
1251 action_exp = decode_agent_options (action_exp, &trace_string);
1254 { /* Repeat over a comma-separated list. */
1255 QUIT; /* Allow user to bail out with ^C. */
1256 action_exp = skip_spaces (action_exp);
1258 if (0 == strncasecmp ("$reg", action_exp, 4))
1260 for (i = 0; i < gdbarch_num_regs (target_gdbarch ()); i++)
1261 collect->add_register (i);
1262 action_exp = strchr (action_exp, ','); /* more? */
1264 else if (0 == strncasecmp ("$arg", action_exp, 4))
1266 collect->add_local_symbols (target_gdbarch (),
1272 action_exp = strchr (action_exp, ','); /* more? */
1274 else if (0 == strncasecmp ("$loc", action_exp, 4))
1276 collect->add_local_symbols (target_gdbarch (),
1282 action_exp = strchr (action_exp, ','); /* more? */
1284 else if (0 == strncasecmp ("$_ret", action_exp, 5))
1287 = gen_trace_for_return_address (tloc->address,
1291 ax_reqs (aexpr.get ());
1292 report_agent_reqs_errors (aexpr.get ());
1294 /* take care of the registers */
1295 if (aexpr->reg_mask_len > 0)
1297 for (int ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1299 QUIT; /* allow user to bail out with ^C */
1300 if (aexpr->reg_mask[ndx1] != 0)
1302 /* assume chars have 8 bits */
1303 for (int ndx2 = 0; ndx2 < 8; ndx2++)
1304 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1306 /* It's used -- record it. */
1307 collect->add_register (ndx1 * 8 + ndx2);
1313 collect->add_aexpr (std::move (aexpr));
1314 action_exp = strchr (action_exp, ','); /* more? */
1316 else if (0 == strncasecmp ("$_sdata", action_exp, 7))
1318 collect->add_static_trace_data ();
1319 action_exp = strchr (action_exp, ','); /* more? */
1325 expression_up exp = parse_exp_1 (&action_exp, tloc->address,
1326 block_for_pc (tloc->address),
1329 switch (exp->elts[0].opcode)
1333 const char *name = &exp->elts[2].string;
1335 i = user_reg_map_name_to_regnum (target_gdbarch (),
1336 name, strlen (name));
1338 internal_error (__FILE__, __LINE__,
1339 _("Register $%s not available"),
1342 printf_filtered ("OP_REGISTER: ");
1343 collect->add_register (i);
1348 /* Safe because we know it's a simple expression. */
1349 tempval = evaluate_expression (exp.get ());
1350 addr = value_address (tempval);
1351 /* Initialize the TYPE_LENGTH if it is a typedef. */
1352 check_typedef (exp->elts[1].type);
1353 collect->add_memrange (target_gdbarch (),
1354 memrange_absolute, addr,
1355 TYPE_LENGTH (exp->elts[1].type));
1356 collect->append_exp (exp.get ());
1361 struct symbol *sym = exp->elts[2].symbol;
1362 const char *name = SYMBOL_NATURAL_NAME (sym);
1364 collect->collect_symbol (exp->elts[2].symbol,
1370 collect->add_wholly_collected (name);
1374 default: /* Full-fledged expression. */
1375 agent_expr_up aexpr = gen_trace_for_expr (tloc->address,
1379 ax_reqs (aexpr.get ());
1381 report_agent_reqs_errors (aexpr.get ());
1383 /* Take care of the registers. */
1384 if (aexpr->reg_mask_len > 0)
1386 for (int ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1388 QUIT; /* Allow user to bail out with ^C. */
1389 if (aexpr->reg_mask[ndx1] != 0)
1391 /* Assume chars have 8 bits. */
1392 for (int ndx2 = 0; ndx2 < 8; ndx2++)
1393 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1395 /* It's used -- record it. */
1396 collect->add_register (ndx1 * 8 + ndx2);
1402 collect->add_aexpr (std::move (aexpr));
1403 collect->append_exp (exp.get ());
1408 while (action_exp && *action_exp++ == ',');
1410 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1413 { /* Repeat over a comma-separated list. */
1414 QUIT; /* Allow user to bail out with ^C. */
1415 action_exp = skip_spaces (action_exp);
1418 expression_up exp = parse_exp_1 (&action_exp, tloc->address,
1419 block_for_pc (tloc->address),
1422 agent_expr_up aexpr = gen_eval_for_expr (tloc->address,
1425 ax_reqs (aexpr.get ());
1426 report_agent_reqs_errors (aexpr.get ());
1428 /* Even though we're not officially collecting, add
1429 to the collect list anyway. */
1430 collect->add_aexpr (std::move (aexpr));
1433 while (action_exp && *action_exp++ == ',');
1435 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1437 /* We check against nested while-stepping when setting
1438 breakpoint action, so no way to run into nested
1440 gdb_assert (stepping_list);
1442 encode_actions_1 (action->body_list_0.get (), tloc, frame_reg,
1443 frame_offset, stepping_list, NULL);
1446 error (_("Invalid tracepoint command '%s'"), action->line);
1450 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1451 and STEPPING_LIST. */
1454 encode_actions (struct bp_location *tloc,
1455 struct collection_list *tracepoint_list,
1456 struct collection_list *stepping_list)
1459 LONGEST frame_offset;
1461 gdbarch_virtual_frame_pointer (tloc->gdbarch,
1462 tloc->address, &frame_reg, &frame_offset);
1464 counted_command_line actions = all_tracepoint_actions (tloc->owner);
1465 encode_actions_1 (actions.get (), tloc, frame_reg, frame_offset,
1466 tracepoint_list, stepping_list);
1467 encode_actions_1 (breakpoint_commands (tloc->owner), tloc,
1468 frame_reg, frame_offset, tracepoint_list, stepping_list);
1470 tracepoint_list->finish ();
1471 stepping_list->finish ();
1474 /* Render all actions into gdb protocol. */
1477 encode_actions_rsp (struct bp_location *tloc,
1478 std::vector<std::string> *tdp_actions,
1479 std::vector<std::string> *stepping_actions)
1481 struct collection_list tracepoint_list, stepping_list;
1483 encode_actions (tloc, &tracepoint_list, &stepping_list);
1485 *tdp_actions = tracepoint_list.stringify ();
1486 *stepping_actions = stepping_list.stringify ();
1490 collection_list::add_aexpr (agent_expr_up aexpr)
1492 m_aexprs.push_back (std::move (aexpr));
1496 process_tracepoint_on_disconnect (void)
1498 VEC(breakpoint_p) *tp_vec = NULL;
1500 struct breakpoint *b;
1501 int has_pending_p = 0;
1503 /* Check whether we still have pending tracepoint. If we have, warn the
1504 user that pending tracepoint will no longer work. */
1505 tp_vec = all_tracepoints ();
1506 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1515 struct bp_location *loc1;
1517 for (loc1 = b->loc; loc1; loc1 = loc1->next)
1519 if (loc1->shlib_disabled)
1530 VEC_free (breakpoint_p, tp_vec);
1533 warning (_("Pending tracepoints will not be resolved while"
1534 " GDB is disconnected\n"));
1537 /* Reset local state of tracing. */
1540 trace_reset_local_state (void)
1542 set_traceframe_num (-1);
1543 set_tracepoint_num (-1);
1544 set_traceframe_context (NULL);
1545 clear_traceframe_info ();
1549 start_tracing (const char *notes)
1551 VEC(breakpoint_p) *tp_vec = NULL;
1553 struct breakpoint *b;
1554 struct trace_state_variable *tsv;
1555 int any_enabled = 0, num_to_download = 0;
1558 tp_vec = all_tracepoints ();
1560 /* No point in tracing without any tracepoints... */
1561 if (VEC_length (breakpoint_p, tp_vec) == 0)
1563 VEC_free (breakpoint_p, tp_vec);
1564 error (_("No tracepoints defined, not starting trace"));
1567 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1569 if (b->enable_state == bp_enabled)
1572 if ((b->type == bp_fast_tracepoint
1573 ? may_insert_fast_tracepoints
1574 : may_insert_tracepoints))
1577 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1578 (b->type == bp_fast_tracepoint ? "fast " : ""), b->number);
1583 if (target_supports_enable_disable_tracepoint ())
1584 warning (_("No tracepoints enabled"));
1587 /* No point in tracing with only disabled tracepoints that
1588 cannot be re-enabled. */
1589 VEC_free (breakpoint_p, tp_vec);
1590 error (_("No tracepoints enabled, not starting trace"));
1594 if (num_to_download <= 0)
1596 VEC_free (breakpoint_p, tp_vec);
1597 error (_("No tracepoints that may be downloaded, not starting trace"));
1600 target_trace_init ();
1602 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1604 struct tracepoint *t = (struct tracepoint *) b;
1605 struct bp_location *loc;
1606 int bp_location_downloaded = 0;
1608 /* Clear `inserted' flag. */
1609 for (loc = b->loc; loc; loc = loc->next)
1612 if ((b->type == bp_fast_tracepoint
1613 ? !may_insert_fast_tracepoints
1614 : !may_insert_tracepoints))
1617 t->number_on_target = 0;
1619 for (loc = b->loc; loc; loc = loc->next)
1621 /* Since tracepoint locations are never duplicated, `inserted'
1622 flag should be zero. */
1623 gdb_assert (!loc->inserted);
1625 target_download_tracepoint (loc);
1628 bp_location_downloaded = 1;
1631 t->number_on_target = b->number;
1633 for (loc = b->loc; loc; loc = loc->next)
1634 if (loc->probe.prob != NULL)
1635 loc->probe.prob->set_semaphore (loc->probe.objfile,
1638 if (bp_location_downloaded)
1639 gdb::observers::breakpoint_modified.notify (b);
1641 VEC_free (breakpoint_p, tp_vec);
1643 /* Send down all the trace state variables too. */
1644 for (const trace_state_variable &tsv : tvariables)
1645 target_download_trace_state_variable (tsv);
1647 /* Tell target to treat text-like sections as transparent. */
1648 target_trace_set_readonly_regions ();
1649 /* Set some mode flags. */
1650 target_set_disconnected_tracing (disconnected_tracing);
1651 target_set_circular_trace_buffer (circular_trace_buffer);
1652 target_set_trace_buffer_size (trace_buffer_size);
1655 notes = trace_notes;
1656 ret = target_set_trace_notes (trace_user, notes, NULL);
1658 if (!ret && (trace_user || notes))
1659 warning (_("Target does not support trace user/notes, info ignored"));
1661 /* Now insert traps and begin collecting data. */
1662 target_trace_start ();
1664 /* Reset our local state. */
1665 trace_reset_local_state ();
1666 current_trace_status()->running = 1;
1669 /* The tstart command requests the target to start a new trace run.
1670 The command passes any arguments it has to the target verbatim, as
1671 an optional "trace note". This is useful as for instance a warning
1672 to other users if the trace runs disconnected, and you don't want
1673 anybody else messing with the target. */
1676 tstart_command (const char *args, int from_tty)
1678 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1680 if (current_trace_status ()->running)
1683 && !query (_("A trace is running already. Start a new run? ")))
1684 error (_("New trace run not started."));
1687 start_tracing (args);
1690 /* The tstop command stops the tracing run. The command passes any
1691 supplied arguments to the target verbatim as a "stop note"; if the
1692 target supports trace notes, then it will be reported back as part
1693 of the trace run's status. */
1696 tstop_command (const char *args, int from_tty)
1698 if (!current_trace_status ()->running)
1699 error (_("Trace is not running."));
1701 stop_tracing (args);
1705 stop_tracing (const char *note)
1708 VEC(breakpoint_p) *tp_vec = NULL;
1710 struct breakpoint *t;
1712 target_trace_stop ();
1714 tp_vec = all_tracepoints ();
1715 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1717 struct bp_location *loc;
1719 if ((t->type == bp_fast_tracepoint
1720 ? !may_insert_fast_tracepoints
1721 : !may_insert_tracepoints))
1724 for (loc = t->loc; loc; loc = loc->next)
1726 /* GDB can be totally absent in some disconnected trace scenarios,
1727 but we don't really care if this semaphore goes out of sync.
1728 That's why we are decrementing it here, but not taking care
1730 if (loc->probe.prob != NULL)
1731 loc->probe.prob->clear_semaphore (loc->probe.objfile,
1736 VEC_free (breakpoint_p, tp_vec);
1739 note = trace_stop_notes;
1740 ret = target_set_trace_notes (NULL, NULL, note);
1743 warning (_("Target does not support trace notes, note ignored"));
1745 /* Should change in response to reply? */
1746 current_trace_status ()->running = 0;
1749 /* tstatus command */
1751 tstatus_command (const char *args, int from_tty)
1753 struct trace_status *ts = current_trace_status ();
1755 VEC(breakpoint_p) *tp_vec = NULL;
1756 struct breakpoint *t;
1758 status = target_get_trace_status (ts);
1762 if (ts->filename != NULL)
1763 printf_filtered (_("Using a trace file.\n"));
1766 printf_filtered (_("Trace can not be run on this target.\n"));
1771 if (!ts->running_known)
1773 printf_filtered (_("Run/stop status is unknown.\n"));
1775 else if (ts->running)
1777 printf_filtered (_("Trace is running on the target.\n"));
1781 switch (ts->stop_reason)
1783 case trace_never_run:
1784 printf_filtered (_("No trace has been run on the target.\n"));
1786 case trace_stop_command:
1788 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1791 printf_filtered (_("Trace stopped by a tstop command.\n"));
1793 case trace_buffer_full:
1794 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1796 case trace_disconnected:
1797 printf_filtered (_("Trace stopped because of disconnection.\n"));
1799 case tracepoint_passcount:
1800 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1801 ts->stopping_tracepoint);
1803 case tracepoint_error:
1804 if (ts->stopping_tracepoint)
1805 printf_filtered (_("Trace stopped by an "
1806 "error (%s, tracepoint %d).\n"),
1807 ts->stop_desc, ts->stopping_tracepoint);
1809 printf_filtered (_("Trace stopped by an error (%s).\n"),
1812 case trace_stop_reason_unknown:
1813 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1816 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1822 if (ts->traceframes_created >= 0
1823 && ts->traceframe_count != ts->traceframes_created)
1825 printf_filtered (_("Buffer contains %d trace "
1826 "frames (of %d created total).\n"),
1827 ts->traceframe_count, ts->traceframes_created);
1829 else if (ts->traceframe_count >= 0)
1831 printf_filtered (_("Collected %d trace frames.\n"),
1832 ts->traceframe_count);
1835 if (ts->buffer_free >= 0)
1837 if (ts->buffer_size >= 0)
1839 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1840 ts->buffer_free, ts->buffer_size);
1841 if (ts->buffer_size > 0)
1842 printf_filtered (_(" (%d%% full)"),
1843 ((int) ((((long long) (ts->buffer_size
1844 - ts->buffer_free)) * 100)
1845 / ts->buffer_size)));
1846 printf_filtered (_(".\n"));
1849 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1853 if (ts->disconnected_tracing)
1854 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1856 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1858 if (ts->circular_buffer)
1859 printf_filtered (_("Trace buffer is circular.\n"));
1861 if (ts->user_name && strlen (ts->user_name) > 0)
1862 printf_filtered (_("Trace user is %s.\n"), ts->user_name);
1864 if (ts->notes && strlen (ts->notes) > 0)
1865 printf_filtered (_("Trace notes: %s.\n"), ts->notes);
1867 /* Now report on what we're doing with tfind. */
1868 if (traceframe_number >= 0)
1869 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1870 traceframe_number, tracepoint_number);
1872 printf_filtered (_("Not looking at any trace frame.\n"));
1874 /* Report start/stop times if supplied. */
1879 LONGEST run_time = ts->stop_time - ts->start_time;
1881 /* Reporting a run time is more readable than two long numbers. */
1882 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
1883 (long int) (ts->start_time / 1000000),
1884 (long int) (ts->start_time % 1000000),
1885 (long int) (run_time / 1000000),
1886 (long int) (run_time % 1000000));
1889 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
1890 (long int) (ts->start_time / 1000000),
1891 (long int) (ts->start_time % 1000000));
1893 else if (ts->stop_time)
1894 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
1895 (long int) (ts->stop_time / 1000000),
1896 (long int) (ts->stop_time % 1000000));
1898 /* Now report any per-tracepoint status available. */
1899 tp_vec = all_tracepoints ();
1901 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1902 target_get_tracepoint_status (t, NULL);
1904 VEC_free (breakpoint_p, tp_vec);
1907 /* Report the trace status to uiout, in a way suitable for MI, and not
1908 suitable for CLI. If ON_STOP is true, suppress a few fields that
1909 are not meaningful in the -trace-stop response.
1911 The implementation is essentially parallel to trace_status_command, but
1912 merging them will result in unreadable code. */
1914 trace_status_mi (int on_stop)
1916 struct ui_out *uiout = current_uiout;
1917 struct trace_status *ts = current_trace_status ();
1920 status = target_get_trace_status (ts);
1922 if (status == -1 && ts->filename == NULL)
1924 uiout->field_string ("supported", "0");
1928 if (ts->filename != NULL)
1929 uiout->field_string ("supported", "file");
1931 uiout->field_string ("supported", "1");
1933 if (ts->filename != NULL)
1934 uiout->field_string ("trace-file", ts->filename);
1936 gdb_assert (ts->running_known);
1940 uiout->field_string ("running", "1");
1942 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1943 Given that the frontend gets the status either on -trace-stop, or from
1944 -trace-status after re-connection, it does not seem like this
1945 information is necessary for anything. It is not necessary for either
1946 figuring the vital state of the target nor for navigation of trace
1947 frames. If the frontend wants to show the current state is some
1948 configure dialog, it can request the value when such dialog is
1949 invoked by the user. */
1953 const char *stop_reason = NULL;
1954 int stopping_tracepoint = -1;
1957 uiout->field_string ("running", "0");
1959 if (ts->stop_reason != trace_stop_reason_unknown)
1961 switch (ts->stop_reason)
1963 case trace_stop_command:
1964 stop_reason = "request";
1966 case trace_buffer_full:
1967 stop_reason = "overflow";
1969 case trace_disconnected:
1970 stop_reason = "disconnection";
1972 case tracepoint_passcount:
1973 stop_reason = "passcount";
1974 stopping_tracepoint = ts->stopping_tracepoint;
1976 case tracepoint_error:
1977 stop_reason = "error";
1978 stopping_tracepoint = ts->stopping_tracepoint;
1984 uiout->field_string ("stop-reason", stop_reason);
1985 if (stopping_tracepoint != -1)
1986 uiout->field_int ("stopping-tracepoint",
1987 stopping_tracepoint);
1988 if (ts->stop_reason == tracepoint_error)
1989 uiout->field_string ("error-description",
1995 if (ts->traceframe_count != -1)
1996 uiout->field_int ("frames", ts->traceframe_count);
1997 if (ts->traceframes_created != -1)
1998 uiout->field_int ("frames-created", ts->traceframes_created);
1999 if (ts->buffer_size != -1)
2000 uiout->field_int ("buffer-size", ts->buffer_size);
2001 if (ts->buffer_free != -1)
2002 uiout->field_int ("buffer-free", ts->buffer_free);
2004 uiout->field_int ("disconnected", ts->disconnected_tracing);
2005 uiout->field_int ("circular", ts->circular_buffer);
2007 uiout->field_string ("user-name", ts->user_name);
2008 uiout->field_string ("notes", ts->notes);
2013 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2014 (long int) (ts->start_time / 1000000),
2015 (long int) (ts->start_time % 1000000));
2016 uiout->field_string ("start-time", buf);
2017 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2018 (long int) (ts->stop_time / 1000000),
2019 (long int) (ts->stop_time % 1000000));
2020 uiout->field_string ("stop-time", buf);
2024 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2025 user if she really wants to detach. */
2028 query_if_trace_running (int from_tty)
2033 /* It can happen that the target that was tracing went away on its
2034 own, and we didn't notice. Get a status update, and if the
2035 current target doesn't even do tracing, then assume it's not
2037 if (target_get_trace_status (current_trace_status ()) < 0)
2038 current_trace_status ()->running = 0;
2040 /* If running interactively, give the user the option to cancel and
2041 then decide what to do differently with the run. Scripts are
2042 just going to disconnect and let the target deal with it,
2043 according to how it's been instructed previously via
2044 disconnected-tracing. */
2045 if (current_trace_status ()->running)
2047 process_tracepoint_on_disconnect ();
2049 if (current_trace_status ()->disconnected_tracing)
2051 if (!query (_("Trace is running and will "
2052 "continue after detach; detach anyway? ")))
2053 error (_("Not confirmed."));
2057 if (!query (_("Trace is running but will "
2058 "stop on detach; detach anyway? ")))
2059 error (_("Not confirmed."));
2064 /* This function handles the details of what to do about an ongoing
2065 tracing run if the user has asked to detach or otherwise disconnect
2069 disconnect_tracing (void)
2071 /* Also we want to be out of tfind mode, otherwise things can get
2072 confusing upon reconnection. Just use these calls instead of
2073 full tfind_1 behavior because we're in the middle of detaching,
2074 and there's no point to updating current stack frame etc. */
2075 trace_reset_local_state ();
2078 /* Worker function for the various flavors of the tfind command. */
2080 tfind_1 (enum trace_find_type type, int num,
2081 CORE_ADDR addr1, CORE_ADDR addr2,
2084 int target_frameno = -1, target_tracept = -1;
2085 struct frame_id old_frame_id = null_frame_id;
2086 struct tracepoint *tp;
2087 struct ui_out *uiout = current_uiout;
2089 /* Only try to get the current stack frame if we have a chance of
2090 succeeding. In particular, if we're trying to get a first trace
2091 frame while all threads are running, it's not going to succeed,
2092 so leave it with a default value and let the frame comparison
2093 below (correctly) decide to print out the source location of the
2095 if (!(type == tfind_number && num == -1)
2096 && (has_stack_frames () || traceframe_number >= 0))
2097 old_frame_id = get_frame_id (get_current_frame ());
2099 target_frameno = target_trace_find (type, num, addr1, addr2,
2102 if (type == tfind_number
2104 && target_frameno == -1)
2106 /* We told the target to get out of tfind mode, and it did. */
2108 else if (target_frameno == -1)
2110 /* A request for a non-existent trace frame has failed.
2111 Our response will be different, depending on FROM_TTY:
2113 If FROM_TTY is true, meaning that this command was
2114 typed interactively by the user, then give an error
2115 and DO NOT change the state of traceframe_number etc.
2117 However if FROM_TTY is false, meaning that we're either
2118 in a script, a loop, or a user-defined command, then
2119 DON'T give an error, but DO change the state of
2120 traceframe_number etc. to invalid.
2122 The rationalle is that if you typed the command, you
2123 might just have committed a typo or something, and you'd
2124 like to NOT lose your current debugging state. However
2125 if you're in a user-defined command or especially in a
2126 loop, then you need a way to detect that the command
2127 failed WITHOUT aborting. This allows you to write
2128 scripts that search thru the trace buffer until the end,
2129 and then continue on to do something else. */
2132 error (_("Target failed to find requested trace frame."));
2136 printf_filtered ("End of trace buffer.\n");
2137 #if 0 /* dubious now? */
2138 /* The following will not recurse, since it's
2140 tfind_command ("-1", from_tty);
2145 tp = get_tracepoint_by_number_on_target (target_tracept);
2147 reinit_frame_cache ();
2148 target_dcache_invalidate ();
2150 set_tracepoint_num (tp ? tp->number : target_tracept);
2152 if (target_frameno != get_traceframe_number ())
2153 gdb::observers::traceframe_changed.notify (target_frameno, tracepoint_number);
2155 set_current_traceframe (target_frameno);
2157 if (target_frameno == -1)
2158 set_traceframe_context (NULL);
2160 set_traceframe_context (get_current_frame ());
2162 if (traceframe_number >= 0)
2164 /* Use different branches for MI and CLI to make CLI messages
2166 if (uiout->is_mi_like_p ())
2168 uiout->field_string ("found", "1");
2169 uiout->field_int ("tracepoint", tracepoint_number);
2170 uiout->field_int ("traceframe", traceframe_number);
2174 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2175 traceframe_number, tracepoint_number);
2180 if (uiout->is_mi_like_p ())
2181 uiout->field_string ("found", "0");
2182 else if (type == tfind_number && num == -1)
2183 printf_unfiltered (_("No longer looking at any trace frame\n"));
2184 else /* This case may never occur, check. */
2185 printf_unfiltered (_("No trace frame found\n"));
2188 /* If we're in nonstop mode and getting out of looking at trace
2189 frames, there won't be any current frame to go back to and
2192 && (has_stack_frames () || traceframe_number >= 0))
2194 enum print_what print_what;
2196 /* NOTE: in imitation of the step command, try to determine
2197 whether we have made a transition from one function to
2198 another. If so, we'll print the "stack frame" (ie. the new
2199 function and it's arguments) -- otherwise we'll just show the
2202 if (frame_id_eq (old_frame_id,
2203 get_frame_id (get_current_frame ())))
2204 print_what = SRC_LINE;
2206 print_what = SRC_AND_LOC;
2208 print_stack_frame (get_selected_frame (NULL), 1, print_what, 1);
2213 /* Error on looking at traceframes while trace is running. */
2216 check_trace_running (struct trace_status *status)
2218 if (status->running && status->filename == NULL)
2219 error (_("May not look at trace frames while trace is running."));
2222 /* trace_find_command takes a trace frame number n,
2223 sends "QTFrame:<n>" to the target,
2224 and accepts a reply that may contain several optional pieces
2225 of information: a frame number, a tracepoint number, and an
2226 indication of whether this is a trap frame or a stepping frame.
2228 The minimal response is just "OK" (which indicates that the
2229 target does not give us a frame number or a tracepoint number).
2230 Instead of that, the target may send us a string containing
2232 F<hexnum> (gives the selected frame number)
2233 T<hexnum> (gives the selected tracepoint number)
2238 tfind_command_1 (const char *args, int from_tty)
2239 { /* This should only be called with a numeric argument. */
2242 check_trace_running (current_trace_status ());
2244 if (args == 0 || *args == 0)
2245 { /* TFIND with no args means find NEXT trace frame. */
2246 if (traceframe_number == -1)
2247 frameno = 0; /* "next" is first one. */
2249 frameno = traceframe_number + 1;
2251 else if (0 == strcmp (args, "-"))
2253 if (traceframe_number == -1)
2254 error (_("not debugging trace buffer"));
2255 else if (from_tty && traceframe_number == 0)
2256 error (_("already at start of trace buffer"));
2258 frameno = traceframe_number - 1;
2260 /* A hack to work around eval's need for fp to have been collected. */
2261 else if (0 == strcmp (args, "-1"))
2264 frameno = parse_and_eval_long (args);
2267 error (_("invalid input (%d is less than zero)"), frameno);
2269 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2273 tfind_command (const char *args, int from_tty)
2275 tfind_command_1 (args, from_tty);
2280 tfind_end_command (const char *args, int from_tty)
2282 tfind_command_1 ("-1", from_tty);
2287 tfind_start_command (const char *args, int from_tty)
2289 tfind_command_1 ("0", from_tty);
2292 /* tfind pc command */
2294 tfind_pc_command (const char *args, int from_tty)
2298 check_trace_running (current_trace_status ());
2300 if (args == 0 || *args == 0)
2301 pc = regcache_read_pc (get_current_regcache ());
2303 pc = parse_and_eval_address (args);
2305 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2308 /* tfind tracepoint command */
2310 tfind_tracepoint_command (const char *args, int from_tty)
2313 struct tracepoint *tp;
2315 check_trace_running (current_trace_status ());
2317 if (args == 0 || *args == 0)
2319 if (tracepoint_number == -1)
2320 error (_("No current tracepoint -- please supply an argument."));
2322 tdp = tracepoint_number; /* Default is current TDP. */
2325 tdp = parse_and_eval_long (args);
2327 /* If we have the tracepoint on hand, use the number that the
2328 target knows about (which may be different if we disconnected
2329 and reconnected). */
2330 tp = get_tracepoint (tdp);
2332 tdp = tp->number_on_target;
2334 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2337 /* TFIND LINE command:
2339 This command will take a sourceline for argument, just like BREAK
2340 or TRACE (ie. anything that "decode_line_1" can handle).
2342 With no argument, this command will find the next trace frame
2343 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2346 tfind_line_command (const char *args, int from_tty)
2348 check_trace_running (current_trace_status ());
2350 symtab_and_line sal;
2351 if (args == 0 || *args == 0)
2353 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2357 std::vector<symtab_and_line> sals
2358 = decode_line_with_current_source (args, DECODE_LINE_FUNFIRSTLINE);
2362 if (sal.symtab == 0)
2363 error (_("No line number information available."));
2365 CORE_ADDR start_pc, end_pc;
2366 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2368 if (start_pc == end_pc)
2370 printf_filtered ("Line %d of \"%s\"",
2372 symtab_to_filename_for_display (sal.symtab));
2374 printf_filtered (" is at address ");
2375 print_address (get_current_arch (), start_pc, gdb_stdout);
2377 printf_filtered (" but contains no code.\n");
2378 sal = find_pc_line (start_pc, 0);
2380 && find_line_pc_range (sal, &start_pc, &end_pc)
2381 && start_pc != end_pc)
2382 printf_filtered ("Attempting to find line %d instead.\n",
2385 error (_("Cannot find a good line."));
2389 /* Is there any case in which we get here, and have an address
2390 which the user would want to see? If we have debugging
2391 symbols and no line numbers? */
2392 error (_("Line number %d is out of range for \"%s\"."),
2393 sal.line, symtab_to_filename_for_display (sal.symtab));
2395 /* Find within range of stated line. */
2397 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2399 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2402 /* tfind range command */
2404 tfind_range_command (const char *args, int from_tty)
2406 static CORE_ADDR start, stop;
2409 check_trace_running (current_trace_status ());
2411 if (args == 0 || *args == 0)
2412 { /* XXX FIXME: what should default behavior be? */
2413 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2417 if (0 != (tmp = strchr (args, ',')))
2419 std::string start_addr (args, tmp);
2421 tmp = skip_spaces (tmp);
2422 start = parse_and_eval_address (start_addr.c_str ());
2423 stop = parse_and_eval_address (tmp);
2426 { /* No explicit end address? */
2427 start = parse_and_eval_address (args);
2428 stop = start + 1; /* ??? */
2431 tfind_1 (tfind_range, 0, start, stop, from_tty);
2434 /* tfind outside command */
2436 tfind_outside_command (const char *args, int from_tty)
2438 CORE_ADDR start, stop;
2441 if (current_trace_status ()->running
2442 && current_trace_status ()->filename == NULL)
2443 error (_("May not look at trace frames while trace is running."));
2445 if (args == 0 || *args == 0)
2446 { /* XXX FIXME: what should default behavior be? */
2447 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2451 if (0 != (tmp = strchr (args, ',')))
2453 std::string start_addr (args, tmp);
2455 tmp = skip_spaces (tmp);
2456 start = parse_and_eval_address (start_addr.c_str ());
2457 stop = parse_and_eval_address (tmp);
2460 { /* No explicit end address? */
2461 start = parse_and_eval_address (args);
2462 stop = start + 1; /* ??? */
2465 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2468 /* info scope command: list the locals for a scope. */
2470 info_scope_command (const char *args_in, int from_tty)
2473 struct bound_minimal_symbol msym;
2474 const struct block *block;
2475 const char *symname;
2476 const char *save_args = args_in;
2477 struct block_iterator iter;
2479 struct gdbarch *gdbarch;
2481 const char *args = args_in;
2483 if (args == 0 || *args == 0)
2484 error (_("requires an argument (function, "
2485 "line or *addr) to define a scope"));
2487 event_location_up location = string_to_event_location (&args,
2489 std::vector<symtab_and_line> sals
2490 = decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE,
2494 /* Presumably decode_line_1 has already warned. */
2498 /* Resolve line numbers to PC. */
2499 resolve_sal_pc (&sals[0]);
2500 block = block_for_pc (sals[0].pc);
2504 QUIT; /* Allow user to bail out with ^C. */
2505 ALL_BLOCK_SYMBOLS (block, iter, sym)
2507 QUIT; /* Allow user to bail out with ^C. */
2509 printf_filtered ("Scope for %s:\n", save_args);
2512 symname = SYMBOL_PRINT_NAME (sym);
2513 if (symname == NULL || *symname == '\0')
2514 continue; /* Probably botched, certainly useless. */
2516 gdbarch = symbol_arch (sym);
2518 printf_filtered ("Symbol %s is ", symname);
2520 if (SYMBOL_COMPUTED_OPS (sym) != NULL)
2521 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2522 BLOCK_START (block),
2526 switch (SYMBOL_CLASS (sym))
2529 case LOC_UNDEF: /* Messed up symbol? */
2530 printf_filtered ("a bogus symbol, class %d.\n",
2531 SYMBOL_CLASS (sym));
2532 count--; /* Don't count this one. */
2535 printf_filtered ("a constant with value %s (%s)",
2536 plongest (SYMBOL_VALUE (sym)),
2537 hex_string (SYMBOL_VALUE (sym)));
2539 case LOC_CONST_BYTES:
2540 printf_filtered ("constant bytes: ");
2541 if (SYMBOL_TYPE (sym))
2542 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2543 fprintf_filtered (gdb_stdout, " %02x",
2544 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2547 printf_filtered ("in static storage at address ");
2548 printf_filtered ("%s", paddress (gdbarch,
2549 SYMBOL_VALUE_ADDRESS (sym)));
2552 /* GDBARCH is the architecture associated with the objfile
2553 the symbol is defined in; the target architecture may be
2554 different, and may provide additional registers. However,
2555 we do not know the target architecture at this point.
2556 We assume the objfile architecture will contain all the
2557 standard registers that occur in debug info in that
2559 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2562 if (SYMBOL_IS_ARGUMENT (sym))
2563 printf_filtered ("an argument in register $%s",
2564 gdbarch_register_name (gdbarch, regno));
2566 printf_filtered ("a local variable in register $%s",
2567 gdbarch_register_name (gdbarch, regno));
2570 printf_filtered ("an argument at stack/frame offset %s",
2571 plongest (SYMBOL_VALUE (sym)));
2574 printf_filtered ("a local variable at frame offset %s",
2575 plongest (SYMBOL_VALUE (sym)));
2578 printf_filtered ("a reference argument at offset %s",
2579 plongest (SYMBOL_VALUE (sym)));
2581 case LOC_REGPARM_ADDR:
2582 /* Note comment at LOC_REGISTER. */
2583 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2585 printf_filtered ("the address of an argument, in register $%s",
2586 gdbarch_register_name (gdbarch, regno));
2589 printf_filtered ("a typedef.\n");
2592 printf_filtered ("a label at address ");
2593 printf_filtered ("%s", paddress (gdbarch,
2594 SYMBOL_VALUE_ADDRESS (sym)));
2597 printf_filtered ("a function at address ");
2598 printf_filtered ("%s",
2599 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2601 case LOC_UNRESOLVED:
2602 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2604 if (msym.minsym == NULL)
2605 printf_filtered ("Unresolved Static");
2608 printf_filtered ("static storage at address ");
2609 printf_filtered ("%s",
2611 BMSYMBOL_VALUE_ADDRESS (msym)));
2614 case LOC_OPTIMIZED_OUT:
2615 printf_filtered ("optimized out.\n");
2618 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2621 if (SYMBOL_TYPE (sym))
2622 printf_filtered (", length %d.\n",
2623 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2625 if (BLOCK_FUNCTION (block))
2628 block = BLOCK_SUPERBLOCK (block);
2631 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2635 /* Helper for trace_dump_command. Dump the action list starting at
2636 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2637 actions of the body of a while-stepping action. STEPPING_FRAME is
2638 set if the current traceframe was determined to be a while-stepping
2642 trace_dump_actions (struct command_line *action,
2643 int stepping_actions, int stepping_frame,
2646 const char *action_exp, *next_comma;
2648 for (; action != NULL; action = action->next)
2650 struct cmd_list_element *cmd;
2652 QUIT; /* Allow user to bail out with ^C. */
2653 action_exp = action->line;
2654 action_exp = skip_spaces (action_exp);
2656 /* The collection actions to be done while stepping are
2657 bracketed by the commands "while-stepping" and "end". */
2659 if (*action_exp == '#') /* comment line */
2662 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2664 error (_("Bad action list item: %s"), action_exp);
2666 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2668 gdb_assert (action->body_list_1 == nullptr);
2669 trace_dump_actions (action->body_list_0.get (),
2670 1, stepping_frame, from_tty);
2672 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2674 /* Display the collected data.
2675 For the trap frame, display only what was collected at
2676 the trap. Likewise for stepping frames, display only
2677 what was collected while stepping. This means that the
2678 two boolean variables, STEPPING_FRAME and
2679 STEPPING_ACTIONS should be equal. */
2680 if (stepping_frame == stepping_actions)
2682 int trace_string = 0;
2684 if (*action_exp == '/')
2685 action_exp = decode_agent_options (action_exp, &trace_string);
2688 { /* Repeat over a comma-separated list. */
2689 QUIT; /* Allow user to bail out with ^C. */
2690 if (*action_exp == ',')
2692 action_exp = skip_spaces (action_exp);
2694 next_comma = strchr (action_exp, ',');
2696 if (0 == strncasecmp (action_exp, "$reg", 4))
2697 registers_info (NULL, from_tty);
2698 else if (0 == strncasecmp (action_exp, "$_ret", 5))
2700 else if (0 == strncasecmp (action_exp, "$loc", 4))
2701 info_locals_command (NULL, from_tty);
2702 else if (0 == strncasecmp (action_exp, "$arg", 4))
2703 info_args_command (NULL, from_tty);
2706 std::string contents;
2707 const char *exp = action_exp;
2708 if (next_comma != NULL)
2710 size_t len = next_comma - action_exp;
2711 contents = std::string (action_exp, len);
2712 exp = contents.c_str ();
2715 printf_filtered ("%s = ", exp);
2716 output_command_const (exp, from_tty);
2717 printf_filtered ("\n");
2719 action_exp = next_comma;
2721 while (action_exp && *action_exp == ',');
2727 /* Return bp_location of the tracepoint associated with the current
2728 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2729 is a stepping traceframe. */
2731 struct bp_location *
2732 get_traceframe_location (int *stepping_frame_p)
2734 struct tracepoint *t;
2735 struct bp_location *tloc;
2736 struct regcache *regcache;
2738 if (tracepoint_number == -1)
2739 error (_("No current trace frame."));
2741 t = get_tracepoint (tracepoint_number);
2744 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2747 /* The current frame is a trap frame if the frame PC is equal to the
2748 tracepoint PC. If not, then the current frame was collected
2749 during single-stepping. */
2750 regcache = get_current_regcache ();
2752 /* If the traceframe's address matches any of the tracepoint's
2753 locations, assume it is a direct hit rather than a while-stepping
2754 frame. (FIXME this is not reliable, should record each frame's
2756 for (tloc = t->loc; tloc; tloc = tloc->next)
2757 if (tloc->address == regcache_read_pc (regcache))
2759 *stepping_frame_p = 0;
2763 /* If this is a stepping frame, we don't know which location
2764 triggered. The first is as good (or bad) a guess as any... */
2765 *stepping_frame_p = 1;
2769 /* Return the default collect actions of a tracepoint T. */
2771 static counted_command_line
2772 all_tracepoint_actions (struct breakpoint *t)
2774 counted_command_line actions (nullptr, command_lines_deleter ());
2776 /* If there are default expressions to collect, make up a collect
2777 action and prepend to the action list to encode. Note that since
2778 validation is per-tracepoint (local var "xyz" might be valid for
2779 one tracepoint and not another, etc), we make up the action on
2780 the fly, and don't cache it. */
2781 if (*default_collect)
2783 struct command_line *default_collect_action;
2784 gdb::unique_xmalloc_ptr<char> default_collect_line
2785 (xstrprintf ("collect %s", default_collect));
2787 validate_actionline (default_collect_line.get (), t);
2788 actions.reset (new struct command_line (simple_control,
2789 default_collect_line.release ()),
2790 command_lines_deleter ());
2796 /* The tdump command. */
2799 tdump_command (const char *args, int from_tty)
2801 int stepping_frame = 0;
2802 struct bp_location *loc;
2804 /* This throws an error is not inspecting a trace frame. */
2805 loc = get_traceframe_location (&stepping_frame);
2807 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2808 tracepoint_number, traceframe_number);
2810 /* This command only makes sense for the current frame, not the
2812 scoped_restore_current_thread restore_thread;
2814 select_frame (get_current_frame ());
2816 counted_command_line actions = all_tracepoint_actions (loc->owner);
2818 trace_dump_actions (actions.get (), 0, stepping_frame, from_tty);
2819 trace_dump_actions (breakpoint_commands (loc->owner), 0, stepping_frame,
2823 /* Encode a piece of a tracepoint's source-level definition in a form
2824 that is suitable for both protocol and saving in files. */
2825 /* This version does not do multiple encodes for long strings; it should
2826 return an offset to the next piece to encode. FIXME */
2829 encode_source_string (int tpnum, ULONGEST addr,
2830 const char *srctype, const char *src,
2831 char *buf, int buf_size)
2833 if (80 + strlen (srctype) > buf_size)
2834 error (_("Buffer too small for source encoding"));
2835 sprintf (buf, "%x:%s:%s:%x:%x:",
2836 tpnum, phex_nz (addr, sizeof (addr)),
2837 srctype, 0, (int) strlen (src));
2838 if (strlen (buf) + strlen (src) * 2 >= buf_size)
2839 error (_("Source string too long for buffer"));
2840 bin2hex ((gdb_byte *) src, buf + strlen (buf), strlen (src));
2844 /* Tell the target what to do with an ongoing tracing run if GDB
2845 disconnects for some reason. */
2848 set_disconnected_tracing (const char *args, int from_tty,
2849 struct cmd_list_element *c)
2851 target_set_disconnected_tracing (disconnected_tracing);
2855 set_circular_trace_buffer (const char *args, int from_tty,
2856 struct cmd_list_element *c)
2858 target_set_circular_trace_buffer (circular_trace_buffer);
2862 set_trace_buffer_size (const char *args, int from_tty,
2863 struct cmd_list_element *c)
2865 target_set_trace_buffer_size (trace_buffer_size);
2869 set_trace_user (const char *args, int from_tty,
2870 struct cmd_list_element *c)
2874 ret = target_set_trace_notes (trace_user, NULL, NULL);
2877 warning (_("Target does not support trace notes, user ignored"));
2881 set_trace_notes (const char *args, int from_tty,
2882 struct cmd_list_element *c)
2886 ret = target_set_trace_notes (NULL, trace_notes, NULL);
2889 warning (_("Target does not support trace notes, note ignored"));
2893 set_trace_stop_notes (const char *args, int from_tty,
2894 struct cmd_list_element *c)
2898 ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
2901 warning (_("Target does not support trace notes, stop note ignored"));
2904 /* Convert the memory pointed to by mem into hex, placing result in buf.
2905 * Return a pointer to the last char put in buf (null)
2906 * "stolen" from sparc-stub.c
2909 static const char hexchars[] = "0123456789abcdef";
2912 mem2hex (gdb_byte *mem, char *buf, int count)
2920 *buf++ = hexchars[ch >> 4];
2921 *buf++ = hexchars[ch & 0xf];
2930 get_traceframe_number (void)
2932 return traceframe_number;
2936 get_tracepoint_number (void)
2938 return tracepoint_number;
2941 /* Make the traceframe NUM be the current trace frame. Does nothing
2942 if NUM is already current. */
2945 set_current_traceframe (int num)
2949 if (traceframe_number == num)
2951 /* Nothing to do. */
2955 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
2958 warning (_("could not change traceframe"));
2960 set_traceframe_num (newnum);
2962 /* Changing the traceframe changes our view of registers and of the
2964 registers_changed ();
2966 clear_traceframe_info ();
2969 scoped_restore_current_traceframe::scoped_restore_current_traceframe ()
2970 : m_traceframe_number (traceframe_number)
2973 /* Given a number and address, return an uploaded tracepoint with that
2974 number, creating if necessary. */
2976 struct uploaded_tp *
2977 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
2979 struct uploaded_tp *utp;
2981 for (utp = *utpp; utp; utp = utp->next)
2982 if (utp->number == num && utp->addr == addr)
2985 utp = new uploaded_tp;
2995 free_uploaded_tps (struct uploaded_tp **utpp)
2997 struct uploaded_tp *next_one;
3001 next_one = (*utpp)->next;
3007 /* Given a number and address, return an uploaded tracepoint with that
3008 number, creating if necessary. */
3010 struct uploaded_tsv *
3011 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3013 struct uploaded_tsv *utsv;
3015 for (utsv = *utsvp; utsv; utsv = utsv->next)
3016 if (utsv->number == num)
3019 utsv = XCNEW (struct uploaded_tsv);
3021 utsv->next = *utsvp;
3028 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3030 struct uploaded_tsv *next_one;
3034 next_one = (*utsvp)->next;
3040 /* FIXME this function is heuristic and will miss the cases where the
3041 conditional is semantically identical but differs in whitespace,
3042 such as "x == 0" vs "x==0". */
3045 cond_string_is_same (char *str1, char *str2)
3047 if (str1 == NULL || str2 == NULL)
3048 return (str1 == str2);
3050 return (strcmp (str1, str2) == 0);
3053 /* Look for an existing tracepoint that seems similar enough to the
3054 uploaded one. Enablement isn't compared, because the user can
3055 toggle that freely, and may have done so in anticipation of the
3056 next trace run. Return the location of matched tracepoint. */
3058 static struct bp_location *
3059 find_matching_tracepoint_location (struct uploaded_tp *utp)
3061 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
3063 struct breakpoint *b;
3064 struct bp_location *loc;
3066 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
3068 struct tracepoint *t = (struct tracepoint *) b;
3070 if (b->type == utp->type
3071 && t->step_count == utp->step
3072 && t->pass_count == utp->pass
3073 && cond_string_is_same (t->cond_string, utp->cond_string)
3074 /* FIXME also test actions. */
3077 /* Scan the locations for an address match. */
3078 for (loc = b->loc; loc; loc = loc->next)
3080 if (loc->address == utp->addr)
3088 /* Given a list of tracepoints uploaded from a target, attempt to
3089 match them up with existing tracepoints, and create new ones if not
3093 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3095 struct uploaded_tp *utp;
3096 /* A set of tracepoints which are modified. */
3097 VEC(breakpoint_p) *modified_tp = NULL;
3099 struct breakpoint *b;
3101 /* Look for GDB tracepoints that match up with our uploaded versions. */
3102 for (utp = *uploaded_tps; utp; utp = utp->next)
3104 struct bp_location *loc;
3105 struct tracepoint *t;
3107 loc = find_matching_tracepoint_location (utp);
3112 /* Mark this location as already inserted. */
3114 t = (struct tracepoint *) loc->owner;
3115 printf_filtered (_("Assuming tracepoint %d is same "
3116 "as target's tracepoint %d at %s.\n"),
3117 loc->owner->number, utp->number,
3118 paddress (loc->gdbarch, utp->addr));
3120 /* The tracepoint LOC->owner was modified (the location LOC
3121 was marked as inserted in the target). Save it in
3122 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3123 observers will be notified later once for each tracepoint
3124 saved in MODIFIED_TP. */
3126 VEC_iterate (breakpoint_p, modified_tp, ix, b);
3128 if (b == loc->owner)
3134 VEC_safe_push (breakpoint_p, modified_tp, loc->owner);
3138 t = create_tracepoint_from_upload (utp);
3140 printf_filtered (_("Created tracepoint %d for "
3141 "target's tracepoint %d at %s.\n"),
3142 t->number, utp->number,
3143 paddress (get_current_arch (), utp->addr));
3145 printf_filtered (_("Failed to create tracepoint for target's "
3146 "tracepoint %d at %s, skipping it.\n"),
3148 paddress (get_current_arch (), utp->addr));
3150 /* Whether found or created, record the number used by the
3151 target, to help with mapping target tracepoints back to their
3152 counterparts here. */
3154 t->number_on_target = utp->number;
3157 /* Notify 'breakpoint-modified' observer that at least one of B's
3158 locations was changed. */
3159 for (ix = 0; VEC_iterate (breakpoint_p, modified_tp, ix, b); ix++)
3160 gdb::observers::breakpoint_modified.notify (b);
3162 VEC_free (breakpoint_p, modified_tp);
3163 free_uploaded_tps (uploaded_tps);
3166 /* Trace state variables don't have much to identify them beyond their
3167 name, so just use that to detect matches. */
3169 static struct trace_state_variable *
3170 find_matching_tsv (struct uploaded_tsv *utsv)
3175 return find_trace_state_variable (utsv->name);
3178 static struct trace_state_variable *
3179 create_tsv_from_upload (struct uploaded_tsv *utsv)
3181 const char *namebase;
3184 struct trace_state_variable *tsv;
3188 namebase = utsv->name;
3194 buf = string_printf ("%s_%d", namebase, try_num++);
3197 /* Fish for a name that is not in use. */
3198 /* (should check against all internal vars?) */
3199 while (find_trace_state_variable (buf.c_str ()))
3200 buf = string_printf ("%s_%d", namebase, try_num++);
3202 /* We have an available name, create the variable. */
3203 tsv = create_trace_state_variable (buf.c_str ());
3204 tsv->initial_value = utsv->initial_value;
3205 tsv->builtin = utsv->builtin;
3207 gdb::observers::tsv_created.notify (tsv);
3212 /* Given a list of uploaded trace state variables, try to match them
3213 up with existing variables, or create additional ones. */
3216 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
3219 struct uploaded_tsv *utsv;
3220 struct trace_state_variable *tsv;
3223 /* Most likely some numbers will have to be reassigned as part of
3224 the merge, so clear them all in anticipation. */
3225 for (trace_state_variable &tsv : tvariables)
3228 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
3230 tsv = find_matching_tsv (utsv);
3234 printf_filtered (_("Assuming trace state variable $%s "
3235 "is same as target's variable %d.\n"),
3236 tsv->name.c_str (), utsv->number);
3240 tsv = create_tsv_from_upload (utsv);
3242 printf_filtered (_("Created trace state variable "
3243 "$%s for target's variable %d.\n"),
3244 tsv->name.c_str (), utsv->number);
3246 /* Give precedence to numberings that come from the target. */
3248 tsv->number = utsv->number;
3251 /* Renumber everything that didn't get a target-assigned number. */
3253 for (const trace_state_variable &tsv : tvariables)
3254 highest = std::max (tsv.number, highest);
3257 for (trace_state_variable &tsv : tvariables)
3258 if (tsv.number == 0)
3259 tsv.number = highest++;
3261 free_uploaded_tsvs (uploaded_tsvs);
3264 /* Parse the part of trace status syntax that is shared between
3265 the remote protocol and the trace file reader. */
3268 parse_trace_status (const char *line, struct trace_status *ts)
3270 const char *p = line, *p1, *p2, *p3, *p_temp;
3274 ts->running_known = 1;
3275 ts->running = (*p++ == '1');
3276 ts->stop_reason = trace_stop_reason_unknown;
3277 xfree (ts->stop_desc);
3278 ts->stop_desc = NULL;
3279 ts->traceframe_count = -1;
3280 ts->traceframes_created = -1;
3281 ts->buffer_free = -1;
3282 ts->buffer_size = -1;
3283 ts->disconnected_tracing = 0;
3284 ts->circular_buffer = 0;
3285 xfree (ts->user_name);
3286 ts->user_name = NULL;
3289 ts->start_time = ts->stop_time = 0;
3293 p1 = strchr (p, ':');
3295 error (_("Malformed trace status, at %s\n\
3296 Status line: '%s'\n"), p, line);
3297 p3 = strchr (p, ';');
3299 p3 = p + strlen (p);
3300 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3302 p = unpack_varlen_hex (++p1, &val);
3303 ts->stop_reason = trace_buffer_full;
3305 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3307 p = unpack_varlen_hex (++p1, &val);
3308 ts->stop_reason = trace_never_run;
3310 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
3313 p = unpack_varlen_hex (++p1, &val);
3314 ts->stop_reason = tracepoint_passcount;
3315 ts->stopping_tracepoint = val;
3317 else if (strncmp (p, stop_reason_names[trace_stop_command], p1 - p) == 0)
3319 p2 = strchr (++p1, ':');
3327 ts->stop_desc = (char *) xmalloc (strlen (line));
3328 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
3329 ts->stop_desc[end] = '\0';
3332 ts->stop_desc = xstrdup ("");
3334 p = unpack_varlen_hex (++p2, &val);
3335 ts->stop_reason = trace_stop_command;
3337 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3339 p = unpack_varlen_hex (++p1, &val);
3340 ts->stop_reason = trace_disconnected;
3342 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3344 p2 = strchr (++p1, ':');
3347 ts->stop_desc = (char *) xmalloc ((p2 - p1) / 2 + 1);
3348 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
3349 ts->stop_desc[end] = '\0';
3352 ts->stop_desc = xstrdup ("");
3354 p = unpack_varlen_hex (++p2, &val);
3355 ts->stopping_tracepoint = val;
3356 ts->stop_reason = tracepoint_error;
3358 else if (strncmp (p, "tframes", p1 - p) == 0)
3360 p = unpack_varlen_hex (++p1, &val);
3361 ts->traceframe_count = val;
3363 else if (strncmp (p, "tcreated", p1 - p) == 0)
3365 p = unpack_varlen_hex (++p1, &val);
3366 ts->traceframes_created = val;
3368 else if (strncmp (p, "tfree", p1 - p) == 0)
3370 p = unpack_varlen_hex (++p1, &val);
3371 ts->buffer_free = val;
3373 else if (strncmp (p, "tsize", p1 - p) == 0)
3375 p = unpack_varlen_hex (++p1, &val);
3376 ts->buffer_size = val;
3378 else if (strncmp (p, "disconn", p1 - p) == 0)
3380 p = unpack_varlen_hex (++p1, &val);
3381 ts->disconnected_tracing = val;
3383 else if (strncmp (p, "circular", p1 - p) == 0)
3385 p = unpack_varlen_hex (++p1, &val);
3386 ts->circular_buffer = val;
3388 else if (strncmp (p, "starttime", p1 - p) == 0)
3390 p = unpack_varlen_hex (++p1, &val);
3391 ts->start_time = val;
3393 else if (strncmp (p, "stoptime", p1 - p) == 0)
3395 p = unpack_varlen_hex (++p1, &val);
3396 ts->stop_time = val;
3398 else if (strncmp (p, "username", p1 - p) == 0)
3401 ts->user_name = (char *) xmalloc (strlen (p) / 2);
3402 end = hex2bin (p1, (gdb_byte *) ts->user_name, (p3 - p1) / 2);
3403 ts->user_name[end] = '\0';
3406 else if (strncmp (p, "notes", p1 - p) == 0)
3409 ts->notes = (char *) xmalloc (strlen (p) / 2);
3410 end = hex2bin (p1, (gdb_byte *) ts->notes, (p3 - p1) / 2);
3411 ts->notes[end] = '\0';
3416 /* Silently skip unknown optional info. */
3417 p_temp = strchr (p1 + 1, ';');
3421 /* Must be at the end. */
3428 parse_tracepoint_status (const char *p, struct breakpoint *bp,
3429 struct uploaded_tp *utp)
3432 struct tracepoint *tp = (struct tracepoint *) bp;
3434 p = unpack_varlen_hex (p, &uval);
3436 tp->hit_count += uval;
3438 utp->hit_count += uval;
3439 p = unpack_varlen_hex (p + 1, &uval);
3441 tp->traceframe_usage += uval;
3443 utp->traceframe_usage += uval;
3444 /* Ignore any extra, allowing for future extensions. */
3447 /* Given a line of text defining a part of a tracepoint, parse it into
3448 an "uploaded tracepoint". */
3451 parse_tracepoint_definition (const char *line, struct uploaded_tp **utpp)
3455 ULONGEST num, addr, step, pass, orig_size, xlen, start;
3458 const char *srctype;
3460 struct uploaded_tp *utp = NULL;
3463 /* Both tracepoint and action definitions start with the same number
3464 and address sequence. */
3466 p = unpack_varlen_hex (p, &num);
3467 p++; /* skip a colon */
3468 p = unpack_varlen_hex (p, &addr);
3469 p++; /* skip a colon */
3472 enabled = (*p++ == 'E');
3473 p++; /* skip a colon */
3474 p = unpack_varlen_hex (p, &step);
3475 p++; /* skip a colon */
3476 p = unpack_varlen_hex (p, &pass);
3477 type = bp_tracepoint;
3479 /* Thumb through optional fields. */
3482 p++; /* skip a colon */
3485 type = bp_fast_tracepoint;
3487 p = unpack_varlen_hex (p, &orig_size);
3491 type = bp_static_tracepoint;
3497 p = unpack_varlen_hex (p, &xlen);
3498 p++; /* skip a comma */
3499 cond = (char *) xmalloc (2 * xlen + 1);
3500 strncpy (cond, p, 2 * xlen);
3501 cond[2 * xlen] = '\0';
3505 warning (_("Unrecognized char '%c' in tracepoint "
3506 "definition, skipping rest"), *p);
3508 utp = get_uploaded_tp (num, addr, utpp);
3510 utp->enabled = enabled;
3515 else if (piece == 'A')
3517 utp = get_uploaded_tp (num, addr, utpp);
3518 utp->actions.push_back (xstrdup (p));
3520 else if (piece == 'S')
3522 utp = get_uploaded_tp (num, addr, utpp);
3523 utp->step_actions.push_back (xstrdup (p));
3525 else if (piece == 'Z')
3527 /* Parse a chunk of source form definition. */
3528 utp = get_uploaded_tp (num, addr, utpp);
3530 p = strchr (p, ':');
3531 p++; /* skip a colon */
3532 p = unpack_varlen_hex (p, &start);
3533 p++; /* skip a colon */
3534 p = unpack_varlen_hex (p, &xlen);
3535 p++; /* skip a colon */
3537 buf = (char *) alloca (strlen (line));
3539 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3542 if (startswith (srctype, "at:"))
3543 utp->at_string = xstrdup (buf);
3544 else if (startswith (srctype, "cond:"))
3545 utp->cond_string = xstrdup (buf);
3546 else if (startswith (srctype, "cmd:"))
3547 utp->cmd_strings.push_back (xstrdup (buf));
3549 else if (piece == 'V')
3551 utp = get_uploaded_tp (num, addr, utpp);
3553 parse_tracepoint_status (p, NULL, utp);
3557 /* Don't error out, the target might be sending us optional
3558 info that we don't care about. */
3559 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
3563 /* Convert a textual description of a trace state variable into an
3567 parse_tsv_definition (const char *line, struct uploaded_tsv **utsvp)
3571 ULONGEST num, initval, builtin;
3573 struct uploaded_tsv *utsv = NULL;
3575 buf = (char *) alloca (strlen (line));
3578 p = unpack_varlen_hex (p, &num);
3579 p++; /* skip a colon */
3580 p = unpack_varlen_hex (p, &initval);
3581 p++; /* skip a colon */
3582 p = unpack_varlen_hex (p, &builtin);
3583 p++; /* skip a colon */
3584 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3587 utsv = get_uploaded_tsv (num, utsvp);
3588 utsv->initial_value = initval;
3589 utsv->builtin = builtin;
3590 utsv->name = xstrdup (buf);
3593 /* Given a line of text defining a static tracepoint marker, parse it
3594 into a "static tracepoint marker" object. Throws an error is
3595 parsing fails. If PP is non-null, it points to one past the end of
3596 the parsed marker definition. */
3599 parse_static_tracepoint_marker_definition (const char *line, const char **pp,
3600 static_tracepoint_marker *marker)
3602 const char *p, *endp;
3606 p = unpack_varlen_hex (p, &addr);
3607 p++; /* skip a colon */
3609 marker->gdbarch = target_gdbarch ();
3610 marker->address = (CORE_ADDR) addr;
3612 endp = strchr (p, ':');
3614 error (_("bad marker definition: %s"), line);
3616 marker->str_id = hex2str (p, (endp - p) / 2);
3619 p++; /* skip a colon */
3621 /* This definition may be followed by another one, separated by a comma. */
3623 endp = strchr (p, ',');
3624 if (endp != nullptr)
3627 hex_len = strlen (p);
3629 marker->extra = hex2str (p, hex_len / 2);
3635 /* Print MARKER to gdb_stdout. */
3638 print_one_static_tracepoint_marker (int count,
3639 const static_tracepoint_marker &marker)
3643 char wrap_indent[80];
3644 char extra_field_indent[80];
3645 struct ui_out *uiout = current_uiout;
3646 VEC(breakpoint_p) *tracepoints;
3648 symtab_and_line sal;
3649 sal.pc = marker.address;
3651 tracepoints = static_tracepoints_here (marker.address);
3653 ui_out_emit_tuple tuple_emitter (uiout, "marker");
3655 /* A counter field to help readability. This is not a stable
3657 uiout->field_int ("count", count);
3659 uiout->field_string ("marker-id", marker.str_id.c_str ());
3661 uiout->field_fmt ("enabled", "%c",
3662 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
3665 strcpy (wrap_indent, " ");
3667 if (gdbarch_addr_bit (marker.gdbarch) <= 32)
3668 strcat (wrap_indent, " ");
3670 strcat (wrap_indent, " ");
3672 strcpy (extra_field_indent, " ");
3674 uiout->field_core_addr ("addr", marker.gdbarch, marker.address);
3676 sal = find_pc_line (marker.address, 0);
3677 sym = find_pc_sect_function (marker.address, NULL);
3680 uiout->text ("in ");
3681 uiout->field_string ("func",
3682 SYMBOL_PRINT_NAME (sym));
3683 uiout->wrap_hint (wrap_indent);
3684 uiout->text (" at ");
3687 uiout->field_skip ("func");
3689 if (sal.symtab != NULL)
3691 uiout->field_string ("file",
3692 symtab_to_filename_for_display (sal.symtab));
3695 if (uiout->is_mi_like_p ())
3697 const char *fullname = symtab_to_fullname (sal.symtab);
3699 uiout->field_string ("fullname", fullname);
3702 uiout->field_skip ("fullname");
3704 uiout->field_int ("line", sal.line);
3708 uiout->field_skip ("fullname");
3709 uiout->field_skip ("line");
3713 uiout->text (extra_field_indent);
3714 uiout->text (_("Data: \""));
3715 uiout->field_string ("extra-data", marker.extra.c_str ());
3716 uiout->text ("\"\n");
3718 if (!VEC_empty (breakpoint_p, tracepoints))
3721 struct breakpoint *b;
3724 ui_out_emit_tuple tuple_emitter (uiout, "tracepoints-at");
3726 uiout->text (extra_field_indent);
3727 uiout->text (_("Probed by static tracepoints: "));
3728 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
3733 uiout->field_int ("tracepoint-id", b->number);
3737 if (uiout->is_mi_like_p ())
3738 uiout->field_int ("number-of-tracepoints",
3739 VEC_length(breakpoint_p, tracepoints));
3743 VEC_free (breakpoint_p, tracepoints);
3747 info_static_tracepoint_markers_command (const char *arg, int from_tty)
3749 struct ui_out *uiout = current_uiout;
3750 std::vector<static_tracepoint_marker> markers
3751 = target_static_tracepoint_markers_by_strid (NULL);
3753 /* We don't have to check target_can_use_agent and agent's capability on
3754 static tracepoint here, in order to be compatible with older GDBserver.
3755 We don't check USE_AGENT is true or not, because static tracepoints
3756 don't work without in-process agent, so we don't bother users to type
3757 `set agent on' when to use static tracepoint. */
3759 ui_out_emit_table table_emitter (uiout, 5, -1,
3760 "StaticTracepointMarkersTable");
3762 uiout->table_header (7, ui_left, "counter", "Cnt");
3764 uiout->table_header (40, ui_left, "marker-id", "ID");
3766 uiout->table_header (3, ui_left, "enabled", "Enb");
3767 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
3768 uiout->table_header (10, ui_left, "addr", "Address");
3770 uiout->table_header (18, ui_left, "addr", "Address");
3771 uiout->table_header (40, ui_noalign, "what", "What");
3773 uiout->table_body ();
3775 for (int i = 0; i < markers.size (); i++)
3776 print_one_static_tracepoint_marker (i + 1, markers[i]);
3779 /* The $_sdata convenience variable is a bit special. We don't know
3780 for sure type of the value until we actually have a chance to fetch
3781 the data --- the size of the object depends on what has been
3782 collected. We solve this by making $_sdata be an internalvar that
3783 creates a new value on access. */
3785 /* Return a new value with the correct type for the sdata object of
3786 the current trace frame. Return a void value if there's no object
3789 static struct value *
3790 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
3793 /* We need to read the whole object before we know its size. */
3794 gdb::optional<gdb::byte_vector> buf
3795 = target_read_alloc (target_stack, TARGET_OBJECT_STATIC_TRACE_DATA,
3802 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
3804 v = allocate_value (type);
3805 memcpy (value_contents_raw (v), buf->data (), buf->size ());
3809 return allocate_value (builtin_type (gdbarch)->builtin_void);
3812 #if !defined(HAVE_LIBEXPAT)
3814 struct std::unique_ptr<traceframe_info>
3815 parse_traceframe_info (const char *tframe_info)
3817 static int have_warned;
3822 warning (_("Can not parse XML trace frame info; XML support "
3823 "was disabled at compile time"));
3829 #else /* HAVE_LIBEXPAT */
3831 #include "xml-support.h"
3833 /* Handle the start of a <memory> element. */
3836 traceframe_info_start_memory (struct gdb_xml_parser *parser,
3837 const struct gdb_xml_element *element,
3839 std::vector<gdb_xml_value> &attributes)
3841 struct traceframe_info *info = (struct traceframe_info *) user_data;
3842 ULONGEST *start_p, *length_p;
3845 = (ULONGEST *) xml_find_attribute (attributes, "start")->value.get ();
3847 = (ULONGEST *) xml_find_attribute (attributes, "length")->value.get ();
3849 info->memory.emplace_back (*start_p, *length_p);
3852 /* Handle the start of a <tvar> element. */
3855 traceframe_info_start_tvar (struct gdb_xml_parser *parser,
3856 const struct gdb_xml_element *element,
3858 std::vector<gdb_xml_value> &attributes)
3860 struct traceframe_info *info = (struct traceframe_info *) user_data;
3861 const char *id_attrib
3862 = (const char *) xml_find_attribute (attributes, "id")->value.get ();
3863 int id = gdb_xml_parse_ulongest (parser, id_attrib);
3865 info->tvars.push_back (id);
3868 /* The allowed elements and attributes for an XML memory map. */
3870 static const struct gdb_xml_attribute memory_attributes[] = {
3871 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
3872 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
3873 { NULL, GDB_XML_AF_NONE, NULL, NULL }
3876 static const struct gdb_xml_attribute tvar_attributes[] = {
3877 { "id", GDB_XML_AF_NONE, NULL, NULL },
3878 { NULL, GDB_XML_AF_NONE, NULL, NULL }
3881 static const struct gdb_xml_element traceframe_info_children[] = {
3882 { "memory", memory_attributes, NULL,
3883 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
3884 traceframe_info_start_memory, NULL },
3885 { "tvar", tvar_attributes, NULL,
3886 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
3887 traceframe_info_start_tvar, NULL },
3888 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
3891 static const struct gdb_xml_element traceframe_info_elements[] = {
3892 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
3894 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
3897 /* Parse a traceframe-info XML document. */
3900 parse_traceframe_info (const char *tframe_info)
3902 traceframe_info_up result (new traceframe_info);
3904 if (gdb_xml_parse_quick (_("trace frame info"),
3905 "traceframe-info.dtd", traceframe_info_elements,
3906 tframe_info, result.get ()) == 0)
3912 #endif /* HAVE_LIBEXPAT */
3914 /* Returns the traceframe_info object for the current traceframe.
3915 This is where we avoid re-fetching the object from the target if we
3916 already have it cached. */
3918 struct traceframe_info *
3919 get_traceframe_info (void)
3921 if (current_traceframe_info == NULL)
3922 current_traceframe_info = target_traceframe_info ();
3924 return current_traceframe_info.get ();
3927 /* If the target supports the query, return in RESULT the set of
3928 collected memory in the current traceframe, found within the LEN
3929 bytes range starting at MEMADDR. Returns true if the target
3930 supports the query, otherwise returns false, and RESULT is left
3934 traceframe_available_memory (std::vector<mem_range> *result,
3935 CORE_ADDR memaddr, ULONGEST len)
3937 struct traceframe_info *info = get_traceframe_info ();
3943 for (mem_range &r : info->memory)
3944 if (mem_ranges_overlap (r.start, r.length, memaddr, len))
3946 ULONGEST lo1, hi1, lo2, hi2;
3949 hi1 = memaddr + len;
3952 hi2 = r.start + r.length;
3954 CORE_ADDR start = std::max (lo1, lo2);
3955 int length = std::min (hi1, hi2) - start;
3957 result->emplace_back (start, length);
3960 normalize_mem_ranges (result);
3967 /* Implementation of `sdata' variable. */
3969 static const struct internalvar_funcs sdata_funcs =
3976 /* module initialization */
3978 _initialize_tracepoint (void)
3980 struct cmd_list_element *c;
3982 /* Explicitly create without lookup, since that tries to create a
3983 value with a void typed value, and when we get here, gdbarch
3984 isn't initialized yet. At this point, we're quite sure there
3985 isn't another convenience variable of the same name. */
3986 create_internalvar_type_lazy ("_sdata", &sdata_funcs, NULL);
3988 traceframe_number = -1;
3989 tracepoint_number = -1;
3991 add_info ("scope", info_scope_command,
3992 _("List the variables local to a scope"));
3994 add_cmd ("tracepoints", class_trace,
3995 _("Tracing of program execution without stopping the program."),
3998 add_com ("tdump", class_trace, tdump_command,
3999 _("Print everything collected at the current tracepoint."));
4001 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
4002 Define a trace state variable.\n\
4003 Argument is a $-prefixed name, optionally followed\n\
4004 by '=' and an expression that sets the initial value\n\
4005 at the start of tracing."));
4006 set_cmd_completer (c, expression_completer);
4008 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
4009 Delete one or more trace state variables.\n\
4010 Arguments are the names of the variables to delete.\n\
4011 If no arguments are supplied, delete all variables."), &deletelist);
4012 /* FIXME add a trace variable completer. */
4014 add_info ("tvariables", info_tvariables_command, _("\
4015 Status of trace state variables and their values.\n\
4018 add_info ("static-tracepoint-markers",
4019 info_static_tracepoint_markers_command, _("\
4020 List target static tracepoints markers.\n\
4023 add_prefix_cmd ("tfind", class_trace, tfind_command, _("\
4024 Select a trace frame;\n\
4025 No argument means forward by one frame; '-' means backward by one frame."),
4026 &tfindlist, "tfind ", 1, &cmdlist);
4028 add_cmd ("outside", class_trace, tfind_outside_command, _("\
4029 Select a trace frame whose PC is outside the given range (exclusive).\n\
4030 Usage: tfind outside addr1, addr2"),
4033 add_cmd ("range", class_trace, tfind_range_command, _("\
4034 Select a trace frame whose PC is in the given range (inclusive).\n\
4035 Usage: tfind range addr1,addr2"),
4038 add_cmd ("line", class_trace, tfind_line_command, _("\
4039 Select a trace frame by source line.\n\
4040 Argument can be a line number (with optional source file),\n\
4041 a function name, or '*' followed by an address.\n\
4042 Default argument is 'the next source line that was traced'."),
4045 add_cmd ("tracepoint", class_trace, tfind_tracepoint_command, _("\
4046 Select a trace frame by tracepoint number.\n\
4047 Default is the tracepoint for the current trace frame."),
4050 add_cmd ("pc", class_trace, tfind_pc_command, _("\
4051 Select a trace frame by PC.\n\
4052 Default is the current PC, or the PC of the current trace frame."),
4055 add_cmd ("end", class_trace, tfind_end_command, _("\
4056 De-select any trace frame and resume 'live' debugging."),
4059 add_alias_cmd ("none", "end", class_trace, 0, &tfindlist);
4061 add_cmd ("start", class_trace, tfind_start_command,
4062 _("Select the first trace frame in the trace buffer."),
4065 add_com ("tstatus", class_trace, tstatus_command,
4066 _("Display the status of the current trace data collection."));
4068 add_com ("tstop", class_trace, tstop_command, _("\
4069 Stop trace data collection.\n\
4070 Usage: tstop [ <notes> ... ]\n\
4071 Any arguments supplied are recorded with the trace as a stop reason and\n\
4072 reported by tstatus (if the target supports trace notes)."));
4074 add_com ("tstart", class_trace, tstart_command, _("\
4075 Start trace data collection.\n\
4076 Usage: tstart [ <notes> ... ]\n\
4077 Any arguments supplied are recorded with the trace as a note and\n\
4078 reported by tstatus (if the target supports trace notes)."));
4080 add_com ("end", class_trace, end_actions_pseudocommand, _("\
4081 Ends a list of commands or actions.\n\
4082 Several GDB commands allow you to enter a list of commands or actions.\n\
4083 Entering \"end\" on a line by itself is the normal way to terminate\n\
4085 Note: the \"end\" command cannot be used at the gdb prompt."));
4087 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
4088 Specify single-stepping behavior at a tracepoint.\n\
4089 Argument is number of instructions to trace in single-step mode\n\
4090 following the tracepoint. This command is normally followed by\n\
4091 one or more \"collect\" commands, to specify what to collect\n\
4092 while single-stepping.\n\n\
4093 Note: this command can only be used in a tracepoint \"actions\" list."));
4095 add_com_alias ("ws", "while-stepping", class_alias, 0);
4096 add_com_alias ("stepping", "while-stepping", class_alias, 0);
4098 add_com ("collect", class_trace, collect_pseudocommand, _("\
4099 Specify one or more data items to be collected at a tracepoint.\n\
4100 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4101 collect all data (variables, registers) referenced by that expression.\n\
4102 Also accepts the following special arguments:\n\
4103 $regs -- all registers.\n\
4104 $args -- all function arguments.\n\
4105 $locals -- all variables local to the block/function scope.\n\
4106 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4107 Note: this command can only be used in a tracepoint \"actions\" list."));
4109 add_com ("teval", class_trace, teval_pseudocommand, _("\
4110 Specify one or more expressions to be evaluated at a tracepoint.\n\
4111 Accepts a comma-separated list of (one or more) expressions.\n\
4112 The result of each evaluation will be discarded.\n\
4113 Note: this command can only be used in a tracepoint \"actions\" list."));
4115 add_com ("actions", class_trace, actions_command, _("\
4116 Specify the actions to be taken at a tracepoint.\n\
4117 Tracepoint actions may include collecting of specified data,\n\
4118 single-stepping, or enabling/disabling other tracepoints,\n\
4119 depending on target's capabilities."));
4121 default_collect = xstrdup ("");
4122 add_setshow_string_cmd ("default-collect", class_trace,
4123 &default_collect, _("\
4124 Set the list of expressions to collect by default"), _("\
4125 Show the list of expressions to collect by default"), NULL,
4127 &setlist, &showlist);
4129 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
4130 &disconnected_tracing, _("\
4131 Set whether tracing continues after GDB disconnects."), _("\
4132 Show whether tracing continues after GDB disconnects."), _("\
4133 Use this to continue a tracing run even if GDB disconnects\n\
4134 or detaches from the target. You can reconnect later and look at\n\
4135 trace data collected in the meantime."),
4136 set_disconnected_tracing,
4141 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
4142 &circular_trace_buffer, _("\
4143 Set target's use of circular trace buffer."), _("\
4144 Show target's use of circular trace buffer."), _("\
4145 Use this to make the trace buffer into a circular buffer,\n\
4146 which will discard traceframes (oldest first) instead of filling\n\
4147 up and stopping the trace run."),
4148 set_circular_trace_buffer,
4153 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class,
4154 &trace_buffer_size, _("\
4155 Set requested size of trace buffer."), _("\
4156 Show requested size of trace buffer."), _("\
4157 Use this to choose a size for the trace buffer. Some targets\n\
4158 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
4159 disables any attempt to set the buffer size and lets the target choose."),
4160 set_trace_buffer_size, NULL,
4161 &setlist, &showlist);
4163 add_setshow_string_cmd ("trace-user", class_trace,
4165 Set the user name to use for current and future trace runs"), _("\
4166 Show the user name to use for current and future trace runs"), NULL,
4167 set_trace_user, NULL,
4168 &setlist, &showlist);
4170 add_setshow_string_cmd ("trace-notes", class_trace,
4172 Set notes string to use for current and future trace runs"), _("\
4173 Show the notes string to use for current and future trace runs"), NULL,
4174 set_trace_notes, NULL,
4175 &setlist, &showlist);
4177 add_setshow_string_cmd ("trace-stop-notes", class_trace,
4178 &trace_stop_notes, _("\
4179 Set notes string to use for future tstop commands"), _("\
4180 Show the notes string to use for future tstop commands"), NULL,
4181 set_trace_stop_notes, NULL,
4182 &setlist, &showlist);