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);
825 if (regno >= (8 * sizeof (m_regs_mask)))
826 error (_("Internal: register number %d too large for tracepoint"),
828 m_regs_mask[regno / 8] |= 1 << (regno % 8);
831 /* Add all the registers from the mask in AEXPR to the mask in the
832 collection list. Registers in the AEXPR mask are already remote
836 collection_list::add_ax_registers (struct agent_expr *aexpr)
838 if (aexpr->reg_mask_len > 0)
840 for (int ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
842 QUIT; /* Allow user to bail out with ^C. */
843 if (aexpr->reg_mask[ndx1] != 0)
845 /* Assume chars have 8 bits. */
846 for (int ndx2 = 0; ndx2 < 8; ndx2++)
847 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
848 /* It's used -- record it. */
849 add_remote_register (ndx1 * 8 + ndx2);
855 /* If REGNO is raw, add its corresponding remote register number to
856 the mask. If REGNO is a pseudo-register, figure out the necessary
857 registers using a temporary agent expression, and add it to the
858 list if it needs more than just a mask. */
861 collection_list::add_local_register (struct gdbarch *gdbarch,
865 if (regno < gdbarch_num_regs (gdbarch))
867 int remote_regno = gdbarch_remote_register_number (gdbarch, regno);
869 if (remote_regno < 0)
870 error (_("Can't collect register %d"), regno);
872 add_remote_register (remote_regno);
876 agent_expr_up aexpr (new agent_expr (gdbarch, scope));
878 ax_reg_mask (aexpr.get (), regno);
880 finalize_tracepoint_aexpr (aexpr.get ());
882 add_ax_registers (aexpr.get ());
884 /* Usually ax_reg_mask for a pseudo-regiser only sets the
885 corresponding raw registers in the ax mask, but if this isn't
886 the case add the expression that is generated to the
889 add_aexpr (std::move (aexpr));
893 /* Add a memrange to a collection list. */
896 collection_list::add_memrange (struct gdbarch *gdbarch,
897 int type, bfd_signed_vma base,
898 unsigned long len, CORE_ADDR scope)
901 printf_filtered ("(%d,%s,%ld)\n", type, paddress (gdbarch, base), len);
903 /* type: memrange_absolute == memory, other n == basereg */
904 /* base: addr if memory, offset if reg relative. */
905 /* len: we actually save end (base + len) for convenience */
906 m_memranges.emplace_back (type, base, base + len);
908 if (type != memrange_absolute) /* Better collect the base register! */
909 add_local_register (gdbarch, type, scope);
912 /* Add a symbol to a collection list. */
915 collection_list::collect_symbol (struct symbol *sym,
916 struct gdbarch *gdbarch,
917 long frame_regno, long frame_offset,
923 bfd_signed_vma offset;
924 int treat_as_expr = 0;
926 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
927 switch (SYMBOL_CLASS (sym))
930 printf_filtered ("%s: don't know symbol class %d\n",
931 SYMBOL_PRINT_NAME (sym),
935 printf_filtered ("constant %s (value %s) will not be collected.\n",
936 SYMBOL_PRINT_NAME (sym), plongest (SYMBOL_VALUE (sym)));
939 offset = SYMBOL_VALUE_ADDRESS (sym);
942 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
943 SYMBOL_PRINT_NAME (sym), len,
944 paddress (gdbarch, offset));
946 /* A struct may be a C++ class with static fields, go to general
947 expression handling. */
948 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
951 add_memrange (gdbarch, memrange_absolute, offset, len, scope);
954 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
956 printf_filtered ("LOC_REG[parm] %s: ",
957 SYMBOL_PRINT_NAME (sym));
958 add_local_register (gdbarch, reg, scope);
959 /* Check for doubles stored in two registers. */
960 /* FIXME: how about larger types stored in 3 or more regs? */
961 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
962 len > register_size (gdbarch, reg))
963 add_local_register (gdbarch, reg + 1, scope);
966 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
967 printf_filtered (" (will not collect %s)\n",
968 SYMBOL_PRINT_NAME (sym));
972 offset = frame_offset + SYMBOL_VALUE (sym);
975 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
976 " from frame ptr reg %d\n",
977 SYMBOL_PRINT_NAME (sym), len,
978 paddress (gdbarch, offset), reg);
980 add_memrange (gdbarch, reg, offset, len, scope);
982 case LOC_REGPARM_ADDR:
983 reg = SYMBOL_VALUE (sym);
987 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset %s"
989 SYMBOL_PRINT_NAME (sym), len,
990 paddress (gdbarch, offset), reg);
992 add_memrange (gdbarch, reg, offset, len, scope);
996 offset = frame_offset + SYMBOL_VALUE (sym);
999 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset %s"
1000 " from frame ptr reg %d\n",
1001 SYMBOL_PRINT_NAME (sym), len,
1002 paddress (gdbarch, offset), reg);
1004 add_memrange (gdbarch, reg, offset, len, scope);
1007 case LOC_UNRESOLVED:
1011 case LOC_OPTIMIZED_OUT:
1012 printf_filtered ("%s has been optimized out of existence.\n",
1013 SYMBOL_PRINT_NAME (sym));
1021 /* Expressions are the most general case. */
1024 agent_expr_up aexpr = gen_trace_for_var (scope, gdbarch,
1027 /* It can happen that the symbol is recorded as a computed
1028 location, but it's been optimized away and doesn't actually
1029 have a location expression. */
1032 printf_filtered ("%s has been optimized out of existence.\n",
1033 SYMBOL_PRINT_NAME (sym));
1037 finalize_tracepoint_aexpr (aexpr.get ());
1039 /* Take care of the registers. */
1040 add_ax_registers (aexpr.get ());
1042 add_aexpr (std::move (aexpr));
1046 /* Data to be passed around in the calls to the locals and args
1049 struct add_local_symbols_data
1051 struct collection_list *collect;
1052 struct gdbarch *gdbarch;
1060 /* The callback for the locals and args iterators. */
1063 do_collect_symbol (const char *print_name,
1067 struct add_local_symbols_data *p = (struct add_local_symbols_data *) cb_data;
1069 p->collect->collect_symbol (sym, p->gdbarch, p->frame_regno,
1070 p->frame_offset, p->pc, p->trace_string);
1073 p->collect->add_wholly_collected (print_name);
1077 collection_list::add_wholly_collected (const char *print_name)
1079 m_wholly_collected.push_back (print_name);
1082 /* Add all locals (or args) symbols to collection list. */
1085 collection_list::add_local_symbols (struct gdbarch *gdbarch, CORE_ADDR pc,
1086 long frame_regno, long frame_offset, int type,
1089 const struct block *block;
1090 struct add_local_symbols_data cb_data;
1092 cb_data.collect = this;
1093 cb_data.gdbarch = gdbarch;
1095 cb_data.frame_regno = frame_regno;
1096 cb_data.frame_offset = frame_offset;
1098 cb_data.trace_string = trace_string;
1102 block = block_for_pc (pc);
1105 warning (_("Can't collect locals; "
1106 "no symbol table info available.\n"));
1110 iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1111 if (cb_data.count == 0)
1112 warning (_("No locals found in scope."));
1116 pc = get_pc_function_start (pc);
1117 block = block_for_pc (pc);
1120 warning (_("Can't collect args; no symbol table info available."));
1124 iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1125 if (cb_data.count == 0)
1126 warning (_("No args found in scope."));
1131 collection_list::add_static_trace_data ()
1134 printf_filtered ("collect static trace data\n");
1135 m_strace_data = true;
1138 collection_list::collection_list ()
1140 m_strace_data (false)
1142 m_memranges.reserve (128);
1143 m_aexprs.reserve (128);
1146 /* Reduce a collection list to string form (for gdb protocol). */
1148 std::vector<std::string>
1149 collection_list::stringify ()
1151 char temp_buf[2048];
1155 std::vector<std::string> str_list;
1160 printf_filtered ("\nCollecting static trace data\n");
1163 str_list.emplace_back (temp_buf, end - temp_buf);
1166 for (i = sizeof (m_regs_mask) - 1; i > 0; i--)
1167 if (m_regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */
1169 if (m_regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
1172 printf_filtered ("\nCollecting registers (mask): 0x");
1177 QUIT; /* Allow user to bail out with ^C. */
1179 printf_filtered ("%02X", m_regs_mask[i]);
1180 sprintf (end, "%02X", m_regs_mask[i]);
1183 str_list.emplace_back (temp_buf);
1186 printf_filtered ("\n");
1187 if (!m_memranges.empty () && info_verbose)
1188 printf_filtered ("Collecting memranges: \n");
1189 for (i = 0, count = 0, end = temp_buf; i < m_memranges.size (); i++)
1191 QUIT; /* Allow user to bail out with ^C. */
1194 printf_filtered ("(%d, %s, %ld)\n",
1195 m_memranges[i].type,
1196 paddress (target_gdbarch (),
1197 m_memranges[i].start),
1198 (long) (m_memranges[i].end
1199 - m_memranges[i].start));
1201 if (count + 27 > MAX_AGENT_EXPR_LEN)
1203 str_list.emplace_back (temp_buf, count);
1209 bfd_signed_vma length
1210 = m_memranges[i].end - m_memranges[i].start;
1212 /* The "%X" conversion specifier expects an unsigned argument,
1213 so passing -1 (memrange_absolute) to it directly gives you
1214 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1216 if (m_memranges[i].type == memrange_absolute)
1217 sprintf (end, "M-1,%s,%lX", phex_nz (m_memranges[i].start, 0),
1220 sprintf (end, "M%X,%s,%lX", m_memranges[i].type,
1221 phex_nz (m_memranges[i].start, 0), (long) length);
1224 count += strlen (end);
1225 end = temp_buf + count;
1228 for (i = 0; i < m_aexprs.size (); i++)
1230 QUIT; /* Allow user to bail out with ^C. */
1231 if ((count + 10 + 2 * m_aexprs[i]->len) > MAX_AGENT_EXPR_LEN)
1233 str_list.emplace_back (temp_buf, count);
1237 sprintf (end, "X%08X,", m_aexprs[i]->len);
1238 end += 10; /* 'X' + 8 hex digits + ',' */
1241 end = mem2hex (m_aexprs[i]->buf, end, m_aexprs[i]->len);
1242 count += 2 * m_aexprs[i]->len;
1247 str_list.emplace_back (temp_buf, count);
1255 /* Add the printed expression EXP to *LIST. */
1258 collection_list::append_exp (struct expression *exp)
1260 string_file tmp_stream;
1262 print_expression (exp, &tmp_stream);
1264 m_computed.push_back (std::move (tmp_stream.string ()));
1268 collection_list::finish ()
1270 memrange_sortmerge (m_memranges);
1274 encode_actions_1 (struct command_line *action,
1275 struct bp_location *tloc,
1277 LONGEST frame_offset,
1278 struct collection_list *collect,
1279 struct collection_list *stepping_list)
1281 const char *action_exp;
1283 struct value *tempval;
1284 struct cmd_list_element *cmd;
1286 for (; action; action = action->next)
1288 QUIT; /* Allow user to bail out with ^C. */
1289 action_exp = action->line;
1290 action_exp = skip_spaces (action_exp);
1292 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1294 error (_("Bad action list item: %s"), action_exp);
1296 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1298 int trace_string = 0;
1300 if (*action_exp == '/')
1301 action_exp = decode_agent_options (action_exp, &trace_string);
1304 { /* Repeat over a comma-separated list. */
1305 QUIT; /* Allow user to bail out with ^C. */
1306 action_exp = skip_spaces (action_exp);
1308 if (0 == strncasecmp ("$reg", action_exp, 4))
1310 for (i = 0; i < gdbarch_num_regs (target_gdbarch ());
1313 int remote_regno = (gdbarch_remote_register_number
1314 (target_gdbarch (), i));
1316 /* Ignore arch regnos without a corresponding
1317 remote regno. This can happen for regnos not
1319 if (remote_regno >= 0)
1320 collect->add_remote_register (remote_regno);
1322 action_exp = strchr (action_exp, ','); /* more? */
1324 else if (0 == strncasecmp ("$arg", action_exp, 4))
1326 collect->add_local_symbols (target_gdbarch (),
1332 action_exp = strchr (action_exp, ','); /* more? */
1334 else if (0 == strncasecmp ("$loc", action_exp, 4))
1336 collect->add_local_symbols (target_gdbarch (),
1342 action_exp = strchr (action_exp, ','); /* more? */
1344 else if (0 == strncasecmp ("$_ret", action_exp, 5))
1347 = gen_trace_for_return_address (tloc->address,
1351 finalize_tracepoint_aexpr (aexpr.get ());
1353 /* take care of the registers */
1354 collect->add_ax_registers (aexpr.get ());
1356 collect->add_aexpr (std::move (aexpr));
1357 action_exp = strchr (action_exp, ','); /* more? */
1359 else if (0 == strncasecmp ("$_sdata", action_exp, 7))
1361 collect->add_static_trace_data ();
1362 action_exp = strchr (action_exp, ','); /* more? */
1368 expression_up exp = parse_exp_1 (&action_exp, tloc->address,
1369 block_for_pc (tloc->address),
1372 switch (exp->elts[0].opcode)
1376 const char *name = &exp->elts[2].string;
1378 i = user_reg_map_name_to_regnum (target_gdbarch (),
1379 name, strlen (name));
1381 internal_error (__FILE__, __LINE__,
1382 _("Register $%s not available"),
1385 printf_filtered ("OP_REGISTER: ");
1386 collect->add_local_register (target_gdbarch (),
1392 /* Safe because we know it's a simple expression. */
1393 tempval = evaluate_expression (exp.get ());
1394 addr = value_address (tempval);
1395 /* Initialize the TYPE_LENGTH if it is a typedef. */
1396 check_typedef (exp->elts[1].type);
1397 collect->add_memrange (target_gdbarch (),
1398 memrange_absolute, addr,
1399 TYPE_LENGTH (exp->elts[1].type),
1401 collect->append_exp (exp.get ());
1406 struct symbol *sym = exp->elts[2].symbol;
1407 const char *name = SYMBOL_NATURAL_NAME (sym);
1409 collect->collect_symbol (exp->elts[2].symbol,
1415 collect->add_wholly_collected (name);
1419 default: /* Full-fledged expression. */
1420 agent_expr_up aexpr = gen_trace_for_expr (tloc->address,
1424 finalize_tracepoint_aexpr (aexpr.get ());
1426 /* Take care of the registers. */
1427 collect->add_ax_registers (aexpr.get ());
1429 collect->add_aexpr (std::move (aexpr));
1430 collect->append_exp (exp.get ());
1435 while (action_exp && *action_exp++ == ',');
1437 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1440 { /* Repeat over a comma-separated list. */
1441 QUIT; /* Allow user to bail out with ^C. */
1442 action_exp = skip_spaces (action_exp);
1445 expression_up exp = parse_exp_1 (&action_exp, tloc->address,
1446 block_for_pc (tloc->address),
1449 agent_expr_up aexpr = gen_eval_for_expr (tloc->address,
1452 finalize_tracepoint_aexpr (aexpr.get ());
1454 /* Even though we're not officially collecting, add
1455 to the collect list anyway. */
1456 collect->add_aexpr (std::move (aexpr));
1459 while (action_exp && *action_exp++ == ',');
1461 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1463 /* We check against nested while-stepping when setting
1464 breakpoint action, so no way to run into nested
1466 gdb_assert (stepping_list);
1468 encode_actions_1 (action->body_list_0.get (), tloc, frame_reg,
1469 frame_offset, stepping_list, NULL);
1472 error (_("Invalid tracepoint command '%s'"), action->line);
1476 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1477 and STEPPING_LIST. */
1480 encode_actions (struct bp_location *tloc,
1481 struct collection_list *tracepoint_list,
1482 struct collection_list *stepping_list)
1485 LONGEST frame_offset;
1487 gdbarch_virtual_frame_pointer (tloc->gdbarch,
1488 tloc->address, &frame_reg, &frame_offset);
1490 counted_command_line actions = all_tracepoint_actions (tloc->owner);
1491 encode_actions_1 (actions.get (), tloc, frame_reg, frame_offset,
1492 tracepoint_list, stepping_list);
1493 encode_actions_1 (breakpoint_commands (tloc->owner), tloc,
1494 frame_reg, frame_offset, tracepoint_list, stepping_list);
1496 tracepoint_list->finish ();
1497 stepping_list->finish ();
1500 /* Render all actions into gdb protocol. */
1503 encode_actions_rsp (struct bp_location *tloc,
1504 std::vector<std::string> *tdp_actions,
1505 std::vector<std::string> *stepping_actions)
1507 struct collection_list tracepoint_list, stepping_list;
1509 encode_actions (tloc, &tracepoint_list, &stepping_list);
1511 *tdp_actions = tracepoint_list.stringify ();
1512 *stepping_actions = stepping_list.stringify ();
1516 collection_list::add_aexpr (agent_expr_up aexpr)
1518 m_aexprs.push_back (std::move (aexpr));
1522 process_tracepoint_on_disconnect (void)
1524 int has_pending_p = 0;
1526 /* Check whether we still have pending tracepoint. If we have, warn the
1527 user that pending tracepoint will no longer work. */
1528 for (breakpoint *b : all_tracepoints ())
1537 struct bp_location *loc1;
1539 for (loc1 = b->loc; loc1; loc1 = loc1->next)
1541 if (loc1->shlib_disabled)
1554 warning (_("Pending tracepoints will not be resolved while"
1555 " GDB is disconnected\n"));
1558 /* Reset local state of tracing. */
1561 trace_reset_local_state (void)
1563 set_traceframe_num (-1);
1564 set_tracepoint_num (-1);
1565 set_traceframe_context (NULL);
1566 clear_traceframe_info ();
1570 start_tracing (const char *notes)
1572 int any_enabled = 0, num_to_download = 0;
1575 std::vector<breakpoint *> tp_vec = all_tracepoints ();
1577 /* No point in tracing without any tracepoints... */
1578 if (tp_vec.empty ())
1579 error (_("No tracepoints defined, not starting trace"));
1581 for (breakpoint *b : tp_vec)
1583 if (b->enable_state == bp_enabled)
1586 if ((b->type == bp_fast_tracepoint
1587 ? may_insert_fast_tracepoints
1588 : may_insert_tracepoints))
1591 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1592 (b->type == bp_fast_tracepoint ? "fast " : ""), b->number);
1597 if (target_supports_enable_disable_tracepoint ())
1598 warning (_("No tracepoints enabled"));
1601 /* No point in tracing with only disabled tracepoints that
1602 cannot be re-enabled. */
1603 error (_("No tracepoints enabled, not starting trace"));
1607 if (num_to_download <= 0)
1608 error (_("No tracepoints that may be downloaded, not starting trace"));
1610 target_trace_init ();
1612 for (breakpoint *b : tp_vec)
1614 struct tracepoint *t = (struct tracepoint *) b;
1615 struct bp_location *loc;
1616 int bp_location_downloaded = 0;
1618 /* Clear `inserted' flag. */
1619 for (loc = b->loc; loc; loc = loc->next)
1622 if ((b->type == bp_fast_tracepoint
1623 ? !may_insert_fast_tracepoints
1624 : !may_insert_tracepoints))
1627 t->number_on_target = 0;
1629 for (loc = b->loc; loc; loc = loc->next)
1631 /* Since tracepoint locations are never duplicated, `inserted'
1632 flag should be zero. */
1633 gdb_assert (!loc->inserted);
1635 target_download_tracepoint (loc);
1638 bp_location_downloaded = 1;
1641 t->number_on_target = b->number;
1643 for (loc = b->loc; loc; loc = loc->next)
1644 if (loc->probe.prob != NULL)
1645 loc->probe.prob->set_semaphore (loc->probe.objfile,
1648 if (bp_location_downloaded)
1649 gdb::observers::breakpoint_modified.notify (b);
1652 /* Send down all the trace state variables too. */
1653 for (const trace_state_variable &tsv : tvariables)
1654 target_download_trace_state_variable (tsv);
1656 /* Tell target to treat text-like sections as transparent. */
1657 target_trace_set_readonly_regions ();
1658 /* Set some mode flags. */
1659 target_set_disconnected_tracing (disconnected_tracing);
1660 target_set_circular_trace_buffer (circular_trace_buffer);
1661 target_set_trace_buffer_size (trace_buffer_size);
1664 notes = trace_notes;
1665 ret = target_set_trace_notes (trace_user, notes, NULL);
1667 if (!ret && (trace_user || notes))
1668 warning (_("Target does not support trace user/notes, info ignored"));
1670 /* Now insert traps and begin collecting data. */
1671 target_trace_start ();
1673 /* Reset our local state. */
1674 trace_reset_local_state ();
1675 current_trace_status()->running = 1;
1678 /* The tstart command requests the target to start a new trace run.
1679 The command passes any arguments it has to the target verbatim, as
1680 an optional "trace note". This is useful as for instance a warning
1681 to other users if the trace runs disconnected, and you don't want
1682 anybody else messing with the target. */
1685 tstart_command (const char *args, int from_tty)
1687 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1689 if (current_trace_status ()->running)
1692 && !query (_("A trace is running already. Start a new run? ")))
1693 error (_("New trace run not started."));
1696 start_tracing (args);
1699 /* The tstop command stops the tracing run. The command passes any
1700 supplied arguments to the target verbatim as a "stop note"; if the
1701 target supports trace notes, then it will be reported back as part
1702 of the trace run's status. */
1705 tstop_command (const char *args, int from_tty)
1707 if (!current_trace_status ()->running)
1708 error (_("Trace is not running."));
1710 stop_tracing (args);
1714 stop_tracing (const char *note)
1718 target_trace_stop ();
1720 for (breakpoint *t : all_tracepoints ())
1722 struct bp_location *loc;
1724 if ((t->type == bp_fast_tracepoint
1725 ? !may_insert_fast_tracepoints
1726 : !may_insert_tracepoints))
1729 for (loc = t->loc; loc; loc = loc->next)
1731 /* GDB can be totally absent in some disconnected trace scenarios,
1732 but we don't really care if this semaphore goes out of sync.
1733 That's why we are decrementing it here, but not taking care
1735 if (loc->probe.prob != NULL)
1736 loc->probe.prob->clear_semaphore (loc->probe.objfile,
1742 note = trace_stop_notes;
1743 ret = target_set_trace_notes (NULL, NULL, note);
1746 warning (_("Target does not support trace notes, note ignored"));
1748 /* Should change in response to reply? */
1749 current_trace_status ()->running = 0;
1752 /* tstatus command */
1754 tstatus_command (const char *args, int from_tty)
1756 struct trace_status *ts = current_trace_status ();
1759 status = target_get_trace_status (ts);
1763 if (ts->filename != NULL)
1764 printf_filtered (_("Using a trace file.\n"));
1767 printf_filtered (_("Trace can not be run on this target.\n"));
1772 if (!ts->running_known)
1774 printf_filtered (_("Run/stop status is unknown.\n"));
1776 else if (ts->running)
1778 printf_filtered (_("Trace is running on the target.\n"));
1782 switch (ts->stop_reason)
1784 case trace_never_run:
1785 printf_filtered (_("No trace has been run on the target.\n"));
1787 case trace_stop_command:
1789 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1792 printf_filtered (_("Trace stopped by a tstop command.\n"));
1794 case trace_buffer_full:
1795 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1797 case trace_disconnected:
1798 printf_filtered (_("Trace stopped because of disconnection.\n"));
1800 case tracepoint_passcount:
1801 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1802 ts->stopping_tracepoint);
1804 case tracepoint_error:
1805 if (ts->stopping_tracepoint)
1806 printf_filtered (_("Trace stopped by an "
1807 "error (%s, tracepoint %d).\n"),
1808 ts->stop_desc, ts->stopping_tracepoint);
1810 printf_filtered (_("Trace stopped by an error (%s).\n"),
1813 case trace_stop_reason_unknown:
1814 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1817 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1823 if (ts->traceframes_created >= 0
1824 && ts->traceframe_count != ts->traceframes_created)
1826 printf_filtered (_("Buffer contains %d trace "
1827 "frames (of %d created total).\n"),
1828 ts->traceframe_count, ts->traceframes_created);
1830 else if (ts->traceframe_count >= 0)
1832 printf_filtered (_("Collected %d trace frames.\n"),
1833 ts->traceframe_count);
1836 if (ts->buffer_free >= 0)
1838 if (ts->buffer_size >= 0)
1840 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1841 ts->buffer_free, ts->buffer_size);
1842 if (ts->buffer_size > 0)
1843 printf_filtered (_(" (%d%% full)"),
1844 ((int) ((((long long) (ts->buffer_size
1845 - ts->buffer_free)) * 100)
1846 / ts->buffer_size)));
1847 printf_filtered (_(".\n"));
1850 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1854 if (ts->disconnected_tracing)
1855 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1857 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1859 if (ts->circular_buffer)
1860 printf_filtered (_("Trace buffer is circular.\n"));
1862 if (ts->user_name && strlen (ts->user_name) > 0)
1863 printf_filtered (_("Trace user is %s.\n"), ts->user_name);
1865 if (ts->notes && strlen (ts->notes) > 0)
1866 printf_filtered (_("Trace notes: %s.\n"), ts->notes);
1868 /* Now report on what we're doing with tfind. */
1869 if (traceframe_number >= 0)
1870 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1871 traceframe_number, tracepoint_number);
1873 printf_filtered (_("Not looking at any trace frame.\n"));
1875 /* Report start/stop times if supplied. */
1880 LONGEST run_time = ts->stop_time - ts->start_time;
1882 /* Reporting a run time is more readable than two long numbers. */
1883 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
1884 (long int) (ts->start_time / 1000000),
1885 (long int) (ts->start_time % 1000000),
1886 (long int) (run_time / 1000000),
1887 (long int) (run_time % 1000000));
1890 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
1891 (long int) (ts->start_time / 1000000),
1892 (long int) (ts->start_time % 1000000));
1894 else if (ts->stop_time)
1895 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
1896 (long int) (ts->stop_time / 1000000),
1897 (long int) (ts->stop_time % 1000000));
1899 /* Now report any per-tracepoint status available. */
1900 for (breakpoint *t : all_tracepoints ())
1901 target_get_tracepoint_status (t, NULL);
1904 /* Report the trace status to uiout, in a way suitable for MI, and not
1905 suitable for CLI. If ON_STOP is true, suppress a few fields that
1906 are not meaningful in the -trace-stop response.
1908 The implementation is essentially parallel to trace_status_command, but
1909 merging them will result in unreadable code. */
1911 trace_status_mi (int on_stop)
1913 struct ui_out *uiout = current_uiout;
1914 struct trace_status *ts = current_trace_status ();
1917 status = target_get_trace_status (ts);
1919 if (status == -1 && ts->filename == NULL)
1921 uiout->field_string ("supported", "0");
1925 if (ts->filename != NULL)
1926 uiout->field_string ("supported", "file");
1928 uiout->field_string ("supported", "1");
1930 if (ts->filename != NULL)
1931 uiout->field_string ("trace-file", ts->filename);
1933 gdb_assert (ts->running_known);
1937 uiout->field_string ("running", "1");
1939 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1940 Given that the frontend gets the status either on -trace-stop, or from
1941 -trace-status after re-connection, it does not seem like this
1942 information is necessary for anything. It is not necessary for either
1943 figuring the vital state of the target nor for navigation of trace
1944 frames. If the frontend wants to show the current state is some
1945 configure dialog, it can request the value when such dialog is
1946 invoked by the user. */
1950 const char *stop_reason = NULL;
1951 int stopping_tracepoint = -1;
1954 uiout->field_string ("running", "0");
1956 if (ts->stop_reason != trace_stop_reason_unknown)
1958 switch (ts->stop_reason)
1960 case trace_stop_command:
1961 stop_reason = "request";
1963 case trace_buffer_full:
1964 stop_reason = "overflow";
1966 case trace_disconnected:
1967 stop_reason = "disconnection";
1969 case tracepoint_passcount:
1970 stop_reason = "passcount";
1971 stopping_tracepoint = ts->stopping_tracepoint;
1973 case tracepoint_error:
1974 stop_reason = "error";
1975 stopping_tracepoint = ts->stopping_tracepoint;
1981 uiout->field_string ("stop-reason", stop_reason);
1982 if (stopping_tracepoint != -1)
1983 uiout->field_int ("stopping-tracepoint",
1984 stopping_tracepoint);
1985 if (ts->stop_reason == tracepoint_error)
1986 uiout->field_string ("error-description",
1992 if (ts->traceframe_count != -1)
1993 uiout->field_int ("frames", ts->traceframe_count);
1994 if (ts->traceframes_created != -1)
1995 uiout->field_int ("frames-created", ts->traceframes_created);
1996 if (ts->buffer_size != -1)
1997 uiout->field_int ("buffer-size", ts->buffer_size);
1998 if (ts->buffer_free != -1)
1999 uiout->field_int ("buffer-free", ts->buffer_free);
2001 uiout->field_int ("disconnected", ts->disconnected_tracing);
2002 uiout->field_int ("circular", ts->circular_buffer);
2004 uiout->field_string ("user-name", ts->user_name);
2005 uiout->field_string ("notes", ts->notes);
2010 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2011 (long int) (ts->start_time / 1000000),
2012 (long int) (ts->start_time % 1000000));
2013 uiout->field_string ("start-time", buf);
2014 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2015 (long int) (ts->stop_time / 1000000),
2016 (long int) (ts->stop_time % 1000000));
2017 uiout->field_string ("stop-time", buf);
2021 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2022 user if she really wants to detach. */
2025 query_if_trace_running (int from_tty)
2030 /* It can happen that the target that was tracing went away on its
2031 own, and we didn't notice. Get a status update, and if the
2032 current target doesn't even do tracing, then assume it's not
2034 if (target_get_trace_status (current_trace_status ()) < 0)
2035 current_trace_status ()->running = 0;
2037 /* If running interactively, give the user the option to cancel and
2038 then decide what to do differently with the run. Scripts are
2039 just going to disconnect and let the target deal with it,
2040 according to how it's been instructed previously via
2041 disconnected-tracing. */
2042 if (current_trace_status ()->running)
2044 process_tracepoint_on_disconnect ();
2046 if (current_trace_status ()->disconnected_tracing)
2048 if (!query (_("Trace is running and will "
2049 "continue after detach; detach anyway? ")))
2050 error (_("Not confirmed."));
2054 if (!query (_("Trace is running but will "
2055 "stop on detach; detach anyway? ")))
2056 error (_("Not confirmed."));
2061 /* This function handles the details of what to do about an ongoing
2062 tracing run if the user has asked to detach or otherwise disconnect
2066 disconnect_tracing (void)
2068 /* Also we want to be out of tfind mode, otherwise things can get
2069 confusing upon reconnection. Just use these calls instead of
2070 full tfind_1 behavior because we're in the middle of detaching,
2071 and there's no point to updating current stack frame etc. */
2072 trace_reset_local_state ();
2075 /* Worker function for the various flavors of the tfind command. */
2077 tfind_1 (enum trace_find_type type, int num,
2078 CORE_ADDR addr1, CORE_ADDR addr2,
2081 int target_frameno = -1, target_tracept = -1;
2082 struct frame_id old_frame_id = null_frame_id;
2083 struct tracepoint *tp;
2084 struct ui_out *uiout = current_uiout;
2086 /* Only try to get the current stack frame if we have a chance of
2087 succeeding. In particular, if we're trying to get a first trace
2088 frame while all threads are running, it's not going to succeed,
2089 so leave it with a default value and let the frame comparison
2090 below (correctly) decide to print out the source location of the
2092 if (!(type == tfind_number && num == -1)
2093 && (has_stack_frames () || traceframe_number >= 0))
2094 old_frame_id = get_frame_id (get_current_frame ());
2096 target_frameno = target_trace_find (type, num, addr1, addr2,
2099 if (type == tfind_number
2101 && target_frameno == -1)
2103 /* We told the target to get out of tfind mode, and it did. */
2105 else if (target_frameno == -1)
2107 /* A request for a non-existent trace frame has failed.
2108 Our response will be different, depending on FROM_TTY:
2110 If FROM_TTY is true, meaning that this command was
2111 typed interactively by the user, then give an error
2112 and DO NOT change the state of traceframe_number etc.
2114 However if FROM_TTY is false, meaning that we're either
2115 in a script, a loop, or a user-defined command, then
2116 DON'T give an error, but DO change the state of
2117 traceframe_number etc. to invalid.
2119 The rationalle is that if you typed the command, you
2120 might just have committed a typo or something, and you'd
2121 like to NOT lose your current debugging state. However
2122 if you're in a user-defined command or especially in a
2123 loop, then you need a way to detect that the command
2124 failed WITHOUT aborting. This allows you to write
2125 scripts that search thru the trace buffer until the end,
2126 and then continue on to do something else. */
2129 error (_("Target failed to find requested trace frame."));
2133 printf_filtered ("End of trace buffer.\n");
2134 #if 0 /* dubious now? */
2135 /* The following will not recurse, since it's
2137 tfind_command ("-1", from_tty);
2142 tp = get_tracepoint_by_number_on_target (target_tracept);
2144 reinit_frame_cache ();
2145 target_dcache_invalidate ();
2147 set_tracepoint_num (tp ? tp->number : target_tracept);
2149 if (target_frameno != get_traceframe_number ())
2150 gdb::observers::traceframe_changed.notify (target_frameno, tracepoint_number);
2152 set_current_traceframe (target_frameno);
2154 if (target_frameno == -1)
2155 set_traceframe_context (NULL);
2157 set_traceframe_context (get_current_frame ());
2159 if (traceframe_number >= 0)
2161 /* Use different branches for MI and CLI to make CLI messages
2163 if (uiout->is_mi_like_p ())
2165 uiout->field_string ("found", "1");
2166 uiout->field_int ("tracepoint", tracepoint_number);
2167 uiout->field_int ("traceframe", traceframe_number);
2171 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2172 traceframe_number, tracepoint_number);
2177 if (uiout->is_mi_like_p ())
2178 uiout->field_string ("found", "0");
2179 else if (type == tfind_number && num == -1)
2180 printf_unfiltered (_("No longer looking at any trace frame\n"));
2181 else /* This case may never occur, check. */
2182 printf_unfiltered (_("No trace frame found\n"));
2185 /* If we're in nonstop mode and getting out of looking at trace
2186 frames, there won't be any current frame to go back to and
2189 && (has_stack_frames () || traceframe_number >= 0))
2191 enum print_what print_what;
2193 /* NOTE: in imitation of the step command, try to determine
2194 whether we have made a transition from one function to
2195 another. If so, we'll print the "stack frame" (ie. the new
2196 function and it's arguments) -- otherwise we'll just show the
2199 if (frame_id_eq (old_frame_id,
2200 get_frame_id (get_current_frame ())))
2201 print_what = SRC_LINE;
2203 print_what = SRC_AND_LOC;
2205 print_stack_frame (get_selected_frame (NULL), 1, print_what, 1);
2210 /* Error on looking at traceframes while trace is running. */
2213 check_trace_running (struct trace_status *status)
2215 if (status->running && status->filename == NULL)
2216 error (_("May not look at trace frames while trace is running."));
2219 /* trace_find_command takes a trace frame number n,
2220 sends "QTFrame:<n>" to the target,
2221 and accepts a reply that may contain several optional pieces
2222 of information: a frame number, a tracepoint number, and an
2223 indication of whether this is a trap frame or a stepping frame.
2225 The minimal response is just "OK" (which indicates that the
2226 target does not give us a frame number or a tracepoint number).
2227 Instead of that, the target may send us a string containing
2229 F<hexnum> (gives the selected frame number)
2230 T<hexnum> (gives the selected tracepoint number)
2235 tfind_command_1 (const char *args, int from_tty)
2236 { /* This should only be called with a numeric argument. */
2239 check_trace_running (current_trace_status ());
2241 if (args == 0 || *args == 0)
2242 { /* TFIND with no args means find NEXT trace frame. */
2243 if (traceframe_number == -1)
2244 frameno = 0; /* "next" is first one. */
2246 frameno = traceframe_number + 1;
2248 else if (0 == strcmp (args, "-"))
2250 if (traceframe_number == -1)
2251 error (_("not debugging trace buffer"));
2252 else if (from_tty && traceframe_number == 0)
2253 error (_("already at start of trace buffer"));
2255 frameno = traceframe_number - 1;
2257 /* A hack to work around eval's need for fp to have been collected. */
2258 else if (0 == strcmp (args, "-1"))
2261 frameno = parse_and_eval_long (args);
2264 error (_("invalid input (%d is less than zero)"), frameno);
2266 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2270 tfind_command (const char *args, int from_tty)
2272 tfind_command_1 (args, from_tty);
2277 tfind_end_command (const char *args, int from_tty)
2279 tfind_command_1 ("-1", from_tty);
2284 tfind_start_command (const char *args, int from_tty)
2286 tfind_command_1 ("0", from_tty);
2289 /* tfind pc command */
2291 tfind_pc_command (const char *args, int from_tty)
2295 check_trace_running (current_trace_status ());
2297 if (args == 0 || *args == 0)
2298 pc = regcache_read_pc (get_current_regcache ());
2300 pc = parse_and_eval_address (args);
2302 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2305 /* tfind tracepoint command */
2307 tfind_tracepoint_command (const char *args, int from_tty)
2310 struct tracepoint *tp;
2312 check_trace_running (current_trace_status ());
2314 if (args == 0 || *args == 0)
2316 if (tracepoint_number == -1)
2317 error (_("No current tracepoint -- please supply an argument."));
2319 tdp = tracepoint_number; /* Default is current TDP. */
2322 tdp = parse_and_eval_long (args);
2324 /* If we have the tracepoint on hand, use the number that the
2325 target knows about (which may be different if we disconnected
2326 and reconnected). */
2327 tp = get_tracepoint (tdp);
2329 tdp = tp->number_on_target;
2331 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2334 /* TFIND LINE command:
2336 This command will take a sourceline for argument, just like BREAK
2337 or TRACE (ie. anything that "decode_line_1" can handle).
2339 With no argument, this command will find the next trace frame
2340 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2343 tfind_line_command (const char *args, int from_tty)
2345 check_trace_running (current_trace_status ());
2347 symtab_and_line sal;
2348 if (args == 0 || *args == 0)
2350 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2354 std::vector<symtab_and_line> sals
2355 = decode_line_with_current_source (args, DECODE_LINE_FUNFIRSTLINE);
2359 if (sal.symtab == 0)
2360 error (_("No line number information available."));
2362 CORE_ADDR start_pc, end_pc;
2363 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2365 if (start_pc == end_pc)
2367 printf_filtered ("Line %d of \"%s\"",
2369 symtab_to_filename_for_display (sal.symtab));
2371 printf_filtered (" is at address ");
2372 print_address (get_current_arch (), start_pc, gdb_stdout);
2374 printf_filtered (" but contains no code.\n");
2375 sal = find_pc_line (start_pc, 0);
2377 && find_line_pc_range (sal, &start_pc, &end_pc)
2378 && start_pc != end_pc)
2379 printf_filtered ("Attempting to find line %d instead.\n",
2382 error (_("Cannot find a good line."));
2386 /* Is there any case in which we get here, and have an address
2387 which the user would want to see? If we have debugging
2388 symbols and no line numbers? */
2389 error (_("Line number %d is out of range for \"%s\"."),
2390 sal.line, symtab_to_filename_for_display (sal.symtab));
2392 /* Find within range of stated line. */
2394 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2396 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2399 /* tfind range command */
2401 tfind_range_command (const char *args, int from_tty)
2403 static CORE_ADDR start, stop;
2406 check_trace_running (current_trace_status ());
2408 if (args == 0 || *args == 0)
2409 { /* XXX FIXME: what should default behavior be? */
2410 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2414 if (0 != (tmp = strchr (args, ',')))
2416 std::string start_addr (args, tmp);
2418 tmp = skip_spaces (tmp);
2419 start = parse_and_eval_address (start_addr.c_str ());
2420 stop = parse_and_eval_address (tmp);
2423 { /* No explicit end address? */
2424 start = parse_and_eval_address (args);
2425 stop = start + 1; /* ??? */
2428 tfind_1 (tfind_range, 0, start, stop, from_tty);
2431 /* tfind outside command */
2433 tfind_outside_command (const char *args, int from_tty)
2435 CORE_ADDR start, stop;
2438 if (current_trace_status ()->running
2439 && current_trace_status ()->filename == NULL)
2440 error (_("May not look at trace frames while trace is running."));
2442 if (args == 0 || *args == 0)
2443 { /* XXX FIXME: what should default behavior be? */
2444 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2448 if (0 != (tmp = strchr (args, ',')))
2450 std::string start_addr (args, tmp);
2452 tmp = skip_spaces (tmp);
2453 start = parse_and_eval_address (start_addr.c_str ());
2454 stop = parse_and_eval_address (tmp);
2457 { /* No explicit end address? */
2458 start = parse_and_eval_address (args);
2459 stop = start + 1; /* ??? */
2462 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2465 /* info scope command: list the locals for a scope. */
2467 info_scope_command (const char *args_in, int from_tty)
2470 struct bound_minimal_symbol msym;
2471 const struct block *block;
2472 const char *symname;
2473 const char *save_args = args_in;
2474 struct block_iterator iter;
2476 struct gdbarch *gdbarch;
2478 const char *args = args_in;
2480 if (args == 0 || *args == 0)
2481 error (_("requires an argument (function, "
2482 "line or *addr) to define a scope"));
2484 event_location_up location = string_to_event_location (&args,
2486 std::vector<symtab_and_line> sals
2487 = decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE,
2491 /* Presumably decode_line_1 has already warned. */
2495 /* Resolve line numbers to PC. */
2496 resolve_sal_pc (&sals[0]);
2497 block = block_for_pc (sals[0].pc);
2501 QUIT; /* Allow user to bail out with ^C. */
2502 ALL_BLOCK_SYMBOLS (block, iter, sym)
2504 QUIT; /* Allow user to bail out with ^C. */
2506 printf_filtered ("Scope for %s:\n", save_args);
2509 symname = SYMBOL_PRINT_NAME (sym);
2510 if (symname == NULL || *symname == '\0')
2511 continue; /* Probably botched, certainly useless. */
2513 gdbarch = symbol_arch (sym);
2515 printf_filtered ("Symbol %s is ", symname);
2517 if (SYMBOL_COMPUTED_OPS (sym) != NULL)
2518 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2519 BLOCK_START (block),
2523 switch (SYMBOL_CLASS (sym))
2526 case LOC_UNDEF: /* Messed up symbol? */
2527 printf_filtered ("a bogus symbol, class %d.\n",
2528 SYMBOL_CLASS (sym));
2529 count--; /* Don't count this one. */
2532 printf_filtered ("a constant with value %s (%s)",
2533 plongest (SYMBOL_VALUE (sym)),
2534 hex_string (SYMBOL_VALUE (sym)));
2536 case LOC_CONST_BYTES:
2537 printf_filtered ("constant bytes: ");
2538 if (SYMBOL_TYPE (sym))
2539 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2540 fprintf_filtered (gdb_stdout, " %02x",
2541 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2544 printf_filtered ("in static storage at address ");
2545 printf_filtered ("%s", paddress (gdbarch,
2546 SYMBOL_VALUE_ADDRESS (sym)));
2549 /* GDBARCH is the architecture associated with the objfile
2550 the symbol is defined in; the target architecture may be
2551 different, and may provide additional registers. However,
2552 we do not know the target architecture at this point.
2553 We assume the objfile architecture will contain all the
2554 standard registers that occur in debug info in that
2556 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2559 if (SYMBOL_IS_ARGUMENT (sym))
2560 printf_filtered ("an argument in register $%s",
2561 gdbarch_register_name (gdbarch, regno));
2563 printf_filtered ("a local variable in register $%s",
2564 gdbarch_register_name (gdbarch, regno));
2567 printf_filtered ("an argument at stack/frame offset %s",
2568 plongest (SYMBOL_VALUE (sym)));
2571 printf_filtered ("a local variable at frame offset %s",
2572 plongest (SYMBOL_VALUE (sym)));
2575 printf_filtered ("a reference argument at offset %s",
2576 plongest (SYMBOL_VALUE (sym)));
2578 case LOC_REGPARM_ADDR:
2579 /* Note comment at LOC_REGISTER. */
2580 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2582 printf_filtered ("the address of an argument, in register $%s",
2583 gdbarch_register_name (gdbarch, regno));
2586 printf_filtered ("a typedef.\n");
2589 printf_filtered ("a label at address ");
2590 printf_filtered ("%s", paddress (gdbarch,
2591 SYMBOL_VALUE_ADDRESS (sym)));
2594 printf_filtered ("a function at address ");
2595 printf_filtered ("%s",
2596 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2598 case LOC_UNRESOLVED:
2599 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2601 if (msym.minsym == NULL)
2602 printf_filtered ("Unresolved Static");
2605 printf_filtered ("static storage at address ");
2606 printf_filtered ("%s",
2608 BMSYMBOL_VALUE_ADDRESS (msym)));
2611 case LOC_OPTIMIZED_OUT:
2612 printf_filtered ("optimized out.\n");
2615 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2618 if (SYMBOL_TYPE (sym))
2619 printf_filtered (", length %d.\n",
2620 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2622 if (BLOCK_FUNCTION (block))
2625 block = BLOCK_SUPERBLOCK (block);
2628 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2632 /* Helper for trace_dump_command. Dump the action list starting at
2633 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2634 actions of the body of a while-stepping action. STEPPING_FRAME is
2635 set if the current traceframe was determined to be a while-stepping
2639 trace_dump_actions (struct command_line *action,
2640 int stepping_actions, int stepping_frame,
2643 const char *action_exp, *next_comma;
2645 for (; action != NULL; action = action->next)
2647 struct cmd_list_element *cmd;
2649 QUIT; /* Allow user to bail out with ^C. */
2650 action_exp = action->line;
2651 action_exp = skip_spaces (action_exp);
2653 /* The collection actions to be done while stepping are
2654 bracketed by the commands "while-stepping" and "end". */
2656 if (*action_exp == '#') /* comment line */
2659 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2661 error (_("Bad action list item: %s"), action_exp);
2663 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2665 gdb_assert (action->body_list_1 == nullptr);
2666 trace_dump_actions (action->body_list_0.get (),
2667 1, stepping_frame, from_tty);
2669 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2671 /* Display the collected data.
2672 For the trap frame, display only what was collected at
2673 the trap. Likewise for stepping frames, display only
2674 what was collected while stepping. This means that the
2675 two boolean variables, STEPPING_FRAME and
2676 STEPPING_ACTIONS should be equal. */
2677 if (stepping_frame == stepping_actions)
2679 int trace_string = 0;
2681 if (*action_exp == '/')
2682 action_exp = decode_agent_options (action_exp, &trace_string);
2685 { /* Repeat over a comma-separated list. */
2686 QUIT; /* Allow user to bail out with ^C. */
2687 if (*action_exp == ',')
2689 action_exp = skip_spaces (action_exp);
2691 next_comma = strchr (action_exp, ',');
2693 if (0 == strncasecmp (action_exp, "$reg", 4))
2694 registers_info (NULL, from_tty);
2695 else if (0 == strncasecmp (action_exp, "$_ret", 5))
2697 else if (0 == strncasecmp (action_exp, "$loc", 4))
2698 info_locals_command (NULL, from_tty);
2699 else if (0 == strncasecmp (action_exp, "$arg", 4))
2700 info_args_command (NULL, from_tty);
2703 std::string contents;
2704 const char *exp = action_exp;
2705 if (next_comma != NULL)
2707 size_t len = next_comma - action_exp;
2708 contents = std::string (action_exp, len);
2709 exp = contents.c_str ();
2712 printf_filtered ("%s = ", exp);
2713 output_command (exp, from_tty);
2714 printf_filtered ("\n");
2716 action_exp = next_comma;
2718 while (action_exp && *action_exp == ',');
2724 /* Return bp_location of the tracepoint associated with the current
2725 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2726 is a stepping traceframe. */
2728 struct bp_location *
2729 get_traceframe_location (int *stepping_frame_p)
2731 struct tracepoint *t;
2732 struct bp_location *tloc;
2733 struct regcache *regcache;
2735 if (tracepoint_number == -1)
2736 error (_("No current trace frame."));
2738 t = get_tracepoint (tracepoint_number);
2741 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2744 /* The current frame is a trap frame if the frame PC is equal to the
2745 tracepoint PC. If not, then the current frame was collected
2746 during single-stepping. */
2747 regcache = get_current_regcache ();
2749 /* If the traceframe's address matches any of the tracepoint's
2750 locations, assume it is a direct hit rather than a while-stepping
2751 frame. (FIXME this is not reliable, should record each frame's
2753 for (tloc = t->loc; tloc; tloc = tloc->next)
2754 if (tloc->address == regcache_read_pc (regcache))
2756 *stepping_frame_p = 0;
2760 /* If this is a stepping frame, we don't know which location
2761 triggered. The first is as good (or bad) a guess as any... */
2762 *stepping_frame_p = 1;
2766 /* Return the default collect actions of a tracepoint T. */
2768 static counted_command_line
2769 all_tracepoint_actions (struct breakpoint *t)
2771 counted_command_line actions (nullptr, command_lines_deleter ());
2773 /* If there are default expressions to collect, make up a collect
2774 action and prepend to the action list to encode. Note that since
2775 validation is per-tracepoint (local var "xyz" might be valid for
2776 one tracepoint and not another, etc), we make up the action on
2777 the fly, and don't cache it. */
2778 if (*default_collect)
2780 gdb::unique_xmalloc_ptr<char> default_collect_line
2781 (xstrprintf ("collect %s", default_collect));
2783 validate_actionline (default_collect_line.get (), t);
2784 actions.reset (new struct command_line (simple_control,
2785 default_collect_line.release ()),
2786 command_lines_deleter ());
2792 /* The tdump command. */
2795 tdump_command (const char *args, int from_tty)
2797 int stepping_frame = 0;
2798 struct bp_location *loc;
2800 /* This throws an error is not inspecting a trace frame. */
2801 loc = get_traceframe_location (&stepping_frame);
2803 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2804 tracepoint_number, traceframe_number);
2806 /* This command only makes sense for the current frame, not the
2808 scoped_restore_current_thread restore_thread;
2810 select_frame (get_current_frame ());
2812 counted_command_line actions = all_tracepoint_actions (loc->owner);
2814 trace_dump_actions (actions.get (), 0, stepping_frame, from_tty);
2815 trace_dump_actions (breakpoint_commands (loc->owner), 0, stepping_frame,
2819 /* Encode a piece of a tracepoint's source-level definition in a form
2820 that is suitable for both protocol and saving in files. */
2821 /* This version does not do multiple encodes for long strings; it should
2822 return an offset to the next piece to encode. FIXME */
2825 encode_source_string (int tpnum, ULONGEST addr,
2826 const char *srctype, const char *src,
2827 char *buf, int buf_size)
2829 if (80 + strlen (srctype) > buf_size)
2830 error (_("Buffer too small for source encoding"));
2831 sprintf (buf, "%x:%s:%s:%x:%x:",
2832 tpnum, phex_nz (addr, sizeof (addr)),
2833 srctype, 0, (int) strlen (src));
2834 if (strlen (buf) + strlen (src) * 2 >= buf_size)
2835 error (_("Source string too long for buffer"));
2836 bin2hex ((gdb_byte *) src, buf + strlen (buf), strlen (src));
2840 /* Tell the target what to do with an ongoing tracing run if GDB
2841 disconnects for some reason. */
2844 set_disconnected_tracing (const char *args, int from_tty,
2845 struct cmd_list_element *c)
2847 target_set_disconnected_tracing (disconnected_tracing);
2851 set_circular_trace_buffer (const char *args, int from_tty,
2852 struct cmd_list_element *c)
2854 target_set_circular_trace_buffer (circular_trace_buffer);
2858 set_trace_buffer_size (const char *args, int from_tty,
2859 struct cmd_list_element *c)
2861 target_set_trace_buffer_size (trace_buffer_size);
2865 set_trace_user (const char *args, int from_tty,
2866 struct cmd_list_element *c)
2870 ret = target_set_trace_notes (trace_user, NULL, NULL);
2873 warning (_("Target does not support trace notes, user ignored"));
2877 set_trace_notes (const char *args, int from_tty,
2878 struct cmd_list_element *c)
2882 ret = target_set_trace_notes (NULL, trace_notes, NULL);
2885 warning (_("Target does not support trace notes, note ignored"));
2889 set_trace_stop_notes (const char *args, int from_tty,
2890 struct cmd_list_element *c)
2894 ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
2897 warning (_("Target does not support trace notes, stop note ignored"));
2900 /* Convert the memory pointed to by mem into hex, placing result in buf.
2901 * Return a pointer to the last char put in buf (null)
2902 * "stolen" from sparc-stub.c
2905 static const char hexchars[] = "0123456789abcdef";
2908 mem2hex (gdb_byte *mem, char *buf, int count)
2916 *buf++ = hexchars[ch >> 4];
2917 *buf++ = hexchars[ch & 0xf];
2926 get_traceframe_number (void)
2928 return traceframe_number;
2932 get_tracepoint_number (void)
2934 return tracepoint_number;
2937 /* Make the traceframe NUM be the current trace frame. Does nothing
2938 if NUM is already current. */
2941 set_current_traceframe (int num)
2945 if (traceframe_number == num)
2947 /* Nothing to do. */
2951 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
2954 warning (_("could not change traceframe"));
2956 set_traceframe_num (newnum);
2958 /* Changing the traceframe changes our view of registers and of the
2960 registers_changed ();
2962 clear_traceframe_info ();
2965 scoped_restore_current_traceframe::scoped_restore_current_traceframe ()
2966 : m_traceframe_number (traceframe_number)
2969 /* Given a number and address, return an uploaded tracepoint with that
2970 number, creating if necessary. */
2972 struct uploaded_tp *
2973 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
2975 struct uploaded_tp *utp;
2977 for (utp = *utpp; utp; utp = utp->next)
2978 if (utp->number == num && utp->addr == addr)
2981 utp = new uploaded_tp;
2991 free_uploaded_tps (struct uploaded_tp **utpp)
2993 struct uploaded_tp *next_one;
2997 next_one = (*utpp)->next;
3003 /* Given a number and address, return an uploaded tracepoint with that
3004 number, creating if necessary. */
3006 struct uploaded_tsv *
3007 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3009 struct uploaded_tsv *utsv;
3011 for (utsv = *utsvp; utsv; utsv = utsv->next)
3012 if (utsv->number == num)
3015 utsv = XCNEW (struct uploaded_tsv);
3017 utsv->next = *utsvp;
3024 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3026 struct uploaded_tsv *next_one;
3030 next_one = (*utsvp)->next;
3036 /* FIXME this function is heuristic and will miss the cases where the
3037 conditional is semantically identical but differs in whitespace,
3038 such as "x == 0" vs "x==0". */
3041 cond_string_is_same (char *str1, char *str2)
3043 if (str1 == NULL || str2 == NULL)
3044 return (str1 == str2);
3046 return (strcmp (str1, str2) == 0);
3049 /* Look for an existing tracepoint that seems similar enough to the
3050 uploaded one. Enablement isn't compared, because the user can
3051 toggle that freely, and may have done so in anticipation of the
3052 next trace run. Return the location of matched tracepoint. */
3054 static struct bp_location *
3055 find_matching_tracepoint_location (struct uploaded_tp *utp)
3057 struct bp_location *loc;
3059 for (breakpoint *b : all_tracepoints ())
3061 struct tracepoint *t = (struct tracepoint *) b;
3063 if (b->type == utp->type
3064 && t->step_count == utp->step
3065 && t->pass_count == utp->pass
3066 && cond_string_is_same (t->cond_string, utp->cond_string)
3067 /* FIXME also test actions. */
3070 /* Scan the locations for an address match. */
3071 for (loc = b->loc; loc; loc = loc->next)
3073 if (loc->address == utp->addr)
3081 /* Given a list of tracepoints uploaded from a target, attempt to
3082 match them up with existing tracepoints, and create new ones if not
3086 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3088 struct uploaded_tp *utp;
3089 /* A set of tracepoints which are modified. */
3090 std::vector<breakpoint *> modified_tp;
3092 /* Look for GDB tracepoints that match up with our uploaded versions. */
3093 for (utp = *uploaded_tps; utp; utp = utp->next)
3095 struct bp_location *loc;
3096 struct tracepoint *t;
3098 loc = find_matching_tracepoint_location (utp);
3103 /* Mark this location as already inserted. */
3105 t = (struct tracepoint *) loc->owner;
3106 printf_filtered (_("Assuming tracepoint %d is same "
3107 "as target's tracepoint %d at %s.\n"),
3108 loc->owner->number, utp->number,
3109 paddress (loc->gdbarch, utp->addr));
3111 /* The tracepoint LOC->owner was modified (the location LOC
3112 was marked as inserted in the target). Save it in
3113 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3114 observers will be notified later once for each tracepoint
3115 saved in MODIFIED_TP. */
3116 for (breakpoint *b : modified_tp)
3117 if (b == loc->owner)
3123 modified_tp.push_back (loc->owner);
3127 t = create_tracepoint_from_upload (utp);
3129 printf_filtered (_("Created tracepoint %d for "
3130 "target's tracepoint %d at %s.\n"),
3131 t->number, utp->number,
3132 paddress (get_current_arch (), utp->addr));
3134 printf_filtered (_("Failed to create tracepoint for target's "
3135 "tracepoint %d at %s, skipping it.\n"),
3137 paddress (get_current_arch (), utp->addr));
3139 /* Whether found or created, record the number used by the
3140 target, to help with mapping target tracepoints back to their
3141 counterparts here. */
3143 t->number_on_target = utp->number;
3146 /* Notify 'breakpoint-modified' observer that at least one of B's
3147 locations was changed. */
3148 for (breakpoint *b : modified_tp)
3149 gdb::observers::breakpoint_modified.notify (b);
3151 free_uploaded_tps (uploaded_tps);
3154 /* Trace state variables don't have much to identify them beyond their
3155 name, so just use that to detect matches. */
3157 static struct trace_state_variable *
3158 find_matching_tsv (struct uploaded_tsv *utsv)
3163 return find_trace_state_variable (utsv->name);
3166 static struct trace_state_variable *
3167 create_tsv_from_upload (struct uploaded_tsv *utsv)
3169 const char *namebase;
3172 struct trace_state_variable *tsv;
3176 namebase = utsv->name;
3182 buf = string_printf ("%s_%d", namebase, try_num++);
3185 /* Fish for a name that is not in use. */
3186 /* (should check against all internal vars?) */
3187 while (find_trace_state_variable (buf.c_str ()))
3188 buf = string_printf ("%s_%d", namebase, try_num++);
3190 /* We have an available name, create the variable. */
3191 tsv = create_trace_state_variable (buf.c_str ());
3192 tsv->initial_value = utsv->initial_value;
3193 tsv->builtin = utsv->builtin;
3195 gdb::observers::tsv_created.notify (tsv);
3200 /* Given a list of uploaded trace state variables, try to match them
3201 up with existing variables, or create additional ones. */
3204 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
3206 struct uploaded_tsv *utsv;
3207 struct trace_state_variable *tsv;
3210 /* Most likely some numbers will have to be reassigned as part of
3211 the merge, so clear them all in anticipation. */
3212 for (trace_state_variable &tsv : tvariables)
3215 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
3217 tsv = find_matching_tsv (utsv);
3221 printf_filtered (_("Assuming trace state variable $%s "
3222 "is same as target's variable %d.\n"),
3223 tsv->name.c_str (), utsv->number);
3227 tsv = create_tsv_from_upload (utsv);
3229 printf_filtered (_("Created trace state variable "
3230 "$%s for target's variable %d.\n"),
3231 tsv->name.c_str (), utsv->number);
3233 /* Give precedence to numberings that come from the target. */
3235 tsv->number = utsv->number;
3238 /* Renumber everything that didn't get a target-assigned number. */
3240 for (const trace_state_variable &tsv : tvariables)
3241 highest = std::max (tsv.number, highest);
3244 for (trace_state_variable &tsv : tvariables)
3245 if (tsv.number == 0)
3246 tsv.number = highest++;
3248 free_uploaded_tsvs (uploaded_tsvs);
3251 /* Parse the part of trace status syntax that is shared between
3252 the remote protocol and the trace file reader. */
3255 parse_trace_status (const char *line, struct trace_status *ts)
3257 const char *p = line, *p1, *p2, *p3, *p_temp;
3261 ts->running_known = 1;
3262 ts->running = (*p++ == '1');
3263 ts->stop_reason = trace_stop_reason_unknown;
3264 xfree (ts->stop_desc);
3265 ts->stop_desc = NULL;
3266 ts->traceframe_count = -1;
3267 ts->traceframes_created = -1;
3268 ts->buffer_free = -1;
3269 ts->buffer_size = -1;
3270 ts->disconnected_tracing = 0;
3271 ts->circular_buffer = 0;
3272 xfree (ts->user_name);
3273 ts->user_name = NULL;
3276 ts->start_time = ts->stop_time = 0;
3280 p1 = strchr (p, ':');
3282 error (_("Malformed trace status, at %s\n\
3283 Status line: '%s'\n"), p, line);
3284 p3 = strchr (p, ';');
3286 p3 = p + strlen (p);
3287 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3289 p = unpack_varlen_hex (++p1, &val);
3290 ts->stop_reason = trace_buffer_full;
3292 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3294 p = unpack_varlen_hex (++p1, &val);
3295 ts->stop_reason = trace_never_run;
3297 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
3300 p = unpack_varlen_hex (++p1, &val);
3301 ts->stop_reason = tracepoint_passcount;
3302 ts->stopping_tracepoint = val;
3304 else if (strncmp (p, stop_reason_names[trace_stop_command], p1 - p) == 0)
3306 p2 = strchr (++p1, ':');
3314 ts->stop_desc = (char *) xmalloc (strlen (line));
3315 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
3316 ts->stop_desc[end] = '\0';
3319 ts->stop_desc = xstrdup ("");
3321 p = unpack_varlen_hex (++p2, &val);
3322 ts->stop_reason = trace_stop_command;
3324 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3326 p = unpack_varlen_hex (++p1, &val);
3327 ts->stop_reason = trace_disconnected;
3329 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3331 p2 = strchr (++p1, ':');
3334 ts->stop_desc = (char *) xmalloc ((p2 - p1) / 2 + 1);
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->stopping_tracepoint = val;
3343 ts->stop_reason = tracepoint_error;
3345 else if (strncmp (p, "tframes", p1 - p) == 0)
3347 p = unpack_varlen_hex (++p1, &val);
3348 ts->traceframe_count = val;
3350 else if (strncmp (p, "tcreated", p1 - p) == 0)
3352 p = unpack_varlen_hex (++p1, &val);
3353 ts->traceframes_created = val;
3355 else if (strncmp (p, "tfree", p1 - p) == 0)
3357 p = unpack_varlen_hex (++p1, &val);
3358 ts->buffer_free = val;
3360 else if (strncmp (p, "tsize", p1 - p) == 0)
3362 p = unpack_varlen_hex (++p1, &val);
3363 ts->buffer_size = val;
3365 else if (strncmp (p, "disconn", p1 - p) == 0)
3367 p = unpack_varlen_hex (++p1, &val);
3368 ts->disconnected_tracing = val;
3370 else if (strncmp (p, "circular", p1 - p) == 0)
3372 p = unpack_varlen_hex (++p1, &val);
3373 ts->circular_buffer = val;
3375 else if (strncmp (p, "starttime", p1 - p) == 0)
3377 p = unpack_varlen_hex (++p1, &val);
3378 ts->start_time = val;
3380 else if (strncmp (p, "stoptime", p1 - p) == 0)
3382 p = unpack_varlen_hex (++p1, &val);
3383 ts->stop_time = val;
3385 else if (strncmp (p, "username", p1 - p) == 0)
3388 ts->user_name = (char *) xmalloc (strlen (p) / 2);
3389 end = hex2bin (p1, (gdb_byte *) ts->user_name, (p3 - p1) / 2);
3390 ts->user_name[end] = '\0';
3393 else if (strncmp (p, "notes", p1 - p) == 0)
3396 ts->notes = (char *) xmalloc (strlen (p) / 2);
3397 end = hex2bin (p1, (gdb_byte *) ts->notes, (p3 - p1) / 2);
3398 ts->notes[end] = '\0';
3403 /* Silently skip unknown optional info. */
3404 p_temp = strchr (p1 + 1, ';');
3408 /* Must be at the end. */
3415 parse_tracepoint_status (const char *p, struct breakpoint *bp,
3416 struct uploaded_tp *utp)
3419 struct tracepoint *tp = (struct tracepoint *) bp;
3421 p = unpack_varlen_hex (p, &uval);
3423 tp->hit_count += uval;
3425 utp->hit_count += uval;
3426 p = unpack_varlen_hex (p + 1, &uval);
3428 tp->traceframe_usage += uval;
3430 utp->traceframe_usage += uval;
3431 /* Ignore any extra, allowing for future extensions. */
3434 /* Given a line of text defining a part of a tracepoint, parse it into
3435 an "uploaded tracepoint". */
3438 parse_tracepoint_definition (const char *line, struct uploaded_tp **utpp)
3442 ULONGEST num, addr, step, pass, orig_size, xlen, start;
3445 const char *srctype;
3447 struct uploaded_tp *utp = NULL;
3450 /* Both tracepoint and action definitions start with the same number
3451 and address sequence. */
3453 p = unpack_varlen_hex (p, &num);
3454 p++; /* skip a colon */
3455 p = unpack_varlen_hex (p, &addr);
3456 p++; /* skip a colon */
3459 enabled = (*p++ == 'E');
3460 p++; /* skip a colon */
3461 p = unpack_varlen_hex (p, &step);
3462 p++; /* skip a colon */
3463 p = unpack_varlen_hex (p, &pass);
3464 type = bp_tracepoint;
3466 /* Thumb through optional fields. */
3469 p++; /* skip a colon */
3472 type = bp_fast_tracepoint;
3474 p = unpack_varlen_hex (p, &orig_size);
3478 type = bp_static_tracepoint;
3484 p = unpack_varlen_hex (p, &xlen);
3485 p++; /* skip a comma */
3486 cond = (char *) xmalloc (2 * xlen + 1);
3487 strncpy (cond, p, 2 * xlen);
3488 cond[2 * xlen] = '\0';
3492 warning (_("Unrecognized char '%c' in tracepoint "
3493 "definition, skipping rest"), *p);
3495 utp = get_uploaded_tp (num, addr, utpp);
3497 utp->enabled = enabled;
3502 else if (piece == 'A')
3504 utp = get_uploaded_tp (num, addr, utpp);
3505 utp->actions.push_back (xstrdup (p));
3507 else if (piece == 'S')
3509 utp = get_uploaded_tp (num, addr, utpp);
3510 utp->step_actions.push_back (xstrdup (p));
3512 else if (piece == 'Z')
3514 /* Parse a chunk of source form definition. */
3515 utp = get_uploaded_tp (num, addr, utpp);
3517 p = strchr (p, ':');
3518 p++; /* skip a colon */
3519 p = unpack_varlen_hex (p, &start);
3520 p++; /* skip a colon */
3521 p = unpack_varlen_hex (p, &xlen);
3522 p++; /* skip a colon */
3524 buf = (char *) alloca (strlen (line));
3526 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3529 if (startswith (srctype, "at:"))
3530 utp->at_string = xstrdup (buf);
3531 else if (startswith (srctype, "cond:"))
3532 utp->cond_string = xstrdup (buf);
3533 else if (startswith (srctype, "cmd:"))
3534 utp->cmd_strings.push_back (xstrdup (buf));
3536 else if (piece == 'V')
3538 utp = get_uploaded_tp (num, addr, utpp);
3540 parse_tracepoint_status (p, NULL, utp);
3544 /* Don't error out, the target might be sending us optional
3545 info that we don't care about. */
3546 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
3550 /* Convert a textual description of a trace state variable into an
3554 parse_tsv_definition (const char *line, struct uploaded_tsv **utsvp)
3558 ULONGEST num, initval, builtin;
3560 struct uploaded_tsv *utsv = NULL;
3562 buf = (char *) alloca (strlen (line));
3565 p = unpack_varlen_hex (p, &num);
3566 p++; /* skip a colon */
3567 p = unpack_varlen_hex (p, &initval);
3568 p++; /* skip a colon */
3569 p = unpack_varlen_hex (p, &builtin);
3570 p++; /* skip a colon */
3571 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3574 utsv = get_uploaded_tsv (num, utsvp);
3575 utsv->initial_value = initval;
3576 utsv->builtin = builtin;
3577 utsv->name = xstrdup (buf);
3580 /* Given a line of text defining a static tracepoint marker, parse it
3581 into a "static tracepoint marker" object. Throws an error is
3582 parsing fails. If PP is non-null, it points to one past the end of
3583 the parsed marker definition. */
3586 parse_static_tracepoint_marker_definition (const char *line, const char **pp,
3587 static_tracepoint_marker *marker)
3589 const char *p, *endp;
3593 p = unpack_varlen_hex (p, &addr);
3594 p++; /* skip a colon */
3596 marker->gdbarch = target_gdbarch ();
3597 marker->address = (CORE_ADDR) addr;
3599 endp = strchr (p, ':');
3601 error (_("bad marker definition: %s"), line);
3603 marker->str_id = hex2str (p, (endp - p) / 2);
3606 p++; /* skip a colon */
3608 /* This definition may be followed by another one, separated by a comma. */
3610 endp = strchr (p, ',');
3611 if (endp != nullptr)
3614 hex_len = strlen (p);
3616 marker->extra = hex2str (p, hex_len / 2);
3622 /* Print MARKER to gdb_stdout. */
3625 print_one_static_tracepoint_marker (int count,
3626 const static_tracepoint_marker &marker)
3630 char wrap_indent[80];
3631 char extra_field_indent[80];
3632 struct ui_out *uiout = current_uiout;
3634 symtab_and_line sal;
3635 sal.pc = marker.address;
3637 std::vector<breakpoint *> tracepoints
3638 = static_tracepoints_here (marker.address);
3640 ui_out_emit_tuple tuple_emitter (uiout, "marker");
3642 /* A counter field to help readability. This is not a stable
3644 uiout->field_int ("count", count);
3646 uiout->field_string ("marker-id", marker.str_id.c_str ());
3648 uiout->field_fmt ("enabled", "%c",
3649 !tracepoints.empty () ? 'y' : 'n');
3652 strcpy (wrap_indent, " ");
3654 if (gdbarch_addr_bit (marker.gdbarch) <= 32)
3655 strcat (wrap_indent, " ");
3657 strcat (wrap_indent, " ");
3659 strcpy (extra_field_indent, " ");
3661 uiout->field_core_addr ("addr", marker.gdbarch, marker.address);
3663 sal = find_pc_line (marker.address, 0);
3664 sym = find_pc_sect_function (marker.address, NULL);
3667 uiout->text ("in ");
3668 uiout->field_string ("func",
3669 SYMBOL_PRINT_NAME (sym));
3670 uiout->wrap_hint (wrap_indent);
3671 uiout->text (" at ");
3674 uiout->field_skip ("func");
3676 if (sal.symtab != NULL)
3678 uiout->field_string ("file",
3679 symtab_to_filename_for_display (sal.symtab));
3682 if (uiout->is_mi_like_p ())
3684 const char *fullname = symtab_to_fullname (sal.symtab);
3686 uiout->field_string ("fullname", fullname);
3689 uiout->field_skip ("fullname");
3691 uiout->field_int ("line", sal.line);
3695 uiout->field_skip ("fullname");
3696 uiout->field_skip ("line");
3700 uiout->text (extra_field_indent);
3701 uiout->text (_("Data: \""));
3702 uiout->field_string ("extra-data", marker.extra.c_str ());
3703 uiout->text ("\"\n");
3705 if (!tracepoints.empty ())
3710 ui_out_emit_tuple tuple_emitter (uiout, "tracepoints-at");
3712 uiout->text (extra_field_indent);
3713 uiout->text (_("Probed by static tracepoints: "));
3714 for (ix = 0; ix < tracepoints.size (); ix++)
3719 uiout->field_int ("tracepoint-id", tracepoints[ix]->number);
3723 if (uiout->is_mi_like_p ())
3724 uiout->field_int ("number-of-tracepoints", tracepoints.size ());
3731 info_static_tracepoint_markers_command (const char *arg, int from_tty)
3733 struct ui_out *uiout = current_uiout;
3734 std::vector<static_tracepoint_marker> markers
3735 = target_static_tracepoint_markers_by_strid (NULL);
3737 /* We don't have to check target_can_use_agent and agent's capability on
3738 static tracepoint here, in order to be compatible with older GDBserver.
3739 We don't check USE_AGENT is true or not, because static tracepoints
3740 don't work without in-process agent, so we don't bother users to type
3741 `set agent on' when to use static tracepoint. */
3743 ui_out_emit_table table_emitter (uiout, 5, -1,
3744 "StaticTracepointMarkersTable");
3746 uiout->table_header (7, ui_left, "counter", "Cnt");
3748 uiout->table_header (40, ui_left, "marker-id", "ID");
3750 uiout->table_header (3, ui_left, "enabled", "Enb");
3751 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
3752 uiout->table_header (10, ui_left, "addr", "Address");
3754 uiout->table_header (18, ui_left, "addr", "Address");
3755 uiout->table_header (40, ui_noalign, "what", "What");
3757 uiout->table_body ();
3759 for (int i = 0; i < markers.size (); i++)
3760 print_one_static_tracepoint_marker (i + 1, markers[i]);
3763 /* The $_sdata convenience variable is a bit special. We don't know
3764 for sure type of the value until we actually have a chance to fetch
3765 the data --- the size of the object depends on what has been
3766 collected. We solve this by making $_sdata be an internalvar that
3767 creates a new value on access. */
3769 /* Return a new value with the correct type for the sdata object of
3770 the current trace frame. Return a void value if there's no object
3773 static struct value *
3774 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
3777 /* We need to read the whole object before we know its size. */
3778 gdb::optional<gdb::byte_vector> buf
3779 = target_read_alloc (current_top_target (), TARGET_OBJECT_STATIC_TRACE_DATA,
3786 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
3788 v = allocate_value (type);
3789 memcpy (value_contents_raw (v), buf->data (), buf->size ());
3793 return allocate_value (builtin_type (gdbarch)->builtin_void);
3796 #if !defined(HAVE_LIBEXPAT)
3798 struct std::unique_ptr<traceframe_info>
3799 parse_traceframe_info (const char *tframe_info)
3801 static int have_warned;
3806 warning (_("Can not parse XML trace frame info; XML support "
3807 "was disabled at compile time"));
3813 #else /* HAVE_LIBEXPAT */
3815 #include "xml-support.h"
3817 /* Handle the start of a <memory> element. */
3820 traceframe_info_start_memory (struct gdb_xml_parser *parser,
3821 const struct gdb_xml_element *element,
3823 std::vector<gdb_xml_value> &attributes)
3825 struct traceframe_info *info = (struct traceframe_info *) user_data;
3826 ULONGEST *start_p, *length_p;
3829 = (ULONGEST *) xml_find_attribute (attributes, "start")->value.get ();
3831 = (ULONGEST *) xml_find_attribute (attributes, "length")->value.get ();
3833 info->memory.emplace_back (*start_p, *length_p);
3836 /* Handle the start of a <tvar> element. */
3839 traceframe_info_start_tvar (struct gdb_xml_parser *parser,
3840 const struct gdb_xml_element *element,
3842 std::vector<gdb_xml_value> &attributes)
3844 struct traceframe_info *info = (struct traceframe_info *) user_data;
3845 const char *id_attrib
3846 = (const char *) xml_find_attribute (attributes, "id")->value.get ();
3847 int id = gdb_xml_parse_ulongest (parser, id_attrib);
3849 info->tvars.push_back (id);
3852 /* The allowed elements and attributes for an XML memory map. */
3854 static const struct gdb_xml_attribute memory_attributes[] = {
3855 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
3856 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
3857 { NULL, GDB_XML_AF_NONE, NULL, NULL }
3860 static const struct gdb_xml_attribute tvar_attributes[] = {
3861 { "id", GDB_XML_AF_NONE, NULL, NULL },
3862 { NULL, GDB_XML_AF_NONE, NULL, NULL }
3865 static const struct gdb_xml_element traceframe_info_children[] = {
3866 { "memory", memory_attributes, NULL,
3867 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
3868 traceframe_info_start_memory, NULL },
3869 { "tvar", tvar_attributes, NULL,
3870 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
3871 traceframe_info_start_tvar, NULL },
3872 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
3875 static const struct gdb_xml_element traceframe_info_elements[] = {
3876 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
3878 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
3881 /* Parse a traceframe-info XML document. */
3884 parse_traceframe_info (const char *tframe_info)
3886 traceframe_info_up result (new traceframe_info);
3888 if (gdb_xml_parse_quick (_("trace frame info"),
3889 "traceframe-info.dtd", traceframe_info_elements,
3890 tframe_info, result.get ()) == 0)
3896 #endif /* HAVE_LIBEXPAT */
3898 /* Returns the traceframe_info object for the current traceframe.
3899 This is where we avoid re-fetching the object from the target if we
3900 already have it cached. */
3902 struct traceframe_info *
3903 get_traceframe_info (void)
3905 if (current_traceframe_info == NULL)
3906 current_traceframe_info = target_traceframe_info ();
3908 return current_traceframe_info.get ();
3911 /* If the target supports the query, return in RESULT the set of
3912 collected memory in the current traceframe, found within the LEN
3913 bytes range starting at MEMADDR. Returns true if the target
3914 supports the query, otherwise returns false, and RESULT is left
3918 traceframe_available_memory (std::vector<mem_range> *result,
3919 CORE_ADDR memaddr, ULONGEST len)
3921 struct traceframe_info *info = get_traceframe_info ();
3927 for (mem_range &r : info->memory)
3928 if (mem_ranges_overlap (r.start, r.length, memaddr, len))
3930 ULONGEST lo1, hi1, lo2, hi2;
3933 hi1 = memaddr + len;
3936 hi2 = r.start + r.length;
3938 CORE_ADDR start = std::max (lo1, lo2);
3939 int length = std::min (hi1, hi2) - start;
3941 result->emplace_back (start, length);
3944 normalize_mem_ranges (result);
3951 /* Implementation of `sdata' variable. */
3953 static const struct internalvar_funcs sdata_funcs =
3960 /* module initialization */
3962 _initialize_tracepoint (void)
3964 struct cmd_list_element *c;
3966 /* Explicitly create without lookup, since that tries to create a
3967 value with a void typed value, and when we get here, gdbarch
3968 isn't initialized yet. At this point, we're quite sure there
3969 isn't another convenience variable of the same name. */
3970 create_internalvar_type_lazy ("_sdata", &sdata_funcs, NULL);
3972 traceframe_number = -1;
3973 tracepoint_number = -1;
3975 add_info ("scope", info_scope_command,
3976 _("List the variables local to a scope"));
3978 add_cmd ("tracepoints", class_trace,
3979 _("Tracing of program execution without stopping the program."),
3982 add_com ("tdump", class_trace, tdump_command,
3983 _("Print everything collected at the current tracepoint."));
3985 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
3986 Define a trace state variable.\n\
3987 Argument is a $-prefixed name, optionally followed\n\
3988 by '=' and an expression that sets the initial value\n\
3989 at the start of tracing."));
3990 set_cmd_completer (c, expression_completer);
3992 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
3993 Delete one or more trace state variables.\n\
3994 Arguments are the names of the variables to delete.\n\
3995 If no arguments are supplied, delete all variables."), &deletelist);
3996 /* FIXME add a trace variable completer. */
3998 add_info ("tvariables", info_tvariables_command, _("\
3999 Status of trace state variables and their values.\n\
4002 add_info ("static-tracepoint-markers",
4003 info_static_tracepoint_markers_command, _("\
4004 List target static tracepoints markers.\n\
4007 add_prefix_cmd ("tfind", class_trace, tfind_command, _("\
4008 Select a trace frame;\n\
4009 No argument means forward by one frame; '-' means backward by one frame."),
4010 &tfindlist, "tfind ", 1, &cmdlist);
4012 add_cmd ("outside", class_trace, tfind_outside_command, _("\
4013 Select a trace frame whose PC is outside the given range (exclusive).\n\
4014 Usage: tfind outside addr1, addr2"),
4017 add_cmd ("range", class_trace, tfind_range_command, _("\
4018 Select a trace frame whose PC is in the given range (inclusive).\n\
4019 Usage: tfind range addr1,addr2"),
4022 add_cmd ("line", class_trace, tfind_line_command, _("\
4023 Select a trace frame by source line.\n\
4024 Argument can be a line number (with optional source file),\n\
4025 a function name, or '*' followed by an address.\n\
4026 Default argument is 'the next source line that was traced'."),
4029 add_cmd ("tracepoint", class_trace, tfind_tracepoint_command, _("\
4030 Select a trace frame by tracepoint number.\n\
4031 Default is the tracepoint for the current trace frame."),
4034 add_cmd ("pc", class_trace, tfind_pc_command, _("\
4035 Select a trace frame by PC.\n\
4036 Default is the current PC, or the PC of the current trace frame."),
4039 add_cmd ("end", class_trace, tfind_end_command, _("\
4040 De-select any trace frame and resume 'live' debugging."),
4043 add_alias_cmd ("none", "end", class_trace, 0, &tfindlist);
4045 add_cmd ("start", class_trace, tfind_start_command,
4046 _("Select the first trace frame in the trace buffer."),
4049 add_com ("tstatus", class_trace, tstatus_command,
4050 _("Display the status of the current trace data collection."));
4052 add_com ("tstop", class_trace, tstop_command, _("\
4053 Stop trace data collection.\n\
4054 Usage: tstop [NOTES]...\n\
4055 Any arguments supplied are recorded with the trace as a stop reason and\n\
4056 reported by tstatus (if the target supports trace notes)."));
4058 add_com ("tstart", class_trace, tstart_command, _("\
4059 Start trace data collection.\n\
4060 Usage: tstart [NOTES]...\n\
4061 Any arguments supplied are recorded with the trace as a note and\n\
4062 reported by tstatus (if the target supports trace notes)."));
4064 add_com ("end", class_trace, end_actions_pseudocommand, _("\
4065 Ends a list of commands or actions.\n\
4066 Several GDB commands allow you to enter a list of commands or actions.\n\
4067 Entering \"end\" on a line by itself is the normal way to terminate\n\
4069 Note: the \"end\" command cannot be used at the gdb prompt."));
4071 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
4072 Specify single-stepping behavior at a tracepoint.\n\
4073 Argument is number of instructions to trace in single-step mode\n\
4074 following the tracepoint. This command is normally followed by\n\
4075 one or more \"collect\" commands, to specify what to collect\n\
4076 while single-stepping.\n\n\
4077 Note: this command can only be used in a tracepoint \"actions\" list."));
4079 add_com_alias ("ws", "while-stepping", class_alias, 0);
4080 add_com_alias ("stepping", "while-stepping", class_alias, 0);
4082 add_com ("collect", class_trace, collect_pseudocommand, _("\
4083 Specify one or more data items to be collected at a tracepoint.\n\
4084 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4085 collect all data (variables, registers) referenced by that expression.\n\
4086 Also accepts the following special arguments:\n\
4087 $regs -- all registers.\n\
4088 $args -- all function arguments.\n\
4089 $locals -- all variables local to the block/function scope.\n\
4090 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4091 Note: this command can only be used in a tracepoint \"actions\" list."));
4093 add_com ("teval", class_trace, teval_pseudocommand, _("\
4094 Specify one or more expressions to be evaluated at a tracepoint.\n\
4095 Accepts a comma-separated list of (one or more) expressions.\n\
4096 The result of each evaluation will be discarded.\n\
4097 Note: this command can only be used in a tracepoint \"actions\" list."));
4099 add_com ("actions", class_trace, actions_command, _("\
4100 Specify the actions to be taken at a tracepoint.\n\
4101 Tracepoint actions may include collecting of specified data,\n\
4102 single-stepping, or enabling/disabling other tracepoints,\n\
4103 depending on target's capabilities."));
4105 default_collect = xstrdup ("");
4106 add_setshow_string_cmd ("default-collect", class_trace,
4107 &default_collect, _("\
4108 Set the list of expressions to collect by default"), _("\
4109 Show the list of expressions to collect by default"), NULL,
4111 &setlist, &showlist);
4113 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
4114 &disconnected_tracing, _("\
4115 Set whether tracing continues after GDB disconnects."), _("\
4116 Show whether tracing continues after GDB disconnects."), _("\
4117 Use this to continue a tracing run even if GDB disconnects\n\
4118 or detaches from the target. You can reconnect later and look at\n\
4119 trace data collected in the meantime."),
4120 set_disconnected_tracing,
4125 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
4126 &circular_trace_buffer, _("\
4127 Set target's use of circular trace buffer."), _("\
4128 Show target's use of circular trace buffer."), _("\
4129 Use this to make the trace buffer into a circular buffer,\n\
4130 which will discard traceframes (oldest first) instead of filling\n\
4131 up and stopping the trace run."),
4132 set_circular_trace_buffer,
4137 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class,
4138 &trace_buffer_size, _("\
4139 Set requested size of trace buffer."), _("\
4140 Show requested size of trace buffer."), _("\
4141 Use this to choose a size for the trace buffer. Some targets\n\
4142 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
4143 disables any attempt to set the buffer size and lets the target choose."),
4144 set_trace_buffer_size, NULL,
4145 &setlist, &showlist);
4147 add_setshow_string_cmd ("trace-user", class_trace,
4149 Set the user name to use for current and future trace runs"), _("\
4150 Show the user name to use for current and future trace runs"), NULL,
4151 set_trace_user, NULL,
4152 &setlist, &showlist);
4154 add_setshow_string_cmd ("trace-notes", class_trace,
4156 Set notes string to use for current and future trace runs"), _("\
4157 Show the notes string to use for current and future trace runs"), NULL,
4158 set_trace_notes, NULL,
4159 &setlist, &showlist);
4161 add_setshow_string_cmd ("trace-stop-notes", class_trace,
4162 &trace_stop_notes, _("\
4163 Set notes string to use for future tstop commands"), _("\
4164 Show the notes string to use for future tstop commands"), NULL,
4165 set_trace_stop_notes, NULL,
4166 &setlist, &showlist);