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 int has_pending_p = 0;
1500 /* Check whether we still have pending tracepoint. If we have, warn the
1501 user that pending tracepoint will no longer work. */
1502 for (breakpoint *b : all_tracepoints ())
1511 struct bp_location *loc1;
1513 for (loc1 = b->loc; loc1; loc1 = loc1->next)
1515 if (loc1->shlib_disabled)
1528 warning (_("Pending tracepoints will not be resolved while"
1529 " GDB is disconnected\n"));
1532 /* Reset local state of tracing. */
1535 trace_reset_local_state (void)
1537 set_traceframe_num (-1);
1538 set_tracepoint_num (-1);
1539 set_traceframe_context (NULL);
1540 clear_traceframe_info ();
1544 start_tracing (const char *notes)
1546 struct trace_state_variable *tsv;
1547 int any_enabled = 0, num_to_download = 0;
1550 std::vector<breakpoint *> tp_vec = all_tracepoints ();
1552 /* No point in tracing without any tracepoints... */
1553 if (tp_vec.empty ())
1554 error (_("No tracepoints defined, not starting trace"));
1556 for (breakpoint *b : tp_vec)
1558 if (b->enable_state == bp_enabled)
1561 if ((b->type == bp_fast_tracepoint
1562 ? may_insert_fast_tracepoints
1563 : may_insert_tracepoints))
1566 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1567 (b->type == bp_fast_tracepoint ? "fast " : ""), b->number);
1572 if (target_supports_enable_disable_tracepoint ())
1573 warning (_("No tracepoints enabled"));
1576 /* No point in tracing with only disabled tracepoints that
1577 cannot be re-enabled. */
1578 error (_("No tracepoints enabled, not starting trace"));
1582 if (num_to_download <= 0)
1583 error (_("No tracepoints that may be downloaded, not starting trace"));
1585 target_trace_init ();
1587 for (breakpoint *b : tp_vec)
1589 struct tracepoint *t = (struct tracepoint *) b;
1590 struct bp_location *loc;
1591 int bp_location_downloaded = 0;
1593 /* Clear `inserted' flag. */
1594 for (loc = b->loc; loc; loc = loc->next)
1597 if ((b->type == bp_fast_tracepoint
1598 ? !may_insert_fast_tracepoints
1599 : !may_insert_tracepoints))
1602 t->number_on_target = 0;
1604 for (loc = b->loc; loc; loc = loc->next)
1606 /* Since tracepoint locations are never duplicated, `inserted'
1607 flag should be zero. */
1608 gdb_assert (!loc->inserted);
1610 target_download_tracepoint (loc);
1613 bp_location_downloaded = 1;
1616 t->number_on_target = b->number;
1618 for (loc = b->loc; loc; loc = loc->next)
1619 if (loc->probe.prob != NULL)
1620 loc->probe.prob->set_semaphore (loc->probe.objfile,
1623 if (bp_location_downloaded)
1624 gdb::observers::breakpoint_modified.notify (b);
1627 /* Send down all the trace state variables too. */
1628 for (const trace_state_variable &tsv : tvariables)
1629 target_download_trace_state_variable (tsv);
1631 /* Tell target to treat text-like sections as transparent. */
1632 target_trace_set_readonly_regions ();
1633 /* Set some mode flags. */
1634 target_set_disconnected_tracing (disconnected_tracing);
1635 target_set_circular_trace_buffer (circular_trace_buffer);
1636 target_set_trace_buffer_size (trace_buffer_size);
1639 notes = trace_notes;
1640 ret = target_set_trace_notes (trace_user, notes, NULL);
1642 if (!ret && (trace_user || notes))
1643 warning (_("Target does not support trace user/notes, info ignored"));
1645 /* Now insert traps and begin collecting data. */
1646 target_trace_start ();
1648 /* Reset our local state. */
1649 trace_reset_local_state ();
1650 current_trace_status()->running = 1;
1653 /* The tstart command requests the target to start a new trace run.
1654 The command passes any arguments it has to the target verbatim, as
1655 an optional "trace note". This is useful as for instance a warning
1656 to other users if the trace runs disconnected, and you don't want
1657 anybody else messing with the target. */
1660 tstart_command (const char *args, int from_tty)
1662 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1664 if (current_trace_status ()->running)
1667 && !query (_("A trace is running already. Start a new run? ")))
1668 error (_("New trace run not started."));
1671 start_tracing (args);
1674 /* The tstop command stops the tracing run. The command passes any
1675 supplied arguments to the target verbatim as a "stop note"; if the
1676 target supports trace notes, then it will be reported back as part
1677 of the trace run's status. */
1680 tstop_command (const char *args, int from_tty)
1682 if (!current_trace_status ()->running)
1683 error (_("Trace is not running."));
1685 stop_tracing (args);
1689 stop_tracing (const char *note)
1693 target_trace_stop ();
1695 for (breakpoint *t : all_tracepoints ())
1697 struct bp_location *loc;
1699 if ((t->type == bp_fast_tracepoint
1700 ? !may_insert_fast_tracepoints
1701 : !may_insert_tracepoints))
1704 for (loc = t->loc; loc; loc = loc->next)
1706 /* GDB can be totally absent in some disconnected trace scenarios,
1707 but we don't really care if this semaphore goes out of sync.
1708 That's why we are decrementing it here, but not taking care
1710 if (loc->probe.prob != NULL)
1711 loc->probe.prob->clear_semaphore (loc->probe.objfile,
1717 note = trace_stop_notes;
1718 ret = target_set_trace_notes (NULL, NULL, note);
1721 warning (_("Target does not support trace notes, note ignored"));
1723 /* Should change in response to reply? */
1724 current_trace_status ()->running = 0;
1727 /* tstatus command */
1729 tstatus_command (const char *args, int from_tty)
1731 struct trace_status *ts = current_trace_status ();
1734 status = target_get_trace_status (ts);
1738 if (ts->filename != NULL)
1739 printf_filtered (_("Using a trace file.\n"));
1742 printf_filtered (_("Trace can not be run on this target.\n"));
1747 if (!ts->running_known)
1749 printf_filtered (_("Run/stop status is unknown.\n"));
1751 else if (ts->running)
1753 printf_filtered (_("Trace is running on the target.\n"));
1757 switch (ts->stop_reason)
1759 case trace_never_run:
1760 printf_filtered (_("No trace has been run on the target.\n"));
1762 case trace_stop_command:
1764 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1767 printf_filtered (_("Trace stopped by a tstop command.\n"));
1769 case trace_buffer_full:
1770 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1772 case trace_disconnected:
1773 printf_filtered (_("Trace stopped because of disconnection.\n"));
1775 case tracepoint_passcount:
1776 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1777 ts->stopping_tracepoint);
1779 case tracepoint_error:
1780 if (ts->stopping_tracepoint)
1781 printf_filtered (_("Trace stopped by an "
1782 "error (%s, tracepoint %d).\n"),
1783 ts->stop_desc, ts->stopping_tracepoint);
1785 printf_filtered (_("Trace stopped by an error (%s).\n"),
1788 case trace_stop_reason_unknown:
1789 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1792 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1798 if (ts->traceframes_created >= 0
1799 && ts->traceframe_count != ts->traceframes_created)
1801 printf_filtered (_("Buffer contains %d trace "
1802 "frames (of %d created total).\n"),
1803 ts->traceframe_count, ts->traceframes_created);
1805 else if (ts->traceframe_count >= 0)
1807 printf_filtered (_("Collected %d trace frames.\n"),
1808 ts->traceframe_count);
1811 if (ts->buffer_free >= 0)
1813 if (ts->buffer_size >= 0)
1815 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1816 ts->buffer_free, ts->buffer_size);
1817 if (ts->buffer_size > 0)
1818 printf_filtered (_(" (%d%% full)"),
1819 ((int) ((((long long) (ts->buffer_size
1820 - ts->buffer_free)) * 100)
1821 / ts->buffer_size)));
1822 printf_filtered (_(".\n"));
1825 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1829 if (ts->disconnected_tracing)
1830 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1832 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1834 if (ts->circular_buffer)
1835 printf_filtered (_("Trace buffer is circular.\n"));
1837 if (ts->user_name && strlen (ts->user_name) > 0)
1838 printf_filtered (_("Trace user is %s.\n"), ts->user_name);
1840 if (ts->notes && strlen (ts->notes) > 0)
1841 printf_filtered (_("Trace notes: %s.\n"), ts->notes);
1843 /* Now report on what we're doing with tfind. */
1844 if (traceframe_number >= 0)
1845 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1846 traceframe_number, tracepoint_number);
1848 printf_filtered (_("Not looking at any trace frame.\n"));
1850 /* Report start/stop times if supplied. */
1855 LONGEST run_time = ts->stop_time - ts->start_time;
1857 /* Reporting a run time is more readable than two long numbers. */
1858 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
1859 (long int) (ts->start_time / 1000000),
1860 (long int) (ts->start_time % 1000000),
1861 (long int) (run_time / 1000000),
1862 (long int) (run_time % 1000000));
1865 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
1866 (long int) (ts->start_time / 1000000),
1867 (long int) (ts->start_time % 1000000));
1869 else if (ts->stop_time)
1870 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
1871 (long int) (ts->stop_time / 1000000),
1872 (long int) (ts->stop_time % 1000000));
1874 /* Now report any per-tracepoint status available. */
1875 for (breakpoint *t : all_tracepoints ())
1876 target_get_tracepoint_status (t, NULL);
1879 /* Report the trace status to uiout, in a way suitable for MI, and not
1880 suitable for CLI. If ON_STOP is true, suppress a few fields that
1881 are not meaningful in the -trace-stop response.
1883 The implementation is essentially parallel to trace_status_command, but
1884 merging them will result in unreadable code. */
1886 trace_status_mi (int on_stop)
1888 struct ui_out *uiout = current_uiout;
1889 struct trace_status *ts = current_trace_status ();
1892 status = target_get_trace_status (ts);
1894 if (status == -1 && ts->filename == NULL)
1896 uiout->field_string ("supported", "0");
1900 if (ts->filename != NULL)
1901 uiout->field_string ("supported", "file");
1903 uiout->field_string ("supported", "1");
1905 if (ts->filename != NULL)
1906 uiout->field_string ("trace-file", ts->filename);
1908 gdb_assert (ts->running_known);
1912 uiout->field_string ("running", "1");
1914 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1915 Given that the frontend gets the status either on -trace-stop, or from
1916 -trace-status after re-connection, it does not seem like this
1917 information is necessary for anything. It is not necessary for either
1918 figuring the vital state of the target nor for navigation of trace
1919 frames. If the frontend wants to show the current state is some
1920 configure dialog, it can request the value when such dialog is
1921 invoked by the user. */
1925 const char *stop_reason = NULL;
1926 int stopping_tracepoint = -1;
1929 uiout->field_string ("running", "0");
1931 if (ts->stop_reason != trace_stop_reason_unknown)
1933 switch (ts->stop_reason)
1935 case trace_stop_command:
1936 stop_reason = "request";
1938 case trace_buffer_full:
1939 stop_reason = "overflow";
1941 case trace_disconnected:
1942 stop_reason = "disconnection";
1944 case tracepoint_passcount:
1945 stop_reason = "passcount";
1946 stopping_tracepoint = ts->stopping_tracepoint;
1948 case tracepoint_error:
1949 stop_reason = "error";
1950 stopping_tracepoint = ts->stopping_tracepoint;
1956 uiout->field_string ("stop-reason", stop_reason);
1957 if (stopping_tracepoint != -1)
1958 uiout->field_int ("stopping-tracepoint",
1959 stopping_tracepoint);
1960 if (ts->stop_reason == tracepoint_error)
1961 uiout->field_string ("error-description",
1967 if (ts->traceframe_count != -1)
1968 uiout->field_int ("frames", ts->traceframe_count);
1969 if (ts->traceframes_created != -1)
1970 uiout->field_int ("frames-created", ts->traceframes_created);
1971 if (ts->buffer_size != -1)
1972 uiout->field_int ("buffer-size", ts->buffer_size);
1973 if (ts->buffer_free != -1)
1974 uiout->field_int ("buffer-free", ts->buffer_free);
1976 uiout->field_int ("disconnected", ts->disconnected_tracing);
1977 uiout->field_int ("circular", ts->circular_buffer);
1979 uiout->field_string ("user-name", ts->user_name);
1980 uiout->field_string ("notes", ts->notes);
1985 xsnprintf (buf, sizeof buf, "%ld.%06ld",
1986 (long int) (ts->start_time / 1000000),
1987 (long int) (ts->start_time % 1000000));
1988 uiout->field_string ("start-time", buf);
1989 xsnprintf (buf, sizeof buf, "%ld.%06ld",
1990 (long int) (ts->stop_time / 1000000),
1991 (long int) (ts->stop_time % 1000000));
1992 uiout->field_string ("stop-time", buf);
1996 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
1997 user if she really wants to detach. */
2000 query_if_trace_running (int from_tty)
2005 /* It can happen that the target that was tracing went away on its
2006 own, and we didn't notice. Get a status update, and if the
2007 current target doesn't even do tracing, then assume it's not
2009 if (target_get_trace_status (current_trace_status ()) < 0)
2010 current_trace_status ()->running = 0;
2012 /* If running interactively, give the user the option to cancel and
2013 then decide what to do differently with the run. Scripts are
2014 just going to disconnect and let the target deal with it,
2015 according to how it's been instructed previously via
2016 disconnected-tracing. */
2017 if (current_trace_status ()->running)
2019 process_tracepoint_on_disconnect ();
2021 if (current_trace_status ()->disconnected_tracing)
2023 if (!query (_("Trace is running and will "
2024 "continue after detach; detach anyway? ")))
2025 error (_("Not confirmed."));
2029 if (!query (_("Trace is running but will "
2030 "stop on detach; detach anyway? ")))
2031 error (_("Not confirmed."));
2036 /* This function handles the details of what to do about an ongoing
2037 tracing run if the user has asked to detach or otherwise disconnect
2041 disconnect_tracing (void)
2043 /* Also we want to be out of tfind mode, otherwise things can get
2044 confusing upon reconnection. Just use these calls instead of
2045 full tfind_1 behavior because we're in the middle of detaching,
2046 and there's no point to updating current stack frame etc. */
2047 trace_reset_local_state ();
2050 /* Worker function for the various flavors of the tfind command. */
2052 tfind_1 (enum trace_find_type type, int num,
2053 CORE_ADDR addr1, CORE_ADDR addr2,
2056 int target_frameno = -1, target_tracept = -1;
2057 struct frame_id old_frame_id = null_frame_id;
2058 struct tracepoint *tp;
2059 struct ui_out *uiout = current_uiout;
2061 /* Only try to get the current stack frame if we have a chance of
2062 succeeding. In particular, if we're trying to get a first trace
2063 frame while all threads are running, it's not going to succeed,
2064 so leave it with a default value and let the frame comparison
2065 below (correctly) decide to print out the source location of the
2067 if (!(type == tfind_number && num == -1)
2068 && (has_stack_frames () || traceframe_number >= 0))
2069 old_frame_id = get_frame_id (get_current_frame ());
2071 target_frameno = target_trace_find (type, num, addr1, addr2,
2074 if (type == tfind_number
2076 && target_frameno == -1)
2078 /* We told the target to get out of tfind mode, and it did. */
2080 else if (target_frameno == -1)
2082 /* A request for a non-existent trace frame has failed.
2083 Our response will be different, depending on FROM_TTY:
2085 If FROM_TTY is true, meaning that this command was
2086 typed interactively by the user, then give an error
2087 and DO NOT change the state of traceframe_number etc.
2089 However if FROM_TTY is false, meaning that we're either
2090 in a script, a loop, or a user-defined command, then
2091 DON'T give an error, but DO change the state of
2092 traceframe_number etc. to invalid.
2094 The rationalle is that if you typed the command, you
2095 might just have committed a typo or something, and you'd
2096 like to NOT lose your current debugging state. However
2097 if you're in a user-defined command or especially in a
2098 loop, then you need a way to detect that the command
2099 failed WITHOUT aborting. This allows you to write
2100 scripts that search thru the trace buffer until the end,
2101 and then continue on to do something else. */
2104 error (_("Target failed to find requested trace frame."));
2108 printf_filtered ("End of trace buffer.\n");
2109 #if 0 /* dubious now? */
2110 /* The following will not recurse, since it's
2112 tfind_command ("-1", from_tty);
2117 tp = get_tracepoint_by_number_on_target (target_tracept);
2119 reinit_frame_cache ();
2120 target_dcache_invalidate ();
2122 set_tracepoint_num (tp ? tp->number : target_tracept);
2124 if (target_frameno != get_traceframe_number ())
2125 gdb::observers::traceframe_changed.notify (target_frameno, tracepoint_number);
2127 set_current_traceframe (target_frameno);
2129 if (target_frameno == -1)
2130 set_traceframe_context (NULL);
2132 set_traceframe_context (get_current_frame ());
2134 if (traceframe_number >= 0)
2136 /* Use different branches for MI and CLI to make CLI messages
2138 if (uiout->is_mi_like_p ())
2140 uiout->field_string ("found", "1");
2141 uiout->field_int ("tracepoint", tracepoint_number);
2142 uiout->field_int ("traceframe", traceframe_number);
2146 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2147 traceframe_number, tracepoint_number);
2152 if (uiout->is_mi_like_p ())
2153 uiout->field_string ("found", "0");
2154 else if (type == tfind_number && num == -1)
2155 printf_unfiltered (_("No longer looking at any trace frame\n"));
2156 else /* This case may never occur, check. */
2157 printf_unfiltered (_("No trace frame found\n"));
2160 /* If we're in nonstop mode and getting out of looking at trace
2161 frames, there won't be any current frame to go back to and
2164 && (has_stack_frames () || traceframe_number >= 0))
2166 enum print_what print_what;
2168 /* NOTE: in imitation of the step command, try to determine
2169 whether we have made a transition from one function to
2170 another. If so, we'll print the "stack frame" (ie. the new
2171 function and it's arguments) -- otherwise we'll just show the
2174 if (frame_id_eq (old_frame_id,
2175 get_frame_id (get_current_frame ())))
2176 print_what = SRC_LINE;
2178 print_what = SRC_AND_LOC;
2180 print_stack_frame (get_selected_frame (NULL), 1, print_what, 1);
2185 /* Error on looking at traceframes while trace is running. */
2188 check_trace_running (struct trace_status *status)
2190 if (status->running && status->filename == NULL)
2191 error (_("May not look at trace frames while trace is running."));
2194 /* trace_find_command takes a trace frame number n,
2195 sends "QTFrame:<n>" to the target,
2196 and accepts a reply that may contain several optional pieces
2197 of information: a frame number, a tracepoint number, and an
2198 indication of whether this is a trap frame or a stepping frame.
2200 The minimal response is just "OK" (which indicates that the
2201 target does not give us a frame number or a tracepoint number).
2202 Instead of that, the target may send us a string containing
2204 F<hexnum> (gives the selected frame number)
2205 T<hexnum> (gives the selected tracepoint number)
2210 tfind_command_1 (const char *args, int from_tty)
2211 { /* This should only be called with a numeric argument. */
2214 check_trace_running (current_trace_status ());
2216 if (args == 0 || *args == 0)
2217 { /* TFIND with no args means find NEXT trace frame. */
2218 if (traceframe_number == -1)
2219 frameno = 0; /* "next" is first one. */
2221 frameno = traceframe_number + 1;
2223 else if (0 == strcmp (args, "-"))
2225 if (traceframe_number == -1)
2226 error (_("not debugging trace buffer"));
2227 else if (from_tty && traceframe_number == 0)
2228 error (_("already at start of trace buffer"));
2230 frameno = traceframe_number - 1;
2232 /* A hack to work around eval's need for fp to have been collected. */
2233 else if (0 == strcmp (args, "-1"))
2236 frameno = parse_and_eval_long (args);
2239 error (_("invalid input (%d is less than zero)"), frameno);
2241 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2245 tfind_command (const char *args, int from_tty)
2247 tfind_command_1 (args, from_tty);
2252 tfind_end_command (const char *args, int from_tty)
2254 tfind_command_1 ("-1", from_tty);
2259 tfind_start_command (const char *args, int from_tty)
2261 tfind_command_1 ("0", from_tty);
2264 /* tfind pc command */
2266 tfind_pc_command (const char *args, int from_tty)
2270 check_trace_running (current_trace_status ());
2272 if (args == 0 || *args == 0)
2273 pc = regcache_read_pc (get_current_regcache ());
2275 pc = parse_and_eval_address (args);
2277 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2280 /* tfind tracepoint command */
2282 tfind_tracepoint_command (const char *args, int from_tty)
2285 struct tracepoint *tp;
2287 check_trace_running (current_trace_status ());
2289 if (args == 0 || *args == 0)
2291 if (tracepoint_number == -1)
2292 error (_("No current tracepoint -- please supply an argument."));
2294 tdp = tracepoint_number; /* Default is current TDP. */
2297 tdp = parse_and_eval_long (args);
2299 /* If we have the tracepoint on hand, use the number that the
2300 target knows about (which may be different if we disconnected
2301 and reconnected). */
2302 tp = get_tracepoint (tdp);
2304 tdp = tp->number_on_target;
2306 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2309 /* TFIND LINE command:
2311 This command will take a sourceline for argument, just like BREAK
2312 or TRACE (ie. anything that "decode_line_1" can handle).
2314 With no argument, this command will find the next trace frame
2315 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2318 tfind_line_command (const char *args, int from_tty)
2320 check_trace_running (current_trace_status ());
2322 symtab_and_line sal;
2323 if (args == 0 || *args == 0)
2325 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2329 std::vector<symtab_and_line> sals
2330 = decode_line_with_current_source (args, DECODE_LINE_FUNFIRSTLINE);
2334 if (sal.symtab == 0)
2335 error (_("No line number information available."));
2337 CORE_ADDR start_pc, end_pc;
2338 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2340 if (start_pc == end_pc)
2342 printf_filtered ("Line %d of \"%s\"",
2344 symtab_to_filename_for_display (sal.symtab));
2346 printf_filtered (" is at address ");
2347 print_address (get_current_arch (), start_pc, gdb_stdout);
2349 printf_filtered (" but contains no code.\n");
2350 sal = find_pc_line (start_pc, 0);
2352 && find_line_pc_range (sal, &start_pc, &end_pc)
2353 && start_pc != end_pc)
2354 printf_filtered ("Attempting to find line %d instead.\n",
2357 error (_("Cannot find a good line."));
2361 /* Is there any case in which we get here, and have an address
2362 which the user would want to see? If we have debugging
2363 symbols and no line numbers? */
2364 error (_("Line number %d is out of range for \"%s\"."),
2365 sal.line, symtab_to_filename_for_display (sal.symtab));
2367 /* Find within range of stated line. */
2369 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2371 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2374 /* tfind range command */
2376 tfind_range_command (const char *args, int from_tty)
2378 static CORE_ADDR start, stop;
2381 check_trace_running (current_trace_status ());
2383 if (args == 0 || *args == 0)
2384 { /* XXX FIXME: what should default behavior be? */
2385 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2389 if (0 != (tmp = strchr (args, ',')))
2391 std::string start_addr (args, tmp);
2393 tmp = skip_spaces (tmp);
2394 start = parse_and_eval_address (start_addr.c_str ());
2395 stop = parse_and_eval_address (tmp);
2398 { /* No explicit end address? */
2399 start = parse_and_eval_address (args);
2400 stop = start + 1; /* ??? */
2403 tfind_1 (tfind_range, 0, start, stop, from_tty);
2406 /* tfind outside command */
2408 tfind_outside_command (const char *args, int from_tty)
2410 CORE_ADDR start, stop;
2413 if (current_trace_status ()->running
2414 && current_trace_status ()->filename == NULL)
2415 error (_("May not look at trace frames while trace is running."));
2417 if (args == 0 || *args == 0)
2418 { /* XXX FIXME: what should default behavior be? */
2419 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2423 if (0 != (tmp = strchr (args, ',')))
2425 std::string start_addr (args, tmp);
2427 tmp = skip_spaces (tmp);
2428 start = parse_and_eval_address (start_addr.c_str ());
2429 stop = parse_and_eval_address (tmp);
2432 { /* No explicit end address? */
2433 start = parse_and_eval_address (args);
2434 stop = start + 1; /* ??? */
2437 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2440 /* info scope command: list the locals for a scope. */
2442 info_scope_command (const char *args_in, int from_tty)
2445 struct bound_minimal_symbol msym;
2446 const struct block *block;
2447 const char *symname;
2448 const char *save_args = args_in;
2449 struct block_iterator iter;
2451 struct gdbarch *gdbarch;
2453 const char *args = args_in;
2455 if (args == 0 || *args == 0)
2456 error (_("requires an argument (function, "
2457 "line or *addr) to define a scope"));
2459 event_location_up location = string_to_event_location (&args,
2461 std::vector<symtab_and_line> sals
2462 = decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE,
2466 /* Presumably decode_line_1 has already warned. */
2470 /* Resolve line numbers to PC. */
2471 resolve_sal_pc (&sals[0]);
2472 block = block_for_pc (sals[0].pc);
2476 QUIT; /* Allow user to bail out with ^C. */
2477 ALL_BLOCK_SYMBOLS (block, iter, sym)
2479 QUIT; /* Allow user to bail out with ^C. */
2481 printf_filtered ("Scope for %s:\n", save_args);
2484 symname = SYMBOL_PRINT_NAME (sym);
2485 if (symname == NULL || *symname == '\0')
2486 continue; /* Probably botched, certainly useless. */
2488 gdbarch = symbol_arch (sym);
2490 printf_filtered ("Symbol %s is ", symname);
2492 if (SYMBOL_COMPUTED_OPS (sym) != NULL)
2493 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2494 BLOCK_ENTRY_PC (block),
2498 switch (SYMBOL_CLASS (sym))
2501 case LOC_UNDEF: /* Messed up symbol? */
2502 printf_filtered ("a bogus symbol, class %d.\n",
2503 SYMBOL_CLASS (sym));
2504 count--; /* Don't count this one. */
2507 printf_filtered ("a constant with value %s (%s)",
2508 plongest (SYMBOL_VALUE (sym)),
2509 hex_string (SYMBOL_VALUE (sym)));
2511 case LOC_CONST_BYTES:
2512 printf_filtered ("constant bytes: ");
2513 if (SYMBOL_TYPE (sym))
2514 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2515 fprintf_filtered (gdb_stdout, " %02x",
2516 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2519 printf_filtered ("in static storage at address ");
2520 printf_filtered ("%s", paddress (gdbarch,
2521 SYMBOL_VALUE_ADDRESS (sym)));
2524 /* GDBARCH is the architecture associated with the objfile
2525 the symbol is defined in; the target architecture may be
2526 different, and may provide additional registers. However,
2527 we do not know the target architecture at this point.
2528 We assume the objfile architecture will contain all the
2529 standard registers that occur in debug info in that
2531 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2534 if (SYMBOL_IS_ARGUMENT (sym))
2535 printf_filtered ("an argument in register $%s",
2536 gdbarch_register_name (gdbarch, regno));
2538 printf_filtered ("a local variable in register $%s",
2539 gdbarch_register_name (gdbarch, regno));
2542 printf_filtered ("an argument at stack/frame offset %s",
2543 plongest (SYMBOL_VALUE (sym)));
2546 printf_filtered ("a local variable at frame offset %s",
2547 plongest (SYMBOL_VALUE (sym)));
2550 printf_filtered ("a reference argument at offset %s",
2551 plongest (SYMBOL_VALUE (sym)));
2553 case LOC_REGPARM_ADDR:
2554 /* Note comment at LOC_REGISTER. */
2555 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2557 printf_filtered ("the address of an argument, in register $%s",
2558 gdbarch_register_name (gdbarch, regno));
2561 printf_filtered ("a typedef.\n");
2564 printf_filtered ("a label at address ");
2565 printf_filtered ("%s", paddress (gdbarch,
2566 SYMBOL_VALUE_ADDRESS (sym)));
2569 printf_filtered ("a function at address ");
2570 printf_filtered ("%s",
2571 paddress (gdbarch, BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym))));
2573 case LOC_UNRESOLVED:
2574 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2576 if (msym.minsym == NULL)
2577 printf_filtered ("Unresolved Static");
2580 printf_filtered ("static storage at address ");
2581 printf_filtered ("%s",
2583 BMSYMBOL_VALUE_ADDRESS (msym)));
2586 case LOC_OPTIMIZED_OUT:
2587 printf_filtered ("optimized out.\n");
2590 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2593 if (SYMBOL_TYPE (sym))
2594 printf_filtered (", length %d.\n",
2595 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2597 if (BLOCK_FUNCTION (block))
2600 block = BLOCK_SUPERBLOCK (block);
2603 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2607 /* Helper for trace_dump_command. Dump the action list starting at
2608 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2609 actions of the body of a while-stepping action. STEPPING_FRAME is
2610 set if the current traceframe was determined to be a while-stepping
2614 trace_dump_actions (struct command_line *action,
2615 int stepping_actions, int stepping_frame,
2618 const char *action_exp, *next_comma;
2620 for (; action != NULL; action = action->next)
2622 struct cmd_list_element *cmd;
2624 QUIT; /* Allow user to bail out with ^C. */
2625 action_exp = action->line;
2626 action_exp = skip_spaces (action_exp);
2628 /* The collection actions to be done while stepping are
2629 bracketed by the commands "while-stepping" and "end". */
2631 if (*action_exp == '#') /* comment line */
2634 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2636 error (_("Bad action list item: %s"), action_exp);
2638 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2640 gdb_assert (action->body_list_1 == nullptr);
2641 trace_dump_actions (action->body_list_0.get (),
2642 1, stepping_frame, from_tty);
2644 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2646 /* Display the collected data.
2647 For the trap frame, display only what was collected at
2648 the trap. Likewise for stepping frames, display only
2649 what was collected while stepping. This means that the
2650 two boolean variables, STEPPING_FRAME and
2651 STEPPING_ACTIONS should be equal. */
2652 if (stepping_frame == stepping_actions)
2654 int trace_string = 0;
2656 if (*action_exp == '/')
2657 action_exp = decode_agent_options (action_exp, &trace_string);
2660 { /* Repeat over a comma-separated list. */
2661 QUIT; /* Allow user to bail out with ^C. */
2662 if (*action_exp == ',')
2664 action_exp = skip_spaces (action_exp);
2666 next_comma = strchr (action_exp, ',');
2668 if (0 == strncasecmp (action_exp, "$reg", 4))
2669 registers_info (NULL, from_tty);
2670 else if (0 == strncasecmp (action_exp, "$_ret", 5))
2672 else if (0 == strncasecmp (action_exp, "$loc", 4))
2673 info_locals_command (NULL, from_tty);
2674 else if (0 == strncasecmp (action_exp, "$arg", 4))
2675 info_args_command (NULL, from_tty);
2678 std::string contents;
2679 const char *exp = action_exp;
2680 if (next_comma != NULL)
2682 size_t len = next_comma - action_exp;
2683 contents = std::string (action_exp, len);
2684 exp = contents.c_str ();
2687 printf_filtered ("%s = ", exp);
2688 output_command (exp, from_tty);
2689 printf_filtered ("\n");
2691 action_exp = next_comma;
2693 while (action_exp && *action_exp == ',');
2699 /* Return bp_location of the tracepoint associated with the current
2700 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2701 is a stepping traceframe. */
2703 struct bp_location *
2704 get_traceframe_location (int *stepping_frame_p)
2706 struct tracepoint *t;
2707 struct bp_location *tloc;
2708 struct regcache *regcache;
2710 if (tracepoint_number == -1)
2711 error (_("No current trace frame."));
2713 t = get_tracepoint (tracepoint_number);
2716 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2719 /* The current frame is a trap frame if the frame PC is equal to the
2720 tracepoint PC. If not, then the current frame was collected
2721 during single-stepping. */
2722 regcache = get_current_regcache ();
2724 /* If the traceframe's address matches any of the tracepoint's
2725 locations, assume it is a direct hit rather than a while-stepping
2726 frame. (FIXME this is not reliable, should record each frame's
2728 for (tloc = t->loc; tloc; tloc = tloc->next)
2729 if (tloc->address == regcache_read_pc (regcache))
2731 *stepping_frame_p = 0;
2735 /* If this is a stepping frame, we don't know which location
2736 triggered. The first is as good (or bad) a guess as any... */
2737 *stepping_frame_p = 1;
2741 /* Return the default collect actions of a tracepoint T. */
2743 static counted_command_line
2744 all_tracepoint_actions (struct breakpoint *t)
2746 counted_command_line actions (nullptr, command_lines_deleter ());
2748 /* If there are default expressions to collect, make up a collect
2749 action and prepend to the action list to encode. Note that since
2750 validation is per-tracepoint (local var "xyz" might be valid for
2751 one tracepoint and not another, etc), we make up the action on
2752 the fly, and don't cache it. */
2753 if (*default_collect)
2755 struct command_line *default_collect_action;
2756 gdb::unique_xmalloc_ptr<char> default_collect_line
2757 (xstrprintf ("collect %s", default_collect));
2759 validate_actionline (default_collect_line.get (), t);
2760 actions.reset (new struct command_line (simple_control,
2761 default_collect_line.release ()),
2762 command_lines_deleter ());
2768 /* The tdump command. */
2771 tdump_command (const char *args, int from_tty)
2773 int stepping_frame = 0;
2774 struct bp_location *loc;
2776 /* This throws an error is not inspecting a trace frame. */
2777 loc = get_traceframe_location (&stepping_frame);
2779 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2780 tracepoint_number, traceframe_number);
2782 /* This command only makes sense for the current frame, not the
2784 scoped_restore_current_thread restore_thread;
2786 select_frame (get_current_frame ());
2788 counted_command_line actions = all_tracepoint_actions (loc->owner);
2790 trace_dump_actions (actions.get (), 0, stepping_frame, from_tty);
2791 trace_dump_actions (breakpoint_commands (loc->owner), 0, stepping_frame,
2795 /* Encode a piece of a tracepoint's source-level definition in a form
2796 that is suitable for both protocol and saving in files. */
2797 /* This version does not do multiple encodes for long strings; it should
2798 return an offset to the next piece to encode. FIXME */
2801 encode_source_string (int tpnum, ULONGEST addr,
2802 const char *srctype, const char *src,
2803 char *buf, int buf_size)
2805 if (80 + strlen (srctype) > buf_size)
2806 error (_("Buffer too small for source encoding"));
2807 sprintf (buf, "%x:%s:%s:%x:%x:",
2808 tpnum, phex_nz (addr, sizeof (addr)),
2809 srctype, 0, (int) strlen (src));
2810 if (strlen (buf) + strlen (src) * 2 >= buf_size)
2811 error (_("Source string too long for buffer"));
2812 bin2hex ((gdb_byte *) src, buf + strlen (buf), strlen (src));
2816 /* Tell the target what to do with an ongoing tracing run if GDB
2817 disconnects for some reason. */
2820 set_disconnected_tracing (const char *args, int from_tty,
2821 struct cmd_list_element *c)
2823 target_set_disconnected_tracing (disconnected_tracing);
2827 set_circular_trace_buffer (const char *args, int from_tty,
2828 struct cmd_list_element *c)
2830 target_set_circular_trace_buffer (circular_trace_buffer);
2834 set_trace_buffer_size (const char *args, int from_tty,
2835 struct cmd_list_element *c)
2837 target_set_trace_buffer_size (trace_buffer_size);
2841 set_trace_user (const char *args, int from_tty,
2842 struct cmd_list_element *c)
2846 ret = target_set_trace_notes (trace_user, NULL, NULL);
2849 warning (_("Target does not support trace notes, user ignored"));
2853 set_trace_notes (const char *args, int from_tty,
2854 struct cmd_list_element *c)
2858 ret = target_set_trace_notes (NULL, trace_notes, NULL);
2861 warning (_("Target does not support trace notes, note ignored"));
2865 set_trace_stop_notes (const char *args, int from_tty,
2866 struct cmd_list_element *c)
2870 ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
2873 warning (_("Target does not support trace notes, stop note ignored"));
2876 /* Convert the memory pointed to by mem into hex, placing result in buf.
2877 * Return a pointer to the last char put in buf (null)
2878 * "stolen" from sparc-stub.c
2881 static const char hexchars[] = "0123456789abcdef";
2884 mem2hex (gdb_byte *mem, char *buf, int count)
2892 *buf++ = hexchars[ch >> 4];
2893 *buf++ = hexchars[ch & 0xf];
2902 get_traceframe_number (void)
2904 return traceframe_number;
2908 get_tracepoint_number (void)
2910 return tracepoint_number;
2913 /* Make the traceframe NUM be the current trace frame. Does nothing
2914 if NUM is already current. */
2917 set_current_traceframe (int num)
2921 if (traceframe_number == num)
2923 /* Nothing to do. */
2927 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
2930 warning (_("could not change traceframe"));
2932 set_traceframe_num (newnum);
2934 /* Changing the traceframe changes our view of registers and of the
2936 registers_changed ();
2938 clear_traceframe_info ();
2941 scoped_restore_current_traceframe::scoped_restore_current_traceframe ()
2942 : m_traceframe_number (traceframe_number)
2945 /* Given a number and address, return an uploaded tracepoint with that
2946 number, creating if necessary. */
2948 struct uploaded_tp *
2949 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
2951 struct uploaded_tp *utp;
2953 for (utp = *utpp; utp; utp = utp->next)
2954 if (utp->number == num && utp->addr == addr)
2957 utp = new uploaded_tp;
2967 free_uploaded_tps (struct uploaded_tp **utpp)
2969 struct uploaded_tp *next_one;
2973 next_one = (*utpp)->next;
2979 /* Given a number and address, return an uploaded tracepoint with that
2980 number, creating if necessary. */
2982 struct uploaded_tsv *
2983 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
2985 struct uploaded_tsv *utsv;
2987 for (utsv = *utsvp; utsv; utsv = utsv->next)
2988 if (utsv->number == num)
2991 utsv = XCNEW (struct uploaded_tsv);
2993 utsv->next = *utsvp;
3000 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3002 struct uploaded_tsv *next_one;
3006 next_one = (*utsvp)->next;
3012 /* FIXME this function is heuristic and will miss the cases where the
3013 conditional is semantically identical but differs in whitespace,
3014 such as "x == 0" vs "x==0". */
3017 cond_string_is_same (char *str1, char *str2)
3019 if (str1 == NULL || str2 == NULL)
3020 return (str1 == str2);
3022 return (strcmp (str1, str2) == 0);
3025 /* Look for an existing tracepoint that seems similar enough to the
3026 uploaded one. Enablement isn't compared, because the user can
3027 toggle that freely, and may have done so in anticipation of the
3028 next trace run. Return the location of matched tracepoint. */
3030 static struct bp_location *
3031 find_matching_tracepoint_location (struct uploaded_tp *utp)
3033 struct bp_location *loc;
3035 for (breakpoint *b : all_tracepoints ())
3037 struct tracepoint *t = (struct tracepoint *) b;
3039 if (b->type == utp->type
3040 && t->step_count == utp->step
3041 && t->pass_count == utp->pass
3042 && cond_string_is_same (t->cond_string, utp->cond_string)
3043 /* FIXME also test actions. */
3046 /* Scan the locations for an address match. */
3047 for (loc = b->loc; loc; loc = loc->next)
3049 if (loc->address == utp->addr)
3057 /* Given a list of tracepoints uploaded from a target, attempt to
3058 match them up with existing tracepoints, and create new ones if not
3062 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3064 struct uploaded_tp *utp;
3065 /* A set of tracepoints which are modified. */
3066 std::vector<breakpoint *> modified_tp;
3068 /* Look for GDB tracepoints that match up with our uploaded versions. */
3069 for (utp = *uploaded_tps; utp; utp = utp->next)
3071 struct bp_location *loc;
3072 struct tracepoint *t;
3074 loc = find_matching_tracepoint_location (utp);
3079 /* Mark this location as already inserted. */
3081 t = (struct tracepoint *) loc->owner;
3082 printf_filtered (_("Assuming tracepoint %d is same "
3083 "as target's tracepoint %d at %s.\n"),
3084 loc->owner->number, utp->number,
3085 paddress (loc->gdbarch, utp->addr));
3087 /* The tracepoint LOC->owner was modified (the location LOC
3088 was marked as inserted in the target). Save it in
3089 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3090 observers will be notified later once for each tracepoint
3091 saved in MODIFIED_TP. */
3092 for (breakpoint *b : modified_tp)
3093 if (b == loc->owner)
3099 modified_tp.push_back (loc->owner);
3103 t = create_tracepoint_from_upload (utp);
3105 printf_filtered (_("Created tracepoint %d for "
3106 "target's tracepoint %d at %s.\n"),
3107 t->number, utp->number,
3108 paddress (get_current_arch (), utp->addr));
3110 printf_filtered (_("Failed to create tracepoint for target's "
3111 "tracepoint %d at %s, skipping it.\n"),
3113 paddress (get_current_arch (), utp->addr));
3115 /* Whether found or created, record the number used by the
3116 target, to help with mapping target tracepoints back to their
3117 counterparts here. */
3119 t->number_on_target = utp->number;
3122 /* Notify 'breakpoint-modified' observer that at least one of B's
3123 locations was changed. */
3124 for (breakpoint *b : modified_tp)
3125 gdb::observers::breakpoint_modified.notify (b);
3127 free_uploaded_tps (uploaded_tps);
3130 /* Trace state variables don't have much to identify them beyond their
3131 name, so just use that to detect matches. */
3133 static struct trace_state_variable *
3134 find_matching_tsv (struct uploaded_tsv *utsv)
3139 return find_trace_state_variable (utsv->name);
3142 static struct trace_state_variable *
3143 create_tsv_from_upload (struct uploaded_tsv *utsv)
3145 const char *namebase;
3148 struct trace_state_variable *tsv;
3152 namebase = utsv->name;
3158 buf = string_printf ("%s_%d", namebase, try_num++);
3161 /* Fish for a name that is not in use. */
3162 /* (should check against all internal vars?) */
3163 while (find_trace_state_variable (buf.c_str ()))
3164 buf = string_printf ("%s_%d", namebase, try_num++);
3166 /* We have an available name, create the variable. */
3167 tsv = create_trace_state_variable (buf.c_str ());
3168 tsv->initial_value = utsv->initial_value;
3169 tsv->builtin = utsv->builtin;
3171 gdb::observers::tsv_created.notify (tsv);
3176 /* Given a list of uploaded trace state variables, try to match them
3177 up with existing variables, or create additional ones. */
3180 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
3183 struct uploaded_tsv *utsv;
3184 struct trace_state_variable *tsv;
3187 /* Most likely some numbers will have to be reassigned as part of
3188 the merge, so clear them all in anticipation. */
3189 for (trace_state_variable &tsv : tvariables)
3192 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
3194 tsv = find_matching_tsv (utsv);
3198 printf_filtered (_("Assuming trace state variable $%s "
3199 "is same as target's variable %d.\n"),
3200 tsv->name.c_str (), utsv->number);
3204 tsv = create_tsv_from_upload (utsv);
3206 printf_filtered (_("Created trace state variable "
3207 "$%s for target's variable %d.\n"),
3208 tsv->name.c_str (), utsv->number);
3210 /* Give precedence to numberings that come from the target. */
3212 tsv->number = utsv->number;
3215 /* Renumber everything that didn't get a target-assigned number. */
3217 for (const trace_state_variable &tsv : tvariables)
3218 highest = std::max (tsv.number, highest);
3221 for (trace_state_variable &tsv : tvariables)
3222 if (tsv.number == 0)
3223 tsv.number = highest++;
3225 free_uploaded_tsvs (uploaded_tsvs);
3228 /* Parse the part of trace status syntax that is shared between
3229 the remote protocol and the trace file reader. */
3232 parse_trace_status (const char *line, struct trace_status *ts)
3234 const char *p = line, *p1, *p2, *p3, *p_temp;
3238 ts->running_known = 1;
3239 ts->running = (*p++ == '1');
3240 ts->stop_reason = trace_stop_reason_unknown;
3241 xfree (ts->stop_desc);
3242 ts->stop_desc = NULL;
3243 ts->traceframe_count = -1;
3244 ts->traceframes_created = -1;
3245 ts->buffer_free = -1;
3246 ts->buffer_size = -1;
3247 ts->disconnected_tracing = 0;
3248 ts->circular_buffer = 0;
3249 xfree (ts->user_name);
3250 ts->user_name = NULL;
3253 ts->start_time = ts->stop_time = 0;
3257 p1 = strchr (p, ':');
3259 error (_("Malformed trace status, at %s\n\
3260 Status line: '%s'\n"), p, line);
3261 p3 = strchr (p, ';');
3263 p3 = p + strlen (p);
3264 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3266 p = unpack_varlen_hex (++p1, &val);
3267 ts->stop_reason = trace_buffer_full;
3269 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3271 p = unpack_varlen_hex (++p1, &val);
3272 ts->stop_reason = trace_never_run;
3274 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
3277 p = unpack_varlen_hex (++p1, &val);
3278 ts->stop_reason = tracepoint_passcount;
3279 ts->stopping_tracepoint = val;
3281 else if (strncmp (p, stop_reason_names[trace_stop_command], p1 - p) == 0)
3283 p2 = strchr (++p1, ':');
3291 ts->stop_desc = (char *) xmalloc (strlen (line));
3292 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
3293 ts->stop_desc[end] = '\0';
3296 ts->stop_desc = xstrdup ("");
3298 p = unpack_varlen_hex (++p2, &val);
3299 ts->stop_reason = trace_stop_command;
3301 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3303 p = unpack_varlen_hex (++p1, &val);
3304 ts->stop_reason = trace_disconnected;
3306 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3308 p2 = strchr (++p1, ':');
3311 ts->stop_desc = (char *) xmalloc ((p2 - p1) / 2 + 1);
3312 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
3313 ts->stop_desc[end] = '\0';
3316 ts->stop_desc = xstrdup ("");
3318 p = unpack_varlen_hex (++p2, &val);
3319 ts->stopping_tracepoint = val;
3320 ts->stop_reason = tracepoint_error;
3322 else if (strncmp (p, "tframes", p1 - p) == 0)
3324 p = unpack_varlen_hex (++p1, &val);
3325 ts->traceframe_count = val;
3327 else if (strncmp (p, "tcreated", p1 - p) == 0)
3329 p = unpack_varlen_hex (++p1, &val);
3330 ts->traceframes_created = val;
3332 else if (strncmp (p, "tfree", p1 - p) == 0)
3334 p = unpack_varlen_hex (++p1, &val);
3335 ts->buffer_free = val;
3337 else if (strncmp (p, "tsize", p1 - p) == 0)
3339 p = unpack_varlen_hex (++p1, &val);
3340 ts->buffer_size = val;
3342 else if (strncmp (p, "disconn", p1 - p) == 0)
3344 p = unpack_varlen_hex (++p1, &val);
3345 ts->disconnected_tracing = val;
3347 else if (strncmp (p, "circular", p1 - p) == 0)
3349 p = unpack_varlen_hex (++p1, &val);
3350 ts->circular_buffer = val;
3352 else if (strncmp (p, "starttime", p1 - p) == 0)
3354 p = unpack_varlen_hex (++p1, &val);
3355 ts->start_time = val;
3357 else if (strncmp (p, "stoptime", p1 - p) == 0)
3359 p = unpack_varlen_hex (++p1, &val);
3360 ts->stop_time = val;
3362 else if (strncmp (p, "username", p1 - p) == 0)
3365 ts->user_name = (char *) xmalloc (strlen (p) / 2);
3366 end = hex2bin (p1, (gdb_byte *) ts->user_name, (p3 - p1) / 2);
3367 ts->user_name[end] = '\0';
3370 else if (strncmp (p, "notes", p1 - p) == 0)
3373 ts->notes = (char *) xmalloc (strlen (p) / 2);
3374 end = hex2bin (p1, (gdb_byte *) ts->notes, (p3 - p1) / 2);
3375 ts->notes[end] = '\0';
3380 /* Silently skip unknown optional info. */
3381 p_temp = strchr (p1 + 1, ';');
3385 /* Must be at the end. */
3392 parse_tracepoint_status (const char *p, struct breakpoint *bp,
3393 struct uploaded_tp *utp)
3396 struct tracepoint *tp = (struct tracepoint *) bp;
3398 p = unpack_varlen_hex (p, &uval);
3400 tp->hit_count += uval;
3402 utp->hit_count += uval;
3403 p = unpack_varlen_hex (p + 1, &uval);
3405 tp->traceframe_usage += uval;
3407 utp->traceframe_usage += uval;
3408 /* Ignore any extra, allowing for future extensions. */
3411 /* Given a line of text defining a part of a tracepoint, parse it into
3412 an "uploaded tracepoint". */
3415 parse_tracepoint_definition (const char *line, struct uploaded_tp **utpp)
3419 ULONGEST num, addr, step, pass, orig_size, xlen, start;
3422 const char *srctype;
3424 struct uploaded_tp *utp = NULL;
3427 /* Both tracepoint and action definitions start with the same number
3428 and address sequence. */
3430 p = unpack_varlen_hex (p, &num);
3431 p++; /* skip a colon */
3432 p = unpack_varlen_hex (p, &addr);
3433 p++; /* skip a colon */
3436 enabled = (*p++ == 'E');
3437 p++; /* skip a colon */
3438 p = unpack_varlen_hex (p, &step);
3439 p++; /* skip a colon */
3440 p = unpack_varlen_hex (p, &pass);
3441 type = bp_tracepoint;
3443 /* Thumb through optional fields. */
3446 p++; /* skip a colon */
3449 type = bp_fast_tracepoint;
3451 p = unpack_varlen_hex (p, &orig_size);
3455 type = bp_static_tracepoint;
3461 p = unpack_varlen_hex (p, &xlen);
3462 p++; /* skip a comma */
3463 cond = (char *) xmalloc (2 * xlen + 1);
3464 strncpy (cond, p, 2 * xlen);
3465 cond[2 * xlen] = '\0';
3469 warning (_("Unrecognized char '%c' in tracepoint "
3470 "definition, skipping rest"), *p);
3472 utp = get_uploaded_tp (num, addr, utpp);
3474 utp->enabled = enabled;
3479 else if (piece == 'A')
3481 utp = get_uploaded_tp (num, addr, utpp);
3482 utp->actions.push_back (xstrdup (p));
3484 else if (piece == 'S')
3486 utp = get_uploaded_tp (num, addr, utpp);
3487 utp->step_actions.push_back (xstrdup (p));
3489 else if (piece == 'Z')
3491 /* Parse a chunk of source form definition. */
3492 utp = get_uploaded_tp (num, addr, utpp);
3494 p = strchr (p, ':');
3495 p++; /* skip a colon */
3496 p = unpack_varlen_hex (p, &start);
3497 p++; /* skip a colon */
3498 p = unpack_varlen_hex (p, &xlen);
3499 p++; /* skip a colon */
3501 buf = (char *) alloca (strlen (line));
3503 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3506 if (startswith (srctype, "at:"))
3507 utp->at_string = xstrdup (buf);
3508 else if (startswith (srctype, "cond:"))
3509 utp->cond_string = xstrdup (buf);
3510 else if (startswith (srctype, "cmd:"))
3511 utp->cmd_strings.push_back (xstrdup (buf));
3513 else if (piece == 'V')
3515 utp = get_uploaded_tp (num, addr, utpp);
3517 parse_tracepoint_status (p, NULL, utp);
3521 /* Don't error out, the target might be sending us optional
3522 info that we don't care about. */
3523 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
3527 /* Convert a textual description of a trace state variable into an
3531 parse_tsv_definition (const char *line, struct uploaded_tsv **utsvp)
3535 ULONGEST num, initval, builtin;
3537 struct uploaded_tsv *utsv = NULL;
3539 buf = (char *) alloca (strlen (line));
3542 p = unpack_varlen_hex (p, &num);
3543 p++; /* skip a colon */
3544 p = unpack_varlen_hex (p, &initval);
3545 p++; /* skip a colon */
3546 p = unpack_varlen_hex (p, &builtin);
3547 p++; /* skip a colon */
3548 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3551 utsv = get_uploaded_tsv (num, utsvp);
3552 utsv->initial_value = initval;
3553 utsv->builtin = builtin;
3554 utsv->name = xstrdup (buf);
3557 /* Given a line of text defining a static tracepoint marker, parse it
3558 into a "static tracepoint marker" object. Throws an error is
3559 parsing fails. If PP is non-null, it points to one past the end of
3560 the parsed marker definition. */
3563 parse_static_tracepoint_marker_definition (const char *line, const char **pp,
3564 static_tracepoint_marker *marker)
3566 const char *p, *endp;
3570 p = unpack_varlen_hex (p, &addr);
3571 p++; /* skip a colon */
3573 marker->gdbarch = target_gdbarch ();
3574 marker->address = (CORE_ADDR) addr;
3576 endp = strchr (p, ':');
3578 error (_("bad marker definition: %s"), line);
3580 marker->str_id = hex2str (p, (endp - p) / 2);
3583 p++; /* skip a colon */
3585 /* This definition may be followed by another one, separated by a comma. */
3587 endp = strchr (p, ',');
3588 if (endp != nullptr)
3591 hex_len = strlen (p);
3593 marker->extra = hex2str (p, hex_len / 2);
3599 /* Print MARKER to gdb_stdout. */
3602 print_one_static_tracepoint_marker (int count,
3603 const static_tracepoint_marker &marker)
3607 char wrap_indent[80];
3608 char extra_field_indent[80];
3609 struct ui_out *uiout = current_uiout;
3611 symtab_and_line sal;
3612 sal.pc = marker.address;
3614 std::vector<breakpoint *> tracepoints
3615 = static_tracepoints_here (marker.address);
3617 ui_out_emit_tuple tuple_emitter (uiout, "marker");
3619 /* A counter field to help readability. This is not a stable
3621 uiout->field_int ("count", count);
3623 uiout->field_string ("marker-id", marker.str_id.c_str ());
3625 uiout->field_fmt ("enabled", "%c",
3626 !tracepoints.empty () ? 'y' : 'n');
3629 strcpy (wrap_indent, " ");
3631 if (gdbarch_addr_bit (marker.gdbarch) <= 32)
3632 strcat (wrap_indent, " ");
3634 strcat (wrap_indent, " ");
3636 strcpy (extra_field_indent, " ");
3638 uiout->field_core_addr ("addr", marker.gdbarch, marker.address);
3640 sal = find_pc_line (marker.address, 0);
3641 sym = find_pc_sect_function (marker.address, NULL);
3644 uiout->text ("in ");
3645 uiout->field_string ("func",
3646 SYMBOL_PRINT_NAME (sym));
3647 uiout->wrap_hint (wrap_indent);
3648 uiout->text (" at ");
3651 uiout->field_skip ("func");
3653 if (sal.symtab != NULL)
3655 uiout->field_string ("file",
3656 symtab_to_filename_for_display (sal.symtab));
3659 if (uiout->is_mi_like_p ())
3661 const char *fullname = symtab_to_fullname (sal.symtab);
3663 uiout->field_string ("fullname", fullname);
3666 uiout->field_skip ("fullname");
3668 uiout->field_int ("line", sal.line);
3672 uiout->field_skip ("fullname");
3673 uiout->field_skip ("line");
3677 uiout->text (extra_field_indent);
3678 uiout->text (_("Data: \""));
3679 uiout->field_string ("extra-data", marker.extra.c_str ());
3680 uiout->text ("\"\n");
3682 if (!tracepoints.empty ())
3685 struct breakpoint *b;
3688 ui_out_emit_tuple tuple_emitter (uiout, "tracepoints-at");
3690 uiout->text (extra_field_indent);
3691 uiout->text (_("Probed by static tracepoints: "));
3692 for (ix = 0; ix < tracepoints.size (); ix++)
3697 uiout->field_int ("tracepoint-id", tracepoints[ix]->number);
3701 if (uiout->is_mi_like_p ())
3702 uiout->field_int ("number-of-tracepoints", tracepoints.size ());
3709 info_static_tracepoint_markers_command (const char *arg, int from_tty)
3711 struct ui_out *uiout = current_uiout;
3712 std::vector<static_tracepoint_marker> markers
3713 = target_static_tracepoint_markers_by_strid (NULL);
3715 /* We don't have to check target_can_use_agent and agent's capability on
3716 static tracepoint here, in order to be compatible with older GDBserver.
3717 We don't check USE_AGENT is true or not, because static tracepoints
3718 don't work without in-process agent, so we don't bother users to type
3719 `set agent on' when to use static tracepoint. */
3721 ui_out_emit_table table_emitter (uiout, 5, -1,
3722 "StaticTracepointMarkersTable");
3724 uiout->table_header (7, ui_left, "counter", "Cnt");
3726 uiout->table_header (40, ui_left, "marker-id", "ID");
3728 uiout->table_header (3, ui_left, "enabled", "Enb");
3729 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
3730 uiout->table_header (10, ui_left, "addr", "Address");
3732 uiout->table_header (18, ui_left, "addr", "Address");
3733 uiout->table_header (40, ui_noalign, "what", "What");
3735 uiout->table_body ();
3737 for (int i = 0; i < markers.size (); i++)
3738 print_one_static_tracepoint_marker (i + 1, markers[i]);
3741 /* The $_sdata convenience variable is a bit special. We don't know
3742 for sure type of the value until we actually have a chance to fetch
3743 the data --- the size of the object depends on what has been
3744 collected. We solve this by making $_sdata be an internalvar that
3745 creates a new value on access. */
3747 /* Return a new value with the correct type for the sdata object of
3748 the current trace frame. Return a void value if there's no object
3751 static struct value *
3752 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
3755 /* We need to read the whole object before we know its size. */
3756 gdb::optional<gdb::byte_vector> buf
3757 = target_read_alloc (current_top_target (), TARGET_OBJECT_STATIC_TRACE_DATA,
3764 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
3766 v = allocate_value (type);
3767 memcpy (value_contents_raw (v), buf->data (), buf->size ());
3771 return allocate_value (builtin_type (gdbarch)->builtin_void);
3774 #if !defined(HAVE_LIBEXPAT)
3776 struct std::unique_ptr<traceframe_info>
3777 parse_traceframe_info (const char *tframe_info)
3779 static int have_warned;
3784 warning (_("Can not parse XML trace frame info; XML support "
3785 "was disabled at compile time"));
3791 #else /* HAVE_LIBEXPAT */
3793 #include "xml-support.h"
3795 /* Handle the start of a <memory> element. */
3798 traceframe_info_start_memory (struct gdb_xml_parser *parser,
3799 const struct gdb_xml_element *element,
3801 std::vector<gdb_xml_value> &attributes)
3803 struct traceframe_info *info = (struct traceframe_info *) user_data;
3804 ULONGEST *start_p, *length_p;
3807 = (ULONGEST *) xml_find_attribute (attributes, "start")->value.get ();
3809 = (ULONGEST *) xml_find_attribute (attributes, "length")->value.get ();
3811 info->memory.emplace_back (*start_p, *length_p);
3814 /* Handle the start of a <tvar> element. */
3817 traceframe_info_start_tvar (struct gdb_xml_parser *parser,
3818 const struct gdb_xml_element *element,
3820 std::vector<gdb_xml_value> &attributes)
3822 struct traceframe_info *info = (struct traceframe_info *) user_data;
3823 const char *id_attrib
3824 = (const char *) xml_find_attribute (attributes, "id")->value.get ();
3825 int id = gdb_xml_parse_ulongest (parser, id_attrib);
3827 info->tvars.push_back (id);
3830 /* The allowed elements and attributes for an XML memory map. */
3832 static const struct gdb_xml_attribute memory_attributes[] = {
3833 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
3834 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
3835 { NULL, GDB_XML_AF_NONE, NULL, NULL }
3838 static const struct gdb_xml_attribute tvar_attributes[] = {
3839 { "id", GDB_XML_AF_NONE, NULL, NULL },
3840 { NULL, GDB_XML_AF_NONE, NULL, NULL }
3843 static const struct gdb_xml_element traceframe_info_children[] = {
3844 { "memory", memory_attributes, NULL,
3845 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
3846 traceframe_info_start_memory, NULL },
3847 { "tvar", tvar_attributes, NULL,
3848 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
3849 traceframe_info_start_tvar, NULL },
3850 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
3853 static const struct gdb_xml_element traceframe_info_elements[] = {
3854 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
3856 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
3859 /* Parse a traceframe-info XML document. */
3862 parse_traceframe_info (const char *tframe_info)
3864 traceframe_info_up result (new traceframe_info);
3866 if (gdb_xml_parse_quick (_("trace frame info"),
3867 "traceframe-info.dtd", traceframe_info_elements,
3868 tframe_info, result.get ()) == 0)
3874 #endif /* HAVE_LIBEXPAT */
3876 /* Returns the traceframe_info object for the current traceframe.
3877 This is where we avoid re-fetching the object from the target if we
3878 already have it cached. */
3880 struct traceframe_info *
3881 get_traceframe_info (void)
3883 if (current_traceframe_info == NULL)
3884 current_traceframe_info = target_traceframe_info ();
3886 return current_traceframe_info.get ();
3889 /* If the target supports the query, return in RESULT the set of
3890 collected memory in the current traceframe, found within the LEN
3891 bytes range starting at MEMADDR. Returns true if the target
3892 supports the query, otherwise returns false, and RESULT is left
3896 traceframe_available_memory (std::vector<mem_range> *result,
3897 CORE_ADDR memaddr, ULONGEST len)
3899 struct traceframe_info *info = get_traceframe_info ();
3905 for (mem_range &r : info->memory)
3906 if (mem_ranges_overlap (r.start, r.length, memaddr, len))
3908 ULONGEST lo1, hi1, lo2, hi2;
3911 hi1 = memaddr + len;
3914 hi2 = r.start + r.length;
3916 CORE_ADDR start = std::max (lo1, lo2);
3917 int length = std::min (hi1, hi2) - start;
3919 result->emplace_back (start, length);
3922 normalize_mem_ranges (result);
3929 /* Implementation of `sdata' variable. */
3931 static const struct internalvar_funcs sdata_funcs =
3938 /* See tracepoint.h. */
3939 cmd_list_element *while_stepping_cmd_element = nullptr;
3941 /* module initialization */
3943 _initialize_tracepoint (void)
3945 struct cmd_list_element *c;
3947 /* Explicitly create without lookup, since that tries to create a
3948 value with a void typed value, and when we get here, gdbarch
3949 isn't initialized yet. At this point, we're quite sure there
3950 isn't another convenience variable of the same name. */
3951 create_internalvar_type_lazy ("_sdata", &sdata_funcs, NULL);
3953 traceframe_number = -1;
3954 tracepoint_number = -1;
3956 add_info ("scope", info_scope_command,
3957 _("List the variables local to a scope"));
3959 add_cmd ("tracepoints", class_trace,
3960 _("Tracing of program execution without stopping the program."),
3963 add_com ("tdump", class_trace, tdump_command,
3964 _("Print everything collected at the current tracepoint."));
3966 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
3967 Define a trace state variable.\n\
3968 Argument is a $-prefixed name, optionally followed\n\
3969 by '=' and an expression that sets the initial value\n\
3970 at the start of tracing."));
3971 set_cmd_completer (c, expression_completer);
3973 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
3974 Delete one or more trace state variables.\n\
3975 Arguments are the names of the variables to delete.\n\
3976 If no arguments are supplied, delete all variables."), &deletelist);
3977 /* FIXME add a trace variable completer. */
3979 add_info ("tvariables", info_tvariables_command, _("\
3980 Status of trace state variables and their values.\n\
3983 add_info ("static-tracepoint-markers",
3984 info_static_tracepoint_markers_command, _("\
3985 List target static tracepoints markers.\n\
3988 add_prefix_cmd ("tfind", class_trace, tfind_command, _("\
3989 Select a trace frame;\n\
3990 No argument means forward by one frame; '-' means backward by one frame."),
3991 &tfindlist, "tfind ", 1, &cmdlist);
3993 add_cmd ("outside", class_trace, tfind_outside_command, _("\
3994 Select a trace frame whose PC is outside the given range (exclusive).\n\
3995 Usage: tfind outside addr1, addr2"),
3998 add_cmd ("range", class_trace, tfind_range_command, _("\
3999 Select a trace frame whose PC is in the given range (inclusive).\n\
4000 Usage: tfind range addr1,addr2"),
4003 add_cmd ("line", class_trace, tfind_line_command, _("\
4004 Select a trace frame by source line.\n\
4005 Argument can be a line number (with optional source file),\n\
4006 a function name, or '*' followed by an address.\n\
4007 Default argument is 'the next source line that was traced'."),
4010 add_cmd ("tracepoint", class_trace, tfind_tracepoint_command, _("\
4011 Select a trace frame by tracepoint number.\n\
4012 Default is the tracepoint for the current trace frame."),
4015 add_cmd ("pc", class_trace, tfind_pc_command, _("\
4016 Select a trace frame by PC.\n\
4017 Default is the current PC, or the PC of the current trace frame."),
4020 add_cmd ("end", class_trace, tfind_end_command, _("\
4021 De-select any trace frame and resume 'live' debugging."),
4024 add_alias_cmd ("none", "end", class_trace, 0, &tfindlist);
4026 add_cmd ("start", class_trace, tfind_start_command,
4027 _("Select the first trace frame in the trace buffer."),
4030 add_com ("tstatus", class_trace, tstatus_command,
4031 _("Display the status of the current trace data collection."));
4033 add_com ("tstop", class_trace, tstop_command, _("\
4034 Stop trace data collection.\n\
4035 Usage: tstop [NOTES]...\n\
4036 Any arguments supplied are recorded with the trace as a stop reason and\n\
4037 reported by tstatus (if the target supports trace notes)."));
4039 add_com ("tstart", class_trace, tstart_command, _("\
4040 Start trace data collection.\n\
4041 Usage: tstart [NOTES]...\n\
4042 Any arguments supplied are recorded with the trace as a note and\n\
4043 reported by tstatus (if the target supports trace notes)."));
4045 add_com ("end", class_trace, end_actions_pseudocommand, _("\
4046 Ends a list of commands or actions.\n\
4047 Several GDB commands allow you to enter a list of commands or actions.\n\
4048 Entering \"end\" on a line by itself is the normal way to terminate\n\
4050 Note: the \"end\" command cannot be used at the gdb prompt."));
4052 while_stepping_cmd_element = add_com ("while-stepping", class_trace,
4053 while_stepping_pseudocommand, _("\
4054 Specify single-stepping behavior at a tracepoint.\n\
4055 Argument is number of instructions to trace in single-step mode\n\
4056 following the tracepoint. This command is normally followed by\n\
4057 one or more \"collect\" commands, to specify what to collect\n\
4058 while single-stepping.\n\n\
4059 Note: this command can only be used in a tracepoint \"actions\" list."));
4061 add_com_alias ("ws", "while-stepping", class_alias, 0);
4062 add_com_alias ("stepping", "while-stepping", class_alias, 0);
4064 add_com ("collect", class_trace, collect_pseudocommand, _("\
4065 Specify one or more data items to be collected at a tracepoint.\n\
4066 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4067 collect all data (variables, registers) referenced by that expression.\n\
4068 Also accepts the following special arguments:\n\
4069 $regs -- all registers.\n\
4070 $args -- all function arguments.\n\
4071 $locals -- all variables local to the block/function scope.\n\
4072 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4073 Note: this command can only be used in a tracepoint \"actions\" list."));
4075 add_com ("teval", class_trace, teval_pseudocommand, _("\
4076 Specify one or more expressions to be evaluated at a tracepoint.\n\
4077 Accepts a comma-separated list of (one or more) expressions.\n\
4078 The result of each evaluation will be discarded.\n\
4079 Note: this command can only be used in a tracepoint \"actions\" list."));
4081 add_com ("actions", class_trace, actions_command, _("\
4082 Specify the actions to be taken at a tracepoint.\n\
4083 Tracepoint actions may include collecting of specified data,\n\
4084 single-stepping, or enabling/disabling other tracepoints,\n\
4085 depending on target's capabilities."));
4087 default_collect = xstrdup ("");
4088 add_setshow_string_cmd ("default-collect", class_trace,
4089 &default_collect, _("\
4090 Set the list of expressions to collect by default"), _("\
4091 Show the list of expressions to collect by default"), NULL,
4093 &setlist, &showlist);
4095 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
4096 &disconnected_tracing, _("\
4097 Set whether tracing continues after GDB disconnects."), _("\
4098 Show whether tracing continues after GDB disconnects."), _("\
4099 Use this to continue a tracing run even if GDB disconnects\n\
4100 or detaches from the target. You can reconnect later and look at\n\
4101 trace data collected in the meantime."),
4102 set_disconnected_tracing,
4107 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
4108 &circular_trace_buffer, _("\
4109 Set target's use of circular trace buffer."), _("\
4110 Show target's use of circular trace buffer."), _("\
4111 Use this to make the trace buffer into a circular buffer,\n\
4112 which will discard traceframes (oldest first) instead of filling\n\
4113 up and stopping the trace run."),
4114 set_circular_trace_buffer,
4119 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class,
4120 &trace_buffer_size, _("\
4121 Set requested size of trace buffer."), _("\
4122 Show requested size of trace buffer."), _("\
4123 Use this to choose a size for the trace buffer. Some targets\n\
4124 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
4125 disables any attempt to set the buffer size and lets the target choose."),
4126 set_trace_buffer_size, NULL,
4127 &setlist, &showlist);
4129 add_setshow_string_cmd ("trace-user", class_trace,
4131 Set the user name to use for current and future trace runs"), _("\
4132 Show the user name to use for current and future trace runs"), NULL,
4133 set_trace_user, NULL,
4134 &setlist, &showlist);
4136 add_setshow_string_cmd ("trace-notes", class_trace,
4138 Set notes string to use for current and future trace runs"), _("\
4139 Show the notes string to use for current and future trace runs"), NULL,
4140 set_trace_notes, NULL,
4141 &setlist, &showlist);
4143 add_setshow_string_cmd ("trace-stop-notes", class_trace,
4144 &trace_stop_notes, _("\
4145 Set notes string to use for future tstop commands"), _("\
4146 Show the notes string to use for future tstop commands"), NULL,
4147 set_trace_stop_notes, NULL,
4148 &setlist, &showlist);