1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2014 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"
33 #include "breakpoint.h"
34 #include "tracepoint.h"
37 #include "completer.h"
39 #include "dictionary.h"
41 #include "user-regs.h"
45 #include "filenames.h"
46 #include "gdbthread.h"
53 #include "exceptions.h"
54 #include "cli/cli-utils.h"
57 #include "filestuff.h"
59 /* readline include files */
60 #include "readline/readline.h"
61 #include "readline/history.h"
63 /* readline defines this. */
72 /* Maximum length of an agent aexpression.
73 This accounts for the fact that packets are limited to 400 bytes
74 (which includes everything -- including the checksum), and assumes
75 the worst case of maximum length for each of the pieces of a
78 NOTE: expressions get mem2hex'ed otherwise this would be twice as
79 large. (400 - 31)/2 == 184 */
80 #define MAX_AGENT_EXPR_LEN 184
84 /* A hook used to notify the UI of tracepoint operations. */
86 void (*deprecated_trace_find_hook) (char *arg, int from_tty);
87 void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
92 This module defines the following debugger commands:
93 trace : set a tracepoint on a function, line, or address.
94 info trace : list all debugger-defined tracepoints.
95 delete trace : delete one or more tracepoints.
96 enable trace : enable one or more tracepoints.
97 disable trace : disable one or more tracepoints.
98 actions : specify actions to be taken at a tracepoint.
99 passcount : specify a pass count for a tracepoint.
100 tstart : start a trace experiment.
101 tstop : stop a trace experiment.
102 tstatus : query the status of a trace experiment.
103 tfind : find a trace frame in the trace buffer.
104 tdump : print everything collected at the current tracepoint.
105 save-tracepoints : write tracepoint setup into a file.
107 This module defines the following user-visible debugger variables:
108 $trace_frame : sequence number of trace frame currently being debugged.
109 $trace_line : source line of trace frame currently being debugged.
110 $trace_file : source file of trace frame currently being debugged.
111 $tracepoint : tracepoint number of trace frame currently being debugged.
115 /* ======= Important global variables: ======= */
117 /* The list of all trace state variables. We don't retain pointers to
118 any of these for any reason - API is by name or number only - so it
119 works to have a vector of objects. */
121 typedef struct trace_state_variable tsv_s;
124 static VEC(tsv_s) *tvariables;
126 /* The next integer to assign to a variable. */
128 static int next_tsv_number = 1;
130 /* Number of last traceframe collected. */
131 static int traceframe_number;
133 /* Tracepoint for last traceframe collected. */
134 static int tracepoint_number;
136 /* The traceframe info of the current traceframe. NULL if we haven't
137 yet attempted to fetch it, or if the target does not support
138 fetching this object, or if we're not inspecting a traceframe
140 static struct traceframe_info *traceframe_info;
142 /* Tracing command lists. */
143 static struct cmd_list_element *tfindlist;
145 /* List of expressions to collect by default at each tracepoint hit. */
146 char *default_collect = "";
148 static int disconnected_tracing;
150 /* This variable controls whether we ask the target for a linear or
151 circular trace buffer. */
153 static int circular_trace_buffer;
155 /* This variable is the requested trace buffer size, or -1 to indicate
156 that we don't care and leave it up to the target to set a size. */
158 static int trace_buffer_size = -1;
160 /* Textual notes applying to the current and/or future trace runs. */
162 char *trace_user = NULL;
164 /* Textual notes applying to the current and/or future trace runs. */
166 char *trace_notes = NULL;
168 /* Textual notes applying to the stopping of a trace. */
170 char *trace_stop_notes = NULL;
172 /* ======= Important command functions: ======= */
173 static void trace_actions_command (char *, int);
174 static void trace_start_command (char *, int);
175 static void trace_stop_command (char *, int);
176 static void trace_status_command (char *, int);
177 static void trace_find_command (char *, int);
178 static void trace_find_pc_command (char *, int);
179 static void trace_find_tracepoint_command (char *, int);
180 static void trace_find_line_command (char *, int);
181 static void trace_find_range_command (char *, int);
182 static void trace_find_outside_command (char *, int);
183 static void trace_dump_command (char *, int);
185 /* support routines */
187 struct collection_list;
188 static void add_aexpr (struct collection_list *, struct agent_expr *);
189 static char *mem2hex (gdb_byte *, char *, int);
190 static void add_register (struct collection_list *collection,
193 static void free_uploaded_tps (struct uploaded_tp **utpp);
194 static void free_uploaded_tsvs (struct uploaded_tsv **utsvp);
196 static struct command_line *
197 all_tracepoint_actions_and_cleanup (struct breakpoint *t);
199 extern void _initialize_tracepoint (void);
201 static struct trace_status trace_status;
203 char *stop_reason_names[] = {
213 struct trace_status *
214 current_trace_status (void)
216 return &trace_status;
222 free_traceframe_info (struct traceframe_info *info)
226 VEC_free (mem_range_s, info->memory);
227 VEC_free (int, info->tvars);
233 /* Free and clear the traceframe info cache of the current
237 clear_traceframe_info (void)
239 free_traceframe_info (traceframe_info);
240 traceframe_info = NULL;
243 /* Set traceframe number to NUM. */
245 set_traceframe_num (int num)
247 traceframe_number = num;
248 set_internalvar_integer (lookup_internalvar ("trace_frame"), num);
251 /* Set tracepoint number to NUM. */
253 set_tracepoint_num (int num)
255 tracepoint_number = num;
256 set_internalvar_integer (lookup_internalvar ("tracepoint"), num);
259 /* Set externally visible debug variables for querying/printing
260 the traceframe context (line, function, file). */
263 set_traceframe_context (struct frame_info *trace_frame)
266 struct symbol *traceframe_fun;
267 struct symtab_and_line traceframe_sal;
269 /* Save as globals for internal use. */
270 if (trace_frame != NULL
271 && get_frame_pc_if_available (trace_frame, &trace_pc))
273 traceframe_sal = find_pc_line (trace_pc, 0);
274 traceframe_fun = find_pc_function (trace_pc);
276 /* Save linenumber as "$trace_line", a debugger variable visible to
278 set_internalvar_integer (lookup_internalvar ("trace_line"),
279 traceframe_sal.line);
283 init_sal (&traceframe_sal);
284 traceframe_fun = NULL;
285 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
288 /* Save func name as "$trace_func", a debugger variable visible to
290 if (traceframe_fun == NULL
291 || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
292 clear_internalvar (lookup_internalvar ("trace_func"));
294 set_internalvar_string (lookup_internalvar ("trace_func"),
295 SYMBOL_LINKAGE_NAME (traceframe_fun));
297 /* Save file name as "$trace_file", a debugger variable visible to
299 if (traceframe_sal.symtab == NULL)
300 clear_internalvar (lookup_internalvar ("trace_file"));
302 set_internalvar_string (lookup_internalvar ("trace_file"),
303 symtab_to_filename_for_display (traceframe_sal.symtab));
306 /* Create a new trace state variable with the given name. */
308 struct trace_state_variable *
309 create_trace_state_variable (const char *name)
311 struct trace_state_variable tsv;
313 memset (&tsv, 0, sizeof (tsv));
314 tsv.name = xstrdup (name);
315 tsv.number = next_tsv_number++;
316 return VEC_safe_push (tsv_s, tvariables, &tsv);
319 /* Look for a trace state variable of the given name. */
321 struct trace_state_variable *
322 find_trace_state_variable (const char *name)
324 struct trace_state_variable *tsv;
327 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
328 if (strcmp (name, tsv->name) == 0)
334 /* Look for a trace state variable of the given number. Return NULL if
337 struct trace_state_variable *
338 find_trace_state_variable_by_number (int number)
340 struct trace_state_variable *tsv;
343 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
344 if (tsv->number == number)
351 delete_trace_state_variable (const char *name)
353 struct trace_state_variable *tsv;
356 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
357 if (strcmp (name, tsv->name) == 0)
359 observer_notify_tsv_deleted (tsv);
361 xfree ((void *)tsv->name);
362 VEC_unordered_remove (tsv_s, tvariables, ix);
367 warning (_("No trace variable named \"$%s\", not deleting"), name);
370 /* Throws an error if NAME is not valid syntax for a trace state
374 validate_trace_state_variable_name (const char *name)
379 error (_("Must supply a non-empty variable name"));
381 /* All digits in the name is reserved for value history
383 for (p = name; isdigit (*p); p++)
386 error (_("$%s is not a valid trace state variable name"), name);
388 for (p = name; isalnum (*p) || *p == '_'; p++)
391 error (_("$%s is not a valid trace state variable name"), name);
394 /* The 'tvariable' command collects a name and optional expression to
395 evaluate into an initial value. */
398 trace_variable_command (char *args, int from_tty)
400 struct cleanup *old_chain;
402 struct trace_state_variable *tsv;
406 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
408 /* Only allow two syntaxes; "$name" and "$name=value". */
409 p = skip_spaces (args);
412 error (_("Name of trace variable should start with '$'"));
415 while (isalnum (*p) || *p == '_')
417 name = savestring (name, p - name);
418 old_chain = make_cleanup (xfree, name);
421 if (*p != '=' && *p != '\0')
422 error (_("Syntax must be $NAME [ = EXPR ]"));
424 validate_trace_state_variable_name (name);
427 initval = value_as_long (parse_and_eval (++p));
429 /* If the variable already exists, just change its initial value. */
430 tsv = find_trace_state_variable (name);
433 if (tsv->initial_value != initval)
435 tsv->initial_value = initval;
436 observer_notify_tsv_modified (tsv);
438 printf_filtered (_("Trace state variable $%s "
439 "now has initial value %s.\n"),
440 tsv->name, plongest (tsv->initial_value));
441 do_cleanups (old_chain);
445 /* Create a new variable. */
446 tsv = create_trace_state_variable (name);
447 tsv->initial_value = initval;
449 observer_notify_tsv_created (tsv);
451 printf_filtered (_("Trace state variable $%s "
452 "created, with initial value %s.\n"),
453 tsv->name, plongest (tsv->initial_value));
455 do_cleanups (old_chain);
459 delete_trace_variable_command (char *args, int from_tty)
463 struct cleanup *back_to;
467 if (query (_("Delete all trace state variables? ")))
468 VEC_free (tsv_s, tvariables);
470 observer_notify_tsv_deleted (NULL);
474 argv = gdb_buildargv (args);
475 back_to = make_cleanup_freeargv (argv);
477 for (ix = 0; argv[ix] != NULL; ix++)
479 if (*argv[ix] == '$')
480 delete_trace_state_variable (argv[ix] + 1);
482 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv[ix]);
485 do_cleanups (back_to);
491 tvariables_info_1 (void)
493 struct trace_state_variable *tsv;
496 struct cleanup *back_to;
497 struct ui_out *uiout = current_uiout;
499 if (VEC_length (tsv_s, tvariables) == 0 && !ui_out_is_mi_like_p (uiout))
501 printf_filtered (_("No trace state variables.\n"));
505 /* Try to acquire values from the target. */
506 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix, ++count)
507 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
510 back_to = make_cleanup_ui_out_table_begin_end (uiout, 3,
511 count, "trace-variables");
512 ui_out_table_header (uiout, 15, ui_left, "name", "Name");
513 ui_out_table_header (uiout, 11, ui_left, "initial", "Initial");
514 ui_out_table_header (uiout, 11, ui_left, "current", "Current");
516 ui_out_table_body (uiout);
518 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
520 struct cleanup *back_to2;
524 back_to2 = make_cleanup_ui_out_tuple_begin_end (uiout, "variable");
526 name = concat ("$", tsv->name, (char *) NULL);
527 make_cleanup (xfree, name);
528 ui_out_field_string (uiout, "name", name);
529 ui_out_field_string (uiout, "initial", plongest (tsv->initial_value));
531 if (tsv->value_known)
532 c = plongest (tsv->value);
533 else if (ui_out_is_mi_like_p (uiout))
534 /* For MI, we prefer not to use magic string constants, but rather
535 omit the field completely. The difference between unknown and
536 undefined does not seem important enough to represent. */
538 else if (current_trace_status ()->running || traceframe_number >= 0)
539 /* The value is/was defined, but we don't have it. */
542 /* It is not meaningful to ask about the value. */
545 ui_out_field_string (uiout, "current", c);
546 ui_out_text (uiout, "\n");
548 do_cleanups (back_to2);
551 do_cleanups (back_to);
554 /* List all the trace state variables. */
557 tvariables_info (char *args, int from_tty)
559 tvariables_info_1 ();
562 /* Stash definitions of tsvs into the given file. */
565 save_trace_state_variables (struct ui_file *fp)
567 struct trace_state_variable *tsv;
570 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
572 fprintf_unfiltered (fp, "tvariable $%s", tsv->name);
573 if (tsv->initial_value)
574 fprintf_unfiltered (fp, " = %s", plongest (tsv->initial_value));
575 fprintf_unfiltered (fp, "\n");
579 /* ACTIONS functions: */
581 /* The three functions:
582 collect_pseudocommand,
583 while_stepping_pseudocommand, and
584 end_actions_pseudocommand
585 are placeholders for "commands" that are actually ONLY to be used
586 within a tracepoint action list. If the actual function is ever called,
587 it means that somebody issued the "command" at the top level,
588 which is always an error. */
591 end_actions_pseudocommand (char *args, int from_tty)
593 error (_("This command cannot be used at the top level."));
597 while_stepping_pseudocommand (char *args, int from_tty)
599 error (_("This command can only be used in a tracepoint actions list."));
603 collect_pseudocommand (char *args, int from_tty)
605 error (_("This command can only be used in a tracepoint actions list."));
609 teval_pseudocommand (char *args, int from_tty)
611 error (_("This command can only be used in a tracepoint actions list."));
614 /* Parse any collection options, such as /s for strings. */
617 decode_agent_options (const char *exp, int *trace_string)
619 struct value_print_options opts;
626 /* Call this to borrow the print elements default for collection
628 get_user_print_options (&opts);
633 if (target_supports_string_tracing ())
635 /* Allow an optional decimal number giving an explicit maximum
636 string length, defaulting it to the "print elements" value;
637 so "collect/s80 mystr" gets at most 80 bytes of string. */
638 *trace_string = opts.print_max;
640 if (*exp >= '0' && *exp <= '9')
641 *trace_string = atoi (exp);
642 while (*exp >= '0' && *exp <= '9')
646 error (_("Target does not support \"/s\" option for string tracing."));
649 error (_("Undefined collection format \"%c\"."), *exp);
651 exp = skip_spaces_const (exp);
656 /* Enter a list of actions for a tracepoint. */
658 trace_actions_command (char *args, int from_tty)
660 struct tracepoint *t;
661 struct command_line *l;
663 t = get_tracepoint_by_number (&args, NULL, 1);
667 xstrprintf ("Enter actions for tracepoint %d, one per line.",
669 struct cleanup *cleanups = make_cleanup (xfree, tmpbuf);
671 l = read_command_lines (tmpbuf, from_tty, 1,
672 check_tracepoint_command, t);
673 do_cleanups (cleanups);
674 breakpoint_set_commands (&t->base, l);
676 /* else just return */
679 /* Report the results of checking the agent expression, as errors or
683 report_agent_reqs_errors (struct agent_expr *aexpr)
685 /* All of the "flaws" are serious bytecode generation issues that
686 should never occur. */
687 if (aexpr->flaw != agent_flaw_none)
688 internal_error (__FILE__, __LINE__, _("expression is malformed"));
690 /* If analysis shows a stack underflow, GDB must have done something
691 badly wrong in its bytecode generation. */
692 if (aexpr->min_height < 0)
693 internal_error (__FILE__, __LINE__,
694 _("expression has min height < 0"));
696 /* Issue this error if the stack is predicted to get too deep. The
697 limit is rather arbitrary; a better scheme might be for the
698 target to report how much stack it will have available. The
699 depth roughly corresponds to parenthesization, so a limit of 20
700 amounts to 20 levels of expression nesting, which is actually
701 a pretty big hairy expression. */
702 if (aexpr->max_height > 20)
703 error (_("Expression is too complicated."));
706 /* worker function */
708 validate_actionline (const char *line, struct breakpoint *b)
710 struct cmd_list_element *c;
711 struct expression *exp = NULL;
712 struct cleanup *old_chain = NULL;
715 struct bp_location *loc;
716 struct agent_expr *aexpr;
717 struct tracepoint *t = (struct tracepoint *) b;
719 /* If EOF is typed, *line is NULL. */
723 p = skip_spaces_const (line);
725 /* Symbol lookup etc. */
726 if (*p == '\0') /* empty line: just prompt for another line. */
729 if (*p == '#') /* comment line */
732 c = lookup_cmd (&p, cmdlist, "", -1, 1);
734 error (_("`%s' is not a tracepoint action, or is ambiguous."), p);
736 if (cmd_cfunc_eq (c, collect_pseudocommand))
738 int trace_string = 0;
741 p = decode_agent_options (p, &trace_string);
744 { /* Repeat over a comma-separated list. */
745 QUIT; /* Allow user to bail out with ^C. */
746 p = skip_spaces_const (p);
748 if (*p == '$') /* Look for special pseudo-symbols. */
750 if (0 == strncasecmp ("reg", p + 1, 3)
751 || 0 == strncasecmp ("arg", p + 1, 3)
752 || 0 == strncasecmp ("loc", p + 1, 3)
753 || 0 == strncasecmp ("_ret", p + 1, 4)
754 || 0 == strncasecmp ("_sdata", p + 1, 6))
759 /* else fall thru, treat p as an expression and parse it! */
762 for (loc = t->base.loc; loc; loc = loc->next)
765 exp = parse_exp_1 (&p, loc->address,
766 block_for_pc (loc->address), 1);
767 old_chain = make_cleanup (free_current_contents, &exp);
769 if (exp->elts[0].opcode == OP_VAR_VALUE)
771 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
773 error (_("constant `%s' (value %s) "
774 "will not be collected."),
775 SYMBOL_PRINT_NAME (exp->elts[2].symbol),
776 plongest (SYMBOL_VALUE (exp->elts[2].symbol)));
778 else if (SYMBOL_CLASS (exp->elts[2].symbol)
779 == LOC_OPTIMIZED_OUT)
781 error (_("`%s' is optimized away "
782 "and cannot be collected."),
783 SYMBOL_PRINT_NAME (exp->elts[2].symbol));
787 /* We have something to collect, make sure that the expr to
788 bytecode translator can handle it and that it's not too
790 aexpr = gen_trace_for_expr (loc->address, exp, trace_string);
791 make_cleanup_free_agent_expr (aexpr);
793 if (aexpr->len > MAX_AGENT_EXPR_LEN)
794 error (_("Expression is too complicated."));
798 report_agent_reqs_errors (aexpr);
800 do_cleanups (old_chain);
803 while (p && *p++ == ',');
806 else if (cmd_cfunc_eq (c, teval_pseudocommand))
809 { /* Repeat over a comma-separated list. */
810 QUIT; /* Allow user to bail out with ^C. */
811 p = skip_spaces_const (p);
814 for (loc = t->base.loc; loc; loc = loc->next)
818 /* Only expressions are allowed for this action. */
819 exp = parse_exp_1 (&p, loc->address,
820 block_for_pc (loc->address), 1);
821 old_chain = make_cleanup (free_current_contents, &exp);
823 /* We have something to evaluate, make sure that the expr to
824 bytecode translator can handle it and that it's not too
826 aexpr = gen_eval_for_expr (loc->address, exp);
827 make_cleanup_free_agent_expr (aexpr);
829 if (aexpr->len > MAX_AGENT_EXPR_LEN)
830 error (_("Expression is too complicated."));
833 report_agent_reqs_errors (aexpr);
835 do_cleanups (old_chain);
838 while (p && *p++ == ',');
841 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
845 p = skip_spaces_const (p);
846 t->step_count = strtol (p, &endp, 0);
847 if (endp == p || t->step_count == 0)
848 error (_("while-stepping step count `%s' is malformed."), line);
852 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
856 error (_("`%s' is not a supported tracepoint action."), line);
860 memrange_absolute = -1
863 /* MEMRANGE functions: */
865 static int memrange_cmp (const void *, const void *);
867 /* Compare memranges for qsort. */
869 memrange_cmp (const void *va, const void *vb)
871 const struct memrange *a = va, *b = vb;
873 if (a->type < b->type)
875 if (a->type > b->type)
877 if (a->type == memrange_absolute)
879 if ((bfd_vma) a->start < (bfd_vma) b->start)
881 if ((bfd_vma) a->start > (bfd_vma) b->start)
886 if (a->start < b->start)
888 if (a->start > b->start)
894 /* Sort the memrange list using qsort, and merge adjacent memranges. */
896 memrange_sortmerge (struct collection_list *memranges)
900 qsort (memranges->list, memranges->next_memrange,
901 sizeof (struct memrange), memrange_cmp);
902 if (memranges->next_memrange > 0)
904 for (a = 0, b = 1; b < memranges->next_memrange; b++)
906 /* If memrange b overlaps or is adjacent to memrange a,
908 if (memranges->list[a].type == memranges->list[b].type
909 && memranges->list[b].start <= memranges->list[a].end)
911 if (memranges->list[b].end > memranges->list[a].end)
912 memranges->list[a].end = memranges->list[b].end;
913 continue; /* next b, same a */
917 memcpy (&memranges->list[a], &memranges->list[b],
918 sizeof (struct memrange));
920 memranges->next_memrange = a + 1;
924 /* Add a register to a collection list. */
926 add_register (struct collection_list *collection, unsigned int regno)
929 printf_filtered ("collect register %d\n", regno);
930 if (regno >= (8 * sizeof (collection->regs_mask)))
931 error (_("Internal: register number %d too large for tracepoint"),
933 collection->regs_mask[regno / 8] |= 1 << (regno % 8);
936 /* Add a memrange to a collection list. */
938 add_memrange (struct collection_list *memranges,
939 int type, bfd_signed_vma base,
944 printf_filtered ("(%d,", type);
946 printf_filtered (",%ld)\n", len);
949 /* type: memrange_absolute == memory, other n == basereg */
950 memranges->list[memranges->next_memrange].type = type;
951 /* base: addr if memory, offset if reg relative. */
952 memranges->list[memranges->next_memrange].start = base;
953 /* len: we actually save end (base + len) for convenience */
954 memranges->list[memranges->next_memrange].end = base + len;
955 memranges->next_memrange++;
956 if (memranges->next_memrange >= memranges->listsize)
958 memranges->listsize *= 2;
959 memranges->list = xrealloc (memranges->list,
960 memranges->listsize);
963 if (type != memrange_absolute) /* Better collect the base register! */
964 add_register (memranges, type);
967 /* Add a symbol to a collection list. */
969 collect_symbol (struct collection_list *collect,
971 struct gdbarch *gdbarch,
972 long frame_regno, long frame_offset,
978 bfd_signed_vma offset;
979 int treat_as_expr = 0;
981 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
982 switch (SYMBOL_CLASS (sym))
985 printf_filtered ("%s: don't know symbol class %d\n",
986 SYMBOL_PRINT_NAME (sym),
990 printf_filtered ("constant %s (value %s) will not be collected.\n",
991 SYMBOL_PRINT_NAME (sym), plongest (SYMBOL_VALUE (sym)));
994 offset = SYMBOL_VALUE_ADDRESS (sym);
999 sprintf_vma (tmp, offset);
1000 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1001 SYMBOL_PRINT_NAME (sym), len,
1004 /* A struct may be a C++ class with static fields, go to general
1005 expression handling. */
1006 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
1009 add_memrange (collect, memrange_absolute, offset, len);
1012 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
1014 printf_filtered ("LOC_REG[parm] %s: ",
1015 SYMBOL_PRINT_NAME (sym));
1016 add_register (collect, reg);
1017 /* Check for doubles stored in two registers. */
1018 /* FIXME: how about larger types stored in 3 or more regs? */
1019 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
1020 len > register_size (gdbarch, reg))
1021 add_register (collect, reg + 1);
1024 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1025 printf_filtered (" (will not collect %s)\n",
1026 SYMBOL_PRINT_NAME (sym));
1030 offset = frame_offset + SYMBOL_VALUE (sym);
1033 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1034 SYMBOL_PRINT_NAME (sym), len);
1035 printf_vma (offset);
1036 printf_filtered (" from frame ptr reg %d\n", reg);
1038 add_memrange (collect, reg, offset, len);
1040 case LOC_REGPARM_ADDR:
1041 reg = SYMBOL_VALUE (sym);
1045 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1046 SYMBOL_PRINT_NAME (sym), len);
1047 printf_vma (offset);
1048 printf_filtered (" from reg %d\n", reg);
1050 add_memrange (collect, reg, offset, len);
1054 offset = frame_offset + SYMBOL_VALUE (sym);
1057 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1058 SYMBOL_PRINT_NAME (sym), len);
1059 printf_vma (offset);
1060 printf_filtered (" from frame ptr reg %d\n", reg);
1062 add_memrange (collect, reg, offset, len);
1065 case LOC_UNRESOLVED:
1069 case LOC_OPTIMIZED_OUT:
1070 printf_filtered ("%s has been optimized out of existence.\n",
1071 SYMBOL_PRINT_NAME (sym));
1079 /* Expressions are the most general case. */
1082 struct agent_expr *aexpr;
1083 struct cleanup *old_chain1 = NULL;
1085 aexpr = gen_trace_for_var (scope, gdbarch, sym, trace_string);
1087 /* It can happen that the symbol is recorded as a computed
1088 location, but it's been optimized away and doesn't actually
1089 have a location expression. */
1092 printf_filtered ("%s has been optimized out of existence.\n",
1093 SYMBOL_PRINT_NAME (sym));
1097 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1101 report_agent_reqs_errors (aexpr);
1103 discard_cleanups (old_chain1);
1104 add_aexpr (collect, aexpr);
1106 /* Take care of the registers. */
1107 if (aexpr->reg_mask_len > 0)
1111 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1113 QUIT; /* Allow user to bail out with ^C. */
1114 if (aexpr->reg_mask[ndx1] != 0)
1116 /* Assume chars have 8 bits. */
1117 for (ndx2 = 0; ndx2 < 8; ndx2++)
1118 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1119 /* It's used -- record it. */
1120 add_register (collect, ndx1 * 8 + ndx2);
1127 /* Data to be passed around in the calls to the locals and args
1130 struct add_local_symbols_data
1132 struct collection_list *collect;
1133 struct gdbarch *gdbarch;
1141 /* The callback for the locals and args iterators. */
1144 do_collect_symbol (const char *print_name,
1148 struct add_local_symbols_data *p = cb_data;
1150 collect_symbol (p->collect, sym, p->gdbarch, p->frame_regno,
1151 p->frame_offset, p->pc, p->trace_string);
1154 VEC_safe_push (char_ptr, p->collect->wholly_collected,
1155 xstrdup (print_name));
1158 /* Add all locals (or args) symbols to collection list. */
1160 add_local_symbols (struct collection_list *collect,
1161 struct gdbarch *gdbarch, CORE_ADDR pc,
1162 long frame_regno, long frame_offset, int type,
1165 struct block *block;
1166 struct add_local_symbols_data cb_data;
1168 cb_data.collect = collect;
1169 cb_data.gdbarch = gdbarch;
1171 cb_data.frame_regno = frame_regno;
1172 cb_data.frame_offset = frame_offset;
1174 cb_data.trace_string = trace_string;
1178 block = block_for_pc (pc);
1181 warning (_("Can't collect locals; "
1182 "no symbol table info available.\n"));
1186 iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1187 if (cb_data.count == 0)
1188 warning (_("No locals found in scope."));
1192 pc = get_pc_function_start (pc);
1193 block = block_for_pc (pc);
1196 warning (_("Can't collect args; no symbol table info available."));
1200 iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1201 if (cb_data.count == 0)
1202 warning (_("No args found in scope."));
1207 add_static_trace_data (struct collection_list *collection)
1210 printf_filtered ("collect static trace data\n");
1211 collection->strace_data = 1;
1214 /* worker function */
1216 clear_collection_list (struct collection_list *list)
1220 list->next_memrange = 0;
1221 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1223 free_agent_expr (list->aexpr_list[ndx]);
1224 list->aexpr_list[ndx] = NULL;
1226 list->next_aexpr_elt = 0;
1227 memset (list->regs_mask, 0, sizeof (list->regs_mask));
1228 list->strace_data = 0;
1230 xfree (list->aexpr_list);
1233 VEC_free (char_ptr, list->wholly_collected);
1234 VEC_free (char_ptr, list->computed);
1237 /* A cleanup wrapper for function clear_collection_list. */
1240 do_clear_collection_list (void *list)
1242 struct collection_list *l = list;
1244 clear_collection_list (l);
1247 /* Initialize collection_list CLIST. */
1250 init_collection_list (struct collection_list *clist)
1252 memset (clist, 0, sizeof *clist);
1254 clist->listsize = 128;
1255 clist->list = xcalloc (clist->listsize,
1256 sizeof (struct memrange));
1258 clist->aexpr_listsize = 128;
1259 clist->aexpr_list = xcalloc (clist->aexpr_listsize,
1260 sizeof (struct agent_expr *));
1263 /* Reduce a collection list to string form (for gdb protocol). */
1265 stringify_collection_list (struct collection_list *list)
1267 char temp_buf[2048];
1271 char *(*str_list)[];
1275 count = 1 + 1 + list->next_memrange + list->next_aexpr_elt + 1;
1276 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1278 if (list->strace_data)
1281 printf_filtered ("\nCollecting static trace data\n");
1284 (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
1288 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1289 if (list->regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */
1291 if (list->regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
1294 printf_filtered ("\nCollecting registers (mask): 0x");
1299 QUIT; /* Allow user to bail out with ^C. */
1301 printf_filtered ("%02X", list->regs_mask[i]);
1302 sprintf (end, "%02X", list->regs_mask[i]);
1305 (*str_list)[ndx] = xstrdup (temp_buf);
1309 printf_filtered ("\n");
1310 if (list->next_memrange > 0 && info_verbose)
1311 printf_filtered ("Collecting memranges: \n");
1312 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1314 QUIT; /* Allow user to bail out with ^C. */
1315 sprintf_vma (tmp2, list->list[i].start);
1318 printf_filtered ("(%d, %s, %ld)\n",
1321 (long) (list->list[i].end - list->list[i].start));
1323 if (count + 27 > MAX_AGENT_EXPR_LEN)
1325 (*str_list)[ndx] = savestring (temp_buf, count);
1332 bfd_signed_vma length = list->list[i].end - list->list[i].start;
1334 /* The "%X" conversion specifier expects an unsigned argument,
1335 so passing -1 (memrange_absolute) to it directly gives you
1336 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1338 if (list->list[i].type == memrange_absolute)
1339 sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
1341 sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
1344 count += strlen (end);
1345 end = temp_buf + count;
1348 for (i = 0; i < list->next_aexpr_elt; i++)
1350 QUIT; /* Allow user to bail out with ^C. */
1351 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1353 (*str_list)[ndx] = savestring (temp_buf, count);
1358 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1359 end += 10; /* 'X' + 8 hex digits + ',' */
1362 end = mem2hex (list->aexpr_list[i]->buf,
1363 end, list->aexpr_list[i]->len);
1364 count += 2 * list->aexpr_list[i]->len;
1369 (*str_list)[ndx] = savestring (temp_buf, count);
1374 (*str_list)[ndx] = NULL;
1385 /* Add the printed expression EXP to *LIST. */
1388 append_exp (struct expression *exp, VEC(char_ptr) **list)
1390 struct ui_file *tmp_stream = mem_fileopen ();
1393 print_expression (exp, tmp_stream);
1395 text = ui_file_xstrdup (tmp_stream, NULL);
1397 VEC_safe_push (char_ptr, *list, text);
1398 ui_file_delete (tmp_stream);
1402 encode_actions_1 (struct command_line *action,
1403 struct bp_location *tloc,
1405 LONGEST frame_offset,
1406 struct collection_list *collect,
1407 struct collection_list *stepping_list)
1409 const char *action_exp;
1410 struct expression *exp = NULL;
1412 struct value *tempval;
1413 struct cmd_list_element *cmd;
1414 struct agent_expr *aexpr;
1416 for (; action; action = action->next)
1418 QUIT; /* Allow user to bail out with ^C. */
1419 action_exp = action->line;
1420 action_exp = skip_spaces_const (action_exp);
1422 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1424 error (_("Bad action list item: %s"), action_exp);
1426 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1428 int trace_string = 0;
1430 if (*action_exp == '/')
1431 action_exp = decode_agent_options (action_exp, &trace_string);
1434 { /* Repeat over a comma-separated list. */
1435 QUIT; /* Allow user to bail out with ^C. */
1436 action_exp = skip_spaces_const (action_exp);
1438 if (0 == strncasecmp ("$reg", action_exp, 4))
1440 for (i = 0; i < gdbarch_num_regs (tloc->gdbarch); i++)
1441 add_register (collect, i);
1442 action_exp = strchr (action_exp, ','); /* more? */
1444 else if (0 == strncasecmp ("$arg", action_exp, 4))
1446 add_local_symbols (collect,
1453 action_exp = strchr (action_exp, ','); /* more? */
1455 else if (0 == strncasecmp ("$loc", action_exp, 4))
1457 add_local_symbols (collect,
1464 action_exp = strchr (action_exp, ','); /* more? */
1466 else if (0 == strncasecmp ("$_ret", action_exp, 5))
1468 struct cleanup *old_chain1 = NULL;
1470 aexpr = gen_trace_for_return_address (tloc->address,
1474 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1477 report_agent_reqs_errors (aexpr);
1479 discard_cleanups (old_chain1);
1480 add_aexpr (collect, aexpr);
1482 /* take care of the registers */
1483 if (aexpr->reg_mask_len > 0)
1487 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1489 QUIT; /* allow user to bail out with ^C */
1490 if (aexpr->reg_mask[ndx1] != 0)
1492 /* assume chars have 8 bits */
1493 for (ndx2 = 0; ndx2 < 8; ndx2++)
1494 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1495 /* it's used -- record it */
1496 add_register (collect,
1502 action_exp = strchr (action_exp, ','); /* more? */
1504 else if (0 == strncasecmp ("$_sdata", action_exp, 7))
1506 add_static_trace_data (collect);
1507 action_exp = strchr (action_exp, ','); /* more? */
1512 struct cleanup *old_chain = NULL;
1513 struct cleanup *old_chain1 = NULL;
1515 exp = parse_exp_1 (&action_exp, tloc->address,
1516 block_for_pc (tloc->address), 1);
1517 old_chain = make_cleanup (free_current_contents, &exp);
1519 switch (exp->elts[0].opcode)
1523 const char *name = &exp->elts[2].string;
1525 i = user_reg_map_name_to_regnum (tloc->gdbarch,
1526 name, strlen (name));
1528 internal_error (__FILE__, __LINE__,
1529 _("Register $%s not available"),
1532 printf_filtered ("OP_REGISTER: ");
1533 add_register (collect, i);
1538 /* Safe because we know it's a simple expression. */
1539 tempval = evaluate_expression (exp);
1540 addr = value_address (tempval);
1541 /* Initialize the TYPE_LENGTH if it is a typedef. */
1542 check_typedef (exp->elts[1].type);
1543 add_memrange (collect, memrange_absolute, addr,
1544 TYPE_LENGTH (exp->elts[1].type));
1545 append_exp (exp, &collect->computed);
1550 struct symbol *sym = exp->elts[2].symbol;
1551 char_ptr name = (char_ptr) SYMBOL_NATURAL_NAME (sym);
1553 collect_symbol (collect,
1554 exp->elts[2].symbol,
1560 VEC_safe_push (char_ptr,
1561 collect->wholly_collected,
1566 default: /* Full-fledged expression. */
1567 aexpr = gen_trace_for_expr (tloc->address, exp,
1570 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1574 report_agent_reqs_errors (aexpr);
1576 discard_cleanups (old_chain1);
1577 add_aexpr (collect, aexpr);
1579 /* Take care of the registers. */
1580 if (aexpr->reg_mask_len > 0)
1585 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1587 QUIT; /* Allow user to bail out with ^C. */
1588 if (aexpr->reg_mask[ndx1] != 0)
1590 /* Assume chars have 8 bits. */
1591 for (ndx2 = 0; ndx2 < 8; ndx2++)
1592 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1593 /* It's used -- record it. */
1594 add_register (collect,
1600 append_exp (exp, &collect->computed);
1603 do_cleanups (old_chain);
1606 while (action_exp && *action_exp++ == ',');
1608 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1611 { /* Repeat over a comma-separated list. */
1612 QUIT; /* Allow user to bail out with ^C. */
1613 action_exp = skip_spaces_const (action_exp);
1616 struct cleanup *old_chain = NULL;
1617 struct cleanup *old_chain1 = NULL;
1619 exp = parse_exp_1 (&action_exp, tloc->address,
1620 block_for_pc (tloc->address), 1);
1621 old_chain = make_cleanup (free_current_contents, &exp);
1623 aexpr = gen_eval_for_expr (tloc->address, exp);
1624 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1627 report_agent_reqs_errors (aexpr);
1629 discard_cleanups (old_chain1);
1630 /* Even though we're not officially collecting, add
1631 to the collect list anyway. */
1632 add_aexpr (collect, aexpr);
1634 do_cleanups (old_chain);
1637 while (action_exp && *action_exp++ == ',');
1639 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1641 /* We check against nested while-stepping when setting
1642 breakpoint action, so no way to run into nested
1644 gdb_assert (stepping_list);
1646 encode_actions_1 (action->body_list[0], tloc, frame_reg,
1647 frame_offset, stepping_list, NULL);
1650 error (_("Invalid tracepoint command '%s'"), action->line);
1654 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1655 and STEPPING_LIST. Return a cleanup pointer to clean up both
1656 TRACEPOINT_LIST and STEPPING_LIST. */
1659 encode_actions_and_make_cleanup (struct bp_location *tloc,
1660 struct collection_list *tracepoint_list,
1661 struct collection_list *stepping_list)
1663 char *default_collect_line = NULL;
1664 struct command_line *actions;
1665 struct command_line *default_collect_action = NULL;
1667 LONGEST frame_offset;
1668 struct cleanup *back_to, *return_chain;
1670 return_chain = make_cleanup (null_cleanup, NULL);
1671 init_collection_list (tracepoint_list);
1672 init_collection_list (stepping_list);
1674 make_cleanup (do_clear_collection_list, tracepoint_list);
1675 make_cleanup (do_clear_collection_list, stepping_list);
1677 back_to = make_cleanup (null_cleanup, NULL);
1678 gdbarch_virtual_frame_pointer (tloc->gdbarch,
1679 tloc->address, &frame_reg, &frame_offset);
1681 actions = all_tracepoint_actions_and_cleanup (tloc->owner);
1683 encode_actions_1 (actions, tloc, frame_reg, frame_offset,
1684 tracepoint_list, stepping_list);
1686 memrange_sortmerge (tracepoint_list);
1687 memrange_sortmerge (stepping_list);
1689 do_cleanups (back_to);
1690 return return_chain;
1693 /* Render all actions into gdb protocol. */
1696 encode_actions_rsp (struct bp_location *tloc, char ***tdp_actions,
1697 char ***stepping_actions)
1699 struct collection_list tracepoint_list, stepping_list;
1700 struct cleanup *cleanup;
1702 *tdp_actions = NULL;
1703 *stepping_actions = NULL;
1705 cleanup = encode_actions_and_make_cleanup (tloc, &tracepoint_list,
1708 *tdp_actions = stringify_collection_list (&tracepoint_list);
1709 *stepping_actions = stringify_collection_list (&stepping_list);
1711 do_cleanups (cleanup);
1715 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1717 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1719 collect->aexpr_list =
1720 xrealloc (collect->aexpr_list,
1721 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1722 collect->aexpr_listsize *= 2;
1724 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1725 collect->next_aexpr_elt++;
1729 process_tracepoint_on_disconnect (void)
1731 VEC(breakpoint_p) *tp_vec = NULL;
1733 struct breakpoint *b;
1734 int has_pending_p = 0;
1736 /* Check whether we still have pending tracepoint. If we have, warn the
1737 user that pending tracepoint will no longer work. */
1738 tp_vec = all_tracepoints ();
1739 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1748 struct bp_location *loc1;
1750 for (loc1 = b->loc; loc1; loc1 = loc1->next)
1752 if (loc1->shlib_disabled)
1763 VEC_free (breakpoint_p, tp_vec);
1766 warning (_("Pending tracepoints will not be resolved while"
1767 " GDB is disconnected\n"));
1770 /* Reset local state of tracing. */
1773 trace_reset_local_state (void)
1775 set_traceframe_num (-1);
1776 set_tracepoint_num (-1);
1777 set_traceframe_context (NULL);
1778 clear_traceframe_info ();
1782 start_tracing (char *notes)
1784 VEC(breakpoint_p) *tp_vec = NULL;
1786 struct breakpoint *b;
1787 struct trace_state_variable *tsv;
1788 int any_enabled = 0, num_to_download = 0;
1791 tp_vec = all_tracepoints ();
1793 /* No point in tracing without any tracepoints... */
1794 if (VEC_length (breakpoint_p, tp_vec) == 0)
1796 VEC_free (breakpoint_p, tp_vec);
1797 error (_("No tracepoints defined, not starting trace"));
1800 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1802 struct tracepoint *t = (struct tracepoint *) b;
1803 struct bp_location *loc;
1805 if (b->enable_state == bp_enabled)
1808 if ((b->type == bp_fast_tracepoint
1809 ? may_insert_fast_tracepoints
1810 : may_insert_tracepoints))
1813 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1814 (b->type == bp_fast_tracepoint ? "fast " : ""), b->number);
1819 if (target_supports_enable_disable_tracepoint ())
1820 warning (_("No tracepoints enabled"));
1823 /* No point in tracing with only disabled tracepoints that
1824 cannot be re-enabled. */
1825 VEC_free (breakpoint_p, tp_vec);
1826 error (_("No tracepoints enabled, not starting trace"));
1830 if (num_to_download <= 0)
1832 VEC_free (breakpoint_p, tp_vec);
1833 error (_("No tracepoints that may be downloaded, not starting trace"));
1836 target_trace_init ();
1838 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1840 struct tracepoint *t = (struct tracepoint *) b;
1841 struct bp_location *loc;
1842 int bp_location_downloaded = 0;
1844 /* Clear `inserted' flag. */
1845 for (loc = b->loc; loc; loc = loc->next)
1848 if ((b->type == bp_fast_tracepoint
1849 ? !may_insert_fast_tracepoints
1850 : !may_insert_tracepoints))
1853 t->number_on_target = 0;
1855 for (loc = b->loc; loc; loc = loc->next)
1857 /* Since tracepoint locations are never duplicated, `inserted'
1858 flag should be zero. */
1859 gdb_assert (!loc->inserted);
1861 target_download_tracepoint (loc);
1864 bp_location_downloaded = 1;
1867 t->number_on_target = b->number;
1869 for (loc = b->loc; loc; loc = loc->next)
1870 if (loc->probe != NULL)
1871 loc->probe->pops->set_semaphore (loc->probe, loc->gdbarch);
1873 if (bp_location_downloaded)
1874 observer_notify_breakpoint_modified (b);
1876 VEC_free (breakpoint_p, tp_vec);
1878 /* Send down all the trace state variables too. */
1879 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1881 target_download_trace_state_variable (tsv);
1884 /* Tell target to treat text-like sections as transparent. */
1885 target_trace_set_readonly_regions ();
1886 /* Set some mode flags. */
1887 target_set_disconnected_tracing (disconnected_tracing);
1888 target_set_circular_trace_buffer (circular_trace_buffer);
1889 target_set_trace_buffer_size (trace_buffer_size);
1892 notes = trace_notes;
1893 ret = target_set_trace_notes (trace_user, notes, NULL);
1895 if (!ret && (trace_user || notes))
1896 warning (_("Target does not support trace user/notes, info ignored"));
1898 /* Now insert traps and begin collecting data. */
1899 target_trace_start ();
1901 /* Reset our local state. */
1902 trace_reset_local_state ();
1903 current_trace_status()->running = 1;
1906 /* The tstart command requests the target to start a new trace run.
1907 The command passes any arguments it has to the target verbatim, as
1908 an optional "trace note". This is useful as for instance a warning
1909 to other users if the trace runs disconnected, and you don't want
1910 anybody else messing with the target. */
1913 trace_start_command (char *args, int from_tty)
1915 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1917 if (current_trace_status ()->running)
1920 && !query (_("A trace is running already. Start a new run? ")))
1921 error (_("New trace run not started."));
1924 start_tracing (args);
1927 /* The tstop command stops the tracing run. The command passes any
1928 supplied arguments to the target verbatim as a "stop note"; if the
1929 target supports trace notes, then it will be reported back as part
1930 of the trace run's status. */
1933 trace_stop_command (char *args, int from_tty)
1935 if (!current_trace_status ()->running)
1936 error (_("Trace is not running."));
1938 stop_tracing (args);
1942 stop_tracing (char *note)
1945 VEC(breakpoint_p) *tp_vec = NULL;
1947 struct breakpoint *t;
1949 target_trace_stop ();
1951 tp_vec = all_tracepoints ();
1952 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1954 struct bp_location *loc;
1956 if ((t->type == bp_fast_tracepoint
1957 ? !may_insert_fast_tracepoints
1958 : !may_insert_tracepoints))
1961 for (loc = t->loc; loc; loc = loc->next)
1963 /* GDB can be totally absent in some disconnected trace scenarios,
1964 but we don't really care if this semaphore goes out of sync.
1965 That's why we are decrementing it here, but not taking care
1967 if (loc->probe != NULL)
1968 loc->probe->pops->clear_semaphore (loc->probe, loc->gdbarch);
1972 VEC_free (breakpoint_p, tp_vec);
1975 note = trace_stop_notes;
1976 ret = target_set_trace_notes (NULL, NULL, note);
1979 warning (_("Target does not support trace notes, note ignored"));
1981 /* Should change in response to reply? */
1982 current_trace_status ()->running = 0;
1985 /* tstatus command */
1987 trace_status_command (char *args, int from_tty)
1989 struct trace_status *ts = current_trace_status ();
1991 VEC(breakpoint_p) *tp_vec = NULL;
1992 struct breakpoint *t;
1994 status = target_get_trace_status (ts);
1998 if (ts->filename != NULL)
1999 printf_filtered (_("Using a trace file.\n"));
2002 printf_filtered (_("Trace can not be run on this target.\n"));
2007 if (!ts->running_known)
2009 printf_filtered (_("Run/stop status is unknown.\n"));
2011 else if (ts->running)
2013 printf_filtered (_("Trace is running on the target.\n"));
2017 switch (ts->stop_reason)
2019 case trace_never_run:
2020 printf_filtered (_("No trace has been run on the target.\n"));
2024 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
2027 printf_filtered (_("Trace stopped by a tstop command.\n"));
2029 case trace_buffer_full:
2030 printf_filtered (_("Trace stopped because the buffer was full.\n"));
2032 case trace_disconnected:
2033 printf_filtered (_("Trace stopped because of disconnection.\n"));
2035 case tracepoint_passcount:
2036 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
2037 ts->stopping_tracepoint);
2039 case tracepoint_error:
2040 if (ts->stopping_tracepoint)
2041 printf_filtered (_("Trace stopped by an "
2042 "error (%s, tracepoint %d).\n"),
2043 ts->stop_desc, ts->stopping_tracepoint);
2045 printf_filtered (_("Trace stopped by an error (%s).\n"),
2048 case trace_stop_reason_unknown:
2049 printf_filtered (_("Trace stopped for an unknown reason.\n"));
2052 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
2058 if (ts->traceframes_created >= 0
2059 && ts->traceframe_count != ts->traceframes_created)
2061 printf_filtered (_("Buffer contains %d trace "
2062 "frames (of %d created total).\n"),
2063 ts->traceframe_count, ts->traceframes_created);
2065 else if (ts->traceframe_count >= 0)
2067 printf_filtered (_("Collected %d trace frames.\n"),
2068 ts->traceframe_count);
2071 if (ts->buffer_free >= 0)
2073 if (ts->buffer_size >= 0)
2075 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2076 ts->buffer_free, ts->buffer_size);
2077 if (ts->buffer_size > 0)
2078 printf_filtered (_(" (%d%% full)"),
2079 ((int) ((((long long) (ts->buffer_size
2080 - ts->buffer_free)) * 100)
2081 / ts->buffer_size)));
2082 printf_filtered (_(".\n"));
2085 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2089 if (ts->disconnected_tracing)
2090 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2092 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2094 if (ts->circular_buffer)
2095 printf_filtered (_("Trace buffer is circular.\n"));
2097 if (ts->user_name && strlen (ts->user_name) > 0)
2098 printf_filtered (_("Trace user is %s.\n"), ts->user_name);
2100 if (ts->notes && strlen (ts->notes) > 0)
2101 printf_filtered (_("Trace notes: %s.\n"), ts->notes);
2103 /* Now report on what we're doing with tfind. */
2104 if (traceframe_number >= 0)
2105 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2106 traceframe_number, tracepoint_number);
2108 printf_filtered (_("Not looking at any trace frame.\n"));
2110 /* Report start/stop times if supplied. */
2115 LONGEST run_time = ts->stop_time - ts->start_time;
2117 /* Reporting a run time is more readable than two long numbers. */
2118 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2119 (long int) (ts->start_time / 1000000),
2120 (long int) (ts->start_time % 1000000),
2121 (long int) (run_time / 1000000),
2122 (long int) (run_time % 1000000));
2125 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2126 (long int) (ts->start_time / 1000000),
2127 (long int) (ts->start_time % 1000000));
2129 else if (ts->stop_time)
2130 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2131 (long int) (ts->stop_time / 1000000),
2132 (long int) (ts->stop_time % 1000000));
2134 /* Now report any per-tracepoint status available. */
2135 tp_vec = all_tracepoints ();
2137 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
2138 target_get_tracepoint_status (t, NULL);
2140 VEC_free (breakpoint_p, tp_vec);
2143 /* Report the trace status to uiout, in a way suitable for MI, and not
2144 suitable for CLI. If ON_STOP is true, suppress a few fields that
2145 are not meaningful in the -trace-stop response.
2147 The implementation is essentially parallel to trace_status_command, but
2148 merging them will result in unreadable code. */
2150 trace_status_mi (int on_stop)
2152 struct ui_out *uiout = current_uiout;
2153 struct trace_status *ts = current_trace_status ();
2156 status = target_get_trace_status (ts);
2158 if (status == -1 && ts->filename == NULL)
2160 ui_out_field_string (uiout, "supported", "0");
2164 if (ts->filename != NULL)
2165 ui_out_field_string (uiout, "supported", "file");
2167 ui_out_field_string (uiout, "supported", "1");
2169 if (ts->filename != NULL)
2170 ui_out_field_string (uiout, "trace-file", ts->filename);
2172 gdb_assert (ts->running_known);
2176 ui_out_field_string (uiout, "running", "1");
2178 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2179 Given that the frontend gets the status either on -trace-stop, or from
2180 -trace-status after re-connection, it does not seem like this
2181 information is necessary for anything. It is not necessary for either
2182 figuring the vital state of the target nor for navigation of trace
2183 frames. If the frontend wants to show the current state is some
2184 configure dialog, it can request the value when such dialog is
2185 invoked by the user. */
2189 char *stop_reason = NULL;
2190 int stopping_tracepoint = -1;
2193 ui_out_field_string (uiout, "running", "0");
2195 if (ts->stop_reason != trace_stop_reason_unknown)
2197 switch (ts->stop_reason)
2200 stop_reason = "request";
2202 case trace_buffer_full:
2203 stop_reason = "overflow";
2205 case trace_disconnected:
2206 stop_reason = "disconnection";
2208 case tracepoint_passcount:
2209 stop_reason = "passcount";
2210 stopping_tracepoint = ts->stopping_tracepoint;
2212 case tracepoint_error:
2213 stop_reason = "error";
2214 stopping_tracepoint = ts->stopping_tracepoint;
2220 ui_out_field_string (uiout, "stop-reason", stop_reason);
2221 if (stopping_tracepoint != -1)
2222 ui_out_field_int (uiout, "stopping-tracepoint",
2223 stopping_tracepoint);
2224 if (ts->stop_reason == tracepoint_error)
2225 ui_out_field_string (uiout, "error-description",
2231 if (ts->traceframe_count != -1)
2232 ui_out_field_int (uiout, "frames", ts->traceframe_count);
2233 if (ts->traceframes_created != -1)
2234 ui_out_field_int (uiout, "frames-created", ts->traceframes_created);
2235 if (ts->buffer_size != -1)
2236 ui_out_field_int (uiout, "buffer-size", ts->buffer_size);
2237 if (ts->buffer_free != -1)
2238 ui_out_field_int (uiout, "buffer-free", ts->buffer_free);
2240 ui_out_field_int (uiout, "disconnected", ts->disconnected_tracing);
2241 ui_out_field_int (uiout, "circular", ts->circular_buffer);
2243 ui_out_field_string (uiout, "user-name", ts->user_name);
2244 ui_out_field_string (uiout, "notes", ts->notes);
2249 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2250 (long int) (ts->start_time / 1000000),
2251 (long int) (ts->start_time % 1000000));
2252 ui_out_field_string (uiout, "start-time", buf);
2253 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2254 (long int) (ts->stop_time / 1000000),
2255 (long int) (ts->stop_time % 1000000));
2256 ui_out_field_string (uiout, "stop-time", buf);
2260 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2261 user if she really wants to detach. */
2264 query_if_trace_running (int from_tty)
2269 /* It can happen that the target that was tracing went away on its
2270 own, and we didn't notice. Get a status update, and if the
2271 current target doesn't even do tracing, then assume it's not
2273 if (target_get_trace_status (current_trace_status ()) < 0)
2274 current_trace_status ()->running = 0;
2276 /* If running interactively, give the user the option to cancel and
2277 then decide what to do differently with the run. Scripts are
2278 just going to disconnect and let the target deal with it,
2279 according to how it's been instructed previously via
2280 disconnected-tracing. */
2281 if (current_trace_status ()->running)
2283 process_tracepoint_on_disconnect ();
2285 if (current_trace_status ()->disconnected_tracing)
2287 if (!query (_("Trace is running and will "
2288 "continue after detach; detach anyway? ")))
2289 error (_("Not confirmed."));
2293 if (!query (_("Trace is running but will "
2294 "stop on detach; detach anyway? ")))
2295 error (_("Not confirmed."));
2300 /* This function handles the details of what to do about an ongoing
2301 tracing run if the user has asked to detach or otherwise disconnect
2305 disconnect_tracing (void)
2307 /* Also we want to be out of tfind mode, otherwise things can get
2308 confusing upon reconnection. Just use these calls instead of
2309 full tfind_1 behavior because we're in the middle of detaching,
2310 and there's no point to updating current stack frame etc. */
2311 trace_reset_local_state ();
2314 /* Worker function for the various flavors of the tfind command. */
2316 tfind_1 (enum trace_find_type type, int num,
2317 CORE_ADDR addr1, CORE_ADDR addr2,
2320 int target_frameno = -1, target_tracept = -1;
2321 struct frame_id old_frame_id = null_frame_id;
2322 struct tracepoint *tp;
2323 struct ui_out *uiout = current_uiout;
2325 /* Only try to get the current stack frame if we have a chance of
2326 succeeding. In particular, if we're trying to get a first trace
2327 frame while all threads are running, it's not going to succeed,
2328 so leave it with a default value and let the frame comparison
2329 below (correctly) decide to print out the source location of the
2331 if (!(type == tfind_number && num == -1)
2332 && (has_stack_frames () || traceframe_number >= 0))
2333 old_frame_id = get_frame_id (get_current_frame ());
2335 target_frameno = target_trace_find (type, num, addr1, addr2,
2338 if (type == tfind_number
2340 && target_frameno == -1)
2342 /* We told the target to get out of tfind mode, and it did. */
2344 else if (target_frameno == -1)
2346 /* A request for a non-existent trace frame has failed.
2347 Our response will be different, depending on FROM_TTY:
2349 If FROM_TTY is true, meaning that this command was
2350 typed interactively by the user, then give an error
2351 and DO NOT change the state of traceframe_number etc.
2353 However if FROM_TTY is false, meaning that we're either
2354 in a script, a loop, or a user-defined command, then
2355 DON'T give an error, but DO change the state of
2356 traceframe_number etc. to invalid.
2358 The rationalle is that if you typed the command, you
2359 might just have committed a typo or something, and you'd
2360 like to NOT lose your current debugging state. However
2361 if you're in a user-defined command or especially in a
2362 loop, then you need a way to detect that the command
2363 failed WITHOUT aborting. This allows you to write
2364 scripts that search thru the trace buffer until the end,
2365 and then continue on to do something else. */
2368 error (_("Target failed to find requested trace frame."));
2372 printf_filtered ("End of trace buffer.\n");
2373 #if 0 /* dubious now? */
2374 /* The following will not recurse, since it's
2376 trace_find_command ("-1", from_tty);
2381 tp = get_tracepoint_by_number_on_target (target_tracept);
2383 reinit_frame_cache ();
2384 target_dcache_invalidate ();
2386 set_tracepoint_num (tp ? tp->base.number : target_tracept);
2388 if (target_frameno != get_traceframe_number ())
2389 observer_notify_traceframe_changed (target_frameno, tracepoint_number);
2391 set_current_traceframe (target_frameno);
2393 if (target_frameno == -1)
2394 set_traceframe_context (NULL);
2396 set_traceframe_context (get_current_frame ());
2398 if (traceframe_number >= 0)
2400 /* Use different branches for MI and CLI to make CLI messages
2402 if (ui_out_is_mi_like_p (uiout))
2404 ui_out_field_string (uiout, "found", "1");
2405 ui_out_field_int (uiout, "tracepoint", tracepoint_number);
2406 ui_out_field_int (uiout, "traceframe", traceframe_number);
2410 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2411 traceframe_number, tracepoint_number);
2416 if (ui_out_is_mi_like_p (uiout))
2417 ui_out_field_string (uiout, "found", "0");
2418 else if (type == tfind_number && num == -1)
2419 printf_unfiltered (_("No longer looking at any trace frame\n"));
2420 else /* This case may never occur, check. */
2421 printf_unfiltered (_("No trace frame found\n"));
2424 /* If we're in nonstop mode and getting out of looking at trace
2425 frames, there won't be any current frame to go back to and
2428 && (has_stack_frames () || traceframe_number >= 0))
2430 enum print_what print_what;
2432 /* NOTE: in imitation of the step command, try to determine
2433 whether we have made a transition from one function to
2434 another. If so, we'll print the "stack frame" (ie. the new
2435 function and it's arguments) -- otherwise we'll just show the
2438 if (frame_id_eq (old_frame_id,
2439 get_frame_id (get_current_frame ())))
2440 print_what = SRC_LINE;
2442 print_what = SRC_AND_LOC;
2444 print_stack_frame (get_selected_frame (NULL), 1, print_what, 1);
2449 /* trace_find_command takes a trace frame number n,
2450 sends "QTFrame:<n>" to the target,
2451 and accepts a reply that may contain several optional pieces
2452 of information: a frame number, a tracepoint number, and an
2453 indication of whether this is a trap frame or a stepping frame.
2455 The minimal response is just "OK" (which indicates that the
2456 target does not give us a frame number or a tracepoint number).
2457 Instead of that, the target may send us a string containing
2459 F<hexnum> (gives the selected frame number)
2460 T<hexnum> (gives the selected tracepoint number)
2465 trace_find_command (char *args, int from_tty)
2466 { /* This should only be called with a numeric argument. */
2469 if (current_trace_status ()->running
2470 && current_trace_status ()->filename == NULL)
2471 error (_("May not look at trace frames while trace is running."));
2473 if (args == 0 || *args == 0)
2474 { /* TFIND with no args means find NEXT trace frame. */
2475 if (traceframe_number == -1)
2476 frameno = 0; /* "next" is first one. */
2478 frameno = traceframe_number + 1;
2480 else if (0 == strcmp (args, "-"))
2482 if (traceframe_number == -1)
2483 error (_("not debugging trace buffer"));
2484 else if (from_tty && traceframe_number == 0)
2485 error (_("already at start of trace buffer"));
2487 frameno = traceframe_number - 1;
2489 /* A hack to work around eval's need for fp to have been collected. */
2490 else if (0 == strcmp (args, "-1"))
2493 frameno = parse_and_eval_long (args);
2496 error (_("invalid input (%d is less than zero)"), frameno);
2498 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2503 trace_find_end_command (char *args, int from_tty)
2505 trace_find_command ("-1", from_tty);
2510 trace_find_start_command (char *args, int from_tty)
2512 trace_find_command ("0", from_tty);
2515 /* tfind pc command */
2517 trace_find_pc_command (char *args, int from_tty)
2521 if (current_trace_status ()->running
2522 && current_trace_status ()->filename == NULL)
2523 error (_("May not look at trace frames while trace is running."));
2525 if (args == 0 || *args == 0)
2526 pc = regcache_read_pc (get_current_regcache ());
2528 pc = parse_and_eval_address (args);
2530 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2533 /* tfind tracepoint command */
2535 trace_find_tracepoint_command (char *args, int from_tty)
2538 struct tracepoint *tp;
2540 if (current_trace_status ()->running
2541 && current_trace_status ()->filename == NULL)
2542 error (_("May not look at trace frames while trace is running."));
2544 if (args == 0 || *args == 0)
2546 if (tracepoint_number == -1)
2547 error (_("No current tracepoint -- please supply an argument."));
2549 tdp = tracepoint_number; /* Default is current TDP. */
2552 tdp = parse_and_eval_long (args);
2554 /* If we have the tracepoint on hand, use the number that the
2555 target knows about (which may be different if we disconnected
2556 and reconnected). */
2557 tp = get_tracepoint (tdp);
2559 tdp = tp->number_on_target;
2561 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2564 /* TFIND LINE command:
2566 This command will take a sourceline for argument, just like BREAK
2567 or TRACE (ie. anything that "decode_line_1" can handle).
2569 With no argument, this command will find the next trace frame
2570 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2573 trace_find_line_command (char *args, int from_tty)
2575 static CORE_ADDR start_pc, end_pc;
2576 struct symtabs_and_lines sals;
2577 struct symtab_and_line sal;
2578 struct cleanup *old_chain;
2580 if (current_trace_status ()->running
2581 && current_trace_status ()->filename == NULL)
2582 error (_("May not look at trace frames while trace is running."));
2584 if (args == 0 || *args == 0)
2586 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2588 sals.sals = (struct symtab_and_line *)
2589 xmalloc (sizeof (struct symtab_and_line));
2594 sals = decode_line_with_current_source (args, DECODE_LINE_FUNFIRSTLINE);
2598 old_chain = make_cleanup (xfree, sals.sals);
2599 if (sal.symtab == 0)
2600 error (_("No line number information available."));
2602 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2604 if (start_pc == end_pc)
2606 printf_filtered ("Line %d of \"%s\"",
2608 symtab_to_filename_for_display (sal.symtab));
2610 printf_filtered (" is at address ");
2611 print_address (get_current_arch (), start_pc, gdb_stdout);
2613 printf_filtered (" but contains no code.\n");
2614 sal = find_pc_line (start_pc, 0);
2616 && find_line_pc_range (sal, &start_pc, &end_pc)
2617 && start_pc != end_pc)
2618 printf_filtered ("Attempting to find line %d instead.\n",
2621 error (_("Cannot find a good line."));
2625 /* Is there any case in which we get here, and have an address
2626 which the user would want to see? If we have debugging
2627 symbols and no line numbers? */
2628 error (_("Line number %d is out of range for \"%s\"."),
2629 sal.line, symtab_to_filename_for_display (sal.symtab));
2631 /* Find within range of stated line. */
2633 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2635 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2636 do_cleanups (old_chain);
2639 /* tfind range command */
2641 trace_find_range_command (char *args, int from_tty)
2643 static CORE_ADDR start, stop;
2646 if (current_trace_status ()->running
2647 && current_trace_status ()->filename == NULL)
2648 error (_("May not look at trace frames while trace is running."));
2650 if (args == 0 || *args == 0)
2651 { /* XXX FIXME: what should default behavior be? */
2652 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2656 if (0 != (tmp = strchr (args, ',')))
2658 *tmp++ = '\0'; /* Terminate start address. */
2659 tmp = skip_spaces (tmp);
2660 start = parse_and_eval_address (args);
2661 stop = parse_and_eval_address (tmp);
2664 { /* No explicit end address? */
2665 start = parse_and_eval_address (args);
2666 stop = start + 1; /* ??? */
2669 tfind_1 (tfind_range, 0, start, stop, from_tty);
2672 /* tfind outside command */
2674 trace_find_outside_command (char *args, int from_tty)
2676 CORE_ADDR start, stop;
2679 if (current_trace_status ()->running
2680 && current_trace_status ()->filename == NULL)
2681 error (_("May not look at trace frames while trace is running."));
2683 if (args == 0 || *args == 0)
2684 { /* XXX FIXME: what should default behavior be? */
2685 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2689 if (0 != (tmp = strchr (args, ',')))
2691 *tmp++ = '\0'; /* Terminate start address. */
2692 tmp = skip_spaces (tmp);
2693 start = parse_and_eval_address (args);
2694 stop = parse_and_eval_address (tmp);
2697 { /* No explicit end address? */
2698 start = parse_and_eval_address (args);
2699 stop = start + 1; /* ??? */
2702 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2705 /* info scope command: list the locals for a scope. */
2707 scope_info (char *args, int from_tty)
2709 struct symtabs_and_lines sals;
2711 struct minimal_symbol *msym;
2712 struct block *block;
2713 const char *symname;
2714 char *save_args = args;
2715 struct block_iterator iter;
2717 struct gdbarch *gdbarch;
2720 if (args == 0 || *args == 0)
2721 error (_("requires an argument (function, "
2722 "line or *addr) to define a scope"));
2724 sals = decode_line_1 (&args, DECODE_LINE_FUNFIRSTLINE, NULL, 0);
2725 if (sals.nelts == 0)
2726 return; /* Presumably decode_line_1 has already warned. */
2728 /* Resolve line numbers to PC. */
2729 resolve_sal_pc (&sals.sals[0]);
2730 block = block_for_pc (sals.sals[0].pc);
2734 QUIT; /* Allow user to bail out with ^C. */
2735 ALL_BLOCK_SYMBOLS (block, iter, sym)
2737 QUIT; /* Allow user to bail out with ^C. */
2739 printf_filtered ("Scope for %s:\n", save_args);
2742 symname = SYMBOL_PRINT_NAME (sym);
2743 if (symname == NULL || *symname == '\0')
2744 continue; /* Probably botched, certainly useless. */
2746 gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
2748 printf_filtered ("Symbol %s is ", symname);
2750 if (SYMBOL_COMPUTED_OPS (sym) != NULL)
2751 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2752 BLOCK_START (block),
2756 switch (SYMBOL_CLASS (sym))
2759 case LOC_UNDEF: /* Messed up symbol? */
2760 printf_filtered ("a bogus symbol, class %d.\n",
2761 SYMBOL_CLASS (sym));
2762 count--; /* Don't count this one. */
2765 printf_filtered ("a constant with value %s (%s)",
2766 plongest (SYMBOL_VALUE (sym)),
2767 hex_string (SYMBOL_VALUE (sym)));
2769 case LOC_CONST_BYTES:
2770 printf_filtered ("constant bytes: ");
2771 if (SYMBOL_TYPE (sym))
2772 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2773 fprintf_filtered (gdb_stdout, " %02x",
2774 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2777 printf_filtered ("in static storage at address ");
2778 printf_filtered ("%s", paddress (gdbarch,
2779 SYMBOL_VALUE_ADDRESS (sym)));
2782 /* GDBARCH is the architecture associated with the objfile
2783 the symbol is defined in; the target architecture may be
2784 different, and may provide additional registers. However,
2785 we do not know the target architecture at this point.
2786 We assume the objfile architecture will contain all the
2787 standard registers that occur in debug info in that
2789 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2792 if (SYMBOL_IS_ARGUMENT (sym))
2793 printf_filtered ("an argument in register $%s",
2794 gdbarch_register_name (gdbarch, regno));
2796 printf_filtered ("a local variable in register $%s",
2797 gdbarch_register_name (gdbarch, regno));
2800 printf_filtered ("an argument at stack/frame offset %s",
2801 plongest (SYMBOL_VALUE (sym)));
2804 printf_filtered ("a local variable at frame offset %s",
2805 plongest (SYMBOL_VALUE (sym)));
2808 printf_filtered ("a reference argument at offset %s",
2809 plongest (SYMBOL_VALUE (sym)));
2811 case LOC_REGPARM_ADDR:
2812 /* Note comment at LOC_REGISTER. */
2813 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2815 printf_filtered ("the address of an argument, in register $%s",
2816 gdbarch_register_name (gdbarch, regno));
2819 printf_filtered ("a typedef.\n");
2822 printf_filtered ("a label at address ");
2823 printf_filtered ("%s", paddress (gdbarch,
2824 SYMBOL_VALUE_ADDRESS (sym)));
2827 printf_filtered ("a function at address ");
2828 printf_filtered ("%s",
2829 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2831 case LOC_UNRESOLVED:
2832 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2835 printf_filtered ("Unresolved Static");
2838 printf_filtered ("static storage at address ");
2839 printf_filtered ("%s",
2841 SYMBOL_VALUE_ADDRESS (msym)));
2844 case LOC_OPTIMIZED_OUT:
2845 printf_filtered ("optimized out.\n");
2848 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2851 if (SYMBOL_TYPE (sym))
2852 printf_filtered (", length %d.\n",
2853 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2855 if (BLOCK_FUNCTION (block))
2858 block = BLOCK_SUPERBLOCK (block);
2861 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2865 /* Helper for trace_dump_command. Dump the action list starting at
2866 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2867 actions of the body of a while-stepping action. STEPPING_FRAME is
2868 set if the current traceframe was determined to be a while-stepping
2872 trace_dump_actions (struct command_line *action,
2873 int stepping_actions, int stepping_frame,
2876 const char *action_exp, *next_comma;
2878 for (; action != NULL; action = action->next)
2880 struct cmd_list_element *cmd;
2882 QUIT; /* Allow user to bail out with ^C. */
2883 action_exp = action->line;
2884 action_exp = skip_spaces_const (action_exp);
2886 /* The collection actions to be done while stepping are
2887 bracketed by the commands "while-stepping" and "end". */
2889 if (*action_exp == '#') /* comment line */
2892 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2894 error (_("Bad action list item: %s"), action_exp);
2896 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2900 for (i = 0; i < action->body_count; ++i)
2901 trace_dump_actions (action->body_list[i],
2902 1, stepping_frame, from_tty);
2904 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2906 /* Display the collected data.
2907 For the trap frame, display only what was collected at
2908 the trap. Likewise for stepping frames, display only
2909 what was collected while stepping. This means that the
2910 two boolean variables, STEPPING_FRAME and
2911 STEPPING_ACTIONS should be equal. */
2912 if (stepping_frame == stepping_actions)
2915 struct cleanup *old_chain
2916 = make_cleanup (free_current_contents, &cmd);
2917 int trace_string = 0;
2919 if (*action_exp == '/')
2920 action_exp = decode_agent_options (action_exp, &trace_string);
2923 { /* Repeat over a comma-separated list. */
2924 QUIT; /* Allow user to bail out with ^C. */
2925 if (*action_exp == ',')
2927 action_exp = skip_spaces_const (action_exp);
2929 next_comma = strchr (action_exp, ',');
2931 if (0 == strncasecmp (action_exp, "$reg", 4))
2932 registers_info (NULL, from_tty);
2933 else if (0 == strncasecmp (action_exp, "$_ret", 5))
2935 else if (0 == strncasecmp (action_exp, "$loc", 4))
2936 locals_info (NULL, from_tty);
2937 else if (0 == strncasecmp (action_exp, "$arg", 4))
2938 args_info (NULL, from_tty);
2941 if (next_comma != NULL)
2943 size_t len = next_comma - action_exp;
2945 cmd = xrealloc (cmd, len + 1);
2946 memcpy (cmd, action_exp, len);
2951 size_t len = strlen (action_exp);
2953 cmd = xrealloc (cmd, len + 1);
2954 memcpy (cmd, action_exp, len + 1);
2957 printf_filtered ("%s = ", cmd);
2958 output_command_const (cmd, from_tty);
2959 printf_filtered ("\n");
2961 action_exp = next_comma;
2963 while (action_exp && *action_exp == ',');
2965 do_cleanups (old_chain);
2971 /* Return bp_location of the tracepoint associated with the current
2972 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2973 is a stepping traceframe. */
2975 struct bp_location *
2976 get_traceframe_location (int *stepping_frame_p)
2978 struct tracepoint *t;
2979 struct bp_location *tloc;
2980 struct regcache *regcache;
2982 if (tracepoint_number == -1)
2983 error (_("No current trace frame."));
2985 t = get_tracepoint (tracepoint_number);
2988 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2991 /* The current frame is a trap frame if the frame PC is equal to the
2992 tracepoint PC. If not, then the current frame was collected
2993 during single-stepping. */
2994 regcache = get_current_regcache ();
2996 /* If the traceframe's address matches any of the tracepoint's
2997 locations, assume it is a direct hit rather than a while-stepping
2998 frame. (FIXME this is not reliable, should record each frame's
3000 for (tloc = t->base.loc; tloc; tloc = tloc->next)
3001 if (tloc->address == regcache_read_pc (regcache))
3003 *stepping_frame_p = 0;
3007 /* If this is a stepping frame, we don't know which location
3008 triggered. The first is as good (or bad) a guess as any... */
3009 *stepping_frame_p = 1;
3013 /* Return all the actions, including default collect, of a tracepoint
3014 T. It constructs cleanups into the chain, and leaves the caller to
3015 handle them (call do_cleanups). */
3017 static struct command_line *
3018 all_tracepoint_actions_and_cleanup (struct breakpoint *t)
3020 struct command_line *actions;
3022 actions = breakpoint_commands (t);
3024 /* If there are default expressions to collect, make up a collect
3025 action and prepend to the action list to encode. Note that since
3026 validation is per-tracepoint (local var "xyz" might be valid for
3027 one tracepoint and not another, etc), we make up the action on
3028 the fly, and don't cache it. */
3029 if (*default_collect)
3031 struct command_line *default_collect_action;
3032 char *default_collect_line;
3034 default_collect_line = xstrprintf ("collect %s", default_collect);
3035 make_cleanup (xfree, default_collect_line);
3037 validate_actionline (default_collect_line, t);
3038 default_collect_action = xmalloc (sizeof (struct command_line));
3039 make_cleanup (xfree, default_collect_action);
3040 default_collect_action->next = actions;
3041 default_collect_action->line = default_collect_line;
3042 actions = default_collect_action;
3048 /* The tdump command. */
3051 trace_dump_command (char *args, int from_tty)
3053 int stepping_frame = 0;
3054 struct bp_location *loc;
3055 struct cleanup *old_chain;
3056 struct command_line *actions;
3058 /* This throws an error is not inspecting a trace frame. */
3059 loc = get_traceframe_location (&stepping_frame);
3061 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
3062 tracepoint_number, traceframe_number);
3064 old_chain = make_cleanup (null_cleanup, NULL);
3066 /* This command only makes sense for the current frame, not the
3068 make_cleanup_restore_current_thread ();
3069 select_frame (get_current_frame ());
3071 actions = all_tracepoint_actions_and_cleanup (loc->owner);
3073 trace_dump_actions (actions, 0, stepping_frame, from_tty);
3075 do_cleanups (old_chain);
3078 /* Encode a piece of a tracepoint's source-level definition in a form
3079 that is suitable for both protocol and saving in files. */
3080 /* This version does not do multiple encodes for long strings; it should
3081 return an offset to the next piece to encode. FIXME */
3084 encode_source_string (int tpnum, ULONGEST addr,
3085 char *srctype, char *src, char *buf, int buf_size)
3087 if (80 + strlen (srctype) > buf_size)
3088 error (_("Buffer too small for source encoding"));
3089 sprintf (buf, "%x:%s:%s:%x:%x:",
3090 tpnum, phex_nz (addr, sizeof (addr)),
3091 srctype, 0, (int) strlen (src));
3092 if (strlen (buf) + strlen (src) * 2 >= buf_size)
3093 error (_("Source string too long for buffer"));
3094 bin2hex ((gdb_byte *) src, buf + strlen (buf), 0);
3098 /* Free trace file writer. */
3101 trace_file_writer_xfree (void *arg)
3103 struct trace_file_writer *writer = arg;
3105 writer->ops->dtor (writer);
3109 /* TFILE trace writer. */
3111 struct tfile_trace_file_writer
3113 struct trace_file_writer base;
3115 /* File pointer to tfile trace file. */
3117 /* Path name of the tfile trace file. */
3121 /* This is the implementation of trace_file_write_ops method
3122 target_save. We just call the generic target
3123 target_save_trace_data to do target-side saving. */
3126 tfile_target_save (struct trace_file_writer *self,
3127 const char *filename)
3129 int err = target_save_trace_data (filename);
3134 /* This is the implementation of trace_file_write_ops method
3138 tfile_dtor (struct trace_file_writer *self)
3140 struct tfile_trace_file_writer *writer
3141 = (struct tfile_trace_file_writer *) self;
3143 xfree (writer->pathname);
3145 if (writer->fp != NULL)
3146 fclose (writer->fp);
3149 /* This is the implementation of trace_file_write_ops method
3150 start. It creates the trace file FILENAME and registers some
3154 tfile_start (struct trace_file_writer *self, const char *filename)
3156 struct tfile_trace_file_writer *writer
3157 = (struct tfile_trace_file_writer *) self;
3159 writer->pathname = tilde_expand (filename);
3160 writer->fp = gdb_fopen_cloexec (writer->pathname, "wb");
3161 if (writer->fp == NULL)
3162 error (_("Unable to open file '%s' for saving trace data (%s)"),
3163 writer->pathname, safe_strerror (errno));
3166 /* This is the implementation of trace_file_write_ops method
3167 write_header. Write the TFILE header. */
3170 tfile_write_header (struct trace_file_writer *self)
3172 struct tfile_trace_file_writer *writer
3173 = (struct tfile_trace_file_writer *) self;
3176 /* Write a file header, with a high-bit-set char to indicate a
3177 binary file, plus a hint as what this file is, and a version
3178 number in case of future needs. */
3179 written = fwrite ("\x7fTRACE0\n", 8, 1, writer->fp);
3181 perror_with_name (writer->pathname);
3184 /* This is the implementation of trace_file_write_ops method
3185 write_regblock_type. Write the size of register block. */
3188 tfile_write_regblock_type (struct trace_file_writer *self, int size)
3190 struct tfile_trace_file_writer *writer
3191 = (struct tfile_trace_file_writer *) self;
3193 fprintf (writer->fp, "R %x\n", size);
3196 /* This is the implementation of trace_file_write_ops method
3200 tfile_write_status (struct trace_file_writer *self,
3201 struct trace_status *ts)
3203 struct tfile_trace_file_writer *writer
3204 = (struct tfile_trace_file_writer *) self;
3206 fprintf (writer->fp, "status %c;%s",
3207 (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
3208 if (ts->stop_reason == tracepoint_error
3209 || ts->stop_reason == tstop_command)
3211 char *buf = (char *) alloca (strlen (ts->stop_desc) * 2 + 1);
3213 bin2hex ((gdb_byte *) ts->stop_desc, buf, 0);
3214 fprintf (writer->fp, ":%s", buf);
3216 fprintf (writer->fp, ":%x", ts->stopping_tracepoint);
3217 if (ts->traceframe_count >= 0)
3218 fprintf (writer->fp, ";tframes:%x", ts->traceframe_count);
3219 if (ts->traceframes_created >= 0)
3220 fprintf (writer->fp, ";tcreated:%x", ts->traceframes_created);
3221 if (ts->buffer_free >= 0)
3222 fprintf (writer->fp, ";tfree:%x", ts->buffer_free);
3223 if (ts->buffer_size >= 0)
3224 fprintf (writer->fp, ";tsize:%x", ts->buffer_size);
3225 if (ts->disconnected_tracing)
3226 fprintf (writer->fp, ";disconn:%x", ts->disconnected_tracing);
3227 if (ts->circular_buffer)
3228 fprintf (writer->fp, ";circular:%x", ts->circular_buffer);
3231 fprintf (writer->fp, ";starttime:%s",
3232 phex_nz (ts->start_time, sizeof (ts->start_time)));
3236 fprintf (writer->fp, ";stoptime:%s",
3237 phex_nz (ts->stop_time, sizeof (ts->stop_time)));
3239 if (ts->notes != NULL)
3241 char *buf = (char *) alloca (strlen (ts->notes) * 2 + 1);
3243 bin2hex ((gdb_byte *) ts->notes, buf, 0);
3244 fprintf (writer->fp, ";notes:%s", buf);
3246 if (ts->user_name != NULL)
3248 char *buf = (char *) alloca (strlen (ts->user_name) * 2 + 1);
3250 bin2hex ((gdb_byte *) ts->user_name, buf, 0);
3251 fprintf (writer->fp, ";username:%s", buf);
3253 fprintf (writer->fp, "\n");
3256 /* This is the implementation of trace_file_write_ops method
3257 write_uploaded_tsv. */
3260 tfile_write_uploaded_tsv (struct trace_file_writer *self,
3261 struct uploaded_tsv *utsv)
3264 struct tfile_trace_file_writer *writer
3265 = (struct tfile_trace_file_writer *) self;
3269 buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
3270 bin2hex ((gdb_byte *) (utsv->name), buf, 0);
3273 fprintf (writer->fp, "tsv %x:%s:%x:%s\n",
3274 utsv->number, phex_nz (utsv->initial_value, 8),
3275 utsv->builtin, buf);
3281 #define MAX_TRACE_UPLOAD 2000
3283 /* This is the implementation of trace_file_write_ops method
3284 write_uploaded_tp. */
3287 tfile_write_uploaded_tp (struct trace_file_writer *self,
3288 struct uploaded_tp *utp)
3290 struct tfile_trace_file_writer *writer
3291 = (struct tfile_trace_file_writer *) self;
3294 char buf[MAX_TRACE_UPLOAD];
3296 fprintf (writer->fp, "tp T%x:%s:%c:%x:%x",
3297 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
3298 (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
3299 if (utp->type == bp_fast_tracepoint)
3300 fprintf (writer->fp, ":F%x", utp->orig_size);
3302 fprintf (writer->fp,
3303 ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
3305 fprintf (writer->fp, "\n");
3306 for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
3307 fprintf (writer->fp, "tp A%x:%s:%s\n",
3308 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
3309 for (a = 0; VEC_iterate (char_ptr, utp->step_actions, a, act); ++a)
3310 fprintf (writer->fp, "tp S%x:%s:%s\n",
3311 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
3314 encode_source_string (utp->number, utp->addr,
3315 "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
3316 fprintf (writer->fp, "tp Z%s\n", buf);
3318 if (utp->cond_string)
3320 encode_source_string (utp->number, utp->addr,
3321 "cond", utp->cond_string,
3322 buf, MAX_TRACE_UPLOAD);
3323 fprintf (writer->fp, "tp Z%s\n", buf);
3325 for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
3327 encode_source_string (utp->number, utp->addr, "cmd", act,
3328 buf, MAX_TRACE_UPLOAD);
3329 fprintf (writer->fp, "tp Z%s\n", buf);
3331 fprintf (writer->fp, "tp V%x:%s:%x:%s\n",
3332 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
3334 phex_nz (utp->traceframe_usage,
3335 sizeof (utp->traceframe_usage)));
3338 /* This is the implementation of trace_file_write_ops method
3339 write_definition_end. */
3342 tfile_write_definition_end (struct trace_file_writer *self)
3344 struct tfile_trace_file_writer *writer
3345 = (struct tfile_trace_file_writer *) self;
3347 fprintf (writer->fp, "\n");
3350 /* This is the implementation of trace_file_write_ops method
3354 tfile_write_raw_data (struct trace_file_writer *self, gdb_byte *buf,
3357 struct tfile_trace_file_writer *writer
3358 = (struct tfile_trace_file_writer *) self;
3360 if (fwrite (buf, len, 1, writer->fp) < 1)
3361 perror_with_name (writer->pathname);
3364 /* This is the implementation of trace_file_write_ops method
3368 tfile_end (struct trace_file_writer *self)
3370 struct tfile_trace_file_writer *writer
3371 = (struct tfile_trace_file_writer *) self;
3372 uint32_t gotten = 0;
3374 /* Mark the end of trace data. */
3375 if (fwrite (&gotten, 4, 1, writer->fp) < 1)
3376 perror_with_name (writer->pathname);
3379 /* Operations to write trace buffers into TFILE format. */
3381 static const struct trace_file_write_ops tfile_write_ops =
3387 tfile_write_regblock_type,
3389 tfile_write_uploaded_tsv,
3390 tfile_write_uploaded_tp,
3391 tfile_write_definition_end,
3392 tfile_write_raw_data,
3397 /* Helper macros. */
3399 #define TRACE_WRITE_R_BLOCK(writer, buf, size) \
3400 writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
3401 #define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
3402 writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
3404 #define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
3405 writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
3407 #define TRACE_WRITE_V_BLOCK(writer, num, val) \
3408 writer->ops->frame_ops->write_v_block ((writer), (num), (val))
3410 /* Save tracepoint data to file named FILENAME through WRITER. WRITER
3411 determines the trace file format. If TARGET_DOES_SAVE is non-zero,
3412 the save is performed on the target, otherwise GDB obtains all trace
3413 data and saves it locally. */
3416 trace_save (const char *filename, struct trace_file_writer *writer,
3417 int target_does_save)
3419 struct trace_status *ts = current_trace_status ();
3421 struct uploaded_tp *uploaded_tps = NULL, *utp;
3422 struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
3424 ULONGEST offset = 0;
3425 gdb_byte buf[MAX_TRACE_UPLOAD];
3426 #define MAX_TRACE_UPLOAD 2000
3428 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
3430 /* If the target is to save the data to a file on its own, then just
3431 send the command and be done with it. */
3432 if (target_does_save)
3434 if (!writer->ops->target_save (writer, filename))
3435 error (_("Target failed to save trace data to '%s'."),
3440 /* Get the trace status first before opening the file, so if the
3441 target is losing, we can get out without touching files. */
3442 status = target_get_trace_status (ts);
3444 writer->ops->start (writer, filename);
3446 writer->ops->write_header (writer);
3448 /* Write descriptive info. */
3450 /* Write out the size of a register block. */
3451 writer->ops->write_regblock_type (writer, trace_regblock_size);
3453 /* Write out status of the tracing run (aka "tstatus" info). */
3454 writer->ops->write_status (writer, ts);
3456 /* Note that we want to upload tracepoints and save those, rather
3457 than simply writing out the local ones, because the user may have
3458 changed tracepoints in GDB in preparation for a future tracing
3459 run, or maybe just mass-deleted all types of breakpoints as part
3460 of cleaning up. So as not to contaminate the session, leave the
3461 data in its uploaded form, don't make into real tracepoints. */
3463 /* Get trace state variables first, they may be checked when parsing
3464 uploaded commands. */
3466 target_upload_trace_state_variables (&uploaded_tsvs);
3468 for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
3469 writer->ops->write_uploaded_tsv (writer, utsv);
3471 free_uploaded_tsvs (&uploaded_tsvs);
3473 target_upload_tracepoints (&uploaded_tps);
3475 for (utp = uploaded_tps; utp; utp = utp->next)
3476 target_get_tracepoint_status (NULL, utp);
3478 for (utp = uploaded_tps; utp; utp = utp->next)
3479 writer->ops->write_uploaded_tp (writer, utp);
3481 free_uploaded_tps (&uploaded_tps);
3483 /* Mark the end of the definition section. */
3484 writer->ops->write_definition_end (writer);
3486 /* Get and write the trace data proper. */
3491 /* The writer supports writing the contents of trace buffer
3492 directly to trace file. Don't parse the contents of trace
3494 if (writer->ops->write_trace_buffer != NULL)
3496 /* We ask for big blocks, in the hopes of efficiency, but
3497 will take less if the target has packet size limitations
3499 gotten = target_get_raw_trace_data (buf, offset,
3502 error (_("Failure to get requested trace buffer data"));
3503 /* No more data is forthcoming, we're done. */
3507 writer->ops->write_trace_buffer (writer, buf, gotten);
3515 /* Parse the trace buffers according to how data are stored
3516 in trace buffer in GDBserver. */
3518 gotten = target_get_raw_trace_data (buf, offset, 6);
3523 /* Read the first six bytes in, which is the tracepoint
3524 number and trace frame size. */
3526 extract_unsigned_integer (&buf[0], 2, byte_order);
3528 tf_size = (uint32_t)
3529 extract_unsigned_integer (&buf[2], 4, byte_order);
3531 writer->ops->frame_ops->start (writer, tp_num);
3540 for (block = 0; block < tf_size; )
3542 gdb_byte block_type;
3544 /* We'll fetch one block each time, in order to
3545 handle the extremely large 'M' block. We first
3546 fetch one byte to get the type of the block. */
3547 gotten = target_get_raw_trace_data (buf, offset, 1);
3549 error (_("Failure to get requested trace buffer data"));
3555 block_type = buf[0];
3560 = target_get_raw_trace_data (buf, offset,
3561 trace_regblock_size);
3562 if (gotten < trace_regblock_size)
3563 error (_("Failure to get requested trace"
3566 TRACE_WRITE_R_BLOCK (writer, buf,
3567 trace_regblock_size);
3571 unsigned short mlen;
3576 t = target_get_raw_trace_data (buf,offset, 10);
3578 error (_("Failure to get requested trace"
3586 extract_unsigned_integer (buf, 8,
3588 mlen = (unsigned short)
3589 extract_unsigned_integer (&buf[8], 2,
3592 TRACE_WRITE_M_BLOCK_HEADER (writer, addr,
3595 /* The memory contents in 'M' block may be
3596 very large. Fetch the data from the target
3597 and write them into file one by one. */
3598 for (j = 0; j < mlen; )
3600 unsigned int read_length;
3602 if (mlen - j > MAX_TRACE_UPLOAD)
3603 read_length = MAX_TRACE_UPLOAD;
3605 read_length = mlen - j;
3607 t = target_get_raw_trace_data (buf,
3610 if (t < read_length)
3611 error (_("Failure to get requested"
3612 " trace buffer data"));
3614 TRACE_WRITE_M_BLOCK_MEMORY (writer, buf,
3618 gotten += read_length;
3629 = target_get_raw_trace_data (buf, offset,
3632 error (_("Failure to get requested"
3633 " trace buffer data"));
3635 vnum = (int) extract_signed_integer (buf,
3639 = extract_signed_integer (&buf[4], 8,
3642 TRACE_WRITE_V_BLOCK (writer, vnum, val);
3646 error (_("Unknown block type '%c' (0x%x) in"
3648 block_type, block_type);
3658 writer->ops->frame_ops->end (writer);
3662 writer->ops->end (writer);
3665 /* Return a trace writer for TFILE format. */
3667 static struct trace_file_writer *
3668 tfile_trace_file_writer_new (void)
3670 struct tfile_trace_file_writer *writer
3671 = xmalloc (sizeof (struct tfile_trace_file_writer));
3673 writer->base.ops = &tfile_write_ops;
3675 writer->pathname = NULL;
3677 return (struct trace_file_writer *) writer;
3681 trace_save_command (char *args, int from_tty)
3683 int target_does_save = 0;
3685 char *filename = NULL;
3686 struct cleanup *back_to;
3687 int generate_ctf = 0;
3688 struct trace_file_writer *writer = NULL;
3691 error_no_arg (_("file in which to save trace data"));
3693 argv = gdb_buildargv (args);
3694 back_to = make_cleanup_freeargv (argv);
3696 for (; *argv; ++argv)
3698 if (strcmp (*argv, "-r") == 0)
3699 target_does_save = 1;
3700 if (strcmp (*argv, "-ctf") == 0)
3702 else if (**argv == '-')
3703 error (_("unknown option `%s'"), *argv);
3709 error_no_arg (_("file in which to save trace data"));
3712 writer = ctf_trace_file_writer_new ();
3714 writer = tfile_trace_file_writer_new ();
3716 make_cleanup (trace_file_writer_xfree, writer);
3718 trace_save (filename, writer, target_does_save);
3721 printf_filtered (_("Trace data saved to %s '%s'.\n"),
3722 generate_ctf ? "directory" : "file", filename);
3724 do_cleanups (back_to);
3727 /* Save the trace data to file FILENAME of tfile format. */
3730 trace_save_tfile (const char *filename, int target_does_save)
3732 struct trace_file_writer *writer;
3733 struct cleanup *back_to;
3735 writer = tfile_trace_file_writer_new ();
3736 back_to = make_cleanup (trace_file_writer_xfree, writer);
3737 trace_save (filename, writer, target_does_save);
3738 do_cleanups (back_to);
3741 /* Save the trace data to dir DIRNAME of ctf format. */
3744 trace_save_ctf (const char *dirname, int target_does_save)
3746 struct trace_file_writer *writer;
3747 struct cleanup *back_to;
3749 writer = ctf_trace_file_writer_new ();
3750 back_to = make_cleanup (trace_file_writer_xfree, writer);
3752 trace_save (dirname, writer, target_does_save);
3753 do_cleanups (back_to);
3756 /* Tell the target what to do with an ongoing tracing run if GDB
3757 disconnects for some reason. */
3760 set_disconnected_tracing (char *args, int from_tty,
3761 struct cmd_list_element *c)
3763 target_set_disconnected_tracing (disconnected_tracing);
3767 set_circular_trace_buffer (char *args, int from_tty,
3768 struct cmd_list_element *c)
3770 target_set_circular_trace_buffer (circular_trace_buffer);
3774 set_trace_buffer_size (char *args, int from_tty,
3775 struct cmd_list_element *c)
3777 target_set_trace_buffer_size (trace_buffer_size);
3781 set_trace_user (char *args, int from_tty,
3782 struct cmd_list_element *c)
3786 ret = target_set_trace_notes (trace_user, NULL, NULL);
3789 warning (_("Target does not support trace notes, user ignored"));
3793 set_trace_notes (char *args, int from_tty,
3794 struct cmd_list_element *c)
3798 ret = target_set_trace_notes (NULL, trace_notes, NULL);
3801 warning (_("Target does not support trace notes, note ignored"));
3805 set_trace_stop_notes (char *args, int from_tty,
3806 struct cmd_list_element *c)
3810 ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
3813 warning (_("Target does not support trace notes, stop note ignored"));
3816 /* Convert the memory pointed to by mem into hex, placing result in buf.
3817 * Return a pointer to the last char put in buf (null)
3818 * "stolen" from sparc-stub.c
3821 static const char hexchars[] = "0123456789abcdef";
3824 mem2hex (gdb_byte *mem, char *buf, int count)
3832 *buf++ = hexchars[ch >> 4];
3833 *buf++ = hexchars[ch & 0xf];
3842 get_traceframe_number (void)
3844 return traceframe_number;
3848 get_tracepoint_number (void)
3850 return tracepoint_number;
3853 /* Make the traceframe NUM be the current trace frame. Does nothing
3854 if NUM is already current. */
3857 set_current_traceframe (int num)
3861 if (traceframe_number == num)
3863 /* Nothing to do. */
3867 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
3870 warning (_("could not change traceframe"));
3872 set_traceframe_num (newnum);
3874 /* Changing the traceframe changes our view of registers and of the
3876 registers_changed ();
3878 clear_traceframe_info ();
3881 /* Make the traceframe NUM be the current trace frame, and do nothing
3885 set_traceframe_number (int num)
3887 traceframe_number = num;
3890 /* A cleanup used when switching away and back from tfind mode. */
3892 struct current_traceframe_cleanup
3894 /* The traceframe we were inspecting. */
3895 int traceframe_number;
3899 do_restore_current_traceframe_cleanup (void *arg)
3901 struct current_traceframe_cleanup *old = arg;
3903 set_current_traceframe (old->traceframe_number);
3907 restore_current_traceframe_cleanup_dtor (void *arg)
3909 struct current_traceframe_cleanup *old = arg;
3915 make_cleanup_restore_current_traceframe (void)
3917 struct current_traceframe_cleanup *old;
3919 old = xmalloc (sizeof (struct current_traceframe_cleanup));
3920 old->traceframe_number = traceframe_number;
3922 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
3923 restore_current_traceframe_cleanup_dtor);
3927 make_cleanup_restore_traceframe_number (void)
3929 return make_cleanup_restore_integer (&traceframe_number);
3932 /* Given a number and address, return an uploaded tracepoint with that
3933 number, creating if necessary. */
3935 struct uploaded_tp *
3936 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
3938 struct uploaded_tp *utp;
3940 for (utp = *utpp; utp; utp = utp->next)
3941 if (utp->number == num && utp->addr == addr)
3943 utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
3944 memset (utp, 0, sizeof (struct uploaded_tp));
3947 utp->actions = NULL;
3948 utp->step_actions = NULL;
3949 utp->cmd_strings = NULL;
3956 free_uploaded_tps (struct uploaded_tp **utpp)
3958 struct uploaded_tp *next_one;
3962 next_one = (*utpp)->next;
3968 /* Given a number and address, return an uploaded tracepoint with that
3969 number, creating if necessary. */
3971 struct uploaded_tsv *
3972 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3974 struct uploaded_tsv *utsv;
3976 for (utsv = *utsvp; utsv; utsv = utsv->next)
3977 if (utsv->number == num)
3979 utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
3980 memset (utsv, 0, sizeof (struct uploaded_tsv));
3982 utsv->next = *utsvp;
3988 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3990 struct uploaded_tsv *next_one;
3994 next_one = (*utsvp)->next;
4000 /* FIXME this function is heuristic and will miss the cases where the
4001 conditional is semantically identical but differs in whitespace,
4002 such as "x == 0" vs "x==0". */
4005 cond_string_is_same (char *str1, char *str2)
4007 if (str1 == NULL || str2 == NULL)
4008 return (str1 == str2);
4010 return (strcmp (str1, str2) == 0);
4013 /* Look for an existing tracepoint that seems similar enough to the
4014 uploaded one. Enablement isn't compared, because the user can
4015 toggle that freely, and may have done so in anticipation of the
4016 next trace run. Return the location of matched tracepoint. */
4018 static struct bp_location *
4019 find_matching_tracepoint_location (struct uploaded_tp *utp)
4021 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
4023 struct breakpoint *b;
4024 struct bp_location *loc;
4026 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
4028 struct tracepoint *t = (struct tracepoint *) b;
4030 if (b->type == utp->type
4031 && t->step_count == utp->step
4032 && t->pass_count == utp->pass
4033 && cond_string_is_same (t->base.cond_string, utp->cond_string)
4034 /* FIXME also test actions. */
4037 /* Scan the locations for an address match. */
4038 for (loc = b->loc; loc; loc = loc->next)
4040 if (loc->address == utp->addr)
4048 /* Given a list of tracepoints uploaded from a target, attempt to
4049 match them up with existing tracepoints, and create new ones if not
4053 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
4055 struct uploaded_tp *utp;
4056 /* A set of tracepoints which are modified. */
4057 VEC(breakpoint_p) *modified_tp = NULL;
4059 struct breakpoint *b;
4061 /* Look for GDB tracepoints that match up with our uploaded versions. */
4062 for (utp = *uploaded_tps; utp; utp = utp->next)
4064 struct bp_location *loc;
4065 struct tracepoint *t;
4067 loc = find_matching_tracepoint_location (utp);
4072 /* Mark this location as already inserted. */
4074 t = (struct tracepoint *) loc->owner;
4075 printf_filtered (_("Assuming tracepoint %d is same "
4076 "as target's tracepoint %d at %s.\n"),
4077 loc->owner->number, utp->number,
4078 paddress (loc->gdbarch, utp->addr));
4080 /* The tracepoint LOC->owner was modified (the location LOC
4081 was marked as inserted in the target). Save it in
4082 MODIFIED_TP if not there yet. The 'breakpoint-modified'
4083 observers will be notified later once for each tracepoint
4084 saved in MODIFIED_TP. */
4086 VEC_iterate (breakpoint_p, modified_tp, ix, b);
4088 if (b == loc->owner)
4094 VEC_safe_push (breakpoint_p, modified_tp, loc->owner);
4098 t = create_tracepoint_from_upload (utp);
4100 printf_filtered (_("Created tracepoint %d for "
4101 "target's tracepoint %d at %s.\n"),
4102 t->base.number, utp->number,
4103 paddress (get_current_arch (), utp->addr));
4105 printf_filtered (_("Failed to create tracepoint for target's "
4106 "tracepoint %d at %s, skipping it.\n"),
4108 paddress (get_current_arch (), utp->addr));
4110 /* Whether found or created, record the number used by the
4111 target, to help with mapping target tracepoints back to their
4112 counterparts here. */
4114 t->number_on_target = utp->number;
4117 /* Notify 'breakpoint-modified' observer that at least one of B's
4118 locations was changed. */
4119 for (ix = 0; VEC_iterate (breakpoint_p, modified_tp, ix, b); ix++)
4120 observer_notify_breakpoint_modified (b);
4122 VEC_free (breakpoint_p, modified_tp);
4123 free_uploaded_tps (uploaded_tps);
4126 /* Trace state variables don't have much to identify them beyond their
4127 name, so just use that to detect matches. */
4129 static struct trace_state_variable *
4130 find_matching_tsv (struct uploaded_tsv *utsv)
4135 return find_trace_state_variable (utsv->name);
4138 static struct trace_state_variable *
4139 create_tsv_from_upload (struct uploaded_tsv *utsv)
4141 const char *namebase;
4144 struct trace_state_variable *tsv;
4145 struct cleanup *old_chain;
4149 namebase = utsv->name;
4150 buf = xstrprintf ("%s", namebase);
4155 buf = xstrprintf ("%s_%d", namebase, try_num++);
4158 /* Fish for a name that is not in use. */
4159 /* (should check against all internal vars?) */
4160 while (find_trace_state_variable (buf))
4163 buf = xstrprintf ("%s_%d", namebase, try_num++);
4166 old_chain = make_cleanup (xfree, buf);
4168 /* We have an available name, create the variable. */
4169 tsv = create_trace_state_variable (buf);
4170 tsv->initial_value = utsv->initial_value;
4171 tsv->builtin = utsv->builtin;
4173 observer_notify_tsv_created (tsv);
4175 do_cleanups (old_chain);
4180 /* Given a list of uploaded trace state variables, try to match them
4181 up with existing variables, or create additional ones. */
4184 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
4187 struct uploaded_tsv *utsv;
4188 struct trace_state_variable *tsv;
4191 /* Most likely some numbers will have to be reassigned as part of
4192 the merge, so clear them all in anticipation. */
4193 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
4196 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
4198 tsv = find_matching_tsv (utsv);
4202 printf_filtered (_("Assuming trace state variable $%s "
4203 "is same as target's variable %d.\n"),
4204 tsv->name, utsv->number);
4208 tsv = create_tsv_from_upload (utsv);
4210 printf_filtered (_("Created trace state variable "
4211 "$%s for target's variable %d.\n"),
4212 tsv->name, utsv->number);
4214 /* Give precedence to numberings that come from the target. */
4216 tsv->number = utsv->number;
4219 /* Renumber everything that didn't get a target-assigned number. */
4221 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
4222 if (tsv->number > highest)
4223 highest = tsv->number;
4226 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
4227 if (tsv->number == 0)
4228 tsv->number = highest++;
4230 free_uploaded_tsvs (uploaded_tsvs);
4233 /* target tfile command */
4235 static struct target_ops tfile_ops;
4237 /* Fill in tfile_ops with its defined operations and properties. */
4239 #define TRACE_HEADER_SIZE 8
4241 static char *trace_filename;
4242 static int trace_fd = -1;
4243 static off_t trace_frames_offset;
4244 static off_t cur_offset;
4245 static int cur_data_size;
4246 int trace_regblock_size;
4248 static void tfile_interp_line (char *line,
4249 struct uploaded_tp **utpp,
4250 struct uploaded_tsv **utsvp);
4252 /* Read SIZE bytes into READBUF from the trace frame, starting at
4253 TRACE_FD's current position. Note that this call `read'
4254 underneath, hence it advances the file's seek position. Throws an
4255 error if the `read' syscall fails, or less than SIZE bytes are
4259 tfile_read (gdb_byte *readbuf, int size)
4263 gotten = read (trace_fd, readbuf, size);
4265 perror_with_name (trace_filename);
4266 else if (gotten < size)
4267 error (_("Premature end of file while reading trace file"));
4271 tfile_open (char *filename, int from_tty)
4273 volatile struct gdb_exception ex;
4275 struct cleanup *old_chain;
4278 char header[TRACE_HEADER_SIZE];
4279 char linebuf[1000]; /* Should be max remote packet size or so. */
4282 struct trace_status *ts;
4283 struct uploaded_tp *uploaded_tps = NULL;
4284 struct uploaded_tsv *uploaded_tsvs = NULL;
4286 target_preopen (from_tty);
4288 error (_("No trace file specified."));
4290 filename = tilde_expand (filename);
4291 if (!IS_ABSOLUTE_PATH(filename))
4293 temp = concat (current_directory, "/", filename, (char *) NULL);
4298 old_chain = make_cleanup (xfree, filename);
4300 flags = O_BINARY | O_LARGEFILE;
4302 scratch_chan = gdb_open_cloexec (filename, flags, 0);
4303 if (scratch_chan < 0)
4304 perror_with_name (filename);
4306 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
4308 discard_cleanups (old_chain); /* Don't free filename any more. */
4309 unpush_target (&tfile_ops);
4311 trace_filename = xstrdup (filename);
4312 trace_fd = scratch_chan;
4315 /* Read the file header and test for validity. */
4316 tfile_read ((gdb_byte *) &header, TRACE_HEADER_SIZE);
4318 bytes += TRACE_HEADER_SIZE;
4319 if (!(header[0] == 0x7f
4320 && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
4321 error (_("File is not a valid trace file."));
4323 push_target (&tfile_ops);
4325 trace_regblock_size = 0;
4326 ts = current_trace_status ();
4327 /* We know we're working with a file. Record its name. */
4328 ts->filename = trace_filename;
4329 /* Set defaults in case there is no status line. */
4330 ts->running_known = 0;
4331 ts->stop_reason = trace_stop_reason_unknown;
4332 ts->traceframe_count = -1;
4333 ts->buffer_free = 0;
4334 ts->disconnected_tracing = 0;
4335 ts->circular_buffer = 0;
4337 TRY_CATCH (ex, RETURN_MASK_ALL)
4339 /* Read through a section of newline-terminated lines that
4340 define things like tracepoints. */
4344 tfile_read (&byte, 1);
4349 /* Empty line marks end of the definition section. */
4354 tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
4357 linebuf[i++] = byte;
4359 error (_("Excessively long lines in trace file"));
4362 /* Record the starting offset of the binary trace data. */
4363 trace_frames_offset = bytes;
4365 /* If we don't have a blocksize, we can't interpret the
4367 if (trace_regblock_size == 0)
4368 error (_("No register block size recorded in trace file"));
4372 /* Remove the partially set up target. */
4373 unpush_target (&tfile_ops);
4374 throw_exception (ex);
4377 inferior_appeared (current_inferior (), TFILE_PID);
4378 inferior_ptid = pid_to_ptid (TFILE_PID);
4379 add_thread_silent (inferior_ptid);
4381 if (ts->traceframe_count <= 0)
4382 warning (_("No traceframes present in this file."));
4384 /* Add the file's tracepoints and variables into the current mix. */
4386 /* Get trace state variables first, they may be checked when parsing
4387 uploaded commands. */
4388 merge_uploaded_trace_state_variables (&uploaded_tsvs);
4390 merge_uploaded_tracepoints (&uploaded_tps);
4392 post_create_inferior (&tfile_ops, from_tty);
4395 /* Interpret the given line from the definitions part of the trace
4399 tfile_interp_line (char *line, struct uploaded_tp **utpp,
4400 struct uploaded_tsv **utsvp)
4404 if (strncmp (p, "R ", strlen ("R ")) == 0)
4407 trace_regblock_size = strtol (p, &p, 16);
4409 else if (strncmp (p, "status ", strlen ("status ")) == 0)
4411 p += strlen ("status ");
4412 parse_trace_status (p, current_trace_status ());
4414 else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
4416 p += strlen ("tp ");
4417 parse_tracepoint_definition (p, utpp);
4419 else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
4421 p += strlen ("tsv ");
4422 parse_tsv_definition (p, utsvp);
4425 warning (_("Ignoring trace file definition \"%s\""), line);
4428 /* Parse the part of trace status syntax that is shared between
4429 the remote protocol and the trace file reader. */
4432 parse_trace_status (char *line, struct trace_status *ts)
4434 char *p = line, *p1, *p2, *p3, *p_temp;
4438 ts->running_known = 1;
4439 ts->running = (*p++ == '1');
4440 ts->stop_reason = trace_stop_reason_unknown;
4441 xfree (ts->stop_desc);
4442 ts->stop_desc = NULL;
4443 ts->traceframe_count = -1;
4444 ts->traceframes_created = -1;
4445 ts->buffer_free = -1;
4446 ts->buffer_size = -1;
4447 ts->disconnected_tracing = 0;
4448 ts->circular_buffer = 0;
4449 xfree (ts->user_name);
4450 ts->user_name = NULL;
4453 ts->start_time = ts->stop_time = 0;
4457 p1 = strchr (p, ':');
4459 error (_("Malformed trace status, at %s\n\
4460 Status line: '%s'\n"), p, line);
4461 p3 = strchr (p, ';');
4463 p3 = p + strlen (p);
4464 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
4466 p = unpack_varlen_hex (++p1, &val);
4467 ts->stop_reason = trace_buffer_full;
4469 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
4471 p = unpack_varlen_hex (++p1, &val);
4472 ts->stop_reason = trace_never_run;
4474 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
4477 p = unpack_varlen_hex (++p1, &val);
4478 ts->stop_reason = tracepoint_passcount;
4479 ts->stopping_tracepoint = val;
4481 else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
4483 p2 = strchr (++p1, ':');
4491 ts->stop_desc = xmalloc (strlen (line));
4492 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
4493 ts->stop_desc[end] = '\0';
4496 ts->stop_desc = xstrdup ("");
4498 p = unpack_varlen_hex (++p2, &val);
4499 ts->stop_reason = tstop_command;
4501 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
4503 p = unpack_varlen_hex (++p1, &val);
4504 ts->stop_reason = trace_disconnected;
4506 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
4508 p2 = strchr (++p1, ':');
4511 ts->stop_desc = xmalloc ((p2 - p1) / 2 + 1);
4512 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
4513 ts->stop_desc[end] = '\0';
4516 ts->stop_desc = xstrdup ("");
4518 p = unpack_varlen_hex (++p2, &val);
4519 ts->stopping_tracepoint = val;
4520 ts->stop_reason = tracepoint_error;
4522 else if (strncmp (p, "tframes", p1 - p) == 0)
4524 p = unpack_varlen_hex (++p1, &val);
4525 ts->traceframe_count = val;
4527 else if (strncmp (p, "tcreated", p1 - p) == 0)
4529 p = unpack_varlen_hex (++p1, &val);
4530 ts->traceframes_created = val;
4532 else if (strncmp (p, "tfree", p1 - p) == 0)
4534 p = unpack_varlen_hex (++p1, &val);
4535 ts->buffer_free = val;
4537 else if (strncmp (p, "tsize", p1 - p) == 0)
4539 p = unpack_varlen_hex (++p1, &val);
4540 ts->buffer_size = val;
4542 else if (strncmp (p, "disconn", p1 - p) == 0)
4544 p = unpack_varlen_hex (++p1, &val);
4545 ts->disconnected_tracing = val;
4547 else if (strncmp (p, "circular", p1 - p) == 0)
4549 p = unpack_varlen_hex (++p1, &val);
4550 ts->circular_buffer = val;
4552 else if (strncmp (p, "starttime", p1 - p) == 0)
4554 p = unpack_varlen_hex (++p1, &val);
4555 ts->start_time = val;
4557 else if (strncmp (p, "stoptime", p1 - p) == 0)
4559 p = unpack_varlen_hex (++p1, &val);
4560 ts->stop_time = val;
4562 else if (strncmp (p, "username", p1 - p) == 0)
4565 ts->user_name = xmalloc (strlen (p) / 2);
4566 end = hex2bin (p1, (gdb_byte *) ts->user_name, (p3 - p1) / 2);
4567 ts->user_name[end] = '\0';
4570 else if (strncmp (p, "notes", p1 - p) == 0)
4573 ts->notes = xmalloc (strlen (p) / 2);
4574 end = hex2bin (p1, (gdb_byte *) ts->notes, (p3 - p1) / 2);
4575 ts->notes[end] = '\0';
4580 /* Silently skip unknown optional info. */
4581 p_temp = strchr (p1 + 1, ';');
4585 /* Must be at the end. */
4592 parse_tracepoint_status (char *p, struct breakpoint *bp,
4593 struct uploaded_tp *utp)
4596 struct tracepoint *tp = (struct tracepoint *) bp;
4598 p = unpack_varlen_hex (p, &uval);
4600 tp->base.hit_count += uval;
4602 utp->hit_count += uval;
4603 p = unpack_varlen_hex (p + 1, &uval);
4605 tp->traceframe_usage += uval;
4607 utp->traceframe_usage += uval;
4608 /* Ignore any extra, allowing for future extensions. */
4611 /* Given a line of text defining a part of a tracepoint, parse it into
4612 an "uploaded tracepoint". */
4615 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
4619 ULONGEST num, addr, step, pass, orig_size, xlen, start;
4622 char *cond, *srctype, *buf;
4623 struct uploaded_tp *utp = NULL;
4626 /* Both tracepoint and action definitions start with the same number
4627 and address sequence. */
4629 p = unpack_varlen_hex (p, &num);
4630 p++; /* skip a colon */
4631 p = unpack_varlen_hex (p, &addr);
4632 p++; /* skip a colon */
4635 enabled = (*p++ == 'E');
4636 p++; /* skip a colon */
4637 p = unpack_varlen_hex (p, &step);
4638 p++; /* skip a colon */
4639 p = unpack_varlen_hex (p, &pass);
4640 type = bp_tracepoint;
4642 /* Thumb through optional fields. */
4645 p++; /* skip a colon */
4648 type = bp_fast_tracepoint;
4650 p = unpack_varlen_hex (p, &orig_size);
4654 type = bp_static_tracepoint;
4660 p = unpack_varlen_hex (p, &xlen);
4661 p++; /* skip a comma */
4662 cond = (char *) xmalloc (2 * xlen + 1);
4663 strncpy (cond, p, 2 * xlen);
4664 cond[2 * xlen] = '\0';
4668 warning (_("Unrecognized char '%c' in tracepoint "
4669 "definition, skipping rest"), *p);
4671 utp = get_uploaded_tp (num, addr, utpp);
4673 utp->enabled = enabled;
4678 else if (piece == 'A')
4680 utp = get_uploaded_tp (num, addr, utpp);
4681 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
4683 else if (piece == 'S')
4685 utp = get_uploaded_tp (num, addr, utpp);
4686 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
4688 else if (piece == 'Z')
4690 /* Parse a chunk of source form definition. */
4691 utp = get_uploaded_tp (num, addr, utpp);
4693 p = strchr (p, ':');
4694 p++; /* skip a colon */
4695 p = unpack_varlen_hex (p, &start);
4696 p++; /* skip a colon */
4697 p = unpack_varlen_hex (p, &xlen);
4698 p++; /* skip a colon */
4700 buf = alloca (strlen (line));
4702 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
4705 if (strncmp (srctype, "at:", strlen ("at:")) == 0)
4706 utp->at_string = xstrdup (buf);
4707 else if (strncmp (srctype, "cond:", strlen ("cond:")) == 0)
4708 utp->cond_string = xstrdup (buf);
4709 else if (strncmp (srctype, "cmd:", strlen ("cmd:")) == 0)
4710 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
4712 else if (piece == 'V')
4714 utp = get_uploaded_tp (num, addr, utpp);
4716 parse_tracepoint_status (p, NULL, utp);
4720 /* Don't error out, the target might be sending us optional
4721 info that we don't care about. */
4722 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
4726 /* Convert a textual description of a trace state variable into an
4730 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
4733 ULONGEST num, initval, builtin;
4735 struct uploaded_tsv *utsv = NULL;
4737 buf = alloca (strlen (line));
4740 p = unpack_varlen_hex (p, &num);
4741 p++; /* skip a colon */
4742 p = unpack_varlen_hex (p, &initval);
4743 p++; /* skip a colon */
4744 p = unpack_varlen_hex (p, &builtin);
4745 p++; /* skip a colon */
4746 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
4749 utsv = get_uploaded_tsv (num, utsvp);
4750 utsv->initial_value = initval;
4751 utsv->builtin = builtin;
4752 utsv->name = xstrdup (buf);
4755 /* Close the trace file and generally clean up. */
4765 pid = ptid_get_pid (inferior_ptid);
4766 inferior_ptid = null_ptid; /* Avoid confusion from thread stuff. */
4767 exit_inferior_silent (pid);
4771 xfree (trace_filename);
4772 trace_filename = NULL;
4774 trace_reset_local_state ();
4778 tfile_files_info (struct target_ops *t)
4780 printf_filtered ("\t`%s'\n", trace_filename);
4783 /* The trace status for a file is that tracing can never be run. */
4786 tfile_get_trace_status (struct trace_status *ts)
4788 /* Other bits of trace status were collected as part of opening the
4789 trace files, so nothing to do here. */
4795 tfile_get_tracepoint_status (struct breakpoint *tp, struct uploaded_tp *utp)
4797 /* Other bits of trace status were collected as part of opening the
4798 trace files, so nothing to do here. */
4801 /* Given the position of a traceframe in the file, figure out what
4802 address the frame was collected at. This would normally be the
4803 value of a collected PC register, but if not available, we
4807 tfile_get_traceframe_address (off_t tframe_offset)
4811 struct tracepoint *tp;
4812 off_t saved_offset = cur_offset;
4814 /* FIXME dig pc out of collected registers. */
4816 /* Fall back to using tracepoint address. */
4817 lseek (trace_fd, tframe_offset, SEEK_SET);
4818 tfile_read ((gdb_byte *) &tpnum, 2);
4819 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
4821 (target_gdbarch ()));
4823 tp = get_tracepoint_by_number_on_target (tpnum);
4824 /* FIXME this is a poor heuristic if multiple locations. */
4825 if (tp && tp->base.loc)
4826 addr = tp->base.loc->address;
4828 /* Restore our seek position. */
4829 cur_offset = saved_offset;
4830 lseek (trace_fd, cur_offset, SEEK_SET);
4834 /* Given a type of search and some parameters, scan the collection of
4835 traceframes in the file looking for a match. When found, return
4836 both the traceframe and tracepoint number, otherwise -1 for
4840 tfile_trace_find (enum trace_find_type type, int num,
4841 CORE_ADDR addr1, CORE_ADDR addr2, int *tpp)
4844 int tfnum = 0, found = 0;
4845 unsigned int data_size;
4846 struct tracepoint *tp;
4847 off_t offset, tframe_offset;
4857 lseek (trace_fd, trace_frames_offset, SEEK_SET);
4858 offset = trace_frames_offset;
4861 tframe_offset = offset;
4862 tfile_read ((gdb_byte *) &tpnum, 2);
4863 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
4865 (target_gdbarch ()));
4869 tfile_read ((gdb_byte *) &data_size, 4);
4870 data_size = (unsigned int) extract_unsigned_integer
4871 ((gdb_byte *) &data_size, 4,
4872 gdbarch_byte_order (target_gdbarch ()));
4875 if (type == tfind_number)
4877 /* Looking for a specific trace frame. */
4883 /* Start from the _next_ trace frame. */
4884 if (tfnum > traceframe_number)
4889 tfaddr = tfile_get_traceframe_address (tframe_offset);
4890 if (tfaddr == addr1)
4894 tp = get_tracepoint (num);
4895 if (tp && tpnum == tp->number_on_target)
4899 tfaddr = tfile_get_traceframe_address (tframe_offset);
4900 if (addr1 <= tfaddr && tfaddr <= addr2)
4904 tfaddr = tfile_get_traceframe_address (tframe_offset);
4905 if (!(addr1 <= tfaddr && tfaddr <= addr2))
4909 internal_error (__FILE__, __LINE__, _("unknown tfind type"));
4918 cur_offset = offset;
4919 cur_data_size = data_size;
4923 /* Skip past the traceframe's data. */
4924 lseek (trace_fd, data_size, SEEK_CUR);
4925 offset += data_size;
4926 /* Update our own count of traceframes. */
4929 /* Did not find what we were looking for. */
4935 /* Prototype of the callback passed to tframe_walk_blocks. */
4936 typedef int (*walk_blocks_callback_func) (char blocktype, void *data);
4938 /* Callback for traceframe_walk_blocks, used to find a given block
4939 type in a traceframe. */
4942 match_blocktype (char blocktype, void *data)
4944 char *wantedp = data;
4946 if (*wantedp == blocktype)
4952 /* Walk over all traceframe block starting at POS offset from
4953 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4954 unmodified. If CALLBACK returns true, this returns the position in
4955 the traceframe where the block is found, relative to the start of
4956 the traceframe (cur_offset). Returns -1 if no callback call
4957 returned true, indicating that all blocks have been walked. */
4960 traceframe_walk_blocks (walk_blocks_callback_func callback,
4961 int pos, void *data)
4963 /* Iterate through a traceframe's blocks, looking for a block of the
4966 lseek (trace_fd, cur_offset + pos, SEEK_SET);
4967 while (pos < cur_data_size)
4969 unsigned short mlen;
4972 tfile_read ((gdb_byte *) &block_type, 1);
4976 if ((*callback) (block_type, data))
4982 lseek (trace_fd, cur_offset + pos + trace_regblock_size, SEEK_SET);
4983 pos += trace_regblock_size;
4986 lseek (trace_fd, cur_offset + pos + 8, SEEK_SET);
4987 tfile_read ((gdb_byte *) &mlen, 2);
4988 mlen = (unsigned short)
4989 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
4991 (target_gdbarch ()));
4992 lseek (trace_fd, mlen, SEEK_CUR);
4993 pos += (8 + 2 + mlen);
4996 lseek (trace_fd, cur_offset + pos + 4 + 8, SEEK_SET);
5000 error (_("Unknown block type '%c' (0x%x) in trace frame"),
5001 block_type, block_type);
5009 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
5010 position offset of a block of type TYPE_WANTED in the current trace
5011 frame, starting at POS. Returns -1 if no such block was found. */
5014 traceframe_find_block_type (char type_wanted, int pos)
5016 return traceframe_walk_blocks (match_blocktype, pos, &type_wanted);
5019 /* Look for a block of saved registers in the traceframe, and get the
5020 requested register from it. */
5023 tfile_fetch_registers (struct target_ops *ops,
5024 struct regcache *regcache, int regno)
5026 struct gdbarch *gdbarch = get_regcache_arch (regcache);
5027 int offset, regn, regsize, pc_regno;
5030 /* An uninitialized reg size says we're not going to be
5031 successful at getting register blocks. */
5032 if (!trace_regblock_size)
5035 regs = alloca (trace_regblock_size);
5037 if (traceframe_find_block_type ('R', 0) >= 0)
5039 tfile_read (regs, trace_regblock_size);
5041 /* Assume the block is laid out in GDB register number order,
5042 each register with the size that it has in GDB. */
5044 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
5046 regsize = register_size (gdbarch, regn);
5047 /* Make sure we stay within block bounds. */
5048 if (offset + regsize >= trace_regblock_size)
5050 if (regcache_register_status (regcache, regn) == REG_UNKNOWN)
5054 regcache_raw_supply (regcache, regno, regs + offset);
5057 else if (regno == -1)
5059 regcache_raw_supply (regcache, regn, regs + offset);
5067 /* We get here if no register data has been found. Mark registers
5069 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
5070 regcache_raw_supply (regcache, regn, NULL);
5072 /* We can often usefully guess that the PC is going to be the same
5073 as the address of the tracepoint. */
5074 pc_regno = gdbarch_pc_regnum (gdbarch);
5076 /* XXX This guessing code below only works if the PC register isn't
5077 a pseudo-register. The value of a pseudo-register isn't stored
5078 in the (non-readonly) regcache -- instead it's recomputed
5079 (probably from some other cached raw register) whenever the
5080 register is read. This guesswork should probably move to some
5082 if (pc_regno < 0 || pc_regno >= gdbarch_num_regs (gdbarch))
5085 if (regno == -1 || regno == pc_regno)
5087 struct tracepoint *tp = get_tracepoint (tracepoint_number);
5089 if (tp && tp->base.loc)
5091 /* But don't try to guess if tracepoint is multi-location... */
5092 if (tp->base.loc->next)
5094 warning (_("Tracepoint %d has multiple "
5095 "locations, cannot infer $pc"),
5099 /* ... or does while-stepping. */
5100 if (tp->step_count > 0)
5102 warning (_("Tracepoint %d does while-stepping, "
5103 "cannot infer $pc"),
5108 store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
5109 gdbarch_byte_order (gdbarch),
5110 tp->base.loc->address);
5111 regcache_raw_supply (regcache, pc_regno, regs);
5117 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
5118 const char *annex, gdb_byte *readbuf,
5119 const gdb_byte *writebuf, ULONGEST offset, ULONGEST len)
5121 /* We're only doing regular memory for now. */
5122 if (object != TARGET_OBJECT_MEMORY)
5125 if (readbuf == NULL)
5126 error (_("tfile_xfer_partial: trace file is read-only"));
5128 if (traceframe_number != -1)
5132 /* Iterate through the traceframe's blocks, looking for
5134 while ((pos = traceframe_find_block_type ('M', pos)) >= 0)
5136 ULONGEST maddr, amt;
5137 unsigned short mlen;
5138 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
5140 tfile_read ((gdb_byte *) &maddr, 8);
5141 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
5143 tfile_read ((gdb_byte *) &mlen, 2);
5144 mlen = (unsigned short)
5145 extract_unsigned_integer ((gdb_byte *) &mlen, 2, byte_order);
5147 /* If the block includes the first part of the desired
5148 range, return as much it has; GDB will re-request the
5149 remainder, which might be in a different block of this
5151 if (maddr <= offset && offset < (maddr + mlen))
5153 amt = (maddr + mlen) - offset;
5157 if (maddr != offset)
5158 lseek (trace_fd, offset - maddr, SEEK_CUR);
5159 tfile_read (readbuf, amt);
5163 /* Skip over this block. */
5164 pos += (8 + 2 + mlen);
5168 /* It's unduly pedantic to refuse to look at the executable for
5169 read-only pieces; so do the equivalent of readonly regions aka
5171 /* FIXME account for relocation at some point. */
5178 for (s = exec_bfd->sections; s; s = s->next)
5180 if ((s->flags & SEC_LOAD) == 0
5181 || (s->flags & SEC_READONLY) == 0)
5185 size = bfd_get_section_size (s);
5186 if (vma <= offset && offset < (vma + size))
5190 amt = (vma + size) - offset;
5194 amt = bfd_get_section_contents (exec_bfd, s,
5195 readbuf, offset - vma, amt);
5201 /* Indicate failure to find the requested memory block. */
5205 /* Iterate through the blocks of a trace frame, looking for a 'V'
5206 block with a matching tsv number. */
5209 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
5214 /* Iterate over blocks in current frame and find the last 'V'
5215 block in which tsv number is TSVNUM. In one trace frame, there
5216 may be multiple 'V' blocks created for a given trace variable,
5217 and the last matched 'V' block contains the updated value. */
5219 while ((pos = traceframe_find_block_type ('V', pos)) >= 0)
5223 tfile_read ((gdb_byte *) &vnum, 4);
5224 vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
5226 (target_gdbarch ()));
5229 tfile_read ((gdb_byte *) val, 8);
5230 *val = extract_signed_integer ((gdb_byte *) val, 8,
5232 (target_gdbarch ()));
5242 tfile_has_all_memory (struct target_ops *ops)
5248 tfile_has_memory (struct target_ops *ops)
5254 tfile_has_stack (struct target_ops *ops)
5256 return traceframe_number != -1;
5260 tfile_has_registers (struct target_ops *ops)
5262 return traceframe_number != -1;
5266 tfile_thread_alive (struct target_ops *ops, ptid_t ptid)
5271 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
5272 object for the tfile target's current traceframe. */
5275 build_traceframe_info (char blocktype, void *data)
5277 struct traceframe_info *info = data;
5283 struct mem_range *r;
5285 unsigned short mlen;
5287 tfile_read ((gdb_byte *) &maddr, 8);
5288 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
5290 (target_gdbarch ()));
5291 tfile_read ((gdb_byte *) &mlen, 2);
5292 mlen = (unsigned short)
5293 extract_unsigned_integer ((gdb_byte *) &mlen,
5294 2, gdbarch_byte_order
5295 (target_gdbarch ()));
5297 r = VEC_safe_push (mem_range_s, info->memory, NULL);
5307 tfile_read ((gdb_byte *) &vnum, 4);
5308 VEC_safe_push (int, info->tvars, vnum);
5316 warning (_("Unhandled trace block type (%d) '%c ' "
5317 "while building trace frame info."),
5318 blocktype, blocktype);
5325 static struct traceframe_info *
5326 tfile_traceframe_info (void)
5328 struct traceframe_info *info = XCNEW (struct traceframe_info);
5330 traceframe_walk_blocks (build_traceframe_info, 0, info);
5335 init_tfile_ops (void)
5337 tfile_ops.to_shortname = "tfile";
5338 tfile_ops.to_longname = "Local trace dump file";
5340 = "Use a trace file as a target. Specify the filename of the trace file.";
5341 tfile_ops.to_open = tfile_open;
5342 tfile_ops.to_close = tfile_close;
5343 tfile_ops.to_fetch_registers = tfile_fetch_registers;
5344 tfile_ops.to_xfer_partial = tfile_xfer_partial;
5345 tfile_ops.to_files_info = tfile_files_info;
5346 tfile_ops.to_get_trace_status = tfile_get_trace_status;
5347 tfile_ops.to_get_tracepoint_status = tfile_get_tracepoint_status;
5348 tfile_ops.to_trace_find = tfile_trace_find;
5349 tfile_ops.to_get_trace_state_variable_value
5350 = tfile_get_trace_state_variable_value;
5351 tfile_ops.to_stratum = process_stratum;
5352 tfile_ops.to_has_all_memory = tfile_has_all_memory;
5353 tfile_ops.to_has_memory = tfile_has_memory;
5354 tfile_ops.to_has_stack = tfile_has_stack;
5355 tfile_ops.to_has_registers = tfile_has_registers;
5356 tfile_ops.to_traceframe_info = tfile_traceframe_info;
5357 tfile_ops.to_thread_alive = tfile_thread_alive;
5358 tfile_ops.to_magic = OPS_MAGIC;
5362 free_current_marker (void *arg)
5364 struct static_tracepoint_marker **marker_p = arg;
5366 if (*marker_p != NULL)
5368 release_static_tracepoint_marker (*marker_p);
5375 /* Given a line of text defining a static tracepoint marker, parse it
5376 into a "static tracepoint marker" object. Throws an error is
5377 parsing fails. If PP is non-null, it points to one past the end of
5378 the parsed marker definition. */
5381 parse_static_tracepoint_marker_definition (char *line, char **pp,
5382 struct static_tracepoint_marker *marker)
5389 p = unpack_varlen_hex (p, &addr);
5390 p++; /* skip a colon */
5392 marker->gdbarch = target_gdbarch ();
5393 marker->address = (CORE_ADDR) addr;
5395 endp = strchr (p, ':');
5397 error (_("bad marker definition: %s"), line);
5399 marker->str_id = xmalloc (endp - p + 1);
5400 end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
5401 marker->str_id[end] = '\0';
5404 p++; /* skip a colon */
5406 marker->extra = xmalloc (strlen (p) + 1);
5407 end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
5408 marker->extra[end] = '\0';
5414 /* Release a static tracepoint marker's contents. Note that the
5415 object itself isn't released here. There objects are usually on
5419 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
5421 xfree (marker->str_id);
5422 marker->str_id = NULL;
5425 /* Print MARKER to gdb_stdout. */
5428 print_one_static_tracepoint_marker (int count,
5429 struct static_tracepoint_marker *marker)
5431 struct command_line *l;
5434 char wrap_indent[80];
5435 char extra_field_indent[80];
5436 struct ui_out *uiout = current_uiout;
5437 struct cleanup *bkpt_chain;
5438 VEC(breakpoint_p) *tracepoints;
5440 struct symtab_and_line sal;
5444 sal.pc = marker->address;
5446 tracepoints = static_tracepoints_here (marker->address);
5448 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
5450 /* A counter field to help readability. This is not a stable
5452 ui_out_field_int (uiout, "count", count);
5454 ui_out_field_string (uiout, "marker-id", marker->str_id);
5456 ui_out_field_fmt (uiout, "enabled", "%c",
5457 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
5458 ui_out_spaces (uiout, 2);
5460 strcpy (wrap_indent, " ");
5462 if (gdbarch_addr_bit (marker->gdbarch) <= 32)
5463 strcat (wrap_indent, " ");
5465 strcat (wrap_indent, " ");
5467 strcpy (extra_field_indent, " ");
5469 ui_out_field_core_addr (uiout, "addr", marker->gdbarch, marker->address);
5471 sal = find_pc_line (marker->address, 0);
5472 sym = find_pc_sect_function (marker->address, NULL);
5475 ui_out_text (uiout, "in ");
5476 ui_out_field_string (uiout, "func",
5477 SYMBOL_PRINT_NAME (sym));
5478 ui_out_wrap_hint (uiout, wrap_indent);
5479 ui_out_text (uiout, " at ");
5482 ui_out_field_skip (uiout, "func");
5484 if (sal.symtab != NULL)
5486 ui_out_field_string (uiout, "file",
5487 symtab_to_filename_for_display (sal.symtab));
5488 ui_out_text (uiout, ":");
5490 if (ui_out_is_mi_like_p (uiout))
5492 const char *fullname = symtab_to_fullname (sal.symtab);
5494 ui_out_field_string (uiout, "fullname", fullname);
5497 ui_out_field_skip (uiout, "fullname");
5499 ui_out_field_int (uiout, "line", sal.line);
5503 ui_out_field_skip (uiout, "fullname");
5504 ui_out_field_skip (uiout, "line");
5507 ui_out_text (uiout, "\n");
5508 ui_out_text (uiout, extra_field_indent);
5509 ui_out_text (uiout, _("Data: \""));
5510 ui_out_field_string (uiout, "extra-data", marker->extra);
5511 ui_out_text (uiout, "\"\n");
5513 if (!VEC_empty (breakpoint_p, tracepoints))
5515 struct cleanup *cleanup_chain;
5517 struct breakpoint *b;
5519 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
5522 ui_out_text (uiout, extra_field_indent);
5523 ui_out_text (uiout, _("Probed by static tracepoints: "));
5524 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
5527 ui_out_text (uiout, ", ");
5528 ui_out_text (uiout, "#");
5529 ui_out_field_int (uiout, "tracepoint-id", b->number);
5532 do_cleanups (cleanup_chain);
5534 if (ui_out_is_mi_like_p (uiout))
5535 ui_out_field_int (uiout, "number-of-tracepoints",
5536 VEC_length(breakpoint_p, tracepoints));
5538 ui_out_text (uiout, "\n");
5540 VEC_free (breakpoint_p, tracepoints);
5542 do_cleanups (bkpt_chain);
5546 info_static_tracepoint_markers_command (char *arg, int from_tty)
5548 VEC(static_tracepoint_marker_p) *markers;
5549 struct cleanup *old_chain;
5550 struct static_tracepoint_marker *marker;
5551 struct ui_out *uiout = current_uiout;
5554 /* We don't have to check target_can_use_agent and agent's capability on
5555 static tracepoint here, in order to be compatible with older GDBserver.
5556 We don't check USE_AGENT is true or not, because static tracepoints
5557 don't work without in-process agent, so we don't bother users to type
5558 `set agent on' when to use static tracepoint. */
5561 = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
5562 "StaticTracepointMarkersTable");
5564 ui_out_table_header (uiout, 7, ui_left, "counter", "Cnt");
5566 ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
5568 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
5569 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
5570 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
5572 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
5573 ui_out_table_header (uiout, 40, ui_noalign, "what", "What");
5575 ui_out_table_body (uiout);
5577 markers = target_static_tracepoint_markers_by_strid (NULL);
5578 make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
5581 VEC_iterate (static_tracepoint_marker_p,
5582 markers, i, marker);
5585 print_one_static_tracepoint_marker (i + 1, marker);
5586 release_static_tracepoint_marker (marker);
5589 do_cleanups (old_chain);
5592 /* The $_sdata convenience variable is a bit special. We don't know
5593 for sure type of the value until we actually have a chance to fetch
5594 the data --- the size of the object depends on what has been
5595 collected. We solve this by making $_sdata be an internalvar that
5596 creates a new value on access. */
5598 /* Return a new value with the correct type for the sdata object of
5599 the current trace frame. Return a void value if there's no object
5602 static struct value *
5603 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
5609 /* We need to read the whole object before we know its size. */
5610 size = target_read_alloc (¤t_target,
5611 TARGET_OBJECT_STATIC_TRACE_DATA,
5618 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
5620 v = allocate_value (type);
5621 memcpy (value_contents_raw (v), buf, size);
5626 return allocate_value (builtin_type (gdbarch)->builtin_void);
5629 #if !defined(HAVE_LIBEXPAT)
5631 struct traceframe_info *
5632 parse_traceframe_info (const char *tframe_info)
5634 static int have_warned;
5639 warning (_("Can not parse XML trace frame info; XML support "
5640 "was disabled at compile time"));
5646 #else /* HAVE_LIBEXPAT */
5648 #include "xml-support.h"
5650 /* Handle the start of a <memory> element. */
5653 traceframe_info_start_memory (struct gdb_xml_parser *parser,
5654 const struct gdb_xml_element *element,
5655 void *user_data, VEC(gdb_xml_value_s) *attributes)
5657 struct traceframe_info *info = user_data;
5658 struct mem_range *r = VEC_safe_push (mem_range_s, info->memory, NULL);
5659 ULONGEST *start_p, *length_p;
5661 start_p = xml_find_attribute (attributes, "start")->value;
5662 length_p = xml_find_attribute (attributes, "length")->value;
5664 r->start = *start_p;
5665 r->length = *length_p;
5668 /* Handle the start of a <tvar> element. */
5671 traceframe_info_start_tvar (struct gdb_xml_parser *parser,
5672 const struct gdb_xml_element *element,
5674 VEC(gdb_xml_value_s) *attributes)
5676 struct traceframe_info *info = user_data;
5677 const char *id_attrib = xml_find_attribute (attributes, "id")->value;
5678 int id = gdb_xml_parse_ulongest (parser, id_attrib);
5680 VEC_safe_push (int, info->tvars, id);
5683 /* Discard the constructed trace frame info (if an error occurs). */
5686 free_result (void *p)
5688 struct traceframe_info *result = p;
5690 free_traceframe_info (result);
5693 /* The allowed elements and attributes for an XML memory map. */
5695 static const struct gdb_xml_attribute memory_attributes[] = {
5696 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
5697 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
5698 { NULL, GDB_XML_AF_NONE, NULL, NULL }
5701 static const struct gdb_xml_attribute tvar_attributes[] = {
5702 { "id", GDB_XML_AF_NONE, NULL, NULL },
5703 { NULL, GDB_XML_AF_NONE, NULL, NULL }
5706 static const struct gdb_xml_element traceframe_info_children[] = {
5707 { "memory", memory_attributes, NULL,
5708 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
5709 traceframe_info_start_memory, NULL },
5710 { "tvar", tvar_attributes, NULL,
5711 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
5712 traceframe_info_start_tvar, NULL },
5713 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
5716 static const struct gdb_xml_element traceframe_info_elements[] = {
5717 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
5719 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
5722 /* Parse a traceframe-info XML document. */
5724 struct traceframe_info *
5725 parse_traceframe_info (const char *tframe_info)
5727 struct traceframe_info *result;
5728 struct cleanup *back_to;
5730 result = XCNEW (struct traceframe_info);
5731 back_to = make_cleanup (free_result, result);
5733 if (gdb_xml_parse_quick (_("trace frame info"),
5734 "traceframe-info.dtd", traceframe_info_elements,
5735 tframe_info, result) == 0)
5737 /* Parsed successfully, keep the result. */
5738 discard_cleanups (back_to);
5743 do_cleanups (back_to);
5747 #endif /* HAVE_LIBEXPAT */
5749 /* Returns the traceframe_info object for the current traceframe.
5750 This is where we avoid re-fetching the object from the target if we
5751 already have it cached. */
5753 struct traceframe_info *
5754 get_traceframe_info (void)
5756 if (traceframe_info == NULL)
5757 traceframe_info = target_traceframe_info ();
5759 return traceframe_info;
5762 /* If the target supports the query, return in RESULT the set of
5763 collected memory in the current traceframe, found within the LEN
5764 bytes range starting at MEMADDR. Returns true if the target
5765 supports the query, otherwise returns false, and RESULT is left
5769 traceframe_available_memory (VEC(mem_range_s) **result,
5770 CORE_ADDR memaddr, ULONGEST len)
5772 struct traceframe_info *info = get_traceframe_info ();
5776 struct mem_range *r;
5781 for (i = 0; VEC_iterate (mem_range_s, info->memory, i, r); i++)
5782 if (mem_ranges_overlap (r->start, r->length, memaddr, len))
5784 ULONGEST lo1, hi1, lo2, hi2;
5785 struct mem_range *nr;
5788 hi1 = memaddr + len;
5791 hi2 = r->start + r->length;
5793 nr = VEC_safe_push (mem_range_s, *result, NULL);
5795 nr->start = max (lo1, lo2);
5796 nr->length = min (hi1, hi2) - nr->start;
5799 normalize_mem_ranges (*result);
5806 /* Implementation of `sdata' variable. */
5808 static const struct internalvar_funcs sdata_funcs =
5815 /* module initialization */
5817 _initialize_tracepoint (void)
5819 struct cmd_list_element *c;
5821 /* Explicitly create without lookup, since that tries to create a
5822 value with a void typed value, and when we get here, gdbarch
5823 isn't initialized yet. At this point, we're quite sure there
5824 isn't another convenience variable of the same name. */
5825 create_internalvar_type_lazy ("_sdata", &sdata_funcs, NULL);
5827 traceframe_number = -1;
5828 tracepoint_number = -1;
5830 add_info ("scope", scope_info,
5831 _("List the variables local to a scope"));
5833 add_cmd ("tracepoints", class_trace, NULL,
5834 _("Tracing of program execution without stopping the program."),
5837 add_com ("tdump", class_trace, trace_dump_command,
5838 _("Print everything collected at the current tracepoint."));
5840 add_com ("tsave", class_trace, trace_save_command, _("\
5841 Save the trace data to a file.\n\
5842 Use the '-ctf' option to save the data to CTF format.\n\
5843 Use the '-r' option to direct the target to save directly to the file,\n\
5844 using its own filesystem."));
5846 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
5847 Define a trace state variable.\n\
5848 Argument is a $-prefixed name, optionally followed\n\
5849 by '=' and an expression that sets the initial value\n\
5850 at the start of tracing."));
5851 set_cmd_completer (c, expression_completer);
5853 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
5854 Delete one or more trace state variables.\n\
5855 Arguments are the names of the variables to delete.\n\
5856 If no arguments are supplied, delete all variables."), &deletelist);
5857 /* FIXME add a trace variable completer. */
5859 add_info ("tvariables", tvariables_info, _("\
5860 Status of trace state variables and their values.\n\
5863 add_info ("static-tracepoint-markers",
5864 info_static_tracepoint_markers_command, _("\
5865 List target static tracepoints markers.\n\
5868 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
5869 Select a trace frame;\n\
5870 No argument means forward by one frame; '-' means backward by one frame."),
5871 &tfindlist, "tfind ", 1, &cmdlist);
5873 add_cmd ("outside", class_trace, trace_find_outside_command, _("\
5874 Select a trace frame whose PC is outside the given range (exclusive).\n\
5875 Usage: tfind outside addr1, addr2"),
5878 add_cmd ("range", class_trace, trace_find_range_command, _("\
5879 Select a trace frame whose PC is in the given range (inclusive).\n\
5880 Usage: tfind range addr1,addr2"),
5883 add_cmd ("line", class_trace, trace_find_line_command, _("\
5884 Select a trace frame by source line.\n\
5885 Argument can be a line number (with optional source file),\n\
5886 a function name, or '*' followed by an address.\n\
5887 Default argument is 'the next source line that was traced'."),
5890 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
5891 Select a trace frame by tracepoint number.\n\
5892 Default is the tracepoint for the current trace frame."),
5895 add_cmd ("pc", class_trace, trace_find_pc_command, _("\
5896 Select a trace frame by PC.\n\
5897 Default is the current PC, or the PC of the current trace frame."),
5900 add_cmd ("end", class_trace, trace_find_end_command, _("\
5901 De-select any trace frame and resume 'live' debugging."),
5904 add_alias_cmd ("none", "end", class_trace, 0, &tfindlist);
5906 add_cmd ("start", class_trace, trace_find_start_command,
5907 _("Select the first trace frame in the trace buffer."),
5910 add_com ("tstatus", class_trace, trace_status_command,
5911 _("Display the status of the current trace data collection."));
5913 add_com ("tstop", class_trace, trace_stop_command, _("\
5914 Stop trace data collection.\n\
5915 Usage: tstop [ <notes> ... ]\n\
5916 Any arguments supplied are recorded with the trace as a stop reason and\n\
5917 reported by tstatus (if the target supports trace notes)."));
5919 add_com ("tstart", class_trace, trace_start_command, _("\
5920 Start trace data collection.\n\
5921 Usage: tstart [ <notes> ... ]\n\
5922 Any arguments supplied are recorded with the trace as a note and\n\
5923 reported by tstatus (if the target supports trace notes)."));
5925 add_com ("end", class_trace, end_actions_pseudocommand, _("\
5926 Ends a list of commands or actions.\n\
5927 Several GDB commands allow you to enter a list of commands or actions.\n\
5928 Entering \"end\" on a line by itself is the normal way to terminate\n\
5930 Note: the \"end\" command cannot be used at the gdb prompt."));
5932 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
5933 Specify single-stepping behavior at a tracepoint.\n\
5934 Argument is number of instructions to trace in single-step mode\n\
5935 following the tracepoint. This command is normally followed by\n\
5936 one or more \"collect\" commands, to specify what to collect\n\
5937 while single-stepping.\n\n\
5938 Note: this command can only be used in a tracepoint \"actions\" list."));
5940 add_com_alias ("ws", "while-stepping", class_alias, 0);
5941 add_com_alias ("stepping", "while-stepping", class_alias, 0);
5943 add_com ("collect", class_trace, collect_pseudocommand, _("\
5944 Specify one or more data items to be collected at a tracepoint.\n\
5945 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5946 collect all data (variables, registers) referenced by that expression.\n\
5947 Also accepts the following special arguments:\n\
5948 $regs -- all registers.\n\
5949 $args -- all function arguments.\n\
5950 $locals -- all variables local to the block/function scope.\n\
5951 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5952 Note: this command can only be used in a tracepoint \"actions\" list."));
5954 add_com ("teval", class_trace, teval_pseudocommand, _("\
5955 Specify one or more expressions to be evaluated at a tracepoint.\n\
5956 Accepts a comma-separated list of (one or more) expressions.\n\
5957 The result of each evaluation will be discarded.\n\
5958 Note: this command can only be used in a tracepoint \"actions\" list."));
5960 add_com ("actions", class_trace, trace_actions_command, _("\
5961 Specify the actions to be taken at a tracepoint.\n\
5962 Tracepoint actions may include collecting of specified data,\n\
5963 single-stepping, or enabling/disabling other tracepoints,\n\
5964 depending on target's capabilities."));
5966 default_collect = xstrdup ("");
5967 add_setshow_string_cmd ("default-collect", class_trace,
5968 &default_collect, _("\
5969 Set the list of expressions to collect by default"), _("\
5970 Show the list of expressions to collect by default"), NULL,
5972 &setlist, &showlist);
5974 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
5975 &disconnected_tracing, _("\
5976 Set whether tracing continues after GDB disconnects."), _("\
5977 Show whether tracing continues after GDB disconnects."), _("\
5978 Use this to continue a tracing run even if GDB disconnects\n\
5979 or detaches from the target. You can reconnect later and look at\n\
5980 trace data collected in the meantime."),
5981 set_disconnected_tracing,
5986 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
5987 &circular_trace_buffer, _("\
5988 Set target's use of circular trace buffer."), _("\
5989 Show target's use of circular trace buffer."), _("\
5990 Use this to make the trace buffer into a circular buffer,\n\
5991 which will discard traceframes (oldest first) instead of filling\n\
5992 up and stopping the trace run."),
5993 set_circular_trace_buffer,
5998 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class,
5999 &trace_buffer_size, _("\
6000 Set requested size of trace buffer."), _("\
6001 Show requested size of trace buffer."), _("\
6002 Use this to choose a size for the trace buffer. Some targets\n\
6003 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
6004 disables any attempt to set the buffer size and lets the target choose."),
6005 set_trace_buffer_size, NULL,
6006 &setlist, &showlist);
6008 add_setshow_string_cmd ("trace-user", class_trace,
6010 Set the user name to use for current and future trace runs"), _("\
6011 Show the user name to use for current and future trace runs"), NULL,
6012 set_trace_user, NULL,
6013 &setlist, &showlist);
6015 add_setshow_string_cmd ("trace-notes", class_trace,
6017 Set notes string to use for current and future trace runs"), _("\
6018 Show the notes string to use for current and future trace runs"), NULL,
6019 set_trace_notes, NULL,
6020 &setlist, &showlist);
6022 add_setshow_string_cmd ("trace-stop-notes", class_trace,
6023 &trace_stop_notes, _("\
6024 Set notes string to use for future tstop commands"), _("\
6025 Show the notes string to use for future tstop commands"), NULL,
6026 set_trace_stop_notes, NULL,
6027 &setlist, &showlist);
6031 add_target_with_completer (&tfile_ops, filename_completer);