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 /* Call ax_reqs on AEXPR and raise an error if something is wrong. */
621 finalize_tracepoint_aexpr (struct agent_expr *aexpr)
625 if (aexpr->len > MAX_AGENT_EXPR_LEN)
626 error (_("Expression is too complicated."));
628 report_agent_reqs_errors (aexpr);
631 /* worker function */
633 validate_actionline (const char *line, struct breakpoint *b)
635 struct cmd_list_element *c;
638 struct bp_location *loc;
639 struct tracepoint *t = (struct tracepoint *) b;
641 /* If EOF is typed, *line is NULL. */
645 p = skip_spaces (line);
647 /* Symbol lookup etc. */
648 if (*p == '\0') /* empty line: just prompt for another line. */
651 if (*p == '#') /* comment line */
654 c = lookup_cmd (&p, cmdlist, "", -1, 1);
656 error (_("`%s' is not a tracepoint action, or is ambiguous."), p);
658 if (cmd_cfunc_eq (c, collect_pseudocommand))
660 int trace_string = 0;
663 p = decode_agent_options (p, &trace_string);
666 { /* Repeat over a comma-separated list. */
667 QUIT; /* Allow user to bail out with ^C. */
670 if (*p == '$') /* Look for special pseudo-symbols. */
672 if (0 == strncasecmp ("reg", p + 1, 3)
673 || 0 == strncasecmp ("arg", p + 1, 3)
674 || 0 == strncasecmp ("loc", p + 1, 3)
675 || 0 == strncasecmp ("_ret", p + 1, 4)
676 || 0 == strncasecmp ("_sdata", p + 1, 6))
681 /* else fall thru, treat p as an expression and parse it! */
684 for (loc = t->loc; loc; loc = loc->next)
687 expression_up exp = parse_exp_1 (&p, loc->address,
688 block_for_pc (loc->address), 1);
690 if (exp->elts[0].opcode == OP_VAR_VALUE)
692 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
694 error (_("constant `%s' (value %s) "
695 "will not be collected."),
696 SYMBOL_PRINT_NAME (exp->elts[2].symbol),
697 plongest (SYMBOL_VALUE (exp->elts[2].symbol)));
699 else if (SYMBOL_CLASS (exp->elts[2].symbol)
700 == LOC_OPTIMIZED_OUT)
702 error (_("`%s' is optimized away "
703 "and cannot be collected."),
704 SYMBOL_PRINT_NAME (exp->elts[2].symbol));
708 /* We have something to collect, make sure that the expr to
709 bytecode translator can handle it and that it's not too
711 agent_expr_up aexpr = gen_trace_for_expr (loc->address,
715 finalize_tracepoint_aexpr (aexpr.get ());
718 while (p && *p++ == ',');
721 else if (cmd_cfunc_eq (c, teval_pseudocommand))
724 { /* Repeat over a comma-separated list. */
725 QUIT; /* Allow user to bail out with ^C. */
729 for (loc = t->loc; loc; loc = loc->next)
733 /* Only expressions are allowed for this action. */
734 expression_up exp = parse_exp_1 (&p, loc->address,
735 block_for_pc (loc->address), 1);
737 /* We have something to evaluate, make sure that the expr to
738 bytecode translator can handle it and that it's not too
740 agent_expr_up aexpr = gen_eval_for_expr (loc->address, exp.get ());
742 finalize_tracepoint_aexpr (aexpr.get ());
745 while (p && *p++ == ',');
748 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
753 t->step_count = strtol (p, &endp, 0);
754 if (endp == p || t->step_count == 0)
755 error (_("while-stepping step count `%s' is malformed."), line);
759 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
763 error (_("`%s' is not a supported tracepoint action."), line);
767 memrange_absolute = -1
770 /* MEMRANGE functions: */
772 /* Compare memranges for std::sort. */
775 memrange_comp (const memrange &a, const memrange &b)
777 if (a.type == b.type)
779 if (a.type == memrange_absolute)
780 return (bfd_vma) a.start < (bfd_vma) b.start;
782 return a.start < b.start;
785 return a.type < b.type;
788 /* Sort the memrange list using std::sort, and merge adjacent memranges. */
791 memrange_sortmerge (std::vector<memrange> &memranges)
793 if (!memranges.empty ())
797 std::sort (memranges.begin (), memranges.end (), memrange_comp);
799 for (a = 0, b = 1; b < memranges.size (); b++)
801 /* If memrange b overlaps or is adjacent to memrange a,
803 if (memranges[a].type == memranges[b].type
804 && memranges[b].start <= memranges[a].end)
806 if (memranges[b].end > memranges[a].end)
807 memranges[a].end = memranges[b].end;
808 continue; /* next b, same a */
812 memranges[a] = memranges[b];
814 memranges.resize (a + 1);
818 /* Add remote register number REGNO to the collection list mask. */
821 collection_list::add_remote_register (unsigned int regno)
824 printf_filtered ("collect register %d\n", regno);
826 m_regs_mask.at (regno / 8) |= 1 << (regno % 8);
829 /* Add all the registers from the mask in AEXPR to the mask in the
830 collection list. Registers in the AEXPR mask are already remote
834 collection_list::add_ax_registers (struct agent_expr *aexpr)
836 if (aexpr->reg_mask_len > 0)
838 for (int ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
840 QUIT; /* Allow user to bail out with ^C. */
841 if (aexpr->reg_mask[ndx1] != 0)
843 /* Assume chars have 8 bits. */
844 for (int ndx2 = 0; ndx2 < 8; ndx2++)
845 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
846 /* It's used -- record it. */
847 add_remote_register (ndx1 * 8 + ndx2);
853 /* If REGNO is raw, add its corresponding remote register number to
854 the mask. If REGNO is a pseudo-register, figure out the necessary
855 registers using a temporary agent expression, and add it to the
856 list if it needs more than just a mask. */
859 collection_list::add_local_register (struct gdbarch *gdbarch,
863 if (regno < gdbarch_num_regs (gdbarch))
865 int remote_regno = gdbarch_remote_register_number (gdbarch, regno);
867 if (remote_regno < 0)
868 error (_("Can't collect register %d"), regno);
870 add_remote_register (remote_regno);
874 agent_expr_up aexpr (new agent_expr (gdbarch, scope));
876 ax_reg_mask (aexpr.get (), regno);
878 finalize_tracepoint_aexpr (aexpr.get ());
880 add_ax_registers (aexpr.get ());
882 /* Usually ax_reg_mask for a pseudo-regiser only sets the
883 corresponding raw registers in the ax mask, but if this isn't
884 the case add the expression that is generated to the
887 add_aexpr (std::move (aexpr));
891 /* Add a memrange to a collection list. */
894 collection_list::add_memrange (struct gdbarch *gdbarch,
895 int type, bfd_signed_vma base,
896 unsigned long len, CORE_ADDR scope)
899 printf_filtered ("(%d,%s,%ld)\n", type, paddress (gdbarch, base), len);
901 /* type: memrange_absolute == memory, other n == basereg */
902 /* base: addr if memory, offset if reg relative. */
903 /* len: we actually save end (base + len) for convenience */
904 m_memranges.emplace_back (type, base, base + len);
906 if (type != memrange_absolute) /* Better collect the base register! */
907 add_local_register (gdbarch, type, scope);
910 /* Add a symbol to a collection list. */
913 collection_list::collect_symbol (struct symbol *sym,
914 struct gdbarch *gdbarch,
915 long frame_regno, long frame_offset,
921 bfd_signed_vma offset;
922 int treat_as_expr = 0;
924 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
925 switch (SYMBOL_CLASS (sym))
928 printf_filtered ("%s: don't know symbol class %d\n",
929 SYMBOL_PRINT_NAME (sym),
933 printf_filtered ("constant %s (value %s) will not be collected.\n",
934 SYMBOL_PRINT_NAME (sym), plongest (SYMBOL_VALUE (sym)));
937 offset = SYMBOL_VALUE_ADDRESS (sym);
940 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
941 SYMBOL_PRINT_NAME (sym), len,
942 paddress (gdbarch, offset));
944 /* A struct may be a C++ class with static fields, go to general
945 expression handling. */
946 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
949 add_memrange (gdbarch, memrange_absolute, offset, len, scope);
952 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
954 printf_filtered ("LOC_REG[parm] %s: ",
955 SYMBOL_PRINT_NAME (sym));
956 add_local_register (gdbarch, reg, scope);
957 /* Check for doubles stored in two registers. */
958 /* FIXME: how about larger types stored in 3 or more regs? */
959 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
960 len > register_size (gdbarch, reg))
961 add_local_register (gdbarch, reg + 1, scope);
964 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
965 printf_filtered (" (will not collect %s)\n",
966 SYMBOL_PRINT_NAME (sym));
970 offset = frame_offset + SYMBOL_VALUE (sym);
973 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
974 " from frame ptr reg %d\n",
975 SYMBOL_PRINT_NAME (sym), len,
976 paddress (gdbarch, offset), reg);
978 add_memrange (gdbarch, reg, offset, len, scope);
980 case LOC_REGPARM_ADDR:
981 reg = SYMBOL_VALUE (sym);
985 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset %s"
987 SYMBOL_PRINT_NAME (sym), len,
988 paddress (gdbarch, offset), reg);
990 add_memrange (gdbarch, reg, offset, len, scope);
994 offset = frame_offset + SYMBOL_VALUE (sym);
997 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
998 " from frame ptr reg %d\n",
999 SYMBOL_PRINT_NAME (sym), len,
1000 paddress (gdbarch, offset), reg);
1002 add_memrange (gdbarch, reg, offset, len, scope);
1005 case LOC_UNRESOLVED:
1009 case LOC_OPTIMIZED_OUT:
1010 printf_filtered ("%s has been optimized out of existence.\n",
1011 SYMBOL_PRINT_NAME (sym));
1019 /* Expressions are the most general case. */
1022 agent_expr_up aexpr = gen_trace_for_var (scope, gdbarch,
1025 /* It can happen that the symbol is recorded as a computed
1026 location, but it's been optimized away and doesn't actually
1027 have a location expression. */
1030 printf_filtered ("%s has been optimized out of existence.\n",
1031 SYMBOL_PRINT_NAME (sym));
1035 finalize_tracepoint_aexpr (aexpr.get ());
1037 /* Take care of the registers. */
1038 add_ax_registers (aexpr.get ());
1040 add_aexpr (std::move (aexpr));
1044 /* Data to be passed around in the calls to the locals and args
1047 struct add_local_symbols_data
1049 struct collection_list *collect;
1050 struct gdbarch *gdbarch;
1058 /* The callback for the locals and args iterators. */
1061 do_collect_symbol (const char *print_name,
1065 struct add_local_symbols_data *p = (struct add_local_symbols_data *) cb_data;
1067 p->collect->collect_symbol (sym, p->gdbarch, p->frame_regno,
1068 p->frame_offset, p->pc, p->trace_string);
1071 p->collect->add_wholly_collected (print_name);
1075 collection_list::add_wholly_collected (const char *print_name)
1077 m_wholly_collected.push_back (print_name);
1080 /* Add all locals (or args) symbols to collection list. */
1083 collection_list::add_local_symbols (struct gdbarch *gdbarch, CORE_ADDR pc,
1084 long frame_regno, long frame_offset, int type,
1087 const struct block *block;
1088 struct add_local_symbols_data cb_data;
1090 cb_data.collect = this;
1091 cb_data.gdbarch = gdbarch;
1093 cb_data.frame_regno = frame_regno;
1094 cb_data.frame_offset = frame_offset;
1096 cb_data.trace_string = trace_string;
1100 block = block_for_pc (pc);
1103 warning (_("Can't collect locals; "
1104 "no symbol table info available.\n"));
1108 iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1109 if (cb_data.count == 0)
1110 warning (_("No locals found in scope."));
1114 pc = get_pc_function_start (pc);
1115 block = block_for_pc (pc);
1118 warning (_("Can't collect args; no symbol table info available."));
1122 iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1123 if (cb_data.count == 0)
1124 warning (_("No args found in scope."));
1129 collection_list::add_static_trace_data ()
1132 printf_filtered ("collect static trace data\n");
1133 m_strace_data = true;
1136 collection_list::collection_list ()
1137 : m_strace_data (false)
1139 int max_remote_regno = 0;
1140 for (int i = 0; i < gdbarch_num_regs (target_gdbarch ()); i++)
1142 int remote_regno = (gdbarch_remote_register_number
1143 (target_gdbarch (), i));
1145 if (remote_regno >= 0 && remote_regno > max_remote_regno)
1146 max_remote_regno = remote_regno;
1149 m_regs_mask.resize ((max_remote_regno / 8) + 1);
1151 m_memranges.reserve (128);
1152 m_aexprs.reserve (128);
1155 /* Reduce a collection list to string form (for gdb protocol). */
1157 std::vector<std::string>
1158 collection_list::stringify ()
1160 gdb::char_vector temp_buf (2048);
1165 std::vector<std::string> str_list;
1170 printf_filtered ("\nCollecting static trace data\n");
1171 end = temp_buf.data ();
1173 str_list.emplace_back (temp_buf.data (), end - temp_buf.data ());
1176 for (i = m_regs_mask.size () - 1; i > 0; i--)
1177 if (m_regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */
1179 if (m_regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
1182 printf_filtered ("\nCollecting registers (mask): 0x");
1184 /* One char for 'R', one for the null terminator and two per
1186 std::size_t new_size = (i + 1) * 2 + 2;
1187 if (new_size > temp_buf.size ())
1188 temp_buf.resize (new_size);
1190 end = temp_buf.data ();
1194 QUIT; /* Allow user to bail out with ^C. */
1196 printf_filtered ("%02X", m_regs_mask[i]);
1198 end = pack_hex_byte (end, m_regs_mask[i]);
1202 str_list.emplace_back (temp_buf.data ());
1205 printf_filtered ("\n");
1206 if (!m_memranges.empty () && info_verbose)
1207 printf_filtered ("Collecting memranges: \n");
1208 for (i = 0, count = 0, end = temp_buf.data ();
1209 i < m_memranges.size (); i++)
1211 QUIT; /* Allow user to bail out with ^C. */
1214 printf_filtered ("(%d, %s, %ld)\n",
1215 m_memranges[i].type,
1216 paddress (target_gdbarch (),
1217 m_memranges[i].start),
1218 (long) (m_memranges[i].end
1219 - m_memranges[i].start));
1221 if (count + 27 > MAX_AGENT_EXPR_LEN)
1223 str_list.emplace_back (temp_buf.data (), count);
1225 end = temp_buf.data ();
1229 bfd_signed_vma length
1230 = m_memranges[i].end - m_memranges[i].start;
1232 /* The "%X" conversion specifier expects an unsigned argument,
1233 so passing -1 (memrange_absolute) to it directly gives you
1234 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1236 if (m_memranges[i].type == memrange_absolute)
1237 sprintf (end, "M-1,%s,%lX", phex_nz (m_memranges[i].start, 0),
1240 sprintf (end, "M%X,%s,%lX", m_memranges[i].type,
1241 phex_nz (m_memranges[i].start, 0), (long) length);
1244 count += strlen (end);
1245 end = temp_buf.data () + count;
1248 for (i = 0; i < m_aexprs.size (); i++)
1250 QUIT; /* Allow user to bail out with ^C. */
1251 if ((count + 10 + 2 * m_aexprs[i]->len) > MAX_AGENT_EXPR_LEN)
1253 str_list.emplace_back (temp_buf.data (), count);
1255 end = temp_buf.data ();
1257 sprintf (end, "X%08X,", m_aexprs[i]->len);
1258 end += 10; /* 'X' + 8 hex digits + ',' */
1261 end = mem2hex (m_aexprs[i]->buf, end, m_aexprs[i]->len);
1262 count += 2 * m_aexprs[i]->len;
1267 str_list.emplace_back (temp_buf.data (), count);
1269 end = temp_buf.data ();
1275 /* Add the printed expression EXP to *LIST. */
1278 collection_list::append_exp (struct expression *exp)
1280 string_file tmp_stream;
1282 print_expression (exp, &tmp_stream);
1284 m_computed.push_back (std::move (tmp_stream.string ()));
1288 collection_list::finish ()
1290 memrange_sortmerge (m_memranges);
1294 encode_actions_1 (struct command_line *action,
1295 struct bp_location *tloc,
1297 LONGEST frame_offset,
1298 struct collection_list *collect,
1299 struct collection_list *stepping_list)
1301 const char *action_exp;
1303 struct value *tempval;
1304 struct cmd_list_element *cmd;
1306 for (; action; action = action->next)
1308 QUIT; /* Allow user to bail out with ^C. */
1309 action_exp = action->line;
1310 action_exp = skip_spaces (action_exp);
1312 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1314 error (_("Bad action list item: %s"), action_exp);
1316 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1318 int trace_string = 0;
1320 if (*action_exp == '/')
1321 action_exp = decode_agent_options (action_exp, &trace_string);
1324 { /* Repeat over a comma-separated list. */
1325 QUIT; /* Allow user to bail out with ^C. */
1326 action_exp = skip_spaces (action_exp);
1328 if (0 == strncasecmp ("$reg", action_exp, 4))
1330 for (i = 0; i < gdbarch_num_regs (target_gdbarch ());
1333 int remote_regno = (gdbarch_remote_register_number
1334 (target_gdbarch (), i));
1336 /* Ignore arch regnos without a corresponding
1337 remote regno. This can happen for regnos not
1339 if (remote_regno >= 0)
1340 collect->add_remote_register (remote_regno);
1342 action_exp = strchr (action_exp, ','); /* more? */
1344 else if (0 == strncasecmp ("$arg", action_exp, 4))
1346 collect->add_local_symbols (target_gdbarch (),
1352 action_exp = strchr (action_exp, ','); /* more? */
1354 else if (0 == strncasecmp ("$loc", action_exp, 4))
1356 collect->add_local_symbols (target_gdbarch (),
1362 action_exp = strchr (action_exp, ','); /* more? */
1364 else if (0 == strncasecmp ("$_ret", action_exp, 5))
1367 = gen_trace_for_return_address (tloc->address,
1371 finalize_tracepoint_aexpr (aexpr.get ());
1373 /* take care of the registers */
1374 collect->add_ax_registers (aexpr.get ());
1376 collect->add_aexpr (std::move (aexpr));
1377 action_exp = strchr (action_exp, ','); /* more? */
1379 else if (0 == strncasecmp ("$_sdata", action_exp, 7))
1381 collect->add_static_trace_data ();
1382 action_exp = strchr (action_exp, ','); /* more? */
1388 expression_up exp = parse_exp_1 (&action_exp, tloc->address,
1389 block_for_pc (tloc->address),
1392 switch (exp->elts[0].opcode)
1396 const char *name = &exp->elts[2].string;
1398 i = user_reg_map_name_to_regnum (target_gdbarch (),
1399 name, strlen (name));
1401 internal_error (__FILE__, __LINE__,
1402 _("Register $%s not available"),
1405 printf_filtered ("OP_REGISTER: ");
1406 collect->add_local_register (target_gdbarch (),
1412 /* Safe because we know it's a simple expression. */
1413 tempval = evaluate_expression (exp.get ());
1414 addr = value_address (tempval);
1415 /* Initialize the TYPE_LENGTH if it is a typedef. */
1416 check_typedef (exp->elts[1].type);
1417 collect->add_memrange (target_gdbarch (),
1418 memrange_absolute, addr,
1419 TYPE_LENGTH (exp->elts[1].type),
1421 collect->append_exp (exp.get ());
1426 struct symbol *sym = exp->elts[2].symbol;
1427 const char *name = SYMBOL_NATURAL_NAME (sym);
1429 collect->collect_symbol (exp->elts[2].symbol,
1435 collect->add_wholly_collected (name);
1439 default: /* Full-fledged expression. */
1440 agent_expr_up aexpr = gen_trace_for_expr (tloc->address,
1444 finalize_tracepoint_aexpr (aexpr.get ());
1446 /* Take care of the registers. */
1447 collect->add_ax_registers (aexpr.get ());
1449 collect->add_aexpr (std::move (aexpr));
1450 collect->append_exp (exp.get ());
1455 while (action_exp && *action_exp++ == ',');
1457 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1460 { /* Repeat over a comma-separated list. */
1461 QUIT; /* Allow user to bail out with ^C. */
1462 action_exp = skip_spaces (action_exp);
1465 expression_up exp = parse_exp_1 (&action_exp, tloc->address,
1466 block_for_pc (tloc->address),
1469 agent_expr_up aexpr = gen_eval_for_expr (tloc->address,
1472 finalize_tracepoint_aexpr (aexpr.get ());
1474 /* Even though we're not officially collecting, add
1475 to the collect list anyway. */
1476 collect->add_aexpr (std::move (aexpr));
1479 while (action_exp && *action_exp++ == ',');
1481 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1483 /* We check against nested while-stepping when setting
1484 breakpoint action, so no way to run into nested
1486 gdb_assert (stepping_list);
1488 encode_actions_1 (action->body_list_0.get (), tloc, frame_reg,
1489 frame_offset, stepping_list, NULL);
1492 error (_("Invalid tracepoint command '%s'"), action->line);
1496 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1497 and STEPPING_LIST. */
1500 encode_actions (struct bp_location *tloc,
1501 struct collection_list *tracepoint_list,
1502 struct collection_list *stepping_list)
1505 LONGEST frame_offset;
1507 gdbarch_virtual_frame_pointer (tloc->gdbarch,
1508 tloc->address, &frame_reg, &frame_offset);
1510 counted_command_line actions = all_tracepoint_actions (tloc->owner);
1511 encode_actions_1 (actions.get (), tloc, frame_reg, frame_offset,
1512 tracepoint_list, stepping_list);
1513 encode_actions_1 (breakpoint_commands (tloc->owner), tloc,
1514 frame_reg, frame_offset, tracepoint_list, stepping_list);
1516 tracepoint_list->finish ();
1517 stepping_list->finish ();
1520 /* Render all actions into gdb protocol. */
1523 encode_actions_rsp (struct bp_location *tloc,
1524 std::vector<std::string> *tdp_actions,
1525 std::vector<std::string> *stepping_actions)
1527 struct collection_list tracepoint_list, stepping_list;
1529 encode_actions (tloc, &tracepoint_list, &stepping_list);
1531 *tdp_actions = tracepoint_list.stringify ();
1532 *stepping_actions = stepping_list.stringify ();
1536 collection_list::add_aexpr (agent_expr_up aexpr)
1538 m_aexprs.push_back (std::move (aexpr));
1542 process_tracepoint_on_disconnect (void)
1544 int has_pending_p = 0;
1546 /* Check whether we still have pending tracepoint. If we have, warn the
1547 user that pending tracepoint will no longer work. */
1548 for (breakpoint *b : all_tracepoints ())
1557 struct bp_location *loc1;
1559 for (loc1 = b->loc; loc1; loc1 = loc1->next)
1561 if (loc1->shlib_disabled)
1574 warning (_("Pending tracepoints will not be resolved while"
1575 " GDB is disconnected\n"));
1578 /* Reset local state of tracing. */
1581 trace_reset_local_state (void)
1583 set_traceframe_num (-1);
1584 set_tracepoint_num (-1);
1585 set_traceframe_context (NULL);
1586 clear_traceframe_info ();
1590 start_tracing (const char *notes)
1592 int any_enabled = 0, num_to_download = 0;
1595 std::vector<breakpoint *> tp_vec = all_tracepoints ();
1597 /* No point in tracing without any tracepoints... */
1598 if (tp_vec.empty ())
1599 error (_("No tracepoints defined, not starting trace"));
1601 for (breakpoint *b : tp_vec)
1603 if (b->enable_state == bp_enabled)
1606 if ((b->type == bp_fast_tracepoint
1607 ? may_insert_fast_tracepoints
1608 : may_insert_tracepoints))
1611 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1612 (b->type == bp_fast_tracepoint ? "fast " : ""), b->number);
1617 if (target_supports_enable_disable_tracepoint ())
1618 warning (_("No tracepoints enabled"));
1621 /* No point in tracing with only disabled tracepoints that
1622 cannot be re-enabled. */
1623 error (_("No tracepoints enabled, not starting trace"));
1627 if (num_to_download <= 0)
1628 error (_("No tracepoints that may be downloaded, not starting trace"));
1630 target_trace_init ();
1632 for (breakpoint *b : tp_vec)
1634 struct tracepoint *t = (struct tracepoint *) b;
1635 struct bp_location *loc;
1636 int bp_location_downloaded = 0;
1638 /* Clear `inserted' flag. */
1639 for (loc = b->loc; loc; loc = loc->next)
1642 if ((b->type == bp_fast_tracepoint
1643 ? !may_insert_fast_tracepoints
1644 : !may_insert_tracepoints))
1647 t->number_on_target = 0;
1649 for (loc = b->loc; loc; loc = loc->next)
1651 /* Since tracepoint locations are never duplicated, `inserted'
1652 flag should be zero. */
1653 gdb_assert (!loc->inserted);
1655 target_download_tracepoint (loc);
1658 bp_location_downloaded = 1;
1661 t->number_on_target = b->number;
1663 for (loc = b->loc; loc; loc = loc->next)
1664 if (loc->probe.prob != NULL)
1665 loc->probe.prob->set_semaphore (loc->probe.objfile,
1668 if (bp_location_downloaded)
1669 gdb::observers::breakpoint_modified.notify (b);
1672 /* Send down all the trace state variables too. */
1673 for (const trace_state_variable &tsv : tvariables)
1674 target_download_trace_state_variable (tsv);
1676 /* Tell target to treat text-like sections as transparent. */
1677 target_trace_set_readonly_regions ();
1678 /* Set some mode flags. */
1679 target_set_disconnected_tracing (disconnected_tracing);
1680 target_set_circular_trace_buffer (circular_trace_buffer);
1681 target_set_trace_buffer_size (trace_buffer_size);
1684 notes = trace_notes;
1685 ret = target_set_trace_notes (trace_user, notes, NULL);
1687 if (!ret && (trace_user || notes))
1688 warning (_("Target does not support trace user/notes, info ignored"));
1690 /* Now insert traps and begin collecting data. */
1691 target_trace_start ();
1693 /* Reset our local state. */
1694 trace_reset_local_state ();
1695 current_trace_status()->running = 1;
1698 /* The tstart command requests the target to start a new trace run.
1699 The command passes any arguments it has to the target verbatim, as
1700 an optional "trace note". This is useful as for instance a warning
1701 to other users if the trace runs disconnected, and you don't want
1702 anybody else messing with the target. */
1705 tstart_command (const char *args, int from_tty)
1707 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1709 if (current_trace_status ()->running)
1712 && !query (_("A trace is running already. Start a new run? ")))
1713 error (_("New trace run not started."));
1716 start_tracing (args);
1719 /* The tstop command stops the tracing run. The command passes any
1720 supplied arguments to the target verbatim as a "stop note"; if the
1721 target supports trace notes, then it will be reported back as part
1722 of the trace run's status. */
1725 tstop_command (const char *args, int from_tty)
1727 if (!current_trace_status ()->running)
1728 error (_("Trace is not running."));
1730 stop_tracing (args);
1734 stop_tracing (const char *note)
1738 target_trace_stop ();
1740 for (breakpoint *t : all_tracepoints ())
1742 struct bp_location *loc;
1744 if ((t->type == bp_fast_tracepoint
1745 ? !may_insert_fast_tracepoints
1746 : !may_insert_tracepoints))
1749 for (loc = t->loc; loc; loc = loc->next)
1751 /* GDB can be totally absent in some disconnected trace scenarios,
1752 but we don't really care if this semaphore goes out of sync.
1753 That's why we are decrementing it here, but not taking care
1755 if (loc->probe.prob != NULL)
1756 loc->probe.prob->clear_semaphore (loc->probe.objfile,
1762 note = trace_stop_notes;
1763 ret = target_set_trace_notes (NULL, NULL, note);
1766 warning (_("Target does not support trace notes, note ignored"));
1768 /* Should change in response to reply? */
1769 current_trace_status ()->running = 0;
1772 /* tstatus command */
1774 tstatus_command (const char *args, int from_tty)
1776 struct trace_status *ts = current_trace_status ();
1779 status = target_get_trace_status (ts);
1783 if (ts->filename != NULL)
1784 printf_filtered (_("Using a trace file.\n"));
1787 printf_filtered (_("Trace can not be run on this target.\n"));
1792 if (!ts->running_known)
1794 printf_filtered (_("Run/stop status is unknown.\n"));
1796 else if (ts->running)
1798 printf_filtered (_("Trace is running on the target.\n"));
1802 switch (ts->stop_reason)
1804 case trace_never_run:
1805 printf_filtered (_("No trace has been run on the target.\n"));
1807 case trace_stop_command:
1809 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1812 printf_filtered (_("Trace stopped by a tstop command.\n"));
1814 case trace_buffer_full:
1815 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1817 case trace_disconnected:
1818 printf_filtered (_("Trace stopped because of disconnection.\n"));
1820 case tracepoint_passcount:
1821 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1822 ts->stopping_tracepoint);
1824 case tracepoint_error:
1825 if (ts->stopping_tracepoint)
1826 printf_filtered (_("Trace stopped by an "
1827 "error (%s, tracepoint %d).\n"),
1828 ts->stop_desc, ts->stopping_tracepoint);
1830 printf_filtered (_("Trace stopped by an error (%s).\n"),
1833 case trace_stop_reason_unknown:
1834 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1837 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1843 if (ts->traceframes_created >= 0
1844 && ts->traceframe_count != ts->traceframes_created)
1846 printf_filtered (_("Buffer contains %d trace "
1847 "frames (of %d created total).\n"),
1848 ts->traceframe_count, ts->traceframes_created);
1850 else if (ts->traceframe_count >= 0)
1852 printf_filtered (_("Collected %d trace frames.\n"),
1853 ts->traceframe_count);
1856 if (ts->buffer_free >= 0)
1858 if (ts->buffer_size >= 0)
1860 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1861 ts->buffer_free, ts->buffer_size);
1862 if (ts->buffer_size > 0)
1863 printf_filtered (_(" (%d%% full)"),
1864 ((int) ((((long long) (ts->buffer_size
1865 - ts->buffer_free)) * 100)
1866 / ts->buffer_size)));
1867 printf_filtered (_(".\n"));
1870 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1874 if (ts->disconnected_tracing)
1875 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1877 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1879 if (ts->circular_buffer)
1880 printf_filtered (_("Trace buffer is circular.\n"));
1882 if (ts->user_name && strlen (ts->user_name) > 0)
1883 printf_filtered (_("Trace user is %s.\n"), ts->user_name);
1885 if (ts->notes && strlen (ts->notes) > 0)
1886 printf_filtered (_("Trace notes: %s.\n"), ts->notes);
1888 /* Now report on what we're doing with tfind. */
1889 if (traceframe_number >= 0)
1890 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1891 traceframe_number, tracepoint_number);
1893 printf_filtered (_("Not looking at any trace frame.\n"));
1895 /* Report start/stop times if supplied. */
1900 LONGEST run_time = ts->stop_time - ts->start_time;
1902 /* Reporting a run time is more readable than two long numbers. */
1903 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
1904 (long int) (ts->start_time / 1000000),
1905 (long int) (ts->start_time % 1000000),
1906 (long int) (run_time / 1000000),
1907 (long int) (run_time % 1000000));
1910 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
1911 (long int) (ts->start_time / 1000000),
1912 (long int) (ts->start_time % 1000000));
1914 else if (ts->stop_time)
1915 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
1916 (long int) (ts->stop_time / 1000000),
1917 (long int) (ts->stop_time % 1000000));
1919 /* Now report any per-tracepoint status available. */
1920 for (breakpoint *t : all_tracepoints ())
1921 target_get_tracepoint_status (t, NULL);
1924 /* Report the trace status to uiout, in a way suitable for MI, and not
1925 suitable for CLI. If ON_STOP is true, suppress a few fields that
1926 are not meaningful in the -trace-stop response.
1928 The implementation is essentially parallel to trace_status_command, but
1929 merging them will result in unreadable code. */
1931 trace_status_mi (int on_stop)
1933 struct ui_out *uiout = current_uiout;
1934 struct trace_status *ts = current_trace_status ();
1937 status = target_get_trace_status (ts);
1939 if (status == -1 && ts->filename == NULL)
1941 uiout->field_string ("supported", "0");
1945 if (ts->filename != NULL)
1946 uiout->field_string ("supported", "file");
1948 uiout->field_string ("supported", "1");
1950 if (ts->filename != NULL)
1951 uiout->field_string ("trace-file", ts->filename);
1953 gdb_assert (ts->running_known);
1957 uiout->field_string ("running", "1");
1959 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1960 Given that the frontend gets the status either on -trace-stop, or from
1961 -trace-status after re-connection, it does not seem like this
1962 information is necessary for anything. It is not necessary for either
1963 figuring the vital state of the target nor for navigation of trace
1964 frames. If the frontend wants to show the current state is some
1965 configure dialog, it can request the value when such dialog is
1966 invoked by the user. */
1970 const char *stop_reason = NULL;
1971 int stopping_tracepoint = -1;
1974 uiout->field_string ("running", "0");
1976 if (ts->stop_reason != trace_stop_reason_unknown)
1978 switch (ts->stop_reason)
1980 case trace_stop_command:
1981 stop_reason = "request";
1983 case trace_buffer_full:
1984 stop_reason = "overflow";
1986 case trace_disconnected:
1987 stop_reason = "disconnection";
1989 case tracepoint_passcount:
1990 stop_reason = "passcount";
1991 stopping_tracepoint = ts->stopping_tracepoint;
1993 case tracepoint_error:
1994 stop_reason = "error";
1995 stopping_tracepoint = ts->stopping_tracepoint;
2001 uiout->field_string ("stop-reason", stop_reason);
2002 if (stopping_tracepoint != -1)
2003 uiout->field_int ("stopping-tracepoint",
2004 stopping_tracepoint);
2005 if (ts->stop_reason == tracepoint_error)
2006 uiout->field_string ("error-description",
2012 if (ts->traceframe_count != -1)
2013 uiout->field_int ("frames", ts->traceframe_count);
2014 if (ts->traceframes_created != -1)
2015 uiout->field_int ("frames-created", ts->traceframes_created);
2016 if (ts->buffer_size != -1)
2017 uiout->field_int ("buffer-size", ts->buffer_size);
2018 if (ts->buffer_free != -1)
2019 uiout->field_int ("buffer-free", ts->buffer_free);
2021 uiout->field_int ("disconnected", ts->disconnected_tracing);
2022 uiout->field_int ("circular", ts->circular_buffer);
2024 uiout->field_string ("user-name", ts->user_name);
2025 uiout->field_string ("notes", ts->notes);
2030 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2031 (long int) (ts->start_time / 1000000),
2032 (long int) (ts->start_time % 1000000));
2033 uiout->field_string ("start-time", buf);
2034 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2035 (long int) (ts->stop_time / 1000000),
2036 (long int) (ts->stop_time % 1000000));
2037 uiout->field_string ("stop-time", buf);
2041 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2042 user if she really wants to detach. */
2045 query_if_trace_running (int from_tty)
2050 /* It can happen that the target that was tracing went away on its
2051 own, and we didn't notice. Get a status update, and if the
2052 current target doesn't even do tracing, then assume it's not
2054 if (target_get_trace_status (current_trace_status ()) < 0)
2055 current_trace_status ()->running = 0;
2057 /* If running interactively, give the user the option to cancel and
2058 then decide what to do differently with the run. Scripts are
2059 just going to disconnect and let the target deal with it,
2060 according to how it's been instructed previously via
2061 disconnected-tracing. */
2062 if (current_trace_status ()->running)
2064 process_tracepoint_on_disconnect ();
2066 if (current_trace_status ()->disconnected_tracing)
2068 if (!query (_("Trace is running and will "
2069 "continue after detach; detach anyway? ")))
2070 error (_("Not confirmed."));
2074 if (!query (_("Trace is running but will "
2075 "stop on detach; detach anyway? ")))
2076 error (_("Not confirmed."));
2081 /* This function handles the details of what to do about an ongoing
2082 tracing run if the user has asked to detach or otherwise disconnect
2086 disconnect_tracing (void)
2088 /* Also we want to be out of tfind mode, otherwise things can get
2089 confusing upon reconnection. Just use these calls instead of
2090 full tfind_1 behavior because we're in the middle of detaching,
2091 and there's no point to updating current stack frame etc. */
2092 trace_reset_local_state ();
2095 /* Worker function for the various flavors of the tfind command. */
2097 tfind_1 (enum trace_find_type type, int num,
2098 CORE_ADDR addr1, CORE_ADDR addr2,
2101 int target_frameno = -1, target_tracept = -1;
2102 struct frame_id old_frame_id = null_frame_id;
2103 struct tracepoint *tp;
2104 struct ui_out *uiout = current_uiout;
2106 /* Only try to get the current stack frame if we have a chance of
2107 succeeding. In particular, if we're trying to get a first trace
2108 frame while all threads are running, it's not going to succeed,
2109 so leave it with a default value and let the frame comparison
2110 below (correctly) decide to print out the source location of the
2112 if (!(type == tfind_number && num == -1)
2113 && (has_stack_frames () || traceframe_number >= 0))
2114 old_frame_id = get_frame_id (get_current_frame ());
2116 target_frameno = target_trace_find (type, num, addr1, addr2,
2119 if (type == tfind_number
2121 && target_frameno == -1)
2123 /* We told the target to get out of tfind mode, and it did. */
2125 else if (target_frameno == -1)
2127 /* A request for a non-existent trace frame has failed.
2128 Our response will be different, depending on FROM_TTY:
2130 If FROM_TTY is true, meaning that this command was
2131 typed interactively by the user, then give an error
2132 and DO NOT change the state of traceframe_number etc.
2134 However if FROM_TTY is false, meaning that we're either
2135 in a script, a loop, or a user-defined command, then
2136 DON'T give an error, but DO change the state of
2137 traceframe_number etc. to invalid.
2139 The rationalle is that if you typed the command, you
2140 might just have committed a typo or something, and you'd
2141 like to NOT lose your current debugging state. However
2142 if you're in a user-defined command or especially in a
2143 loop, then you need a way to detect that the command
2144 failed WITHOUT aborting. This allows you to write
2145 scripts that search thru the trace buffer until the end,
2146 and then continue on to do something else. */
2149 error (_("Target failed to find requested trace frame."));
2153 printf_filtered ("End of trace buffer.\n");
2154 #if 0 /* dubious now? */
2155 /* The following will not recurse, since it's
2157 tfind_command ("-1", from_tty);
2162 tp = get_tracepoint_by_number_on_target (target_tracept);
2164 reinit_frame_cache ();
2165 target_dcache_invalidate ();
2167 set_tracepoint_num (tp ? tp->number : target_tracept);
2169 if (target_frameno != get_traceframe_number ())
2170 gdb::observers::traceframe_changed.notify (target_frameno, tracepoint_number);
2172 set_current_traceframe (target_frameno);
2174 if (target_frameno == -1)
2175 set_traceframe_context (NULL);
2177 set_traceframe_context (get_current_frame ());
2179 if (traceframe_number >= 0)
2181 /* Use different branches for MI and CLI to make CLI messages
2183 if (uiout->is_mi_like_p ())
2185 uiout->field_string ("found", "1");
2186 uiout->field_int ("tracepoint", tracepoint_number);
2187 uiout->field_int ("traceframe", traceframe_number);
2191 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2192 traceframe_number, tracepoint_number);
2197 if (uiout->is_mi_like_p ())
2198 uiout->field_string ("found", "0");
2199 else if (type == tfind_number && num == -1)
2200 printf_unfiltered (_("No longer looking at any trace frame\n"));
2201 else /* This case may never occur, check. */
2202 printf_unfiltered (_("No trace frame found\n"));
2205 /* If we're in nonstop mode and getting out of looking at trace
2206 frames, there won't be any current frame to go back to and
2209 && (has_stack_frames () || traceframe_number >= 0))
2211 enum print_what print_what;
2213 /* NOTE: in imitation of the step command, try to determine
2214 whether we have made a transition from one function to
2215 another. If so, we'll print the "stack frame" (ie. the new
2216 function and it's arguments) -- otherwise we'll just show the
2219 if (frame_id_eq (old_frame_id,
2220 get_frame_id (get_current_frame ())))
2221 print_what = SRC_LINE;
2223 print_what = SRC_AND_LOC;
2225 print_stack_frame (get_selected_frame (NULL), 1, print_what, 1);
2230 /* Error on looking at traceframes while trace is running. */
2233 check_trace_running (struct trace_status *status)
2235 if (status->running && status->filename == NULL)
2236 error (_("May not look at trace frames while trace is running."));
2239 /* trace_find_command takes a trace frame number n,
2240 sends "QTFrame:<n>" to the target,
2241 and accepts a reply that may contain several optional pieces
2242 of information: a frame number, a tracepoint number, and an
2243 indication of whether this is a trap frame or a stepping frame.
2245 The minimal response is just "OK" (which indicates that the
2246 target does not give us a frame number or a tracepoint number).
2247 Instead of that, the target may send us a string containing
2249 F<hexnum> (gives the selected frame number)
2250 T<hexnum> (gives the selected tracepoint number)
2255 tfind_command_1 (const char *args, int from_tty)
2256 { /* This should only be called with a numeric argument. */
2259 check_trace_running (current_trace_status ());
2261 if (args == 0 || *args == 0)
2262 { /* TFIND with no args means find NEXT trace frame. */
2263 if (traceframe_number == -1)
2264 frameno = 0; /* "next" is first one. */
2266 frameno = traceframe_number + 1;
2268 else if (0 == strcmp (args, "-"))
2270 if (traceframe_number == -1)
2271 error (_("not debugging trace buffer"));
2272 else if (from_tty && traceframe_number == 0)
2273 error (_("already at start of trace buffer"));
2275 frameno = traceframe_number - 1;
2277 /* A hack to work around eval's need for fp to have been collected. */
2278 else if (0 == strcmp (args, "-1"))
2281 frameno = parse_and_eval_long (args);
2284 error (_("invalid input (%d is less than zero)"), frameno);
2286 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2290 tfind_command (const char *args, int from_tty)
2292 tfind_command_1 (args, from_tty);
2297 tfind_end_command (const char *args, int from_tty)
2299 tfind_command_1 ("-1", from_tty);
2304 tfind_start_command (const char *args, int from_tty)
2306 tfind_command_1 ("0", from_tty);
2309 /* tfind pc command */
2311 tfind_pc_command (const char *args, int from_tty)
2315 check_trace_running (current_trace_status ());
2317 if (args == 0 || *args == 0)
2318 pc = regcache_read_pc (get_current_regcache ());
2320 pc = parse_and_eval_address (args);
2322 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2325 /* tfind tracepoint command */
2327 tfind_tracepoint_command (const char *args, int from_tty)
2330 struct tracepoint *tp;
2332 check_trace_running (current_trace_status ());
2334 if (args == 0 || *args == 0)
2336 if (tracepoint_number == -1)
2337 error (_("No current tracepoint -- please supply an argument."));
2339 tdp = tracepoint_number; /* Default is current TDP. */
2342 tdp = parse_and_eval_long (args);
2344 /* If we have the tracepoint on hand, use the number that the
2345 target knows about (which may be different if we disconnected
2346 and reconnected). */
2347 tp = get_tracepoint (tdp);
2349 tdp = tp->number_on_target;
2351 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2354 /* TFIND LINE command:
2356 This command will take a sourceline for argument, just like BREAK
2357 or TRACE (ie. anything that "decode_line_1" can handle).
2359 With no argument, this command will find the next trace frame
2360 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2363 tfind_line_command (const char *args, int from_tty)
2365 check_trace_running (current_trace_status ());
2367 symtab_and_line sal;
2368 if (args == 0 || *args == 0)
2370 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2374 std::vector<symtab_and_line> sals
2375 = decode_line_with_current_source (args, DECODE_LINE_FUNFIRSTLINE);
2379 if (sal.symtab == 0)
2380 error (_("No line number information available."));
2382 CORE_ADDR start_pc, end_pc;
2383 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2385 if (start_pc == end_pc)
2387 printf_filtered ("Line %d of \"%s\"",
2389 symtab_to_filename_for_display (sal.symtab));
2391 printf_filtered (" is at address ");
2392 print_address (get_current_arch (), start_pc, gdb_stdout);
2394 printf_filtered (" but contains no code.\n");
2395 sal = find_pc_line (start_pc, 0);
2397 && find_line_pc_range (sal, &start_pc, &end_pc)
2398 && start_pc != end_pc)
2399 printf_filtered ("Attempting to find line %d instead.\n",
2402 error (_("Cannot find a good line."));
2406 /* Is there any case in which we get here, and have an address
2407 which the user would want to see? If we have debugging
2408 symbols and no line numbers? */
2409 error (_("Line number %d is out of range for \"%s\"."),
2410 sal.line, symtab_to_filename_for_display (sal.symtab));
2412 /* Find within range of stated line. */
2414 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2416 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2419 /* tfind range command */
2421 tfind_range_command (const char *args, int from_tty)
2423 static CORE_ADDR start, stop;
2426 check_trace_running (current_trace_status ());
2428 if (args == 0 || *args == 0)
2429 { /* XXX FIXME: what should default behavior be? */
2430 printf_filtered ("Usage: tfind range STARTADDR, ENDADDR\n");
2434 if (0 != (tmp = strchr (args, ',')))
2436 std::string start_addr (args, tmp);
2438 tmp = skip_spaces (tmp);
2439 start = parse_and_eval_address (start_addr.c_str ());
2440 stop = parse_and_eval_address (tmp);
2443 { /* No explicit end address? */
2444 start = parse_and_eval_address (args);
2445 stop = start + 1; /* ??? */
2448 tfind_1 (tfind_range, 0, start, stop, from_tty);
2451 /* tfind outside command */
2453 tfind_outside_command (const char *args, int from_tty)
2455 CORE_ADDR start, stop;
2458 if (current_trace_status ()->running
2459 && current_trace_status ()->filename == NULL)
2460 error (_("May not look at trace frames while trace is running."));
2462 if (args == 0 || *args == 0)
2463 { /* XXX FIXME: what should default behavior be? */
2464 printf_filtered ("Usage: tfind outside STARTADDR, ENDADDR\n");
2468 if (0 != (tmp = strchr (args, ',')))
2470 std::string start_addr (args, tmp);
2472 tmp = skip_spaces (tmp);
2473 start = parse_and_eval_address (start_addr.c_str ());
2474 stop = parse_and_eval_address (tmp);
2477 { /* No explicit end address? */
2478 start = parse_and_eval_address (args);
2479 stop = start + 1; /* ??? */
2482 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2485 /* info scope command: list the locals for a scope. */
2487 info_scope_command (const char *args_in, int from_tty)
2490 struct bound_minimal_symbol msym;
2491 const struct block *block;
2492 const char *symname;
2493 const char *save_args = args_in;
2494 struct block_iterator iter;
2496 struct gdbarch *gdbarch;
2498 const char *args = args_in;
2500 if (args == 0 || *args == 0)
2501 error (_("requires an argument (function, "
2502 "line or *addr) to define a scope"));
2504 event_location_up location = string_to_event_location (&args,
2506 std::vector<symtab_and_line> sals
2507 = decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE,
2511 /* Presumably decode_line_1 has already warned. */
2515 /* Resolve line numbers to PC. */
2516 resolve_sal_pc (&sals[0]);
2517 block = block_for_pc (sals[0].pc);
2521 QUIT; /* Allow user to bail out with ^C. */
2522 ALL_BLOCK_SYMBOLS (block, iter, sym)
2524 QUIT; /* Allow user to bail out with ^C. */
2526 printf_filtered ("Scope for %s:\n", save_args);
2529 symname = SYMBOL_PRINT_NAME (sym);
2530 if (symname == NULL || *symname == '\0')
2531 continue; /* Probably botched, certainly useless. */
2533 gdbarch = symbol_arch (sym);
2535 printf_filtered ("Symbol %s is ", symname);
2537 if (SYMBOL_COMPUTED_OPS (sym) != NULL)
2538 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2539 BLOCK_ENTRY_PC (block),
2543 switch (SYMBOL_CLASS (sym))
2546 case LOC_UNDEF: /* Messed up symbol? */
2547 printf_filtered ("a bogus symbol, class %d.\n",
2548 SYMBOL_CLASS (sym));
2549 count--; /* Don't count this one. */
2552 printf_filtered ("a constant with value %s (%s)",
2553 plongest (SYMBOL_VALUE (sym)),
2554 hex_string (SYMBOL_VALUE (sym)));
2556 case LOC_CONST_BYTES:
2557 printf_filtered ("constant bytes: ");
2558 if (SYMBOL_TYPE (sym))
2559 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2560 fprintf_filtered (gdb_stdout, " %02x",
2561 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2564 printf_filtered ("in static storage at address ");
2565 printf_filtered ("%s", paddress (gdbarch,
2566 SYMBOL_VALUE_ADDRESS (sym)));
2569 /* GDBARCH is the architecture associated with the objfile
2570 the symbol is defined in; the target architecture may be
2571 different, and may provide additional registers. However,
2572 we do not know the target architecture at this point.
2573 We assume the objfile architecture will contain all the
2574 standard registers that occur in debug info in that
2576 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2579 if (SYMBOL_IS_ARGUMENT (sym))
2580 printf_filtered ("an argument in register $%s",
2581 gdbarch_register_name (gdbarch, regno));
2583 printf_filtered ("a local variable in register $%s",
2584 gdbarch_register_name (gdbarch, regno));
2587 printf_filtered ("an argument at stack/frame offset %s",
2588 plongest (SYMBOL_VALUE (sym)));
2591 printf_filtered ("a local variable at frame offset %s",
2592 plongest (SYMBOL_VALUE (sym)));
2595 printf_filtered ("a reference argument at offset %s",
2596 plongest (SYMBOL_VALUE (sym)));
2598 case LOC_REGPARM_ADDR:
2599 /* Note comment at LOC_REGISTER. */
2600 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2602 printf_filtered ("the address of an argument, in register $%s",
2603 gdbarch_register_name (gdbarch, regno));
2606 printf_filtered ("a typedef.\n");
2609 printf_filtered ("a label at address ");
2610 printf_filtered ("%s", paddress (gdbarch,
2611 SYMBOL_VALUE_ADDRESS (sym)));
2614 printf_filtered ("a function at address ");
2615 printf_filtered ("%s",
2616 paddress (gdbarch, BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym))));
2618 case LOC_UNRESOLVED:
2619 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2621 if (msym.minsym == NULL)
2622 printf_filtered ("Unresolved Static");
2625 printf_filtered ("static storage at address ");
2626 printf_filtered ("%s",
2628 BMSYMBOL_VALUE_ADDRESS (msym)));
2631 case LOC_OPTIMIZED_OUT:
2632 printf_filtered ("optimized out.\n");
2635 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2638 if (SYMBOL_TYPE (sym))
2639 printf_filtered (", length %d.\n",
2640 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2642 if (BLOCK_FUNCTION (block))
2645 block = BLOCK_SUPERBLOCK (block);
2648 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2652 /* Helper for trace_dump_command. Dump the action list starting at
2653 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2654 actions of the body of a while-stepping action. STEPPING_FRAME is
2655 set if the current traceframe was determined to be a while-stepping
2659 trace_dump_actions (struct command_line *action,
2660 int stepping_actions, int stepping_frame,
2663 const char *action_exp, *next_comma;
2665 for (; action != NULL; action = action->next)
2667 struct cmd_list_element *cmd;
2669 QUIT; /* Allow user to bail out with ^C. */
2670 action_exp = action->line;
2671 action_exp = skip_spaces (action_exp);
2673 /* The collection actions to be done while stepping are
2674 bracketed by the commands "while-stepping" and "end". */
2676 if (*action_exp == '#') /* comment line */
2679 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2681 error (_("Bad action list item: %s"), action_exp);
2683 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2685 gdb_assert (action->body_list_1 == nullptr);
2686 trace_dump_actions (action->body_list_0.get (),
2687 1, stepping_frame, from_tty);
2689 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2691 /* Display the collected data.
2692 For the trap frame, display only what was collected at
2693 the trap. Likewise for stepping frames, display only
2694 what was collected while stepping. This means that the
2695 two boolean variables, STEPPING_FRAME and
2696 STEPPING_ACTIONS should be equal. */
2697 if (stepping_frame == stepping_actions)
2699 int trace_string = 0;
2701 if (*action_exp == '/')
2702 action_exp = decode_agent_options (action_exp, &trace_string);
2705 { /* Repeat over a comma-separated list. */
2706 QUIT; /* Allow user to bail out with ^C. */
2707 if (*action_exp == ',')
2709 action_exp = skip_spaces (action_exp);
2711 next_comma = strchr (action_exp, ',');
2713 if (0 == strncasecmp (action_exp, "$reg", 4))
2714 registers_info (NULL, from_tty);
2715 else if (0 == strncasecmp (action_exp, "$_ret", 5))
2717 else if (0 == strncasecmp (action_exp, "$loc", 4))
2718 info_locals_command (NULL, from_tty);
2719 else if (0 == strncasecmp (action_exp, "$arg", 4))
2720 info_args_command (NULL, from_tty);
2723 std::string contents;
2724 const char *exp = action_exp;
2725 if (next_comma != NULL)
2727 size_t len = next_comma - action_exp;
2728 contents = std::string (action_exp, len);
2729 exp = contents.c_str ();
2732 printf_filtered ("%s = ", exp);
2733 output_command (exp, from_tty);
2734 printf_filtered ("\n");
2736 action_exp = next_comma;
2738 while (action_exp && *action_exp == ',');
2744 /* Return bp_location of the tracepoint associated with the current
2745 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2746 is a stepping traceframe. */
2748 struct bp_location *
2749 get_traceframe_location (int *stepping_frame_p)
2751 struct tracepoint *t;
2752 struct bp_location *tloc;
2753 struct regcache *regcache;
2755 if (tracepoint_number == -1)
2756 error (_("No current trace frame."));
2758 t = get_tracepoint (tracepoint_number);
2761 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2764 /* The current frame is a trap frame if the frame PC is equal to the
2765 tracepoint PC. If not, then the current frame was collected
2766 during single-stepping. */
2767 regcache = get_current_regcache ();
2769 /* If the traceframe's address matches any of the tracepoint's
2770 locations, assume it is a direct hit rather than a while-stepping
2771 frame. (FIXME this is not reliable, should record each frame's
2773 for (tloc = t->loc; tloc; tloc = tloc->next)
2774 if (tloc->address == regcache_read_pc (regcache))
2776 *stepping_frame_p = 0;
2780 /* If this is a stepping frame, we don't know which location
2781 triggered. The first is as good (or bad) a guess as any... */
2782 *stepping_frame_p = 1;
2786 /* Return the default collect actions of a tracepoint T. */
2788 static counted_command_line
2789 all_tracepoint_actions (struct breakpoint *t)
2791 counted_command_line actions (nullptr, command_lines_deleter ());
2793 /* If there are default expressions to collect, make up a collect
2794 action and prepend to the action list to encode. Note that since
2795 validation is per-tracepoint (local var "xyz" might be valid for
2796 one tracepoint and not another, etc), we make up the action on
2797 the fly, and don't cache it. */
2798 if (*default_collect)
2800 gdb::unique_xmalloc_ptr<char> default_collect_line
2801 (xstrprintf ("collect %s", default_collect));
2803 validate_actionline (default_collect_line.get (), t);
2804 actions.reset (new struct command_line (simple_control,
2805 default_collect_line.release ()),
2806 command_lines_deleter ());
2812 /* The tdump command. */
2815 tdump_command (const char *args, int from_tty)
2817 int stepping_frame = 0;
2818 struct bp_location *loc;
2820 /* This throws an error is not inspecting a trace frame. */
2821 loc = get_traceframe_location (&stepping_frame);
2823 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2824 tracepoint_number, traceframe_number);
2826 /* This command only makes sense for the current frame, not the
2828 scoped_restore_current_thread restore_thread;
2830 select_frame (get_current_frame ());
2832 counted_command_line actions = all_tracepoint_actions (loc->owner);
2834 trace_dump_actions (actions.get (), 0, stepping_frame, from_tty);
2835 trace_dump_actions (breakpoint_commands (loc->owner), 0, stepping_frame,
2839 /* Encode a piece of a tracepoint's source-level definition in a form
2840 that is suitable for both protocol and saving in files. */
2841 /* This version does not do multiple encodes for long strings; it should
2842 return an offset to the next piece to encode. FIXME */
2845 encode_source_string (int tpnum, ULONGEST addr,
2846 const char *srctype, const char *src,
2847 char *buf, int buf_size)
2849 if (80 + strlen (srctype) > buf_size)
2850 error (_("Buffer too small for source encoding"));
2851 sprintf (buf, "%x:%s:%s:%x:%x:",
2852 tpnum, phex_nz (addr, sizeof (addr)),
2853 srctype, 0, (int) strlen (src));
2854 if (strlen (buf) + strlen (src) * 2 >= buf_size)
2855 error (_("Source string too long for buffer"));
2856 bin2hex ((gdb_byte *) src, buf + strlen (buf), strlen (src));
2860 /* Tell the target what to do with an ongoing tracing run if GDB
2861 disconnects for some reason. */
2864 set_disconnected_tracing (const char *args, int from_tty,
2865 struct cmd_list_element *c)
2867 target_set_disconnected_tracing (disconnected_tracing);
2871 set_circular_trace_buffer (const char *args, int from_tty,
2872 struct cmd_list_element *c)
2874 target_set_circular_trace_buffer (circular_trace_buffer);
2878 set_trace_buffer_size (const char *args, int from_tty,
2879 struct cmd_list_element *c)
2881 target_set_trace_buffer_size (trace_buffer_size);
2885 set_trace_user (const char *args, int from_tty,
2886 struct cmd_list_element *c)
2890 ret = target_set_trace_notes (trace_user, NULL, NULL);
2893 warning (_("Target does not support trace notes, user ignored"));
2897 set_trace_notes (const char *args, int from_tty,
2898 struct cmd_list_element *c)
2902 ret = target_set_trace_notes (NULL, trace_notes, NULL);
2905 warning (_("Target does not support trace notes, note ignored"));
2909 set_trace_stop_notes (const char *args, int from_tty,
2910 struct cmd_list_element *c)
2914 ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
2917 warning (_("Target does not support trace notes, stop note ignored"));
2920 /* Convert the memory pointed to by mem into hex, placing result in buf.
2921 * Return a pointer to the last char put in buf (null)
2922 * "stolen" from sparc-stub.c
2925 static const char hexchars[] = "0123456789abcdef";
2928 mem2hex (gdb_byte *mem, char *buf, int count)
2936 *buf++ = hexchars[ch >> 4];
2937 *buf++ = hexchars[ch & 0xf];
2946 get_traceframe_number (void)
2948 return traceframe_number;
2952 get_tracepoint_number (void)
2954 return tracepoint_number;
2957 /* Make the traceframe NUM be the current trace frame. Does nothing
2958 if NUM is already current. */
2961 set_current_traceframe (int num)
2965 if (traceframe_number == num)
2967 /* Nothing to do. */
2971 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
2974 warning (_("could not change traceframe"));
2976 set_traceframe_num (newnum);
2978 /* Changing the traceframe changes our view of registers and of the
2980 registers_changed ();
2982 clear_traceframe_info ();
2985 scoped_restore_current_traceframe::scoped_restore_current_traceframe ()
2986 : m_traceframe_number (traceframe_number)
2989 /* Given a number and address, return an uploaded tracepoint with that
2990 number, creating if necessary. */
2992 struct uploaded_tp *
2993 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
2995 struct uploaded_tp *utp;
2997 for (utp = *utpp; utp; utp = utp->next)
2998 if (utp->number == num && utp->addr == addr)
3001 utp = new uploaded_tp;
3011 free_uploaded_tps (struct uploaded_tp **utpp)
3013 struct uploaded_tp *next_one;
3017 next_one = (*utpp)->next;
3023 /* Given a number and address, return an uploaded tracepoint with that
3024 number, creating if necessary. */
3026 struct uploaded_tsv *
3027 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3029 struct uploaded_tsv *utsv;
3031 for (utsv = *utsvp; utsv; utsv = utsv->next)
3032 if (utsv->number == num)
3035 utsv = XCNEW (struct uploaded_tsv);
3037 utsv->next = *utsvp;
3044 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3046 struct uploaded_tsv *next_one;
3050 next_one = (*utsvp)->next;
3056 /* FIXME this function is heuristic and will miss the cases where the
3057 conditional is semantically identical but differs in whitespace,
3058 such as "x == 0" vs "x==0". */
3061 cond_string_is_same (char *str1, char *str2)
3063 if (str1 == NULL || str2 == NULL)
3064 return (str1 == str2);
3066 return (strcmp (str1, str2) == 0);
3069 /* Look for an existing tracepoint that seems similar enough to the
3070 uploaded one. Enablement isn't compared, because the user can
3071 toggle that freely, and may have done so in anticipation of the
3072 next trace run. Return the location of matched tracepoint. */
3074 static struct bp_location *
3075 find_matching_tracepoint_location (struct uploaded_tp *utp)
3077 struct bp_location *loc;
3079 for (breakpoint *b : all_tracepoints ())
3081 struct tracepoint *t = (struct tracepoint *) b;
3083 if (b->type == utp->type
3084 && t->step_count == utp->step
3085 && t->pass_count == utp->pass
3086 && cond_string_is_same (t->cond_string, utp->cond_string)
3087 /* FIXME also test actions. */
3090 /* Scan the locations for an address match. */
3091 for (loc = b->loc; loc; loc = loc->next)
3093 if (loc->address == utp->addr)
3101 /* Given a list of tracepoints uploaded from a target, attempt to
3102 match them up with existing tracepoints, and create new ones if not
3106 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3108 struct uploaded_tp *utp;
3109 /* A set of tracepoints which are modified. */
3110 std::vector<breakpoint *> modified_tp;
3112 /* Look for GDB tracepoints that match up with our uploaded versions. */
3113 for (utp = *uploaded_tps; utp; utp = utp->next)
3115 struct bp_location *loc;
3116 struct tracepoint *t;
3118 loc = find_matching_tracepoint_location (utp);
3123 /* Mark this location as already inserted. */
3125 t = (struct tracepoint *) loc->owner;
3126 printf_filtered (_("Assuming tracepoint %d is same "
3127 "as target's tracepoint %d at %s.\n"),
3128 loc->owner->number, utp->number,
3129 paddress (loc->gdbarch, utp->addr));
3131 /* The tracepoint LOC->owner was modified (the location LOC
3132 was marked as inserted in the target). Save it in
3133 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3134 observers will be notified later once for each tracepoint
3135 saved in MODIFIED_TP. */
3136 for (breakpoint *b : modified_tp)
3137 if (b == loc->owner)
3143 modified_tp.push_back (loc->owner);
3147 t = create_tracepoint_from_upload (utp);
3149 printf_filtered (_("Created tracepoint %d for "
3150 "target's tracepoint %d at %s.\n"),
3151 t->number, utp->number,
3152 paddress (get_current_arch (), utp->addr));
3154 printf_filtered (_("Failed to create tracepoint for target's "
3155 "tracepoint %d at %s, skipping it.\n"),
3157 paddress (get_current_arch (), utp->addr));
3159 /* Whether found or created, record the number used by the
3160 target, to help with mapping target tracepoints back to their
3161 counterparts here. */
3163 t->number_on_target = utp->number;
3166 /* Notify 'breakpoint-modified' observer that at least one of B's
3167 locations was changed. */
3168 for (breakpoint *b : modified_tp)
3169 gdb::observers::breakpoint_modified.notify (b);
3171 free_uploaded_tps (uploaded_tps);
3174 /* Trace state variables don't have much to identify them beyond their
3175 name, so just use that to detect matches. */
3177 static struct trace_state_variable *
3178 find_matching_tsv (struct uploaded_tsv *utsv)
3183 return find_trace_state_variable (utsv->name);
3186 static struct trace_state_variable *
3187 create_tsv_from_upload (struct uploaded_tsv *utsv)
3189 const char *namebase;
3192 struct trace_state_variable *tsv;
3196 namebase = utsv->name;
3202 buf = string_printf ("%s_%d", namebase, try_num++);
3205 /* Fish for a name that is not in use. */
3206 /* (should check against all internal vars?) */
3207 while (find_trace_state_variable (buf.c_str ()))
3208 buf = string_printf ("%s_%d", namebase, try_num++);
3210 /* We have an available name, create the variable. */
3211 tsv = create_trace_state_variable (buf.c_str ());
3212 tsv->initial_value = utsv->initial_value;
3213 tsv->builtin = utsv->builtin;
3215 gdb::observers::tsv_created.notify (tsv);
3220 /* Given a list of uploaded trace state variables, try to match them
3221 up with existing variables, or create additional ones. */
3224 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
3226 struct uploaded_tsv *utsv;
3227 struct trace_state_variable *tsv;
3230 /* Most likely some numbers will have to be reassigned as part of
3231 the merge, so clear them all in anticipation. */
3232 for (trace_state_variable &tsv : tvariables)
3235 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
3237 tsv = find_matching_tsv (utsv);
3241 printf_filtered (_("Assuming trace state variable $%s "
3242 "is same as target's variable %d.\n"),
3243 tsv->name.c_str (), utsv->number);
3247 tsv = create_tsv_from_upload (utsv);
3249 printf_filtered (_("Created trace state variable "
3250 "$%s for target's variable %d.\n"),
3251 tsv->name.c_str (), utsv->number);
3253 /* Give precedence to numberings that come from the target. */
3255 tsv->number = utsv->number;
3258 /* Renumber everything that didn't get a target-assigned number. */
3260 for (const trace_state_variable &tsv : tvariables)
3261 highest = std::max (tsv.number, highest);
3264 for (trace_state_variable &tsv : tvariables)
3265 if (tsv.number == 0)
3266 tsv.number = highest++;
3268 free_uploaded_tsvs (uploaded_tsvs);
3271 /* Parse the part of trace status syntax that is shared between
3272 the remote protocol and the trace file reader. */
3275 parse_trace_status (const char *line, struct trace_status *ts)
3277 const char *p = line, *p1, *p2, *p3, *p_temp;
3281 ts->running_known = 1;
3282 ts->running = (*p++ == '1');
3283 ts->stop_reason = trace_stop_reason_unknown;
3284 xfree (ts->stop_desc);
3285 ts->stop_desc = NULL;
3286 ts->traceframe_count = -1;
3287 ts->traceframes_created = -1;
3288 ts->buffer_free = -1;
3289 ts->buffer_size = -1;
3290 ts->disconnected_tracing = 0;
3291 ts->circular_buffer = 0;
3292 xfree (ts->user_name);
3293 ts->user_name = NULL;
3296 ts->start_time = ts->stop_time = 0;
3300 p1 = strchr (p, ':');
3302 error (_("Malformed trace status, at %s\n\
3303 Status line: '%s'\n"), p, line);
3304 p3 = strchr (p, ';');
3306 p3 = p + strlen (p);
3307 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3309 p = unpack_varlen_hex (++p1, &val);
3310 ts->stop_reason = trace_buffer_full;
3312 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3314 p = unpack_varlen_hex (++p1, &val);
3315 ts->stop_reason = trace_never_run;
3317 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
3320 p = unpack_varlen_hex (++p1, &val);
3321 ts->stop_reason = tracepoint_passcount;
3322 ts->stopping_tracepoint = val;
3324 else if (strncmp (p, stop_reason_names[trace_stop_command], p1 - p) == 0)
3326 p2 = strchr (++p1, ':');
3334 ts->stop_desc = (char *) xmalloc (strlen (line));
3335 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
3336 ts->stop_desc[end] = '\0';
3339 ts->stop_desc = xstrdup ("");
3341 p = unpack_varlen_hex (++p2, &val);
3342 ts->stop_reason = trace_stop_command;
3344 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3346 p = unpack_varlen_hex (++p1, &val);
3347 ts->stop_reason = trace_disconnected;
3349 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3351 p2 = strchr (++p1, ':');
3354 ts->stop_desc = (char *) xmalloc ((p2 - p1) / 2 + 1);
3355 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
3356 ts->stop_desc[end] = '\0';
3359 ts->stop_desc = xstrdup ("");
3361 p = unpack_varlen_hex (++p2, &val);
3362 ts->stopping_tracepoint = val;
3363 ts->stop_reason = tracepoint_error;
3365 else if (strncmp (p, "tframes", p1 - p) == 0)
3367 p = unpack_varlen_hex (++p1, &val);
3368 ts->traceframe_count = val;
3370 else if (strncmp (p, "tcreated", p1 - p) == 0)
3372 p = unpack_varlen_hex (++p1, &val);
3373 ts->traceframes_created = val;
3375 else if (strncmp (p, "tfree", p1 - p) == 0)
3377 p = unpack_varlen_hex (++p1, &val);
3378 ts->buffer_free = val;
3380 else if (strncmp (p, "tsize", p1 - p) == 0)
3382 p = unpack_varlen_hex (++p1, &val);
3383 ts->buffer_size = val;
3385 else if (strncmp (p, "disconn", p1 - p) == 0)
3387 p = unpack_varlen_hex (++p1, &val);
3388 ts->disconnected_tracing = val;
3390 else if (strncmp (p, "circular", p1 - p) == 0)
3392 p = unpack_varlen_hex (++p1, &val);
3393 ts->circular_buffer = val;
3395 else if (strncmp (p, "starttime", p1 - p) == 0)
3397 p = unpack_varlen_hex (++p1, &val);
3398 ts->start_time = val;
3400 else if (strncmp (p, "stoptime", p1 - p) == 0)
3402 p = unpack_varlen_hex (++p1, &val);
3403 ts->stop_time = val;
3405 else if (strncmp (p, "username", p1 - p) == 0)
3408 ts->user_name = (char *) xmalloc (strlen (p) / 2);
3409 end = hex2bin (p1, (gdb_byte *) ts->user_name, (p3 - p1) / 2);
3410 ts->user_name[end] = '\0';
3413 else if (strncmp (p, "notes", p1 - p) == 0)
3416 ts->notes = (char *) xmalloc (strlen (p) / 2);
3417 end = hex2bin (p1, (gdb_byte *) ts->notes, (p3 - p1) / 2);
3418 ts->notes[end] = '\0';
3423 /* Silently skip unknown optional info. */
3424 p_temp = strchr (p1 + 1, ';');
3428 /* Must be at the end. */
3435 parse_tracepoint_status (const char *p, struct breakpoint *bp,
3436 struct uploaded_tp *utp)
3439 struct tracepoint *tp = (struct tracepoint *) bp;
3441 p = unpack_varlen_hex (p, &uval);
3443 tp->hit_count += uval;
3445 utp->hit_count += uval;
3446 p = unpack_varlen_hex (p + 1, &uval);
3448 tp->traceframe_usage += uval;
3450 utp->traceframe_usage += uval;
3451 /* Ignore any extra, allowing for future extensions. */
3454 /* Given a line of text defining a part of a tracepoint, parse it into
3455 an "uploaded tracepoint". */
3458 parse_tracepoint_definition (const char *line, struct uploaded_tp **utpp)
3462 ULONGEST num, addr, step, pass, orig_size, xlen, start;
3465 const char *srctype;
3467 struct uploaded_tp *utp = NULL;
3470 /* Both tracepoint and action definitions start with the same number
3471 and address sequence. */
3473 p = unpack_varlen_hex (p, &num);
3474 p++; /* skip a colon */
3475 p = unpack_varlen_hex (p, &addr);
3476 p++; /* skip a colon */
3479 enabled = (*p++ == 'E');
3480 p++; /* skip a colon */
3481 p = unpack_varlen_hex (p, &step);
3482 p++; /* skip a colon */
3483 p = unpack_varlen_hex (p, &pass);
3484 type = bp_tracepoint;
3486 /* Thumb through optional fields. */
3489 p++; /* skip a colon */
3492 type = bp_fast_tracepoint;
3494 p = unpack_varlen_hex (p, &orig_size);
3498 type = bp_static_tracepoint;
3504 p = unpack_varlen_hex (p, &xlen);
3505 p++; /* skip a comma */
3506 cond = (char *) xmalloc (2 * xlen + 1);
3507 strncpy (cond, p, 2 * xlen);
3508 cond[2 * xlen] = '\0';
3512 warning (_("Unrecognized char '%c' in tracepoint "
3513 "definition, skipping rest"), *p);
3515 utp = get_uploaded_tp (num, addr, utpp);
3517 utp->enabled = enabled;
3522 else if (piece == 'A')
3524 utp = get_uploaded_tp (num, addr, utpp);
3525 utp->actions.push_back (xstrdup (p));
3527 else if (piece == 'S')
3529 utp = get_uploaded_tp (num, addr, utpp);
3530 utp->step_actions.push_back (xstrdup (p));
3532 else if (piece == 'Z')
3534 /* Parse a chunk of source form definition. */
3535 utp = get_uploaded_tp (num, addr, utpp);
3537 p = strchr (p, ':');
3538 p++; /* skip a colon */
3539 p = unpack_varlen_hex (p, &start);
3540 p++; /* skip a colon */
3541 p = unpack_varlen_hex (p, &xlen);
3542 p++; /* skip a colon */
3544 buf = (char *) alloca (strlen (line));
3546 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3549 if (startswith (srctype, "at:"))
3550 utp->at_string = xstrdup (buf);
3551 else if (startswith (srctype, "cond:"))
3552 utp->cond_string = xstrdup (buf);
3553 else if (startswith (srctype, "cmd:"))
3554 utp->cmd_strings.push_back (xstrdup (buf));
3556 else if (piece == 'V')
3558 utp = get_uploaded_tp (num, addr, utpp);
3560 parse_tracepoint_status (p, NULL, utp);
3564 /* Don't error out, the target might be sending us optional
3565 info that we don't care about. */
3566 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
3570 /* Convert a textual description of a trace state variable into an
3574 parse_tsv_definition (const char *line, struct uploaded_tsv **utsvp)
3578 ULONGEST num, initval, builtin;
3580 struct uploaded_tsv *utsv = NULL;
3582 buf = (char *) alloca (strlen (line));
3585 p = unpack_varlen_hex (p, &num);
3586 p++; /* skip a colon */
3587 p = unpack_varlen_hex (p, &initval);
3588 p++; /* skip a colon */
3589 p = unpack_varlen_hex (p, &builtin);
3590 p++; /* skip a colon */
3591 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3594 utsv = get_uploaded_tsv (num, utsvp);
3595 utsv->initial_value = initval;
3596 utsv->builtin = builtin;
3597 utsv->name = xstrdup (buf);
3600 /* Given a line of text defining a static tracepoint marker, parse it
3601 into a "static tracepoint marker" object. Throws an error is
3602 parsing fails. If PP is non-null, it points to one past the end of
3603 the parsed marker definition. */
3606 parse_static_tracepoint_marker_definition (const char *line, const char **pp,
3607 static_tracepoint_marker *marker)
3609 const char *p, *endp;
3613 p = unpack_varlen_hex (p, &addr);
3614 p++; /* skip a colon */
3616 marker->gdbarch = target_gdbarch ();
3617 marker->address = (CORE_ADDR) addr;
3619 endp = strchr (p, ':');
3621 error (_("bad marker definition: %s"), line);
3623 marker->str_id = hex2str (p, (endp - p) / 2);
3626 p++; /* skip a colon */
3628 /* This definition may be followed by another one, separated by a comma. */
3630 endp = strchr (p, ',');
3631 if (endp != nullptr)
3634 hex_len = strlen (p);
3636 marker->extra = hex2str (p, hex_len / 2);
3642 /* Print MARKER to gdb_stdout. */
3645 print_one_static_tracepoint_marker (int count,
3646 const static_tracepoint_marker &marker)
3650 char wrap_indent[80];
3651 char extra_field_indent[80];
3652 struct ui_out *uiout = current_uiout;
3654 symtab_and_line sal;
3655 sal.pc = marker.address;
3657 std::vector<breakpoint *> tracepoints
3658 = static_tracepoints_here (marker.address);
3660 ui_out_emit_tuple tuple_emitter (uiout, "marker");
3662 /* A counter field to help readability. This is not a stable
3664 uiout->field_int ("count", count);
3666 uiout->field_string ("marker-id", marker.str_id.c_str ());
3668 uiout->field_fmt ("enabled", "%c",
3669 !tracepoints.empty () ? 'y' : 'n');
3672 strcpy (wrap_indent, " ");
3674 if (gdbarch_addr_bit (marker.gdbarch) <= 32)
3675 strcat (wrap_indent, " ");
3677 strcat (wrap_indent, " ");
3679 strcpy (extra_field_indent, " ");
3681 uiout->field_core_addr ("addr", marker.gdbarch, marker.address);
3683 sal = find_pc_line (marker.address, 0);
3684 sym = find_pc_sect_function (marker.address, NULL);
3687 uiout->text ("in ");
3688 uiout->field_string ("func",
3689 SYMBOL_PRINT_NAME (sym));
3690 uiout->wrap_hint (wrap_indent);
3691 uiout->text (" at ");
3694 uiout->field_skip ("func");
3696 if (sal.symtab != NULL)
3698 uiout->field_string ("file",
3699 symtab_to_filename_for_display (sal.symtab));
3702 if (uiout->is_mi_like_p ())
3704 const char *fullname = symtab_to_fullname (sal.symtab);
3706 uiout->field_string ("fullname", fullname);
3709 uiout->field_skip ("fullname");
3711 uiout->field_int ("line", sal.line);
3715 uiout->field_skip ("fullname");
3716 uiout->field_skip ("line");
3720 uiout->text (extra_field_indent);
3721 uiout->text (_("Data: \""));
3722 uiout->field_string ("extra-data", marker.extra.c_str ());
3723 uiout->text ("\"\n");
3725 if (!tracepoints.empty ())
3730 ui_out_emit_tuple tuple_emitter (uiout, "tracepoints-at");
3732 uiout->text (extra_field_indent);
3733 uiout->text (_("Probed by static tracepoints: "));
3734 for (ix = 0; ix < tracepoints.size (); ix++)
3739 uiout->field_int ("tracepoint-id", tracepoints[ix]->number);
3743 if (uiout->is_mi_like_p ())
3744 uiout->field_int ("number-of-tracepoints", tracepoints.size ());
3751 info_static_tracepoint_markers_command (const char *arg, int from_tty)
3753 struct ui_out *uiout = current_uiout;
3754 std::vector<static_tracepoint_marker> markers
3755 = target_static_tracepoint_markers_by_strid (NULL);
3757 /* We don't have to check target_can_use_agent and agent's capability on
3758 static tracepoint here, in order to be compatible with older GDBserver.
3759 We don't check USE_AGENT is true or not, because static tracepoints
3760 don't work without in-process agent, so we don't bother users to type
3761 `set agent on' when to use static tracepoint. */
3763 ui_out_emit_table table_emitter (uiout, 5, -1,
3764 "StaticTracepointMarkersTable");
3766 uiout->table_header (7, ui_left, "counter", "Cnt");
3768 uiout->table_header (40, ui_left, "marker-id", "ID");
3770 uiout->table_header (3, ui_left, "enabled", "Enb");
3771 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
3772 uiout->table_header (10, ui_left, "addr", "Address");
3774 uiout->table_header (18, ui_left, "addr", "Address");
3775 uiout->table_header (40, ui_noalign, "what", "What");
3777 uiout->table_body ();
3779 for (int i = 0; i < markers.size (); i++)
3780 print_one_static_tracepoint_marker (i + 1, markers[i]);
3783 /* The $_sdata convenience variable is a bit special. We don't know
3784 for sure type of the value until we actually have a chance to fetch
3785 the data --- the size of the object depends on what has been
3786 collected. We solve this by making $_sdata be an internalvar that
3787 creates a new value on access. */
3789 /* Return a new value with the correct type for the sdata object of
3790 the current trace frame. Return a void value if there's no object
3793 static struct value *
3794 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
3797 /* We need to read the whole object before we know its size. */
3798 gdb::optional<gdb::byte_vector> buf
3799 = target_read_alloc (current_top_target (), TARGET_OBJECT_STATIC_TRACE_DATA,
3806 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
3808 v = allocate_value (type);
3809 memcpy (value_contents_raw (v), buf->data (), buf->size ());
3813 return allocate_value (builtin_type (gdbarch)->builtin_void);
3816 #if !defined(HAVE_LIBEXPAT)
3818 struct std::unique_ptr<traceframe_info>
3819 parse_traceframe_info (const char *tframe_info)
3821 static int have_warned;
3826 warning (_("Can not parse XML trace frame info; XML support "
3827 "was disabled at compile time"));
3833 #else /* HAVE_LIBEXPAT */
3835 #include "xml-support.h"
3837 /* Handle the start of a <memory> element. */
3840 traceframe_info_start_memory (struct gdb_xml_parser *parser,
3841 const struct gdb_xml_element *element,
3843 std::vector<gdb_xml_value> &attributes)
3845 struct traceframe_info *info = (struct traceframe_info *) user_data;
3846 ULONGEST *start_p, *length_p;
3849 = (ULONGEST *) xml_find_attribute (attributes, "start")->value.get ();
3851 = (ULONGEST *) xml_find_attribute (attributes, "length")->value.get ();
3853 info->memory.emplace_back (*start_p, *length_p);
3856 /* Handle the start of a <tvar> element. */
3859 traceframe_info_start_tvar (struct gdb_xml_parser *parser,
3860 const struct gdb_xml_element *element,
3862 std::vector<gdb_xml_value> &attributes)
3864 struct traceframe_info *info = (struct traceframe_info *) user_data;
3865 const char *id_attrib
3866 = (const char *) xml_find_attribute (attributes, "id")->value.get ();
3867 int id = gdb_xml_parse_ulongest (parser, id_attrib);
3869 info->tvars.push_back (id);
3872 /* The allowed elements and attributes for an XML memory map. */
3874 static const struct gdb_xml_attribute memory_attributes[] = {
3875 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
3876 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
3877 { NULL, GDB_XML_AF_NONE, NULL, NULL }
3880 static const struct gdb_xml_attribute tvar_attributes[] = {
3881 { "id", GDB_XML_AF_NONE, NULL, NULL },
3882 { NULL, GDB_XML_AF_NONE, NULL, NULL }
3885 static const struct gdb_xml_element traceframe_info_children[] = {
3886 { "memory", memory_attributes, NULL,
3887 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
3888 traceframe_info_start_memory, NULL },
3889 { "tvar", tvar_attributes, NULL,
3890 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
3891 traceframe_info_start_tvar, NULL },
3892 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
3895 static const struct gdb_xml_element traceframe_info_elements[] = {
3896 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
3898 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
3901 /* Parse a traceframe-info XML document. */
3904 parse_traceframe_info (const char *tframe_info)
3906 traceframe_info_up result (new traceframe_info);
3908 if (gdb_xml_parse_quick (_("trace frame info"),
3909 "traceframe-info.dtd", traceframe_info_elements,
3910 tframe_info, result.get ()) == 0)
3916 #endif /* HAVE_LIBEXPAT */
3918 /* Returns the traceframe_info object for the current traceframe.
3919 This is where we avoid re-fetching the object from the target if we
3920 already have it cached. */
3922 struct traceframe_info *
3923 get_traceframe_info (void)
3925 if (current_traceframe_info == NULL)
3926 current_traceframe_info = target_traceframe_info ();
3928 return current_traceframe_info.get ();
3931 /* If the target supports the query, return in RESULT the set of
3932 collected memory in the current traceframe, found within the LEN
3933 bytes range starting at MEMADDR. Returns true if the target
3934 supports the query, otherwise returns false, and RESULT is left
3938 traceframe_available_memory (std::vector<mem_range> *result,
3939 CORE_ADDR memaddr, ULONGEST len)
3941 struct traceframe_info *info = get_traceframe_info ();
3947 for (mem_range &r : info->memory)
3948 if (mem_ranges_overlap (r.start, r.length, memaddr, len))
3950 ULONGEST lo1, hi1, lo2, hi2;
3953 hi1 = memaddr + len;
3956 hi2 = r.start + r.length;
3958 CORE_ADDR start = std::max (lo1, lo2);
3959 int length = std::min (hi1, hi2) - start;
3961 result->emplace_back (start, length);
3964 normalize_mem_ranges (result);
3971 /* Implementation of `sdata' variable. */
3973 static const struct internalvar_funcs sdata_funcs =
3980 /* See tracepoint.h. */
3981 cmd_list_element *while_stepping_cmd_element = nullptr;
3983 /* module initialization */
3985 _initialize_tracepoint (void)
3987 struct cmd_list_element *c;
3989 /* Explicitly create without lookup, since that tries to create a
3990 value with a void typed value, and when we get here, gdbarch
3991 isn't initialized yet. At this point, we're quite sure there
3992 isn't another convenience variable of the same name. */
3993 create_internalvar_type_lazy ("_sdata", &sdata_funcs, NULL);
3995 traceframe_number = -1;
3996 tracepoint_number = -1;
3998 add_info ("scope", info_scope_command,
3999 _("List the variables local to a scope"));
4001 add_cmd ("tracepoints", class_trace,
4002 _("Tracing of program execution without stopping the program."),
4005 add_com ("tdump", class_trace, tdump_command,
4006 _("Print everything collected at the current tracepoint."));
4008 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
4009 Define a trace state variable.\n\
4010 Argument is a $-prefixed name, optionally followed\n\
4011 by '=' and an expression that sets the initial value\n\
4012 at the start of tracing."));
4013 set_cmd_completer (c, expression_completer);
4015 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
4016 Delete one or more trace state variables.\n\
4017 Arguments are the names of the variables to delete.\n\
4018 If no arguments are supplied, delete all variables."), &deletelist);
4019 /* FIXME add a trace variable completer. */
4021 add_info ("tvariables", info_tvariables_command, _("\
4022 Status of trace state variables and their values.\n\
4025 add_info ("static-tracepoint-markers",
4026 info_static_tracepoint_markers_command, _("\
4027 List target static tracepoints markers.\n\
4030 add_prefix_cmd ("tfind", class_trace, tfind_command, _("\
4031 Select a trace frame;\n\
4032 No argument means forward by one frame; '-' means backward by one frame."),
4033 &tfindlist, "tfind ", 1, &cmdlist);
4035 add_cmd ("outside", class_trace, tfind_outside_command, _("\
4036 Select a trace frame whose PC is outside the given range (exclusive).\n\
4037 Usage: tfind outside ADDR1, ADDR2"),
4040 add_cmd ("range", class_trace, tfind_range_command, _("\
4041 Select a trace frame whose PC is in the given range (inclusive).\n\
4042 Usage: tfind range ADDR1, ADDR2"),
4045 add_cmd ("line", class_trace, tfind_line_command, _("\
4046 Select a trace frame by source line.\n\
4047 Argument can be a line number (with optional source file),\n\
4048 a function name, or '*' followed by an address.\n\
4049 Default argument is 'the next source line that was traced'."),
4052 add_cmd ("tracepoint", class_trace, tfind_tracepoint_command, _("\
4053 Select a trace frame by tracepoint number.\n\
4054 Default is the tracepoint for the current trace frame."),
4057 add_cmd ("pc", class_trace, tfind_pc_command, _("\
4058 Select a trace frame by PC.\n\
4059 Default is the current PC, or the PC of the current trace frame."),
4062 add_cmd ("end", class_trace, tfind_end_command, _("\
4063 De-select any trace frame and resume 'live' debugging."),
4066 add_alias_cmd ("none", "end", class_trace, 0, &tfindlist);
4068 add_cmd ("start", class_trace, tfind_start_command,
4069 _("Select the first trace frame in the trace buffer."),
4072 add_com ("tstatus", class_trace, tstatus_command,
4073 _("Display the status of the current trace data collection."));
4075 add_com ("tstop", class_trace, tstop_command, _("\
4076 Stop trace data collection.\n\
4077 Usage: tstop [NOTES]...\n\
4078 Any arguments supplied are recorded with the trace as a stop reason and\n\
4079 reported by tstatus (if the target supports trace notes)."));
4081 add_com ("tstart", class_trace, tstart_command, _("\
4082 Start trace data collection.\n\
4083 Usage: tstart [NOTES]...\n\
4084 Any arguments supplied are recorded with the trace as a note and\n\
4085 reported by tstatus (if the target supports trace notes)."));
4087 add_com ("end", class_trace, end_actions_pseudocommand, _("\
4088 Ends a list of commands or actions.\n\
4089 Several GDB commands allow you to enter a list of commands or actions.\n\
4090 Entering \"end\" on a line by itself is the normal way to terminate\n\
4092 Note: the \"end\" command cannot be used at the gdb prompt."));
4094 while_stepping_cmd_element = add_com ("while-stepping", class_trace,
4095 while_stepping_pseudocommand, _("\
4096 Specify single-stepping behavior at a tracepoint.\n\
4097 Argument is number of instructions to trace in single-step mode\n\
4098 following the tracepoint. This command is normally followed by\n\
4099 one or more \"collect\" commands, to specify what to collect\n\
4100 while single-stepping.\n\n\
4101 Note: this command can only be used in a tracepoint \"actions\" list."));
4103 add_com_alias ("ws", "while-stepping", class_alias, 0);
4104 add_com_alias ("stepping", "while-stepping", class_alias, 0);
4106 add_com ("collect", class_trace, collect_pseudocommand, _("\
4107 Specify one or more data items to be collected at a tracepoint.\n\
4108 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4109 collect all data (variables, registers) referenced by that expression.\n\
4110 Also accepts the following special arguments:\n\
4111 $regs -- all registers.\n\
4112 $args -- all function arguments.\n\
4113 $locals -- all variables local to the block/function scope.\n\
4114 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4115 Note: this command can only be used in a tracepoint \"actions\" list."));
4117 add_com ("teval", class_trace, teval_pseudocommand, _("\
4118 Specify one or more expressions to be evaluated at a tracepoint.\n\
4119 Accepts a comma-separated list of (one or more) expressions.\n\
4120 The result of each evaluation will be discarded.\n\
4121 Note: this command can only be used in a tracepoint \"actions\" list."));
4123 add_com ("actions", class_trace, actions_command, _("\
4124 Specify the actions to be taken at a tracepoint.\n\
4125 Tracepoint actions may include collecting of specified data,\n\
4126 single-stepping, or enabling/disabling other tracepoints,\n\
4127 depending on target's capabilities."));
4129 default_collect = xstrdup ("");
4130 add_setshow_string_cmd ("default-collect", class_trace,
4131 &default_collect, _("\
4132 Set the list of expressions to collect by default"), _("\
4133 Show the list of expressions to collect by default"), NULL,
4135 &setlist, &showlist);
4137 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
4138 &disconnected_tracing, _("\
4139 Set whether tracing continues after GDB disconnects."), _("\
4140 Show whether tracing continues after GDB disconnects."), _("\
4141 Use this to continue a tracing run even if GDB disconnects\n\
4142 or detaches from the target. You can reconnect later and look at\n\
4143 trace data collected in the meantime."),
4144 set_disconnected_tracing,
4149 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
4150 &circular_trace_buffer, _("\
4151 Set target's use of circular trace buffer."), _("\
4152 Show target's use of circular trace buffer."), _("\
4153 Use this to make the trace buffer into a circular buffer,\n\
4154 which will discard traceframes (oldest first) instead of filling\n\
4155 up and stopping the trace run."),
4156 set_circular_trace_buffer,
4161 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class,
4162 &trace_buffer_size, _("\
4163 Set requested size of trace buffer."), _("\
4164 Show requested size of trace buffer."), _("\
4165 Use this to choose a size for the trace buffer. Some targets\n\
4166 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
4167 disables any attempt to set the buffer size and lets the target choose."),
4168 set_trace_buffer_size, NULL,
4169 &setlist, &showlist);
4171 add_setshow_string_cmd ("trace-user", class_trace,
4173 Set the user name to use for current and future trace runs"), _("\
4174 Show the user name to use for current and future trace runs"), NULL,
4175 set_trace_user, NULL,
4176 &setlist, &showlist);
4178 add_setshow_string_cmd ("trace-notes", class_trace,
4180 Set notes string to use for current and future trace runs"), _("\
4181 Show the notes string to use for current and future trace runs"), NULL,
4182 set_trace_notes, NULL,
4183 &setlist, &showlist);
4185 add_setshow_string_cmd ("trace-stop-notes", class_trace,
4186 &trace_stop_notes, _("\
4187 Set notes string to use for future tstop commands"), _("\
4188 Show the notes string to use for future tstop commands"), NULL,
4189 set_trace_stop_notes, NULL,
4190 &setlist, &showlist);