1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2013 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"
30 #include "gdb_string.h"
32 #include "breakpoint.h"
33 #include "tracepoint.h"
36 #include "completer.h"
38 #include "dictionary.h"
40 #include "user-regs.h"
44 #include "filenames.h"
45 #include "gdbthread.h"
53 #include "exceptions.h"
54 #include "cli/cli-utils.h"
57 #include "completer.h"
58 #include "filestuff.h"
60 /* readline include files */
61 #include "readline/readline.h"
62 #include "readline/history.h"
64 /* readline defines this. */
75 /* Maximum length of an agent aexpression.
76 This accounts for the fact that packets are limited to 400 bytes
77 (which includes everything -- including the checksum), and assumes
78 the worst case of maximum length for each of the pieces of a
81 NOTE: expressions get mem2hex'ed otherwise this would be twice as
82 large. (400 - 31)/2 == 184 */
83 #define MAX_AGENT_EXPR_LEN 184
85 /* A hook used to notify the UI of tracepoint operations. */
87 void (*deprecated_trace_find_hook) (char *arg, int from_tty);
88 void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
90 extern void (*deprecated_readline_begin_hook) (char *, ...);
91 extern char *(*deprecated_readline_hook) (char *);
92 extern void (*deprecated_readline_end_hook) (void);
97 This module defines the following debugger commands:
98 trace : set a tracepoint on a function, line, or address.
99 info trace : list all debugger-defined tracepoints.
100 delete trace : delete one or more tracepoints.
101 enable trace : enable one or more tracepoints.
102 disable trace : disable one or more tracepoints.
103 actions : specify actions to be taken at a tracepoint.
104 passcount : specify a pass count for a tracepoint.
105 tstart : start a trace experiment.
106 tstop : stop a trace experiment.
107 tstatus : query the status of a trace experiment.
108 tfind : find a trace frame in the trace buffer.
109 tdump : print everything collected at the current tracepoint.
110 save-tracepoints : write tracepoint setup into a file.
112 This module defines the following user-visible debugger variables:
113 $trace_frame : sequence number of trace frame currently being debugged.
114 $trace_line : source line of trace frame currently being debugged.
115 $trace_file : source file of trace frame currently being debugged.
116 $tracepoint : tracepoint number of trace frame currently being debugged.
120 /* ======= Important global variables: ======= */
122 /* The list of all trace state variables. We don't retain pointers to
123 any of these for any reason - API is by name or number only - so it
124 works to have a vector of objects. */
126 typedef struct trace_state_variable tsv_s;
129 static VEC(tsv_s) *tvariables;
131 /* The next integer to assign to a variable. */
133 static int next_tsv_number = 1;
135 /* Number of last traceframe collected. */
136 static int traceframe_number;
138 /* Tracepoint for last traceframe collected. */
139 static int tracepoint_number;
141 /* Symbol for function for last traceframe collected. */
142 static struct symbol *traceframe_fun;
144 /* Symtab and line for last traceframe collected. */
145 static struct symtab_and_line traceframe_sal;
147 /* The traceframe info of the current traceframe. NULL if we haven't
148 yet attempted to fetch it, or if the target does not support
149 fetching this object, or if we're not inspecting a traceframe
151 static struct traceframe_info *traceframe_info;
153 /* Tracing command lists. */
154 static struct cmd_list_element *tfindlist;
156 /* List of expressions to collect by default at each tracepoint hit. */
157 char *default_collect = "";
159 static int disconnected_tracing;
161 /* This variable controls whether we ask the target for a linear or
162 circular trace buffer. */
164 static int circular_trace_buffer;
166 /* This variable is the requested trace buffer size, or -1 to indicate
167 that we don't care and leave it up to the target to set a size. */
169 static int trace_buffer_size = -1;
171 /* Textual notes applying to the current and/or future trace runs. */
173 char *trace_user = NULL;
175 /* Textual notes applying to the current and/or future trace runs. */
177 char *trace_notes = NULL;
179 /* Textual notes applying to the stopping of a trace. */
181 char *trace_stop_notes = NULL;
183 /* ======= Important command functions: ======= */
184 static void trace_actions_command (char *, int);
185 static void trace_start_command (char *, int);
186 static void trace_stop_command (char *, int);
187 static void trace_status_command (char *, int);
188 static void trace_find_command (char *, int);
189 static void trace_find_pc_command (char *, int);
190 static void trace_find_tracepoint_command (char *, int);
191 static void trace_find_line_command (char *, int);
192 static void trace_find_range_command (char *, int);
193 static void trace_find_outside_command (char *, int);
194 static void trace_dump_command (char *, int);
196 /* support routines */
198 struct collection_list;
199 static void add_aexpr (struct collection_list *, struct agent_expr *);
200 static char *mem2hex (gdb_byte *, char *, int);
201 static void add_register (struct collection_list *collection,
204 static void free_uploaded_tps (struct uploaded_tp **utpp);
205 static void free_uploaded_tsvs (struct uploaded_tsv **utsvp);
207 static struct command_line *
208 all_tracepoint_actions_and_cleanup (struct breakpoint *t);
210 extern void _initialize_tracepoint (void);
212 static struct trace_status trace_status;
214 char *stop_reason_names[] = {
224 struct trace_status *
225 current_trace_status (void)
227 return &trace_status;
233 free_traceframe_info (struct traceframe_info *info)
237 VEC_free (mem_range_s, info->memory);
238 VEC_free (int, info->tvars);
244 /* Free and clear the traceframe info cache of the current
248 clear_traceframe_info (void)
250 free_traceframe_info (traceframe_info);
251 traceframe_info = NULL;
254 /* Set traceframe number to NUM. */
256 set_traceframe_num (int num)
258 traceframe_number = num;
259 set_internalvar_integer (lookup_internalvar ("trace_frame"), num);
262 /* Set tracepoint number to NUM. */
264 set_tracepoint_num (int num)
266 tracepoint_number = num;
267 set_internalvar_integer (lookup_internalvar ("tracepoint"), num);
270 /* Set externally visible debug variables for querying/printing
271 the traceframe context (line, function, file). */
274 set_traceframe_context (struct frame_info *trace_frame)
278 /* Save as globals for internal use. */
279 if (trace_frame != NULL
280 && get_frame_pc_if_available (trace_frame, &trace_pc))
282 traceframe_sal = find_pc_line (trace_pc, 0);
283 traceframe_fun = find_pc_function (trace_pc);
285 /* Save linenumber as "$trace_line", a debugger variable visible to
287 set_internalvar_integer (lookup_internalvar ("trace_line"),
288 traceframe_sal.line);
292 init_sal (&traceframe_sal);
293 traceframe_fun = NULL;
294 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
297 /* Save func name as "$trace_func", a debugger variable visible to
299 if (traceframe_fun == NULL
300 || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
301 clear_internalvar (lookup_internalvar ("trace_func"));
303 set_internalvar_string (lookup_internalvar ("trace_func"),
304 SYMBOL_LINKAGE_NAME (traceframe_fun));
306 /* Save file name as "$trace_file", a debugger variable visible to
308 if (traceframe_sal.symtab == NULL)
309 clear_internalvar (lookup_internalvar ("trace_file"));
311 set_internalvar_string (lookup_internalvar ("trace_file"),
312 symtab_to_filename_for_display (traceframe_sal.symtab));
315 /* Create a new trace state variable with the given name. */
317 struct trace_state_variable *
318 create_trace_state_variable (const char *name)
320 struct trace_state_variable tsv;
322 memset (&tsv, 0, sizeof (tsv));
323 tsv.name = xstrdup (name);
324 tsv.number = next_tsv_number++;
325 return VEC_safe_push (tsv_s, tvariables, &tsv);
328 /* Look for a trace state variable of the given name. */
330 struct trace_state_variable *
331 find_trace_state_variable (const char *name)
333 struct trace_state_variable *tsv;
336 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
337 if (strcmp (name, tsv->name) == 0)
343 /* Look for a trace state variable of the given number. Return NULL if
346 struct trace_state_variable *
347 find_trace_state_variable_by_number (int number)
349 struct trace_state_variable *tsv;
352 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
353 if (tsv->number == number)
360 delete_trace_state_variable (const char *name)
362 struct trace_state_variable *tsv;
365 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
366 if (strcmp (name, tsv->name) == 0)
368 observer_notify_tsv_deleted (tsv);
370 xfree ((void *)tsv->name);
371 VEC_unordered_remove (tsv_s, tvariables, ix);
376 warning (_("No trace variable named \"$%s\", not deleting"), name);
379 /* Throws an error if NAME is not valid syntax for a trace state
383 validate_trace_state_variable_name (const char *name)
388 error (_("Must supply a non-empty variable name"));
390 /* All digits in the name is reserved for value history
392 for (p = name; isdigit (*p); p++)
395 error (_("$%s is not a valid trace state variable name"), name);
397 for (p = name; isalnum (*p) || *p == '_'; p++)
400 error (_("$%s is not a valid trace state variable name"), name);
403 /* The 'tvariable' command collects a name and optional expression to
404 evaluate into an initial value. */
407 trace_variable_command (char *args, int from_tty)
409 struct cleanup *old_chain;
411 struct trace_state_variable *tsv;
415 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
417 /* Only allow two syntaxes; "$name" and "$name=value". */
418 p = skip_spaces (args);
421 error (_("Name of trace variable should start with '$'"));
424 while (isalnum (*p) || *p == '_')
426 name = savestring (name, p - name);
427 old_chain = make_cleanup (xfree, name);
430 if (*p != '=' && *p != '\0')
431 error (_("Syntax must be $NAME [ = EXPR ]"));
433 validate_trace_state_variable_name (name);
436 initval = value_as_long (parse_and_eval (++p));
438 /* If the variable already exists, just change its initial value. */
439 tsv = find_trace_state_variable (name);
442 if (tsv->initial_value != initval)
444 tsv->initial_value = initval;
445 observer_notify_tsv_modified (tsv);
447 printf_filtered (_("Trace state variable $%s "
448 "now has initial value %s.\n"),
449 tsv->name, plongest (tsv->initial_value));
450 do_cleanups (old_chain);
454 /* Create a new variable. */
455 tsv = create_trace_state_variable (name);
456 tsv->initial_value = initval;
458 observer_notify_tsv_created (tsv);
460 printf_filtered (_("Trace state variable $%s "
461 "created, with initial value %s.\n"),
462 tsv->name, plongest (tsv->initial_value));
464 do_cleanups (old_chain);
468 delete_trace_variable_command (char *args, int from_tty)
472 struct cleanup *back_to;
476 if (query (_("Delete all trace state variables? ")))
477 VEC_free (tsv_s, tvariables);
479 observer_notify_tsv_deleted (NULL);
483 argv = gdb_buildargv (args);
484 back_to = make_cleanup_freeargv (argv);
486 for (ix = 0; argv[ix] != NULL; ix++)
488 if (*argv[ix] == '$')
489 delete_trace_state_variable (argv[ix] + 1);
491 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv[ix]);
494 do_cleanups (back_to);
500 tvariables_info_1 (void)
502 struct trace_state_variable *tsv;
505 struct cleanup *back_to;
506 struct ui_out *uiout = current_uiout;
508 if (VEC_length (tsv_s, tvariables) == 0 && !ui_out_is_mi_like_p (uiout))
510 printf_filtered (_("No trace state variables.\n"));
514 /* Try to acquire values from the target. */
515 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix, ++count)
516 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
519 back_to = make_cleanup_ui_out_table_begin_end (uiout, 3,
520 count, "trace-variables");
521 ui_out_table_header (uiout, 15, ui_left, "name", "Name");
522 ui_out_table_header (uiout, 11, ui_left, "initial", "Initial");
523 ui_out_table_header (uiout, 11, ui_left, "current", "Current");
525 ui_out_table_body (uiout);
527 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
529 struct cleanup *back_to2;
533 back_to2 = make_cleanup_ui_out_tuple_begin_end (uiout, "variable");
535 name = concat ("$", tsv->name, (char *) NULL);
536 make_cleanup (xfree, name);
537 ui_out_field_string (uiout, "name", name);
538 ui_out_field_string (uiout, "initial", plongest (tsv->initial_value));
540 if (tsv->value_known)
541 c = plongest (tsv->value);
542 else if (ui_out_is_mi_like_p (uiout))
543 /* For MI, we prefer not to use magic string constants, but rather
544 omit the field completely. The difference between unknown and
545 undefined does not seem important enough to represent. */
547 else if (current_trace_status ()->running || traceframe_number >= 0)
548 /* The value is/was defined, but we don't have it. */
551 /* It is not meaningful to ask about the value. */
554 ui_out_field_string (uiout, "current", c);
555 ui_out_text (uiout, "\n");
557 do_cleanups (back_to2);
560 do_cleanups (back_to);
563 /* List all the trace state variables. */
566 tvariables_info (char *args, int from_tty)
568 tvariables_info_1 ();
571 /* Stash definitions of tsvs into the given file. */
574 save_trace_state_variables (struct ui_file *fp)
576 struct trace_state_variable *tsv;
579 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
581 fprintf_unfiltered (fp, "tvariable $%s", tsv->name);
582 if (tsv->initial_value)
583 fprintf_unfiltered (fp, " = %s", plongest (tsv->initial_value));
584 fprintf_unfiltered (fp, "\n");
588 /* ACTIONS functions: */
590 /* The three functions:
591 collect_pseudocommand,
592 while_stepping_pseudocommand, and
593 end_actions_pseudocommand
594 are placeholders for "commands" that are actually ONLY to be used
595 within a tracepoint action list. If the actual function is ever called,
596 it means that somebody issued the "command" at the top level,
597 which is always an error. */
600 end_actions_pseudocommand (char *args, int from_tty)
602 error (_("This command cannot be used at the top level."));
606 while_stepping_pseudocommand (char *args, int from_tty)
608 error (_("This command can only be used in a tracepoint actions list."));
612 collect_pseudocommand (char *args, int from_tty)
614 error (_("This command can only be used in a tracepoint actions list."));
618 teval_pseudocommand (char *args, int from_tty)
620 error (_("This command can only be used in a tracepoint actions list."));
623 /* Parse any collection options, such as /s for strings. */
626 decode_agent_options (const char *exp, int *trace_string)
628 struct value_print_options opts;
635 /* Call this to borrow the print elements default for collection
637 get_user_print_options (&opts);
642 if (target_supports_string_tracing ())
644 /* Allow an optional decimal number giving an explicit maximum
645 string length, defaulting it to the "print elements" value;
646 so "collect/s80 mystr" gets at most 80 bytes of string. */
647 *trace_string = opts.print_max;
649 if (*exp >= '0' && *exp <= '9')
650 *trace_string = atoi (exp);
651 while (*exp >= '0' && *exp <= '9')
655 error (_("Target does not support \"/s\" option for string tracing."));
658 error (_("Undefined collection format \"%c\"."), *exp);
660 exp = skip_spaces_const (exp);
665 /* Enter a list of actions for a tracepoint. */
667 trace_actions_command (char *args, int from_tty)
669 struct tracepoint *t;
670 struct command_line *l;
672 t = get_tracepoint_by_number (&args, NULL, 1);
676 xstrprintf ("Enter actions for tracepoint %d, one per line.",
678 struct cleanup *cleanups = make_cleanup (xfree, tmpbuf);
680 l = read_command_lines (tmpbuf, from_tty, 1,
681 check_tracepoint_command, t);
682 do_cleanups (cleanups);
683 breakpoint_set_commands (&t->base, l);
685 /* else just return */
688 /* Report the results of checking the agent expression, as errors or
692 report_agent_reqs_errors (struct agent_expr *aexpr)
694 /* All of the "flaws" are serious bytecode generation issues that
695 should never occur. */
696 if (aexpr->flaw != agent_flaw_none)
697 internal_error (__FILE__, __LINE__, _("expression is malformed"));
699 /* If analysis shows a stack underflow, GDB must have done something
700 badly wrong in its bytecode generation. */
701 if (aexpr->min_height < 0)
702 internal_error (__FILE__, __LINE__,
703 _("expression has min height < 0"));
705 /* Issue this error if the stack is predicted to get too deep. The
706 limit is rather arbitrary; a better scheme might be for the
707 target to report how much stack it will have available. The
708 depth roughly corresponds to parenthesization, so a limit of 20
709 amounts to 20 levels of expression nesting, which is actually
710 a pretty big hairy expression. */
711 if (aexpr->max_height > 20)
712 error (_("Expression is too complicated."));
715 /* worker function */
717 validate_actionline (const char *line, struct breakpoint *b)
719 struct cmd_list_element *c;
720 struct expression *exp = NULL;
721 struct cleanup *old_chain = NULL;
724 struct bp_location *loc;
725 struct agent_expr *aexpr;
726 struct tracepoint *t = (struct tracepoint *) b;
728 /* If EOF is typed, *line is NULL. */
732 p = skip_spaces_const (line);
734 /* Symbol lookup etc. */
735 if (*p == '\0') /* empty line: just prompt for another line. */
738 if (*p == '#') /* comment line */
741 c = lookup_cmd (&p, cmdlist, "", -1, 1);
743 error (_("`%s' is not a tracepoint action, or is ambiguous."), p);
745 if (cmd_cfunc_eq (c, collect_pseudocommand))
747 int trace_string = 0;
750 p = decode_agent_options (p, &trace_string);
753 { /* Repeat over a comma-separated list. */
754 QUIT; /* Allow user to bail out with ^C. */
755 p = skip_spaces_const (p);
757 if (*p == '$') /* Look for special pseudo-symbols. */
759 if (0 == strncasecmp ("reg", p + 1, 3)
760 || 0 == strncasecmp ("arg", p + 1, 3)
761 || 0 == strncasecmp ("loc", p + 1, 3)
762 || 0 == strncasecmp ("_ret", p + 1, 4)
763 || 0 == strncasecmp ("_sdata", p + 1, 6))
768 /* else fall thru, treat p as an expression and parse it! */
771 for (loc = t->base.loc; loc; loc = loc->next)
774 exp = parse_exp_1 (&p, loc->address,
775 block_for_pc (loc->address), 1);
776 old_chain = make_cleanup (free_current_contents, &exp);
778 if (exp->elts[0].opcode == OP_VAR_VALUE)
780 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
782 error (_("constant `%s' (value %s) "
783 "will not be collected."),
784 SYMBOL_PRINT_NAME (exp->elts[2].symbol),
785 plongest (SYMBOL_VALUE (exp->elts[2].symbol)));
787 else if (SYMBOL_CLASS (exp->elts[2].symbol)
788 == LOC_OPTIMIZED_OUT)
790 error (_("`%s' is optimized away "
791 "and cannot be collected."),
792 SYMBOL_PRINT_NAME (exp->elts[2].symbol));
796 /* We have something to collect, make sure that the expr to
797 bytecode translator can handle it and that it's not too
799 aexpr = gen_trace_for_expr (loc->address, exp, trace_string);
800 make_cleanup_free_agent_expr (aexpr);
802 if (aexpr->len > MAX_AGENT_EXPR_LEN)
803 error (_("Expression is too complicated."));
807 report_agent_reqs_errors (aexpr);
809 do_cleanups (old_chain);
812 while (p && *p++ == ',');
815 else if (cmd_cfunc_eq (c, teval_pseudocommand))
818 { /* Repeat over a comma-separated list. */
819 QUIT; /* Allow user to bail out with ^C. */
820 p = skip_spaces_const (p);
823 for (loc = t->base.loc; loc; loc = loc->next)
827 /* Only expressions are allowed for this action. */
828 exp = parse_exp_1 (&p, loc->address,
829 block_for_pc (loc->address), 1);
830 old_chain = make_cleanup (free_current_contents, &exp);
832 /* We have something to evaluate, make sure that the expr to
833 bytecode translator can handle it and that it's not too
835 aexpr = gen_eval_for_expr (loc->address, exp);
836 make_cleanup_free_agent_expr (aexpr);
838 if (aexpr->len > MAX_AGENT_EXPR_LEN)
839 error (_("Expression is too complicated."));
842 report_agent_reqs_errors (aexpr);
844 do_cleanups (old_chain);
847 while (p && *p++ == ',');
850 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
854 p = skip_spaces_const (p);
855 t->step_count = strtol (p, &endp, 0);
856 if (endp == p || t->step_count == 0)
857 error (_("while-stepping step count `%s' is malformed."), line);
861 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
865 error (_("`%s' is not a supported tracepoint action."), line);
869 memrange_absolute = -1
872 /* MEMRANGE functions: */
874 static int memrange_cmp (const void *, const void *);
876 /* Compare memranges for qsort. */
878 memrange_cmp (const void *va, const void *vb)
880 const struct memrange *a = va, *b = vb;
882 if (a->type < b->type)
884 if (a->type > b->type)
886 if (a->type == memrange_absolute)
888 if ((bfd_vma) a->start < (bfd_vma) b->start)
890 if ((bfd_vma) a->start > (bfd_vma) b->start)
895 if (a->start < b->start)
897 if (a->start > b->start)
903 /* Sort the memrange list using qsort, and merge adjacent memranges. */
905 memrange_sortmerge (struct collection_list *memranges)
909 qsort (memranges->list, memranges->next_memrange,
910 sizeof (struct memrange), memrange_cmp);
911 if (memranges->next_memrange > 0)
913 for (a = 0, b = 1; b < memranges->next_memrange; b++)
915 /* If memrange b overlaps or is adjacent to memrange a,
917 if (memranges->list[a].type == memranges->list[b].type
918 && memranges->list[b].start <= memranges->list[a].end)
920 if (memranges->list[b].end > memranges->list[a].end)
921 memranges->list[a].end = memranges->list[b].end;
922 continue; /* next b, same a */
926 memcpy (&memranges->list[a], &memranges->list[b],
927 sizeof (struct memrange));
929 memranges->next_memrange = a + 1;
933 /* Add a register to a collection list. */
935 add_register (struct collection_list *collection, unsigned int regno)
938 printf_filtered ("collect register %d\n", regno);
939 if (regno >= (8 * sizeof (collection->regs_mask)))
940 error (_("Internal: register number %d too large for tracepoint"),
942 collection->regs_mask[regno / 8] |= 1 << (regno % 8);
945 /* Add a memrange to a collection list. */
947 add_memrange (struct collection_list *memranges,
948 int type, bfd_signed_vma base,
953 printf_filtered ("(%d,", type);
955 printf_filtered (",%ld)\n", len);
958 /* type: memrange_absolute == memory, other n == basereg */
959 memranges->list[memranges->next_memrange].type = type;
960 /* base: addr if memory, offset if reg relative. */
961 memranges->list[memranges->next_memrange].start = base;
962 /* len: we actually save end (base + len) for convenience */
963 memranges->list[memranges->next_memrange].end = base + len;
964 memranges->next_memrange++;
965 if (memranges->next_memrange >= memranges->listsize)
967 memranges->listsize *= 2;
968 memranges->list = xrealloc (memranges->list,
969 memranges->listsize);
972 if (type != memrange_absolute) /* Better collect the base register! */
973 add_register (memranges, type);
976 /* Add a symbol to a collection list. */
978 collect_symbol (struct collection_list *collect,
980 struct gdbarch *gdbarch,
981 long frame_regno, long frame_offset,
987 bfd_signed_vma offset;
988 int treat_as_expr = 0;
990 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
991 switch (SYMBOL_CLASS (sym))
994 printf_filtered ("%s: don't know symbol class %d\n",
995 SYMBOL_PRINT_NAME (sym),
999 printf_filtered ("constant %s (value %s) will not be collected.\n",
1000 SYMBOL_PRINT_NAME (sym), plongest (SYMBOL_VALUE (sym)));
1003 offset = SYMBOL_VALUE_ADDRESS (sym);
1008 sprintf_vma (tmp, offset);
1009 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1010 SYMBOL_PRINT_NAME (sym), len,
1013 /* A struct may be a C++ class with static fields, go to general
1014 expression handling. */
1015 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
1018 add_memrange (collect, memrange_absolute, offset, len);
1021 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
1023 printf_filtered ("LOC_REG[parm] %s: ",
1024 SYMBOL_PRINT_NAME (sym));
1025 add_register (collect, reg);
1026 /* Check for doubles stored in two registers. */
1027 /* FIXME: how about larger types stored in 3 or more regs? */
1028 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
1029 len > register_size (gdbarch, reg))
1030 add_register (collect, reg + 1);
1033 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1034 printf_filtered (" (will not collect %s)\n",
1035 SYMBOL_PRINT_NAME (sym));
1039 offset = frame_offset + SYMBOL_VALUE (sym);
1042 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1043 SYMBOL_PRINT_NAME (sym), len);
1044 printf_vma (offset);
1045 printf_filtered (" from frame ptr reg %d\n", reg);
1047 add_memrange (collect, reg, offset, len);
1049 case LOC_REGPARM_ADDR:
1050 reg = SYMBOL_VALUE (sym);
1054 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1055 SYMBOL_PRINT_NAME (sym), len);
1056 printf_vma (offset);
1057 printf_filtered (" from reg %d\n", reg);
1059 add_memrange (collect, reg, offset, len);
1063 offset = frame_offset + SYMBOL_VALUE (sym);
1066 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1067 SYMBOL_PRINT_NAME (sym), len);
1068 printf_vma (offset);
1069 printf_filtered (" from frame ptr reg %d\n", reg);
1071 add_memrange (collect, reg, offset, len);
1074 case LOC_UNRESOLVED:
1078 case LOC_OPTIMIZED_OUT:
1079 printf_filtered ("%s has been optimized out of existence.\n",
1080 SYMBOL_PRINT_NAME (sym));
1088 /* Expressions are the most general case. */
1091 struct agent_expr *aexpr;
1092 struct cleanup *old_chain1 = NULL;
1094 aexpr = gen_trace_for_var (scope, gdbarch, sym, trace_string);
1096 /* It can happen that the symbol is recorded as a computed
1097 location, but it's been optimized away and doesn't actually
1098 have a location expression. */
1101 printf_filtered ("%s has been optimized out of existence.\n",
1102 SYMBOL_PRINT_NAME (sym));
1106 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1110 report_agent_reqs_errors (aexpr);
1112 discard_cleanups (old_chain1);
1113 add_aexpr (collect, aexpr);
1115 /* Take care of the registers. */
1116 if (aexpr->reg_mask_len > 0)
1120 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1122 QUIT; /* Allow user to bail out with ^C. */
1123 if (aexpr->reg_mask[ndx1] != 0)
1125 /* Assume chars have 8 bits. */
1126 for (ndx2 = 0; ndx2 < 8; ndx2++)
1127 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1128 /* It's used -- record it. */
1129 add_register (collect, ndx1 * 8 + ndx2);
1136 /* Data to be passed around in the calls to the locals and args
1139 struct add_local_symbols_data
1141 struct collection_list *collect;
1142 struct gdbarch *gdbarch;
1150 /* The callback for the locals and args iterators. */
1153 do_collect_symbol (const char *print_name,
1157 struct add_local_symbols_data *p = cb_data;
1159 collect_symbol (p->collect, sym, p->gdbarch, p->frame_regno,
1160 p->frame_offset, p->pc, p->trace_string);
1163 VEC_safe_push (char_ptr, p->collect->wholly_collected,
1164 xstrdup (print_name));
1167 /* Add all locals (or args) symbols to collection list. */
1169 add_local_symbols (struct collection_list *collect,
1170 struct gdbarch *gdbarch, CORE_ADDR pc,
1171 long frame_regno, long frame_offset, int type,
1174 struct block *block;
1175 struct add_local_symbols_data cb_data;
1177 cb_data.collect = collect;
1178 cb_data.gdbarch = gdbarch;
1180 cb_data.frame_regno = frame_regno;
1181 cb_data.frame_offset = frame_offset;
1183 cb_data.trace_string = trace_string;
1187 block = block_for_pc (pc);
1190 warning (_("Can't collect locals; "
1191 "no symbol table info available.\n"));
1195 iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1196 if (cb_data.count == 0)
1197 warning (_("No locals found in scope."));
1201 pc = get_pc_function_start (pc);
1202 block = block_for_pc (pc);
1205 warning (_("Can't collect args; no symbol table info available."));
1209 iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1210 if (cb_data.count == 0)
1211 warning (_("No args found in scope."));
1216 add_static_trace_data (struct collection_list *collection)
1219 printf_filtered ("collect static trace data\n");
1220 collection->strace_data = 1;
1223 /* worker function */
1225 clear_collection_list (struct collection_list *list)
1229 list->next_memrange = 0;
1230 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1232 free_agent_expr (list->aexpr_list[ndx]);
1233 list->aexpr_list[ndx] = NULL;
1235 list->next_aexpr_elt = 0;
1236 memset (list->regs_mask, 0, sizeof (list->regs_mask));
1237 list->strace_data = 0;
1239 xfree (list->aexpr_list);
1242 VEC_free (char_ptr, list->wholly_collected);
1243 VEC_free (char_ptr, list->computed);
1246 /* A cleanup wrapper for function clear_collection_list. */
1249 do_clear_collection_list (void *list)
1251 struct collection_list *l = list;
1253 clear_collection_list (l);
1256 /* Initialize collection_list CLIST. */
1259 init_collection_list (struct collection_list *clist)
1261 memset (clist, 0, sizeof *clist);
1263 clist->listsize = 128;
1264 clist->list = xcalloc (clist->listsize,
1265 sizeof (struct memrange));
1267 clist->aexpr_listsize = 128;
1268 clist->aexpr_list = xcalloc (clist->aexpr_listsize,
1269 sizeof (struct agent_expr *));
1272 /* Reduce a collection list to string form (for gdb protocol). */
1274 stringify_collection_list (struct collection_list *list)
1276 char temp_buf[2048];
1280 char *(*str_list)[];
1284 count = 1 + 1 + list->next_memrange + list->next_aexpr_elt + 1;
1285 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1287 if (list->strace_data)
1290 printf_filtered ("\nCollecting static trace data\n");
1293 (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
1297 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1298 if (list->regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */
1300 if (list->regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
1303 printf_filtered ("\nCollecting registers (mask): 0x");
1308 QUIT; /* Allow user to bail out with ^C. */
1310 printf_filtered ("%02X", list->regs_mask[i]);
1311 sprintf (end, "%02X", list->regs_mask[i]);
1314 (*str_list)[ndx] = xstrdup (temp_buf);
1318 printf_filtered ("\n");
1319 if (list->next_memrange > 0 && info_verbose)
1320 printf_filtered ("Collecting memranges: \n");
1321 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1323 QUIT; /* Allow user to bail out with ^C. */
1324 sprintf_vma (tmp2, list->list[i].start);
1327 printf_filtered ("(%d, %s, %ld)\n",
1330 (long) (list->list[i].end - list->list[i].start));
1332 if (count + 27 > MAX_AGENT_EXPR_LEN)
1334 (*str_list)[ndx] = savestring (temp_buf, count);
1341 bfd_signed_vma length = list->list[i].end - list->list[i].start;
1343 /* The "%X" conversion specifier expects an unsigned argument,
1344 so passing -1 (memrange_absolute) to it directly gives you
1345 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1347 if (list->list[i].type == memrange_absolute)
1348 sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
1350 sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
1353 count += strlen (end);
1354 end = temp_buf + count;
1357 for (i = 0; i < list->next_aexpr_elt; i++)
1359 QUIT; /* Allow user to bail out with ^C. */
1360 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1362 (*str_list)[ndx] = savestring (temp_buf, count);
1367 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1368 end += 10; /* 'X' + 8 hex digits + ',' */
1371 end = mem2hex (list->aexpr_list[i]->buf,
1372 end, list->aexpr_list[i]->len);
1373 count += 2 * list->aexpr_list[i]->len;
1378 (*str_list)[ndx] = savestring (temp_buf, count);
1383 (*str_list)[ndx] = NULL;
1394 /* Add the printed expression EXP to *LIST. */
1397 append_exp (struct expression *exp, VEC(char_ptr) **list)
1399 struct ui_file *tmp_stream = mem_fileopen ();
1402 print_expression (exp, tmp_stream);
1404 text = ui_file_xstrdup (tmp_stream, NULL);
1406 VEC_safe_push (char_ptr, *list, text);
1407 ui_file_delete (tmp_stream);
1411 encode_actions_1 (struct command_line *action,
1412 struct bp_location *tloc,
1414 LONGEST frame_offset,
1415 struct collection_list *collect,
1416 struct collection_list *stepping_list)
1418 const char *action_exp;
1419 struct expression *exp = NULL;
1421 struct value *tempval;
1422 struct cmd_list_element *cmd;
1423 struct agent_expr *aexpr;
1425 for (; action; action = action->next)
1427 QUIT; /* Allow user to bail out with ^C. */
1428 action_exp = action->line;
1429 action_exp = skip_spaces_const (action_exp);
1431 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1433 error (_("Bad action list item: %s"), action_exp);
1435 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1437 int trace_string = 0;
1439 if (*action_exp == '/')
1440 action_exp = decode_agent_options (action_exp, &trace_string);
1443 { /* Repeat over a comma-separated list. */
1444 QUIT; /* Allow user to bail out with ^C. */
1445 action_exp = skip_spaces_const (action_exp);
1447 if (0 == strncasecmp ("$reg", action_exp, 4))
1449 for (i = 0; i < gdbarch_num_regs (tloc->gdbarch); i++)
1450 add_register (collect, i);
1451 action_exp = strchr (action_exp, ','); /* more? */
1453 else if (0 == strncasecmp ("$arg", action_exp, 4))
1455 add_local_symbols (collect,
1462 action_exp = strchr (action_exp, ','); /* more? */
1464 else if (0 == strncasecmp ("$loc", action_exp, 4))
1466 add_local_symbols (collect,
1473 action_exp = strchr (action_exp, ','); /* more? */
1475 else if (0 == strncasecmp ("$_ret", action_exp, 5))
1477 struct cleanup *old_chain1 = NULL;
1479 aexpr = gen_trace_for_return_address (tloc->address,
1483 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1486 report_agent_reqs_errors (aexpr);
1488 discard_cleanups (old_chain1);
1489 add_aexpr (collect, aexpr);
1491 /* take care of the registers */
1492 if (aexpr->reg_mask_len > 0)
1496 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1498 QUIT; /* allow user to bail out with ^C */
1499 if (aexpr->reg_mask[ndx1] != 0)
1501 /* assume chars have 8 bits */
1502 for (ndx2 = 0; ndx2 < 8; ndx2++)
1503 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1504 /* it's used -- record it */
1505 add_register (collect,
1511 action_exp = strchr (action_exp, ','); /* more? */
1513 else if (0 == strncasecmp ("$_sdata", action_exp, 7))
1515 add_static_trace_data (collect);
1516 action_exp = strchr (action_exp, ','); /* more? */
1521 struct cleanup *old_chain = NULL;
1522 struct cleanup *old_chain1 = NULL;
1524 exp = parse_exp_1 (&action_exp, tloc->address,
1525 block_for_pc (tloc->address), 1);
1526 old_chain = make_cleanup (free_current_contents, &exp);
1528 switch (exp->elts[0].opcode)
1532 const char *name = &exp->elts[2].string;
1534 i = user_reg_map_name_to_regnum (tloc->gdbarch,
1535 name, strlen (name));
1537 internal_error (__FILE__, __LINE__,
1538 _("Register $%s not available"),
1541 printf_filtered ("OP_REGISTER: ");
1542 add_register (collect, i);
1547 /* Safe because we know it's a simple expression. */
1548 tempval = evaluate_expression (exp);
1549 addr = value_address (tempval);
1550 /* Initialize the TYPE_LENGTH if it is a typedef. */
1551 check_typedef (exp->elts[1].type);
1552 add_memrange (collect, memrange_absolute, addr,
1553 TYPE_LENGTH (exp->elts[1].type));
1554 append_exp (exp, &collect->computed);
1559 struct symbol *sym = exp->elts[2].symbol;
1560 char_ptr name = (char_ptr) SYMBOL_NATURAL_NAME (sym);
1562 collect_symbol (collect,
1563 exp->elts[2].symbol,
1569 VEC_safe_push (char_ptr,
1570 collect->wholly_collected,
1575 default: /* Full-fledged expression. */
1576 aexpr = gen_trace_for_expr (tloc->address, exp,
1579 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1583 report_agent_reqs_errors (aexpr);
1585 discard_cleanups (old_chain1);
1586 add_aexpr (collect, aexpr);
1588 /* Take care of the registers. */
1589 if (aexpr->reg_mask_len > 0)
1594 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1596 QUIT; /* Allow user to bail out with ^C. */
1597 if (aexpr->reg_mask[ndx1] != 0)
1599 /* Assume chars have 8 bits. */
1600 for (ndx2 = 0; ndx2 < 8; ndx2++)
1601 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1602 /* It's used -- record it. */
1603 add_register (collect,
1609 append_exp (exp, &collect->computed);
1612 do_cleanups (old_chain);
1615 while (action_exp && *action_exp++ == ',');
1617 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1620 { /* Repeat over a comma-separated list. */
1621 QUIT; /* Allow user to bail out with ^C. */
1622 action_exp = skip_spaces_const (action_exp);
1625 struct cleanup *old_chain = NULL;
1626 struct cleanup *old_chain1 = NULL;
1628 exp = parse_exp_1 (&action_exp, tloc->address,
1629 block_for_pc (tloc->address), 1);
1630 old_chain = make_cleanup (free_current_contents, &exp);
1632 aexpr = gen_eval_for_expr (tloc->address, exp);
1633 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1636 report_agent_reqs_errors (aexpr);
1638 discard_cleanups (old_chain1);
1639 /* Even though we're not officially collecting, add
1640 to the collect list anyway. */
1641 add_aexpr (collect, aexpr);
1643 do_cleanups (old_chain);
1646 while (action_exp && *action_exp++ == ',');
1648 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1650 /* We check against nested while-stepping when setting
1651 breakpoint action, so no way to run into nested
1653 gdb_assert (stepping_list);
1655 encode_actions_1 (action->body_list[0], tloc, frame_reg,
1656 frame_offset, stepping_list, NULL);
1659 error (_("Invalid tracepoint command '%s'"), action->line);
1663 /* Encode actions of tracepoint TLOC->owner and fill TRACEPOINT_LIST
1664 and STEPPING_LIST. Return a cleanup pointer to clean up both
1665 TRACEPOINT_LIST and STEPPING_LIST. */
1668 encode_actions_and_make_cleanup (struct bp_location *tloc,
1669 struct collection_list *tracepoint_list,
1670 struct collection_list *stepping_list)
1672 char *default_collect_line = NULL;
1673 struct command_line *actions;
1674 struct command_line *default_collect_action = NULL;
1676 LONGEST frame_offset;
1677 struct cleanup *back_to, *return_chain;
1679 return_chain = make_cleanup (null_cleanup, NULL);
1680 init_collection_list (tracepoint_list);
1681 init_collection_list (stepping_list);
1683 make_cleanup (do_clear_collection_list, tracepoint_list);
1684 make_cleanup (do_clear_collection_list, stepping_list);
1686 back_to = make_cleanup (null_cleanup, NULL);
1687 gdbarch_virtual_frame_pointer (tloc->gdbarch,
1688 tloc->address, &frame_reg, &frame_offset);
1690 actions = all_tracepoint_actions_and_cleanup (tloc->owner);
1692 encode_actions_1 (actions, tloc, frame_reg, frame_offset,
1693 tracepoint_list, stepping_list);
1695 memrange_sortmerge (tracepoint_list);
1696 memrange_sortmerge (stepping_list);
1698 do_cleanups (back_to);
1699 return return_chain;
1702 /* Render all actions into gdb protocol. */
1705 encode_actions_rsp (struct bp_location *tloc, char ***tdp_actions,
1706 char ***stepping_actions)
1708 struct collection_list tracepoint_list, stepping_list;
1709 struct cleanup *cleanup;
1711 *tdp_actions = NULL;
1712 *stepping_actions = NULL;
1714 cleanup = encode_actions_and_make_cleanup (tloc, &tracepoint_list,
1717 *tdp_actions = stringify_collection_list (&tracepoint_list);
1718 *stepping_actions = stringify_collection_list (&stepping_list);
1720 do_cleanups (cleanup);
1724 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1726 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1728 collect->aexpr_list =
1729 xrealloc (collect->aexpr_list,
1730 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1731 collect->aexpr_listsize *= 2;
1733 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1734 collect->next_aexpr_elt++;
1738 process_tracepoint_on_disconnect (void)
1740 VEC(breakpoint_p) *tp_vec = NULL;
1742 struct breakpoint *b;
1743 int has_pending_p = 0;
1745 /* Check whether we still have pending tracepoint. If we have, warn the
1746 user that pending tracepoint will no longer work. */
1747 tp_vec = all_tracepoints ();
1748 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1757 struct bp_location *loc1;
1759 for (loc1 = b->loc; loc1; loc1 = loc1->next)
1761 if (loc1->shlib_disabled)
1772 VEC_free (breakpoint_p, tp_vec);
1775 warning (_("Pending tracepoints will not be resolved while"
1776 " GDB is disconnected\n"));
1779 /* Reset local state of tracing. */
1782 trace_reset_local_state (void)
1784 set_traceframe_num (-1);
1785 set_tracepoint_num (-1);
1786 set_traceframe_context (NULL);
1787 clear_traceframe_info ();
1791 start_tracing (char *notes)
1793 VEC(breakpoint_p) *tp_vec = NULL;
1795 struct breakpoint *b;
1796 struct trace_state_variable *tsv;
1797 int any_enabled = 0, num_to_download = 0;
1800 tp_vec = all_tracepoints ();
1802 /* No point in tracing without any tracepoints... */
1803 if (VEC_length (breakpoint_p, tp_vec) == 0)
1805 VEC_free (breakpoint_p, tp_vec);
1806 error (_("No tracepoints defined, not starting trace"));
1809 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1811 struct tracepoint *t = (struct tracepoint *) b;
1812 struct bp_location *loc;
1814 if (b->enable_state == bp_enabled)
1817 if ((b->type == bp_fast_tracepoint
1818 ? may_insert_fast_tracepoints
1819 : may_insert_tracepoints))
1822 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1823 (b->type == bp_fast_tracepoint ? "fast " : ""), b->number);
1828 if (target_supports_enable_disable_tracepoint ())
1829 warning (_("No tracepoints enabled"));
1832 /* No point in tracing with only disabled tracepoints that
1833 cannot be re-enabled. */
1834 VEC_free (breakpoint_p, tp_vec);
1835 error (_("No tracepoints enabled, not starting trace"));
1839 if (num_to_download <= 0)
1841 VEC_free (breakpoint_p, tp_vec);
1842 error (_("No tracepoints that may be downloaded, not starting trace"));
1845 target_trace_init ();
1847 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1849 struct tracepoint *t = (struct tracepoint *) b;
1850 struct bp_location *loc;
1851 int bp_location_downloaded = 0;
1853 /* Clear `inserted' flag. */
1854 for (loc = b->loc; loc; loc = loc->next)
1857 if ((b->type == bp_fast_tracepoint
1858 ? !may_insert_fast_tracepoints
1859 : !may_insert_tracepoints))
1862 t->number_on_target = 0;
1864 for (loc = b->loc; loc; loc = loc->next)
1866 /* Since tracepoint locations are never duplicated, `inserted'
1867 flag should be zero. */
1868 gdb_assert (!loc->inserted);
1870 target_download_tracepoint (loc);
1873 bp_location_downloaded = 1;
1876 t->number_on_target = b->number;
1878 for (loc = b->loc; loc; loc = loc->next)
1879 if (loc->probe != NULL)
1880 loc->probe->pops->set_semaphore (loc->probe, loc->gdbarch);
1882 if (bp_location_downloaded)
1883 observer_notify_breakpoint_modified (b);
1885 VEC_free (breakpoint_p, tp_vec);
1887 /* Send down all the trace state variables too. */
1888 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1890 target_download_trace_state_variable (tsv);
1893 /* Tell target to treat text-like sections as transparent. */
1894 target_trace_set_readonly_regions ();
1895 /* Set some mode flags. */
1896 target_set_disconnected_tracing (disconnected_tracing);
1897 target_set_circular_trace_buffer (circular_trace_buffer);
1898 target_set_trace_buffer_size (trace_buffer_size);
1901 notes = trace_notes;
1902 ret = target_set_trace_notes (trace_user, notes, NULL);
1904 if (!ret && (trace_user || notes))
1905 warning (_("Target does not support trace user/notes, info ignored"));
1907 /* Now insert traps and begin collecting data. */
1908 target_trace_start ();
1910 /* Reset our local state. */
1911 trace_reset_local_state ();
1912 current_trace_status()->running = 1;
1915 /* The tstart command requests the target to start a new trace run.
1916 The command passes any arguments it has to the target verbatim, as
1917 an optional "trace note". This is useful as for instance a warning
1918 to other users if the trace runs disconnected, and you don't want
1919 anybody else messing with the target. */
1922 trace_start_command (char *args, int from_tty)
1924 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1926 if (current_trace_status ()->running)
1929 && !query (_("A trace is running already. Start a new run? ")))
1930 error (_("New trace run not started."));
1933 start_tracing (args);
1936 /* The tstop command stops the tracing run. The command passes any
1937 supplied arguments to the target verbatim as a "stop note"; if the
1938 target supports trace notes, then it will be reported back as part
1939 of the trace run's status. */
1942 trace_stop_command (char *args, int from_tty)
1944 if (!current_trace_status ()->running)
1945 error (_("Trace is not running."));
1947 stop_tracing (args);
1951 stop_tracing (char *note)
1954 VEC(breakpoint_p) *tp_vec = NULL;
1956 struct breakpoint *t;
1958 target_trace_stop ();
1960 tp_vec = all_tracepoints ();
1961 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1963 struct bp_location *loc;
1965 if ((t->type == bp_fast_tracepoint
1966 ? !may_insert_fast_tracepoints
1967 : !may_insert_tracepoints))
1970 for (loc = t->loc; loc; loc = loc->next)
1972 /* GDB can be totally absent in some disconnected trace scenarios,
1973 but we don't really care if this semaphore goes out of sync.
1974 That's why we are decrementing it here, but not taking care
1976 if (loc->probe != NULL)
1977 loc->probe->pops->clear_semaphore (loc->probe, loc->gdbarch);
1981 VEC_free (breakpoint_p, tp_vec);
1984 note = trace_stop_notes;
1985 ret = target_set_trace_notes (NULL, NULL, note);
1988 warning (_("Target does not support trace notes, note ignored"));
1990 /* Should change in response to reply? */
1991 current_trace_status ()->running = 0;
1994 /* tstatus command */
1996 trace_status_command (char *args, int from_tty)
1998 struct trace_status *ts = current_trace_status ();
2000 VEC(breakpoint_p) *tp_vec = NULL;
2001 struct breakpoint *t;
2003 status = target_get_trace_status (ts);
2007 if (ts->filename != NULL)
2008 printf_filtered (_("Using a trace file.\n"));
2011 printf_filtered (_("Trace can not be run on this target.\n"));
2016 if (!ts->running_known)
2018 printf_filtered (_("Run/stop status is unknown.\n"));
2020 else if (ts->running)
2022 printf_filtered (_("Trace is running on the target.\n"));
2026 switch (ts->stop_reason)
2028 case trace_never_run:
2029 printf_filtered (_("No trace has been run on the target.\n"));
2033 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
2036 printf_filtered (_("Trace stopped by a tstop command.\n"));
2038 case trace_buffer_full:
2039 printf_filtered (_("Trace stopped because the buffer was full.\n"));
2041 case trace_disconnected:
2042 printf_filtered (_("Trace stopped because of disconnection.\n"));
2044 case tracepoint_passcount:
2045 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
2046 ts->stopping_tracepoint);
2048 case tracepoint_error:
2049 if (ts->stopping_tracepoint)
2050 printf_filtered (_("Trace stopped by an "
2051 "error (%s, tracepoint %d).\n"),
2052 ts->stop_desc, ts->stopping_tracepoint);
2054 printf_filtered (_("Trace stopped by an error (%s).\n"),
2057 case trace_stop_reason_unknown:
2058 printf_filtered (_("Trace stopped for an unknown reason.\n"));
2061 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
2067 if (ts->traceframes_created >= 0
2068 && ts->traceframe_count != ts->traceframes_created)
2070 printf_filtered (_("Buffer contains %d trace "
2071 "frames (of %d created total).\n"),
2072 ts->traceframe_count, ts->traceframes_created);
2074 else if (ts->traceframe_count >= 0)
2076 printf_filtered (_("Collected %d trace frames.\n"),
2077 ts->traceframe_count);
2080 if (ts->buffer_free >= 0)
2082 if (ts->buffer_size >= 0)
2084 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2085 ts->buffer_free, ts->buffer_size);
2086 if (ts->buffer_size > 0)
2087 printf_filtered (_(" (%d%% full)"),
2088 ((int) ((((long long) (ts->buffer_size
2089 - ts->buffer_free)) * 100)
2090 / ts->buffer_size)));
2091 printf_filtered (_(".\n"));
2094 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2098 if (ts->disconnected_tracing)
2099 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2101 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2103 if (ts->circular_buffer)
2104 printf_filtered (_("Trace buffer is circular.\n"));
2106 if (ts->user_name && strlen (ts->user_name) > 0)
2107 printf_filtered (_("Trace user is %s.\n"), ts->user_name);
2109 if (ts->notes && strlen (ts->notes) > 0)
2110 printf_filtered (_("Trace notes: %s.\n"), ts->notes);
2112 /* Now report on what we're doing with tfind. */
2113 if (traceframe_number >= 0)
2114 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2115 traceframe_number, tracepoint_number);
2117 printf_filtered (_("Not looking at any trace frame.\n"));
2119 /* Report start/stop times if supplied. */
2124 LONGEST run_time = ts->stop_time - ts->start_time;
2126 /* Reporting a run time is more readable than two long numbers. */
2127 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2128 (long int) (ts->start_time / 1000000),
2129 (long int) (ts->start_time % 1000000),
2130 (long int) (run_time / 1000000),
2131 (long int) (run_time % 1000000));
2134 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2135 (long int) (ts->start_time / 1000000),
2136 (long int) (ts->start_time % 1000000));
2138 else if (ts->stop_time)
2139 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2140 (long int) (ts->stop_time / 1000000),
2141 (long int) (ts->stop_time % 1000000));
2143 /* Now report any per-tracepoint status available. */
2144 tp_vec = all_tracepoints ();
2146 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
2147 target_get_tracepoint_status (t, NULL);
2149 VEC_free (breakpoint_p, tp_vec);
2152 /* Report the trace status to uiout, in a way suitable for MI, and not
2153 suitable for CLI. If ON_STOP is true, suppress a few fields that
2154 are not meaningful in the -trace-stop response.
2156 The implementation is essentially parallel to trace_status_command, but
2157 merging them will result in unreadable code. */
2159 trace_status_mi (int on_stop)
2161 struct ui_out *uiout = current_uiout;
2162 struct trace_status *ts = current_trace_status ();
2165 status = target_get_trace_status (ts);
2167 if (status == -1 && ts->filename == NULL)
2169 ui_out_field_string (uiout, "supported", "0");
2173 if (ts->filename != NULL)
2174 ui_out_field_string (uiout, "supported", "file");
2176 ui_out_field_string (uiout, "supported", "1");
2178 if (ts->filename != NULL)
2179 ui_out_field_string (uiout, "trace-file", ts->filename);
2181 gdb_assert (ts->running_known);
2185 ui_out_field_string (uiout, "running", "1");
2187 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2188 Given that the frontend gets the status either on -trace-stop, or from
2189 -trace-status after re-connection, it does not seem like this
2190 information is necessary for anything. It is not necessary for either
2191 figuring the vital state of the target nor for navigation of trace
2192 frames. If the frontend wants to show the current state is some
2193 configure dialog, it can request the value when such dialog is
2194 invoked by the user. */
2198 char *stop_reason = NULL;
2199 int stopping_tracepoint = -1;
2202 ui_out_field_string (uiout, "running", "0");
2204 if (ts->stop_reason != trace_stop_reason_unknown)
2206 switch (ts->stop_reason)
2209 stop_reason = "request";
2211 case trace_buffer_full:
2212 stop_reason = "overflow";
2214 case trace_disconnected:
2215 stop_reason = "disconnection";
2217 case tracepoint_passcount:
2218 stop_reason = "passcount";
2219 stopping_tracepoint = ts->stopping_tracepoint;
2221 case tracepoint_error:
2222 stop_reason = "error";
2223 stopping_tracepoint = ts->stopping_tracepoint;
2229 ui_out_field_string (uiout, "stop-reason", stop_reason);
2230 if (stopping_tracepoint != -1)
2231 ui_out_field_int (uiout, "stopping-tracepoint",
2232 stopping_tracepoint);
2233 if (ts->stop_reason == tracepoint_error)
2234 ui_out_field_string (uiout, "error-description",
2240 if (ts->traceframe_count != -1)
2241 ui_out_field_int (uiout, "frames", ts->traceframe_count);
2242 if (ts->traceframes_created != -1)
2243 ui_out_field_int (uiout, "frames-created", ts->traceframes_created);
2244 if (ts->buffer_size != -1)
2245 ui_out_field_int (uiout, "buffer-size", ts->buffer_size);
2246 if (ts->buffer_free != -1)
2247 ui_out_field_int (uiout, "buffer-free", ts->buffer_free);
2249 ui_out_field_int (uiout, "disconnected", ts->disconnected_tracing);
2250 ui_out_field_int (uiout, "circular", ts->circular_buffer);
2252 ui_out_field_string (uiout, "user-name", ts->user_name);
2253 ui_out_field_string (uiout, "notes", ts->notes);
2258 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2259 (long int) (ts->start_time / 1000000),
2260 (long int) (ts->start_time % 1000000));
2261 ui_out_field_string (uiout, "start-time", buf);
2262 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2263 (long int) (ts->stop_time / 1000000),
2264 (long int) (ts->stop_time % 1000000));
2265 ui_out_field_string (uiout, "stop-time", buf);
2269 /* Check if a trace run is ongoing. If so, and FROM_TTY, query the
2270 user if she really wants to detach. */
2273 query_if_trace_running (int from_tty)
2278 /* It can happen that the target that was tracing went away on its
2279 own, and we didn't notice. Get a status update, and if the
2280 current target doesn't even do tracing, then assume it's not
2282 if (target_get_trace_status (current_trace_status ()) < 0)
2283 current_trace_status ()->running = 0;
2285 /* If running interactively, give the user the option to cancel and
2286 then decide what to do differently with the run. Scripts are
2287 just going to disconnect and let the target deal with it,
2288 according to how it's been instructed previously via
2289 disconnected-tracing. */
2290 if (current_trace_status ()->running)
2292 process_tracepoint_on_disconnect ();
2294 if (current_trace_status ()->disconnected_tracing)
2296 if (!query (_("Trace is running and will "
2297 "continue after detach; detach anyway? ")))
2298 error (_("Not confirmed."));
2302 if (!query (_("Trace is running but will "
2303 "stop on detach; detach anyway? ")))
2304 error (_("Not confirmed."));
2309 /* This function handles the details of what to do about an ongoing
2310 tracing run if the user has asked to detach or otherwise disconnect
2314 disconnect_tracing (void)
2316 /* Also we want to be out of tfind mode, otherwise things can get
2317 confusing upon reconnection. Just use these calls instead of
2318 full tfind_1 behavior because we're in the middle of detaching,
2319 and there's no point to updating current stack frame etc. */
2320 trace_reset_local_state ();
2323 /* Worker function for the various flavors of the tfind command. */
2325 tfind_1 (enum trace_find_type type, int num,
2326 CORE_ADDR addr1, CORE_ADDR addr2,
2329 int target_frameno = -1, target_tracept = -1;
2330 struct frame_id old_frame_id = null_frame_id;
2331 struct tracepoint *tp;
2332 struct ui_out *uiout = current_uiout;
2334 /* Only try to get the current stack frame if we have a chance of
2335 succeeding. In particular, if we're trying to get a first trace
2336 frame while all threads are running, it's not going to succeed,
2337 so leave it with a default value and let the frame comparison
2338 below (correctly) decide to print out the source location of the
2340 if (!(type == tfind_number && num == -1)
2341 && (has_stack_frames () || traceframe_number >= 0))
2342 old_frame_id = get_frame_id (get_current_frame ());
2344 target_frameno = target_trace_find (type, num, addr1, addr2,
2347 if (type == tfind_number
2349 && target_frameno == -1)
2351 /* We told the target to get out of tfind mode, and it did. */
2353 else if (target_frameno == -1)
2355 /* A request for a non-existent trace frame has failed.
2356 Our response will be different, depending on FROM_TTY:
2358 If FROM_TTY is true, meaning that this command was
2359 typed interactively by the user, then give an error
2360 and DO NOT change the state of traceframe_number etc.
2362 However if FROM_TTY is false, meaning that we're either
2363 in a script, a loop, or a user-defined command, then
2364 DON'T give an error, but DO change the state of
2365 traceframe_number etc. to invalid.
2367 The rationalle is that if you typed the command, you
2368 might just have committed a typo or something, and you'd
2369 like to NOT lose your current debugging state. However
2370 if you're in a user-defined command or especially in a
2371 loop, then you need a way to detect that the command
2372 failed WITHOUT aborting. This allows you to write
2373 scripts that search thru the trace buffer until the end,
2374 and then continue on to do something else. */
2377 error (_("Target failed to find requested trace frame."));
2381 printf_filtered ("End of trace buffer.\n");
2382 #if 0 /* dubious now? */
2383 /* The following will not recurse, since it's
2385 trace_find_command ("-1", from_tty);
2390 tp = get_tracepoint_by_number_on_target (target_tracept);
2392 reinit_frame_cache ();
2393 target_dcache_invalidate ();
2395 set_tracepoint_num (tp ? tp->base.number : target_tracept);
2397 if (target_frameno != get_traceframe_number ())
2398 observer_notify_traceframe_changed (target_frameno, tracepoint_number);
2400 set_current_traceframe (target_frameno);
2402 if (target_frameno == -1)
2403 set_traceframe_context (NULL);
2405 set_traceframe_context (get_current_frame ());
2407 if (traceframe_number >= 0)
2409 /* Use different branches for MI and CLI to make CLI messages
2411 if (ui_out_is_mi_like_p (uiout))
2413 ui_out_field_string (uiout, "found", "1");
2414 ui_out_field_int (uiout, "tracepoint", tracepoint_number);
2415 ui_out_field_int (uiout, "traceframe", traceframe_number);
2419 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2420 traceframe_number, tracepoint_number);
2425 if (ui_out_is_mi_like_p (uiout))
2426 ui_out_field_string (uiout, "found", "0");
2427 else if (type == tfind_number && num == -1)
2428 printf_unfiltered (_("No longer looking at any trace frame\n"));
2429 else /* This case may never occur, check. */
2430 printf_unfiltered (_("No trace frame found\n"));
2433 /* If we're in nonstop mode and getting out of looking at trace
2434 frames, there won't be any current frame to go back to and
2437 && (has_stack_frames () || traceframe_number >= 0))
2439 enum print_what print_what;
2441 /* NOTE: in imitation of the step command, try to determine
2442 whether we have made a transition from one function to
2443 another. If so, we'll print the "stack frame" (ie. the new
2444 function and it's arguments) -- otherwise we'll just show the
2447 if (frame_id_eq (old_frame_id,
2448 get_frame_id (get_current_frame ())))
2449 print_what = SRC_LINE;
2451 print_what = SRC_AND_LOC;
2453 print_stack_frame (get_selected_frame (NULL), 1, print_what);
2458 /* trace_find_command takes a trace frame number n,
2459 sends "QTFrame:<n>" to the target,
2460 and accepts a reply that may contain several optional pieces
2461 of information: a frame number, a tracepoint number, and an
2462 indication of whether this is a trap frame or a stepping frame.
2464 The minimal response is just "OK" (which indicates that the
2465 target does not give us a frame number or a tracepoint number).
2466 Instead of that, the target may send us a string containing
2468 F<hexnum> (gives the selected frame number)
2469 T<hexnum> (gives the selected tracepoint number)
2474 trace_find_command (char *args, int from_tty)
2475 { /* This should only be called with a numeric argument. */
2478 if (current_trace_status ()->running
2479 && current_trace_status ()->filename == NULL)
2480 error (_("May not look at trace frames while trace is running."));
2482 if (args == 0 || *args == 0)
2483 { /* TFIND with no args means find NEXT trace frame. */
2484 if (traceframe_number == -1)
2485 frameno = 0; /* "next" is first one. */
2487 frameno = traceframe_number + 1;
2489 else if (0 == strcmp (args, "-"))
2491 if (traceframe_number == -1)
2492 error (_("not debugging trace buffer"));
2493 else if (from_tty && traceframe_number == 0)
2494 error (_("already at start of trace buffer"));
2496 frameno = traceframe_number - 1;
2498 /* A hack to work around eval's need for fp to have been collected. */
2499 else if (0 == strcmp (args, "-1"))
2502 frameno = parse_and_eval_long (args);
2505 error (_("invalid input (%d is less than zero)"), frameno);
2507 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2512 trace_find_end_command (char *args, int from_tty)
2514 trace_find_command ("-1", from_tty);
2519 trace_find_start_command (char *args, int from_tty)
2521 trace_find_command ("0", from_tty);
2524 /* tfind pc command */
2526 trace_find_pc_command (char *args, int from_tty)
2530 if (current_trace_status ()->running
2531 && current_trace_status ()->filename == NULL)
2532 error (_("May not look at trace frames while trace is running."));
2534 if (args == 0 || *args == 0)
2535 pc = regcache_read_pc (get_current_regcache ());
2537 pc = parse_and_eval_address (args);
2539 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2542 /* tfind tracepoint command */
2544 trace_find_tracepoint_command (char *args, int from_tty)
2547 struct tracepoint *tp;
2549 if (current_trace_status ()->running
2550 && current_trace_status ()->filename == NULL)
2551 error (_("May not look at trace frames while trace is running."));
2553 if (args == 0 || *args == 0)
2555 if (tracepoint_number == -1)
2556 error (_("No current tracepoint -- please supply an argument."));
2558 tdp = tracepoint_number; /* Default is current TDP. */
2561 tdp = parse_and_eval_long (args);
2563 /* If we have the tracepoint on hand, use the number that the
2564 target knows about (which may be different if we disconnected
2565 and reconnected). */
2566 tp = get_tracepoint (tdp);
2568 tdp = tp->number_on_target;
2570 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2573 /* TFIND LINE command:
2575 This command will take a sourceline for argument, just like BREAK
2576 or TRACE (ie. anything that "decode_line_1" can handle).
2578 With no argument, this command will find the next trace frame
2579 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2582 trace_find_line_command (char *args, int from_tty)
2584 static CORE_ADDR start_pc, end_pc;
2585 struct symtabs_and_lines sals;
2586 struct symtab_and_line sal;
2587 struct cleanup *old_chain;
2589 if (current_trace_status ()->running
2590 && current_trace_status ()->filename == NULL)
2591 error (_("May not look at trace frames while trace is running."));
2593 if (args == 0 || *args == 0)
2595 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2597 sals.sals = (struct symtab_and_line *)
2598 xmalloc (sizeof (struct symtab_and_line));
2603 sals = decode_line_with_current_source (args, DECODE_LINE_FUNFIRSTLINE);
2607 old_chain = make_cleanup (xfree, sals.sals);
2608 if (sal.symtab == 0)
2609 error (_("No line number information available."));
2611 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2613 if (start_pc == end_pc)
2615 printf_filtered ("Line %d of \"%s\"",
2617 symtab_to_filename_for_display (sal.symtab));
2619 printf_filtered (" is at address ");
2620 print_address (get_current_arch (), start_pc, gdb_stdout);
2622 printf_filtered (" but contains no code.\n");
2623 sal = find_pc_line (start_pc, 0);
2625 && find_line_pc_range (sal, &start_pc, &end_pc)
2626 && start_pc != end_pc)
2627 printf_filtered ("Attempting to find line %d instead.\n",
2630 error (_("Cannot find a good line."));
2634 /* Is there any case in which we get here, and have an address
2635 which the user would want to see? If we have debugging
2636 symbols and no line numbers? */
2637 error (_("Line number %d is out of range for \"%s\"."),
2638 sal.line, symtab_to_filename_for_display (sal.symtab));
2640 /* Find within range of stated line. */
2642 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2644 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2645 do_cleanups (old_chain);
2648 /* tfind range command */
2650 trace_find_range_command (char *args, int from_tty)
2652 static CORE_ADDR start, stop;
2655 if (current_trace_status ()->running
2656 && current_trace_status ()->filename == NULL)
2657 error (_("May not look at trace frames while trace is running."));
2659 if (args == 0 || *args == 0)
2660 { /* XXX FIXME: what should default behavior be? */
2661 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2665 if (0 != (tmp = strchr (args, ',')))
2667 *tmp++ = '\0'; /* Terminate start address. */
2668 tmp = skip_spaces (tmp);
2669 start = parse_and_eval_address (args);
2670 stop = parse_and_eval_address (tmp);
2673 { /* No explicit end address? */
2674 start = parse_and_eval_address (args);
2675 stop = start + 1; /* ??? */
2678 tfind_1 (tfind_range, 0, start, stop, from_tty);
2681 /* tfind outside command */
2683 trace_find_outside_command (char *args, int from_tty)
2685 CORE_ADDR start, stop;
2688 if (current_trace_status ()->running
2689 && current_trace_status ()->filename == NULL)
2690 error (_("May not look at trace frames while trace is running."));
2692 if (args == 0 || *args == 0)
2693 { /* XXX FIXME: what should default behavior be? */
2694 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2698 if (0 != (tmp = strchr (args, ',')))
2700 *tmp++ = '\0'; /* Terminate start address. */
2701 tmp = skip_spaces (tmp);
2702 start = parse_and_eval_address (args);
2703 stop = parse_and_eval_address (tmp);
2706 { /* No explicit end address? */
2707 start = parse_and_eval_address (args);
2708 stop = start + 1; /* ??? */
2711 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2714 /* info scope command: list the locals for a scope. */
2716 scope_info (char *args, int from_tty)
2718 struct symtabs_and_lines sals;
2720 struct minimal_symbol *msym;
2721 struct block *block;
2722 const char *symname;
2723 char *save_args = args;
2724 struct block_iterator iter;
2726 struct gdbarch *gdbarch;
2729 if (args == 0 || *args == 0)
2730 error (_("requires an argument (function, "
2731 "line or *addr) to define a scope"));
2733 sals = decode_line_1 (&args, DECODE_LINE_FUNFIRSTLINE, NULL, 0);
2734 if (sals.nelts == 0)
2735 return; /* Presumably decode_line_1 has already warned. */
2737 /* Resolve line numbers to PC. */
2738 resolve_sal_pc (&sals.sals[0]);
2739 block = block_for_pc (sals.sals[0].pc);
2743 QUIT; /* Allow user to bail out with ^C. */
2744 ALL_BLOCK_SYMBOLS (block, iter, sym)
2746 QUIT; /* Allow user to bail out with ^C. */
2748 printf_filtered ("Scope for %s:\n", save_args);
2751 symname = SYMBOL_PRINT_NAME (sym);
2752 if (symname == NULL || *symname == '\0')
2753 continue; /* Probably botched, certainly useless. */
2755 gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
2757 printf_filtered ("Symbol %s is ", symname);
2759 if (SYMBOL_COMPUTED_OPS (sym) != NULL)
2760 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2761 BLOCK_START (block),
2765 switch (SYMBOL_CLASS (sym))
2768 case LOC_UNDEF: /* Messed up symbol? */
2769 printf_filtered ("a bogus symbol, class %d.\n",
2770 SYMBOL_CLASS (sym));
2771 count--; /* Don't count this one. */
2774 printf_filtered ("a constant with value %s (%s)",
2775 plongest (SYMBOL_VALUE (sym)),
2776 hex_string (SYMBOL_VALUE (sym)));
2778 case LOC_CONST_BYTES:
2779 printf_filtered ("constant bytes: ");
2780 if (SYMBOL_TYPE (sym))
2781 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2782 fprintf_filtered (gdb_stdout, " %02x",
2783 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2786 printf_filtered ("in static storage at address ");
2787 printf_filtered ("%s", paddress (gdbarch,
2788 SYMBOL_VALUE_ADDRESS (sym)));
2791 /* GDBARCH is the architecture associated with the objfile
2792 the symbol is defined in; the target architecture may be
2793 different, and may provide additional registers. However,
2794 we do not know the target architecture at this point.
2795 We assume the objfile architecture will contain all the
2796 standard registers that occur in debug info in that
2798 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2801 if (SYMBOL_IS_ARGUMENT (sym))
2802 printf_filtered ("an argument in register $%s",
2803 gdbarch_register_name (gdbarch, regno));
2805 printf_filtered ("a local variable in register $%s",
2806 gdbarch_register_name (gdbarch, regno));
2809 printf_filtered ("an argument at stack/frame offset %s",
2810 plongest (SYMBOL_VALUE (sym)));
2813 printf_filtered ("a local variable at frame offset %s",
2814 plongest (SYMBOL_VALUE (sym)));
2817 printf_filtered ("a reference argument at offset %s",
2818 plongest (SYMBOL_VALUE (sym)));
2820 case LOC_REGPARM_ADDR:
2821 /* Note comment at LOC_REGISTER. */
2822 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2824 printf_filtered ("the address of an argument, in register $%s",
2825 gdbarch_register_name (gdbarch, regno));
2828 printf_filtered ("a typedef.\n");
2831 printf_filtered ("a label at address ");
2832 printf_filtered ("%s", paddress (gdbarch,
2833 SYMBOL_VALUE_ADDRESS (sym)));
2836 printf_filtered ("a function at address ");
2837 printf_filtered ("%s",
2838 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2840 case LOC_UNRESOLVED:
2841 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2844 printf_filtered ("Unresolved Static");
2847 printf_filtered ("static storage at address ");
2848 printf_filtered ("%s",
2850 SYMBOL_VALUE_ADDRESS (msym)));
2853 case LOC_OPTIMIZED_OUT:
2854 printf_filtered ("optimized out.\n");
2857 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
2860 if (SYMBOL_TYPE (sym))
2861 printf_filtered (", length %d.\n",
2862 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2864 if (BLOCK_FUNCTION (block))
2867 block = BLOCK_SUPERBLOCK (block);
2870 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2874 /* Helper for trace_dump_command. Dump the action list starting at
2875 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2876 actions of the body of a while-stepping action. STEPPING_FRAME is
2877 set if the current traceframe was determined to be a while-stepping
2881 trace_dump_actions (struct command_line *action,
2882 int stepping_actions, int stepping_frame,
2885 const char *action_exp, *next_comma;
2887 for (; action != NULL; action = action->next)
2889 struct cmd_list_element *cmd;
2891 QUIT; /* Allow user to bail out with ^C. */
2892 action_exp = action->line;
2893 action_exp = skip_spaces_const (action_exp);
2895 /* The collection actions to be done while stepping are
2896 bracketed by the commands "while-stepping" and "end". */
2898 if (*action_exp == '#') /* comment line */
2901 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2903 error (_("Bad action list item: %s"), action_exp);
2905 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2909 for (i = 0; i < action->body_count; ++i)
2910 trace_dump_actions (action->body_list[i],
2911 1, stepping_frame, from_tty);
2913 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2915 /* Display the collected data.
2916 For the trap frame, display only what was collected at
2917 the trap. Likewise for stepping frames, display only
2918 what was collected while stepping. This means that the
2919 two boolean variables, STEPPING_FRAME and
2920 STEPPING_ACTIONS should be equal. */
2921 if (stepping_frame == stepping_actions)
2924 struct cleanup *old_chain
2925 = make_cleanup (free_current_contents, &cmd);
2926 int trace_string = 0;
2928 if (*action_exp == '/')
2929 action_exp = decode_agent_options (action_exp, &trace_string);
2932 { /* Repeat over a comma-separated list. */
2933 QUIT; /* Allow user to bail out with ^C. */
2934 if (*action_exp == ',')
2936 action_exp = skip_spaces_const (action_exp);
2938 next_comma = strchr (action_exp, ',');
2940 if (0 == strncasecmp (action_exp, "$reg", 4))
2941 registers_info (NULL, from_tty);
2942 else if (0 == strncasecmp (action_exp, "$_ret", 5))
2944 else if (0 == strncasecmp (action_exp, "$loc", 4))
2945 locals_info (NULL, from_tty);
2946 else if (0 == strncasecmp (action_exp, "$arg", 4))
2947 args_info (NULL, from_tty);
2950 if (next_comma != NULL)
2952 size_t len = next_comma - action_exp;
2954 cmd = xrealloc (cmd, len + 1);
2955 memcpy (cmd, action_exp, len);
2960 size_t len = strlen (action_exp);
2962 cmd = xrealloc (cmd, len + 1);
2963 memcpy (cmd, action_exp, len + 1);
2966 printf_filtered ("%s = ", cmd);
2967 output_command_const (cmd, from_tty);
2968 printf_filtered ("\n");
2970 action_exp = next_comma;
2972 while (action_exp && *action_exp == ',');
2974 do_cleanups (old_chain);
2980 /* Return bp_location of the tracepoint associated with the current
2981 traceframe. Set *STEPPING_FRAME_P to 1 if the current traceframe
2982 is a stepping traceframe. */
2984 struct bp_location *
2985 get_traceframe_location (int *stepping_frame_p)
2987 struct tracepoint *t;
2988 struct bp_location *tloc;
2989 struct regcache *regcache;
2991 if (tracepoint_number == -1)
2992 error (_("No current trace frame."));
2994 t = get_tracepoint (tracepoint_number);
2997 error (_("No known tracepoint matches 'current' tracepoint #%d."),
3000 /* The current frame is a trap frame if the frame PC is equal to the
3001 tracepoint PC. If not, then the current frame was collected
3002 during single-stepping. */
3003 regcache = get_current_regcache ();
3005 /* If the traceframe's address matches any of the tracepoint's
3006 locations, assume it is a direct hit rather than a while-stepping
3007 frame. (FIXME this is not reliable, should record each frame's
3009 for (tloc = t->base.loc; tloc; tloc = tloc->next)
3010 if (tloc->address == regcache_read_pc (regcache))
3012 *stepping_frame_p = 0;
3016 /* If this is a stepping frame, we don't know which location
3017 triggered. The first is as good (or bad) a guess as any... */
3018 *stepping_frame_p = 1;
3022 /* Return all the actions, including default collect, of a tracepoint
3023 T. It constructs cleanups into the chain, and leaves the caller to
3024 handle them (call do_cleanups). */
3026 static struct command_line *
3027 all_tracepoint_actions_and_cleanup (struct breakpoint *t)
3029 struct command_line *actions;
3031 actions = breakpoint_commands (t);
3033 /* If there are default expressions to collect, make up a collect
3034 action and prepend to the action list to encode. Note that since
3035 validation is per-tracepoint (local var "xyz" might be valid for
3036 one tracepoint and not another, etc), we make up the action on
3037 the fly, and don't cache it. */
3038 if (*default_collect)
3040 struct command_line *default_collect_action;
3041 char *default_collect_line;
3043 default_collect_line = xstrprintf ("collect %s", default_collect);
3044 make_cleanup (xfree, default_collect_line);
3046 validate_actionline (default_collect_line, t);
3047 default_collect_action = xmalloc (sizeof (struct command_line));
3048 make_cleanup (xfree, default_collect_action);
3049 default_collect_action->next = actions;
3050 default_collect_action->line = default_collect_line;
3051 actions = default_collect_action;
3057 /* The tdump command. */
3060 trace_dump_command (char *args, int from_tty)
3062 int stepping_frame = 0;
3063 struct bp_location *loc;
3064 struct cleanup *old_chain;
3065 struct command_line *actions;
3067 /* This throws an error is not inspecting a trace frame. */
3068 loc = get_traceframe_location (&stepping_frame);
3070 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
3071 tracepoint_number, traceframe_number);
3073 old_chain = make_cleanup (null_cleanup, NULL);
3074 actions = all_tracepoint_actions_and_cleanup (loc->owner);
3076 trace_dump_actions (actions, 0, stepping_frame, from_tty);
3078 do_cleanups (old_chain);
3081 /* Encode a piece of a tracepoint's source-level definition in a form
3082 that is suitable for both protocol and saving in files. */
3083 /* This version does not do multiple encodes for long strings; it should
3084 return an offset to the next piece to encode. FIXME */
3087 encode_source_string (int tpnum, ULONGEST addr,
3088 char *srctype, char *src, char *buf, int buf_size)
3090 if (80 + strlen (srctype) > buf_size)
3091 error (_("Buffer too small for source encoding"));
3092 sprintf (buf, "%x:%s:%s:%x:%x:",
3093 tpnum, phex_nz (addr, sizeof (addr)),
3094 srctype, 0, (int) strlen (src));
3095 if (strlen (buf) + strlen (src) * 2 >= buf_size)
3096 error (_("Source string too long for buffer"));
3097 bin2hex ((gdb_byte *) src, buf + strlen (buf), 0);
3101 /* Free trace file writer. */
3104 trace_file_writer_xfree (void *arg)
3106 struct trace_file_writer *writer = arg;
3108 writer->ops->dtor (writer);
3112 /* TFILE trace writer. */
3114 struct tfile_trace_file_writer
3116 struct trace_file_writer base;
3118 /* File pointer to tfile trace file. */
3120 /* Path name of the tfile trace file. */
3124 /* This is the implementation of trace_file_write_ops method
3125 target_save. We just call the generic target
3126 target_save_trace_data to do target-side saving. */
3129 tfile_target_save (struct trace_file_writer *self,
3130 const char *filename)
3132 int err = target_save_trace_data (filename);
3137 /* This is the implementation of trace_file_write_ops method
3141 tfile_dtor (struct trace_file_writer *self)
3143 struct tfile_trace_file_writer *writer
3144 = (struct tfile_trace_file_writer *) self;
3146 xfree (writer->pathname);
3148 if (writer->fp != NULL)
3149 fclose (writer->fp);
3152 /* This is the implementation of trace_file_write_ops method
3153 start. It creates the trace file FILENAME and registers some
3157 tfile_start (struct trace_file_writer *self, const char *filename)
3159 struct tfile_trace_file_writer *writer
3160 = (struct tfile_trace_file_writer *) self;
3162 writer->pathname = tilde_expand (filename);
3163 writer->fp = gdb_fopen_cloexec (writer->pathname, "wb");
3164 if (writer->fp == NULL)
3165 error (_("Unable to open file '%s' for saving trace data (%s)"),
3166 filename, safe_strerror (errno));
3169 /* This is the implementation of trace_file_write_ops method
3170 write_header. Write the TFILE header. */
3173 tfile_write_header (struct trace_file_writer *self)
3175 struct tfile_trace_file_writer *writer
3176 = (struct tfile_trace_file_writer *) self;
3179 /* Write a file header, with a high-bit-set char to indicate a
3180 binary file, plus a hint as what this file is, and a version
3181 number in case of future needs. */
3182 written = fwrite ("\x7fTRACE0\n", 8, 1, writer->fp);
3184 perror_with_name (writer->pathname);
3187 /* This is the implementation of trace_file_write_ops method
3188 write_regblock_type. Write the size of register block. */
3191 tfile_write_regblock_type (struct trace_file_writer *self, int size)
3193 struct tfile_trace_file_writer *writer
3194 = (struct tfile_trace_file_writer *) self;
3196 fprintf (writer->fp, "R %x\n", size);
3199 /* This is the implementation of trace_file_write_ops method
3203 tfile_write_status (struct trace_file_writer *self,
3204 struct trace_status *ts)
3206 struct tfile_trace_file_writer *writer
3207 = (struct tfile_trace_file_writer *) self;
3209 fprintf (writer->fp, "status %c;%s",
3210 (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
3211 if (ts->stop_reason == tracepoint_error
3212 || ts->stop_reason == tstop_command)
3214 char *buf = (char *) alloca (strlen (ts->stop_desc) * 2 + 1);
3216 bin2hex ((gdb_byte *) ts->stop_desc, buf, 0);
3217 fprintf (writer->fp, ":%s", buf);
3219 fprintf (writer->fp, ":%x", ts->stopping_tracepoint);
3220 if (ts->traceframe_count >= 0)
3221 fprintf (writer->fp, ";tframes:%x", ts->traceframe_count);
3222 if (ts->traceframes_created >= 0)
3223 fprintf (writer->fp, ";tcreated:%x", ts->traceframes_created);
3224 if (ts->buffer_free >= 0)
3225 fprintf (writer->fp, ";tfree:%x", ts->buffer_free);
3226 if (ts->buffer_size >= 0)
3227 fprintf (writer->fp, ";tsize:%x", ts->buffer_size);
3228 if (ts->disconnected_tracing)
3229 fprintf (writer->fp, ";disconn:%x", ts->disconnected_tracing);
3230 if (ts->circular_buffer)
3231 fprintf (writer->fp, ";circular:%x", ts->circular_buffer);
3234 fprintf (writer->fp, ";starttime:%s",
3235 phex_nz (ts->start_time, sizeof (ts->start_time)));
3239 fprintf (writer->fp, ";stoptime:%s",
3240 phex_nz (ts->stop_time, sizeof (ts->stop_time)));
3242 if (ts->notes != NULL)
3244 char *buf = (char *) alloca (strlen (ts->notes) * 2 + 1);
3246 bin2hex ((gdb_byte *) ts->notes, buf, 0);
3247 fprintf (writer->fp, ";notes:%s", buf);
3249 if (ts->user_name != NULL)
3251 char *buf = (char *) alloca (strlen (ts->user_name) * 2 + 1);
3253 bin2hex ((gdb_byte *) ts->user_name, buf, 0);
3254 fprintf (writer->fp, ";username:%s", buf);
3256 fprintf (writer->fp, "\n");
3259 /* This is the implementation of trace_file_write_ops method
3260 write_uploaded_tsv. */
3263 tfile_write_uploaded_tsv (struct trace_file_writer *self,
3264 struct uploaded_tsv *utsv)
3267 struct tfile_trace_file_writer *writer
3268 = (struct tfile_trace_file_writer *) self;
3272 buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
3273 bin2hex ((gdb_byte *) (utsv->name), buf, 0);
3276 fprintf (writer->fp, "tsv %x:%s:%x:%s\n",
3277 utsv->number, phex_nz (utsv->initial_value, 8),
3278 utsv->builtin, buf);
3284 #define MAX_TRACE_UPLOAD 2000
3286 /* This is the implementation of trace_file_write_ops method
3287 write_uploaded_tp. */
3290 tfile_write_uploaded_tp (struct trace_file_writer *self,
3291 struct uploaded_tp *utp)
3293 struct tfile_trace_file_writer *writer
3294 = (struct tfile_trace_file_writer *) self;
3297 char buf[MAX_TRACE_UPLOAD];
3299 fprintf (writer->fp, "tp T%x:%s:%c:%x:%x",
3300 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
3301 (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
3302 if (utp->type == bp_fast_tracepoint)
3303 fprintf (writer->fp, ":F%x", utp->orig_size);
3305 fprintf (writer->fp,
3306 ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
3308 fprintf (writer->fp, "\n");
3309 for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
3310 fprintf (writer->fp, "tp A%x:%s:%s\n",
3311 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
3312 for (a = 0; VEC_iterate (char_ptr, utp->step_actions, a, act); ++a)
3313 fprintf (writer->fp, "tp S%x:%s:%s\n",
3314 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
3317 encode_source_string (utp->number, utp->addr,
3318 "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
3319 fprintf (writer->fp, "tp Z%s\n", buf);
3321 if (utp->cond_string)
3323 encode_source_string (utp->number, utp->addr,
3324 "cond", utp->cond_string,
3325 buf, MAX_TRACE_UPLOAD);
3326 fprintf (writer->fp, "tp Z%s\n", buf);
3328 for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
3330 encode_source_string (utp->number, utp->addr, "cmd", act,
3331 buf, MAX_TRACE_UPLOAD);
3332 fprintf (writer->fp, "tp Z%s\n", buf);
3334 fprintf (writer->fp, "tp V%x:%s:%x:%s\n",
3335 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
3337 phex_nz (utp->traceframe_usage,
3338 sizeof (utp->traceframe_usage)));
3341 /* This is the implementation of trace_file_write_ops method
3342 write_definition_end. */
3345 tfile_write_definition_end (struct trace_file_writer *self)
3347 struct tfile_trace_file_writer *writer
3348 = (struct tfile_trace_file_writer *) self;
3350 fprintf (writer->fp, "\n");
3353 /* This is the implementation of trace_file_write_ops method
3357 tfile_write_raw_data (struct trace_file_writer *self, gdb_byte *buf,
3360 struct tfile_trace_file_writer *writer
3361 = (struct tfile_trace_file_writer *) self;
3363 if (fwrite (buf, len, 1, writer->fp) < 1)
3364 perror_with_name (writer->pathname);
3367 /* This is the implementation of trace_file_write_ops method
3371 tfile_end (struct trace_file_writer *self)
3373 struct tfile_trace_file_writer *writer
3374 = (struct tfile_trace_file_writer *) self;
3375 uint32_t gotten = 0;
3377 /* Mark the end of trace data. */
3378 if (fwrite (&gotten, 4, 1, writer->fp) < 1)
3379 perror_with_name (writer->pathname);
3382 /* Operations to write trace buffers into TFILE format. */
3384 static const struct trace_file_write_ops tfile_write_ops =
3390 tfile_write_regblock_type,
3392 tfile_write_uploaded_tsv,
3393 tfile_write_uploaded_tp,
3394 tfile_write_definition_end,
3395 tfile_write_raw_data,
3400 /* Helper macros. */
3402 #define TRACE_WRITE_R_BLOCK(writer, buf, size) \
3403 writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
3404 #define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
3405 writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
3407 #define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
3408 writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
3410 #define TRACE_WRITE_V_BLOCK(writer, num, val) \
3411 writer->ops->frame_ops->write_v_block ((writer), (num), (val))
3413 /* Save tracepoint data to file named FILENAME through WRITER. WRITER
3414 determines the trace file format. If TARGET_DOES_SAVE is non-zero,
3415 the save is performed on the target, otherwise GDB obtains all trace
3416 data and saves it locally. */
3419 trace_save (const char *filename, struct trace_file_writer *writer,
3420 int target_does_save)
3422 struct trace_status *ts = current_trace_status ();
3424 struct uploaded_tp *uploaded_tps = NULL, *utp;
3425 struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
3427 ULONGEST offset = 0;
3428 gdb_byte buf[MAX_TRACE_UPLOAD];
3429 #define MAX_TRACE_UPLOAD 2000
3431 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
3433 /* If the target is to save the data to a file on its own, then just
3434 send the command and be done with it. */
3435 if (target_does_save)
3437 if (!writer->ops->target_save (writer, filename))
3438 error (_("Target failed to save trace data to '%s'."),
3443 /* Get the trace status first before opening the file, so if the
3444 target is losing, we can get out without touching files. */
3445 status = target_get_trace_status (ts);
3447 writer->ops->start (writer, filename);
3449 writer->ops->write_header (writer);
3451 /* Write descriptive info. */
3453 /* Write out the size of a register block. */
3454 writer->ops->write_regblock_type (writer, trace_regblock_size);
3456 /* Write out status of the tracing run (aka "tstatus" info). */
3457 writer->ops->write_status (writer, ts);
3459 /* Note that we want to upload tracepoints and save those, rather
3460 than simply writing out the local ones, because the user may have
3461 changed tracepoints in GDB in preparation for a future tracing
3462 run, or maybe just mass-deleted all types of breakpoints as part
3463 of cleaning up. So as not to contaminate the session, leave the
3464 data in its uploaded form, don't make into real tracepoints. */
3466 /* Get trace state variables first, they may be checked when parsing
3467 uploaded commands. */
3469 target_upload_trace_state_variables (&uploaded_tsvs);
3471 for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
3472 writer->ops->write_uploaded_tsv (writer, utsv);
3474 free_uploaded_tsvs (&uploaded_tsvs);
3476 target_upload_tracepoints (&uploaded_tps);
3478 for (utp = uploaded_tps; utp; utp = utp->next)
3479 target_get_tracepoint_status (NULL, utp);
3481 for (utp = uploaded_tps; utp; utp = utp->next)
3482 writer->ops->write_uploaded_tp (writer, utp);
3484 free_uploaded_tps (&uploaded_tps);
3486 /* Mark the end of the definition section. */
3487 writer->ops->write_definition_end (writer);
3489 /* Get and write the trace data proper. */
3494 /* The writer supports writing the contents of trace buffer
3495 directly to trace file. Don't parse the contents of trace
3497 if (writer->ops->write_trace_buffer != NULL)
3499 /* We ask for big blocks, in the hopes of efficiency, but
3500 will take less if the target has packet size limitations
3502 gotten = target_get_raw_trace_data (buf, offset,
3505 error (_("Failure to get requested trace buffer data"));
3506 /* No more data is forthcoming, we're done. */
3510 writer->ops->write_trace_buffer (writer, buf, gotten);
3518 /* Parse the trace buffers according to how data are stored
3519 in trace buffer in GDBserver. */
3521 gotten = target_get_raw_trace_data (buf, offset, 6);
3526 /* Read the first six bytes in, which is the tracepoint
3527 number and trace frame size. */
3529 extract_unsigned_integer (&buf[0], 2, byte_order);
3531 tf_size = (uint32_t)
3532 extract_unsigned_integer (&buf[2], 4, byte_order);
3534 writer->ops->frame_ops->start (writer, tp_num);
3543 for (block = 0; block < tf_size; )
3545 gdb_byte block_type;
3547 /* We'll fetch one block each time, in order to
3548 handle the extremely large 'M' block. We first
3549 fetch one byte to get the type of the block. */
3550 gotten = target_get_raw_trace_data (buf, offset, 1);
3552 error (_("Failure to get requested trace buffer data"));
3558 block_type = buf[0];
3563 = target_get_raw_trace_data (buf, offset,
3564 trace_regblock_size);
3565 if (gotten < trace_regblock_size)
3566 error (_("Failure to get requested trace"
3569 TRACE_WRITE_R_BLOCK (writer, buf,
3570 trace_regblock_size);
3574 unsigned short mlen;
3579 t = target_get_raw_trace_data (buf,offset, 10);
3581 error (_("Failure to get requested trace"
3589 extract_unsigned_integer (buf, 8,
3591 mlen = (unsigned short)
3592 extract_unsigned_integer (&buf[8], 2,
3595 TRACE_WRITE_M_BLOCK_HEADER (writer, addr,
3598 /* The memory contents in 'M' block may be
3599 very large. Fetch the data from the target
3600 and write them into file one by one. */
3601 for (j = 0; j < mlen; )
3603 unsigned int read_length;
3605 if (mlen - j > MAX_TRACE_UPLOAD)
3606 read_length = MAX_TRACE_UPLOAD;
3608 read_length = mlen - j;
3610 t = target_get_raw_trace_data (buf,
3613 if (t < read_length)
3614 error (_("Failure to get requested"
3615 " trace buffer data"));
3617 TRACE_WRITE_M_BLOCK_MEMORY (writer, buf,
3621 gotten += read_length;
3632 = target_get_raw_trace_data (buf, offset,
3635 error (_("Failure to get requested"
3636 " trace buffer data"));
3638 vnum = (int) extract_signed_integer (buf,
3642 = extract_signed_integer (&buf[4], 8,
3645 TRACE_WRITE_V_BLOCK (writer, vnum, val);
3649 error (_("Unknown block type '%c' (0x%x) in"
3651 block_type, block_type);
3661 writer->ops->frame_ops->end (writer);
3665 writer->ops->end (writer);
3668 /* Return a trace writer for TFILE format. */
3670 static struct trace_file_writer *
3671 tfile_trace_file_writer_new (void)
3673 struct tfile_trace_file_writer *writer
3674 = xmalloc (sizeof (struct tfile_trace_file_writer));
3676 writer->base.ops = &tfile_write_ops;
3678 writer->pathname = NULL;
3680 return (struct trace_file_writer *) writer;
3684 trace_save_command (char *args, int from_tty)
3686 int target_does_save = 0;
3688 char *filename = NULL;
3689 struct cleanup *back_to;
3690 int generate_ctf = 0;
3691 struct trace_file_writer *writer = NULL;
3694 error_no_arg (_("file in which to save trace data"));
3696 argv = gdb_buildargv (args);
3697 back_to = make_cleanup_freeargv (argv);
3699 for (; *argv; ++argv)
3701 if (strcmp (*argv, "-r") == 0)
3702 target_does_save = 1;
3703 if (strcmp (*argv, "-ctf") == 0)
3705 else if (**argv == '-')
3706 error (_("unknown option `%s'"), *argv);
3712 error_no_arg (_("file in which to save trace data"));
3715 writer = ctf_trace_file_writer_new ();
3717 writer = tfile_trace_file_writer_new ();
3719 make_cleanup (trace_file_writer_xfree, writer);
3721 trace_save (filename, writer, target_does_save);
3724 printf_filtered (_("Trace data saved to %s '%s'.\n"),
3725 generate_ctf ? "directory" : "file", filename);
3727 do_cleanups (back_to);
3730 /* Save the trace data to file FILENAME of tfile format. */
3733 trace_save_tfile (const char *filename, int target_does_save)
3735 struct trace_file_writer *writer;
3736 struct cleanup *back_to;
3738 writer = tfile_trace_file_writer_new ();
3739 back_to = make_cleanup (trace_file_writer_xfree, writer);
3740 trace_save (filename, writer, target_does_save);
3741 do_cleanups (back_to);
3744 /* Save the trace data to dir DIRNAME of ctf format. */
3747 trace_save_ctf (const char *dirname, int target_does_save)
3749 struct trace_file_writer *writer;
3750 struct cleanup *back_to;
3752 writer = ctf_trace_file_writer_new ();
3753 back_to = make_cleanup (trace_file_writer_xfree, writer);
3755 trace_save (dirname, writer, target_does_save);
3756 do_cleanups (back_to);
3759 /* Tell the target what to do with an ongoing tracing run if GDB
3760 disconnects for some reason. */
3763 set_disconnected_tracing (char *args, int from_tty,
3764 struct cmd_list_element *c)
3766 target_set_disconnected_tracing (disconnected_tracing);
3770 set_circular_trace_buffer (char *args, int from_tty,
3771 struct cmd_list_element *c)
3773 target_set_circular_trace_buffer (circular_trace_buffer);
3777 set_trace_buffer_size (char *args, int from_tty,
3778 struct cmd_list_element *c)
3780 target_set_trace_buffer_size (trace_buffer_size);
3784 set_trace_user (char *args, int from_tty,
3785 struct cmd_list_element *c)
3789 ret = target_set_trace_notes (trace_user, NULL, NULL);
3792 warning (_("Target does not support trace notes, user ignored"));
3796 set_trace_notes (char *args, int from_tty,
3797 struct cmd_list_element *c)
3801 ret = target_set_trace_notes (NULL, trace_notes, NULL);
3804 warning (_("Target does not support trace notes, note ignored"));
3808 set_trace_stop_notes (char *args, int from_tty,
3809 struct cmd_list_element *c)
3813 ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
3816 warning (_("Target does not support trace notes, stop note ignored"));
3819 /* Convert the memory pointed to by mem into hex, placing result in buf.
3820 * Return a pointer to the last char put in buf (null)
3821 * "stolen" from sparc-stub.c
3824 static const char hexchars[] = "0123456789abcdef";
3827 mem2hex (gdb_byte *mem, char *buf, int count)
3835 *buf++ = hexchars[ch >> 4];
3836 *buf++ = hexchars[ch & 0xf];
3845 get_traceframe_number (void)
3847 return traceframe_number;
3851 get_tracepoint_number (void)
3853 return tracepoint_number;
3856 /* Make the traceframe NUM be the current trace frame. Does nothing
3857 if NUM is already current. */
3860 set_current_traceframe (int num)
3864 if (traceframe_number == num)
3866 /* Nothing to do. */
3870 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
3873 warning (_("could not change traceframe"));
3875 set_traceframe_num (newnum);
3877 /* Changing the traceframe changes our view of registers and of the
3879 registers_changed ();
3881 clear_traceframe_info ();
3884 /* Make the traceframe NUM be the current trace frame, and do nothing
3888 set_traceframe_number (int num)
3890 traceframe_number = num;
3893 /* A cleanup used when switching away and back from tfind mode. */
3895 struct current_traceframe_cleanup
3897 /* The traceframe we were inspecting. */
3898 int traceframe_number;
3902 do_restore_current_traceframe_cleanup (void *arg)
3904 struct current_traceframe_cleanup *old = arg;
3906 set_current_traceframe (old->traceframe_number);
3910 restore_current_traceframe_cleanup_dtor (void *arg)
3912 struct current_traceframe_cleanup *old = arg;
3918 make_cleanup_restore_current_traceframe (void)
3920 struct current_traceframe_cleanup *old;
3922 old = xmalloc (sizeof (struct current_traceframe_cleanup));
3923 old->traceframe_number = traceframe_number;
3925 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
3926 restore_current_traceframe_cleanup_dtor);
3930 make_cleanup_restore_traceframe_number (void)
3932 return make_cleanup_restore_integer (&traceframe_number);
3935 /* Given a number and address, return an uploaded tracepoint with that
3936 number, creating if necessary. */
3938 struct uploaded_tp *
3939 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
3941 struct uploaded_tp *utp;
3943 for (utp = *utpp; utp; utp = utp->next)
3944 if (utp->number == num && utp->addr == addr)
3946 utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
3947 memset (utp, 0, sizeof (struct uploaded_tp));
3950 utp->actions = NULL;
3951 utp->step_actions = NULL;
3952 utp->cmd_strings = NULL;
3959 free_uploaded_tps (struct uploaded_tp **utpp)
3961 struct uploaded_tp *next_one;
3965 next_one = (*utpp)->next;
3971 /* Given a number and address, return an uploaded tracepoint with that
3972 number, creating if necessary. */
3974 struct uploaded_tsv *
3975 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3977 struct uploaded_tsv *utsv;
3979 for (utsv = *utsvp; utsv; utsv = utsv->next)
3980 if (utsv->number == num)
3982 utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
3983 memset (utsv, 0, sizeof (struct uploaded_tsv));
3985 utsv->next = *utsvp;
3991 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3993 struct uploaded_tsv *next_one;
3997 next_one = (*utsvp)->next;
4003 /* FIXME this function is heuristic and will miss the cases where the
4004 conditional is semantically identical but differs in whitespace,
4005 such as "x == 0" vs "x==0". */
4008 cond_string_is_same (char *str1, char *str2)
4010 if (str1 == NULL || str2 == NULL)
4011 return (str1 == str2);
4013 return (strcmp (str1, str2) == 0);
4016 /* Look for an existing tracepoint that seems similar enough to the
4017 uploaded one. Enablement isn't compared, because the user can
4018 toggle that freely, and may have done so in anticipation of the
4019 next trace run. Return the location of matched tracepoint. */
4021 static struct bp_location *
4022 find_matching_tracepoint_location (struct uploaded_tp *utp)
4024 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
4026 struct breakpoint *b;
4027 struct bp_location *loc;
4029 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
4031 struct tracepoint *t = (struct tracepoint *) b;
4033 if (b->type == utp->type
4034 && t->step_count == utp->step
4035 && t->pass_count == utp->pass
4036 && cond_string_is_same (t->base.cond_string, utp->cond_string)
4037 /* FIXME also test actions. */
4040 /* Scan the locations for an address match. */
4041 for (loc = b->loc; loc; loc = loc->next)
4043 if (loc->address == utp->addr)
4051 /* Given a list of tracepoints uploaded from a target, attempt to
4052 match them up with existing tracepoints, and create new ones if not
4056 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
4058 struct uploaded_tp *utp;
4059 /* A set of tracepoints which are modified. */
4060 VEC(breakpoint_p) *modified_tp = NULL;
4062 struct breakpoint *b;
4064 /* Look for GDB tracepoints that match up with our uploaded versions. */
4065 for (utp = *uploaded_tps; utp; utp = utp->next)
4067 struct bp_location *loc;
4068 struct tracepoint *t;
4070 loc = find_matching_tracepoint_location (utp);
4075 /* Mark this location as already inserted. */
4077 t = (struct tracepoint *) loc->owner;
4078 printf_filtered (_("Assuming tracepoint %d is same "
4079 "as target's tracepoint %d at %s.\n"),
4080 loc->owner->number, utp->number,
4081 paddress (loc->gdbarch, utp->addr));
4083 /* The tracepoint LOC->owner was modified (the location LOC
4084 was marked as inserted in the target). Save it in
4085 MODIFIED_TP if not there yet. The 'breakpoint-modified'
4086 observers will be notified later once for each tracepoint
4087 saved in MODIFIED_TP. */
4089 VEC_iterate (breakpoint_p, modified_tp, ix, b);
4091 if (b == loc->owner)
4097 VEC_safe_push (breakpoint_p, modified_tp, loc->owner);
4101 t = create_tracepoint_from_upload (utp);
4103 printf_filtered (_("Created tracepoint %d for "
4104 "target's tracepoint %d at %s.\n"),
4105 t->base.number, utp->number,
4106 paddress (get_current_arch (), utp->addr));
4108 printf_filtered (_("Failed to create tracepoint for target's "
4109 "tracepoint %d at %s, skipping it.\n"),
4111 paddress (get_current_arch (), utp->addr));
4113 /* Whether found or created, record the number used by the
4114 target, to help with mapping target tracepoints back to their
4115 counterparts here. */
4117 t->number_on_target = utp->number;
4120 /* Notify 'breakpoint-modified' observer that at least one of B's
4121 locations was changed. */
4122 for (ix = 0; VEC_iterate (breakpoint_p, modified_tp, ix, b); ix++)
4123 observer_notify_breakpoint_modified (b);
4125 VEC_free (breakpoint_p, modified_tp);
4126 free_uploaded_tps (uploaded_tps);
4129 /* Trace state variables don't have much to identify them beyond their
4130 name, so just use that to detect matches. */
4132 static struct trace_state_variable *
4133 find_matching_tsv (struct uploaded_tsv *utsv)
4138 return find_trace_state_variable (utsv->name);
4141 static struct trace_state_variable *
4142 create_tsv_from_upload (struct uploaded_tsv *utsv)
4144 const char *namebase;
4147 struct trace_state_variable *tsv;
4148 struct cleanup *old_chain;
4152 namebase = utsv->name;
4153 buf = xstrprintf ("%s", namebase);
4158 buf = xstrprintf ("%s_%d", namebase, try_num++);
4161 /* Fish for a name that is not in use. */
4162 /* (should check against all internal vars?) */
4163 while (find_trace_state_variable (buf))
4166 buf = xstrprintf ("%s_%d", namebase, try_num++);
4169 old_chain = make_cleanup (xfree, buf);
4171 /* We have an available name, create the variable. */
4172 tsv = create_trace_state_variable (buf);
4173 tsv->initial_value = utsv->initial_value;
4174 tsv->builtin = utsv->builtin;
4176 observer_notify_tsv_created (tsv);
4178 do_cleanups (old_chain);
4183 /* Given a list of uploaded trace state variables, try to match them
4184 up with existing variables, or create additional ones. */
4187 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
4190 struct uploaded_tsv *utsv;
4191 struct trace_state_variable *tsv;
4194 /* Most likely some numbers will have to be reassigned as part of
4195 the merge, so clear them all in anticipation. */
4196 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
4199 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
4201 tsv = find_matching_tsv (utsv);
4205 printf_filtered (_("Assuming trace state variable $%s "
4206 "is same as target's variable %d.\n"),
4207 tsv->name, utsv->number);
4211 tsv = create_tsv_from_upload (utsv);
4213 printf_filtered (_("Created trace state variable "
4214 "$%s for target's variable %d.\n"),
4215 tsv->name, utsv->number);
4217 /* Give precedence to numberings that come from the target. */
4219 tsv->number = utsv->number;
4222 /* Renumber everything that didn't get a target-assigned number. */
4224 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
4225 if (tsv->number > highest)
4226 highest = tsv->number;
4229 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
4230 if (tsv->number == 0)
4231 tsv->number = highest++;
4233 free_uploaded_tsvs (uploaded_tsvs);
4236 /* target tfile command */
4238 static struct target_ops tfile_ops;
4240 /* Fill in tfile_ops with its defined operations and properties. */
4242 #define TRACE_HEADER_SIZE 8
4244 static char *trace_filename;
4245 static int trace_fd = -1;
4246 static off_t trace_frames_offset;
4247 static off_t cur_offset;
4248 static int cur_data_size;
4249 int trace_regblock_size;
4251 static void tfile_interp_line (char *line,
4252 struct uploaded_tp **utpp,
4253 struct uploaded_tsv **utsvp);
4255 /* Read SIZE bytes into READBUF from the trace frame, starting at
4256 TRACE_FD's current position. Note that this call `read'
4257 underneath, hence it advances the file's seek position. Throws an
4258 error if the `read' syscall fails, or less than SIZE bytes are
4262 tfile_read (gdb_byte *readbuf, int size)
4266 gotten = read (trace_fd, readbuf, size);
4268 perror_with_name (trace_filename);
4269 else if (gotten < size)
4270 error (_("Premature end of file while reading trace file"));
4274 tfile_open (char *filename, int from_tty)
4276 volatile struct gdb_exception ex;
4278 struct cleanup *old_chain;
4281 char header[TRACE_HEADER_SIZE];
4282 char linebuf[1000]; /* Should be max remote packet size or so. */
4285 struct trace_status *ts;
4286 struct uploaded_tp *uploaded_tps = NULL;
4287 struct uploaded_tsv *uploaded_tsvs = NULL;
4289 target_preopen (from_tty);
4291 error (_("No trace file specified."));
4293 filename = tilde_expand (filename);
4294 if (!IS_ABSOLUTE_PATH(filename))
4296 temp = concat (current_directory, "/", filename, (char *) NULL);
4301 old_chain = make_cleanup (xfree, filename);
4303 flags = O_BINARY | O_LARGEFILE;
4305 scratch_chan = gdb_open_cloexec (filename, flags, 0);
4306 if (scratch_chan < 0)
4307 perror_with_name (filename);
4309 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
4311 discard_cleanups (old_chain); /* Don't free filename any more. */
4312 unpush_target (&tfile_ops);
4314 trace_filename = xstrdup (filename);
4315 trace_fd = scratch_chan;
4318 /* Read the file header and test for validity. */
4319 tfile_read ((gdb_byte *) &header, TRACE_HEADER_SIZE);
4321 bytes += TRACE_HEADER_SIZE;
4322 if (!(header[0] == 0x7f
4323 && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
4324 error (_("File is not a valid trace file."));
4326 push_target (&tfile_ops);
4328 trace_regblock_size = 0;
4329 ts = current_trace_status ();
4330 /* We know we're working with a file. Record its name. */
4331 ts->filename = trace_filename;
4332 /* Set defaults in case there is no status line. */
4333 ts->running_known = 0;
4334 ts->stop_reason = trace_stop_reason_unknown;
4335 ts->traceframe_count = -1;
4336 ts->buffer_free = 0;
4337 ts->disconnected_tracing = 0;
4338 ts->circular_buffer = 0;
4340 TRY_CATCH (ex, RETURN_MASK_ALL)
4342 /* Read through a section of newline-terminated lines that
4343 define things like tracepoints. */
4347 tfile_read (&byte, 1);
4352 /* Empty line marks end of the definition section. */
4357 tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
4360 linebuf[i++] = byte;
4362 error (_("Excessively long lines in trace file"));
4365 /* Record the starting offset of the binary trace data. */
4366 trace_frames_offset = bytes;
4368 /* If we don't have a blocksize, we can't interpret the
4370 if (trace_regblock_size == 0)
4371 error (_("No register block size recorded in trace file"));
4375 /* Pop the partially set up target. */
4377 throw_exception (ex);
4380 if (ts->traceframe_count <= 0)
4381 warning (_("No traceframes present in this file."));
4383 /* Add the file's tracepoints and variables into the current mix. */
4385 /* Get trace state variables first, they may be checked when parsing
4386 uploaded commands. */
4387 merge_uploaded_trace_state_variables (&uploaded_tsvs);
4389 merge_uploaded_tracepoints (&uploaded_tps);
4392 /* Interpret the given line from the definitions part of the trace
4396 tfile_interp_line (char *line, struct uploaded_tp **utpp,
4397 struct uploaded_tsv **utsvp)
4401 if (strncmp (p, "R ", strlen ("R ")) == 0)
4404 trace_regblock_size = strtol (p, &p, 16);
4406 else if (strncmp (p, "status ", strlen ("status ")) == 0)
4408 p += strlen ("status ");
4409 parse_trace_status (p, current_trace_status ());
4411 else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
4413 p += strlen ("tp ");
4414 parse_tracepoint_definition (p, utpp);
4416 else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
4418 p += strlen ("tsv ");
4419 parse_tsv_definition (p, utsvp);
4422 warning (_("Ignoring trace file definition \"%s\""), line);
4425 /* Parse the part of trace status syntax that is shared between
4426 the remote protocol and the trace file reader. */
4429 parse_trace_status (char *line, struct trace_status *ts)
4431 char *p = line, *p1, *p2, *p3, *p_temp;
4435 ts->running_known = 1;
4436 ts->running = (*p++ == '1');
4437 ts->stop_reason = trace_stop_reason_unknown;
4438 xfree (ts->stop_desc);
4439 ts->stop_desc = NULL;
4440 ts->traceframe_count = -1;
4441 ts->traceframes_created = -1;
4442 ts->buffer_free = -1;
4443 ts->buffer_size = -1;
4444 ts->disconnected_tracing = 0;
4445 ts->circular_buffer = 0;
4446 xfree (ts->user_name);
4447 ts->user_name = NULL;
4450 ts->start_time = ts->stop_time = 0;
4454 p1 = strchr (p, ':');
4456 error (_("Malformed trace status, at %s\n\
4457 Status line: '%s'\n"), p, line);
4458 p3 = strchr (p, ';');
4460 p3 = p + strlen (p);
4461 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
4463 p = unpack_varlen_hex (++p1, &val);
4464 ts->stop_reason = trace_buffer_full;
4466 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
4468 p = unpack_varlen_hex (++p1, &val);
4469 ts->stop_reason = trace_never_run;
4471 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
4474 p = unpack_varlen_hex (++p1, &val);
4475 ts->stop_reason = tracepoint_passcount;
4476 ts->stopping_tracepoint = val;
4478 else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
4480 p2 = strchr (++p1, ':');
4488 ts->stop_desc = xmalloc (strlen (line));
4489 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
4490 ts->stop_desc[end] = '\0';
4493 ts->stop_desc = xstrdup ("");
4495 p = unpack_varlen_hex (++p2, &val);
4496 ts->stop_reason = tstop_command;
4498 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
4500 p = unpack_varlen_hex (++p1, &val);
4501 ts->stop_reason = trace_disconnected;
4503 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
4505 p2 = strchr (++p1, ':');
4508 ts->stop_desc = xmalloc ((p2 - p1) / 2 + 1);
4509 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
4510 ts->stop_desc[end] = '\0';
4513 ts->stop_desc = xstrdup ("");
4515 p = unpack_varlen_hex (++p2, &val);
4516 ts->stopping_tracepoint = val;
4517 ts->stop_reason = tracepoint_error;
4519 else if (strncmp (p, "tframes", p1 - p) == 0)
4521 p = unpack_varlen_hex (++p1, &val);
4522 ts->traceframe_count = val;
4524 else if (strncmp (p, "tcreated", p1 - p) == 0)
4526 p = unpack_varlen_hex (++p1, &val);
4527 ts->traceframes_created = val;
4529 else if (strncmp (p, "tfree", p1 - p) == 0)
4531 p = unpack_varlen_hex (++p1, &val);
4532 ts->buffer_free = val;
4534 else if (strncmp (p, "tsize", p1 - p) == 0)
4536 p = unpack_varlen_hex (++p1, &val);
4537 ts->buffer_size = val;
4539 else if (strncmp (p, "disconn", p1 - p) == 0)
4541 p = unpack_varlen_hex (++p1, &val);
4542 ts->disconnected_tracing = val;
4544 else if (strncmp (p, "circular", p1 - p) == 0)
4546 p = unpack_varlen_hex (++p1, &val);
4547 ts->circular_buffer = val;
4549 else if (strncmp (p, "starttime", p1 - p) == 0)
4551 p = unpack_varlen_hex (++p1, &val);
4552 ts->start_time = val;
4554 else if (strncmp (p, "stoptime", p1 - p) == 0)
4556 p = unpack_varlen_hex (++p1, &val);
4557 ts->stop_time = val;
4559 else if (strncmp (p, "username", p1 - p) == 0)
4562 ts->user_name = xmalloc (strlen (p) / 2);
4563 end = hex2bin (p1, (gdb_byte *) ts->user_name, (p3 - p1) / 2);
4564 ts->user_name[end] = '\0';
4567 else if (strncmp (p, "notes", p1 - p) == 0)
4570 ts->notes = xmalloc (strlen (p) / 2);
4571 end = hex2bin (p1, (gdb_byte *) ts->notes, (p3 - p1) / 2);
4572 ts->notes[end] = '\0';
4577 /* Silently skip unknown optional info. */
4578 p_temp = strchr (p1 + 1, ';');
4582 /* Must be at the end. */
4589 parse_tracepoint_status (char *p, struct breakpoint *bp,
4590 struct uploaded_tp *utp)
4593 struct tracepoint *tp = (struct tracepoint *) bp;
4595 p = unpack_varlen_hex (p, &uval);
4597 tp->base.hit_count += uval;
4599 utp->hit_count += uval;
4600 p = unpack_varlen_hex (p + 1, &uval);
4602 tp->traceframe_usage += uval;
4604 utp->traceframe_usage += uval;
4605 /* Ignore any extra, allowing for future extensions. */
4608 /* Given a line of text defining a part of a tracepoint, parse it into
4609 an "uploaded tracepoint". */
4612 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
4616 ULONGEST num, addr, step, pass, orig_size, xlen, start;
4619 char *cond, *srctype, *buf;
4620 struct uploaded_tp *utp = NULL;
4623 /* Both tracepoint and action definitions start with the same number
4624 and address sequence. */
4626 p = unpack_varlen_hex (p, &num);
4627 p++; /* skip a colon */
4628 p = unpack_varlen_hex (p, &addr);
4629 p++; /* skip a colon */
4632 enabled = (*p++ == 'E');
4633 p++; /* skip a colon */
4634 p = unpack_varlen_hex (p, &step);
4635 p++; /* skip a colon */
4636 p = unpack_varlen_hex (p, &pass);
4637 type = bp_tracepoint;
4639 /* Thumb through optional fields. */
4642 p++; /* skip a colon */
4645 type = bp_fast_tracepoint;
4647 p = unpack_varlen_hex (p, &orig_size);
4651 type = bp_static_tracepoint;
4657 p = unpack_varlen_hex (p, &xlen);
4658 p++; /* skip a comma */
4659 cond = (char *) xmalloc (2 * xlen + 1);
4660 strncpy (cond, p, 2 * xlen);
4661 cond[2 * xlen] = '\0';
4665 warning (_("Unrecognized char '%c' in tracepoint "
4666 "definition, skipping rest"), *p);
4668 utp = get_uploaded_tp (num, addr, utpp);
4670 utp->enabled = enabled;
4675 else if (piece == 'A')
4677 utp = get_uploaded_tp (num, addr, utpp);
4678 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
4680 else if (piece == 'S')
4682 utp = get_uploaded_tp (num, addr, utpp);
4683 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
4685 else if (piece == 'Z')
4687 /* Parse a chunk of source form definition. */
4688 utp = get_uploaded_tp (num, addr, utpp);
4690 p = strchr (p, ':');
4691 p++; /* skip a colon */
4692 p = unpack_varlen_hex (p, &start);
4693 p++; /* skip a colon */
4694 p = unpack_varlen_hex (p, &xlen);
4695 p++; /* skip a colon */
4697 buf = alloca (strlen (line));
4699 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
4702 if (strncmp (srctype, "at:", strlen ("at:")) == 0)
4703 utp->at_string = xstrdup (buf);
4704 else if (strncmp (srctype, "cond:", strlen ("cond:")) == 0)
4705 utp->cond_string = xstrdup (buf);
4706 else if (strncmp (srctype, "cmd:", strlen ("cmd:")) == 0)
4707 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
4709 else if (piece == 'V')
4711 utp = get_uploaded_tp (num, addr, utpp);
4713 parse_tracepoint_status (p, NULL, utp);
4717 /* Don't error out, the target might be sending us optional
4718 info that we don't care about. */
4719 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
4723 /* Convert a textual description of a trace state variable into an
4727 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
4730 ULONGEST num, initval, builtin;
4732 struct uploaded_tsv *utsv = NULL;
4734 buf = alloca (strlen (line));
4737 p = unpack_varlen_hex (p, &num);
4738 p++; /* skip a colon */
4739 p = unpack_varlen_hex (p, &initval);
4740 p++; /* skip a colon */
4741 p = unpack_varlen_hex (p, &builtin);
4742 p++; /* skip a colon */
4743 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
4746 utsv = get_uploaded_tsv (num, utsvp);
4747 utsv->initial_value = initval;
4748 utsv->builtin = builtin;
4749 utsv->name = xstrdup (buf);
4752 /* Close the trace file and generally clean up. */
4764 xfree (trace_filename);
4765 trace_filename = NULL;
4767 trace_reset_local_state ();
4771 tfile_files_info (struct target_ops *t)
4773 printf_filtered ("\t`%s'\n", trace_filename);
4776 /* The trace status for a file is that tracing can never be run. */
4779 tfile_get_trace_status (struct trace_status *ts)
4781 /* Other bits of trace status were collected as part of opening the
4782 trace files, so nothing to do here. */
4788 tfile_get_tracepoint_status (struct breakpoint *tp, struct uploaded_tp *utp)
4790 /* Other bits of trace status were collected as part of opening the
4791 trace files, so nothing to do here. */
4794 /* Given the position of a traceframe in the file, figure out what
4795 address the frame was collected at. This would normally be the
4796 value of a collected PC register, but if not available, we
4800 tfile_get_traceframe_address (off_t tframe_offset)
4804 struct tracepoint *tp;
4805 off_t saved_offset = cur_offset;
4807 /* FIXME dig pc out of collected registers. */
4809 /* Fall back to using tracepoint address. */
4810 lseek (trace_fd, tframe_offset, SEEK_SET);
4811 tfile_read ((gdb_byte *) &tpnum, 2);
4812 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
4814 (target_gdbarch ()));
4816 tp = get_tracepoint_by_number_on_target (tpnum);
4817 /* FIXME this is a poor heuristic if multiple locations. */
4818 if (tp && tp->base.loc)
4819 addr = tp->base.loc->address;
4821 /* Restore our seek position. */
4822 cur_offset = saved_offset;
4823 lseek (trace_fd, cur_offset, SEEK_SET);
4827 /* Given a type of search and some parameters, scan the collection of
4828 traceframes in the file looking for a match. When found, return
4829 both the traceframe and tracepoint number, otherwise -1 for
4833 tfile_trace_find (enum trace_find_type type, int num,
4834 CORE_ADDR addr1, CORE_ADDR addr2, int *tpp)
4837 int tfnum = 0, found = 0;
4838 unsigned int data_size;
4839 struct tracepoint *tp;
4840 off_t offset, tframe_offset;
4850 lseek (trace_fd, trace_frames_offset, SEEK_SET);
4851 offset = trace_frames_offset;
4854 tframe_offset = offset;
4855 tfile_read ((gdb_byte *) &tpnum, 2);
4856 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
4858 (target_gdbarch ()));
4862 tfile_read ((gdb_byte *) &data_size, 4);
4863 data_size = (unsigned int) extract_unsigned_integer
4864 ((gdb_byte *) &data_size, 4,
4865 gdbarch_byte_order (target_gdbarch ()));
4868 if (type == tfind_number)
4870 /* Looking for a specific trace frame. */
4876 /* Start from the _next_ trace frame. */
4877 if (tfnum > traceframe_number)
4882 tfaddr = tfile_get_traceframe_address (tframe_offset);
4883 if (tfaddr == addr1)
4887 tp = get_tracepoint (num);
4888 if (tp && tpnum == tp->number_on_target)
4892 tfaddr = tfile_get_traceframe_address (tframe_offset);
4893 if (addr1 <= tfaddr && tfaddr <= addr2)
4897 tfaddr = tfile_get_traceframe_address (tframe_offset);
4898 if (!(addr1 <= tfaddr && tfaddr <= addr2))
4902 internal_error (__FILE__, __LINE__, _("unknown tfind type"));
4911 cur_offset = offset;
4912 cur_data_size = data_size;
4916 /* Skip past the traceframe's data. */
4917 lseek (trace_fd, data_size, SEEK_CUR);
4918 offset += data_size;
4919 /* Update our own count of traceframes. */
4922 /* Did not find what we were looking for. */
4928 /* Prototype of the callback passed to tframe_walk_blocks. */
4929 typedef int (*walk_blocks_callback_func) (char blocktype, void *data);
4931 /* Callback for traceframe_walk_blocks, used to find a given block
4932 type in a traceframe. */
4935 match_blocktype (char blocktype, void *data)
4937 char *wantedp = data;
4939 if (*wantedp == blocktype)
4945 /* Walk over all traceframe block starting at POS offset from
4946 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4947 unmodified. If CALLBACK returns true, this returns the position in
4948 the traceframe where the block is found, relative to the start of
4949 the traceframe (cur_offset). Returns -1 if no callback call
4950 returned true, indicating that all blocks have been walked. */
4953 traceframe_walk_blocks (walk_blocks_callback_func callback,
4954 int pos, void *data)
4956 /* Iterate through a traceframe's blocks, looking for a block of the
4959 lseek (trace_fd, cur_offset + pos, SEEK_SET);
4960 while (pos < cur_data_size)
4962 unsigned short mlen;
4965 tfile_read ((gdb_byte *) &block_type, 1);
4969 if ((*callback) (block_type, data))
4975 lseek (trace_fd, cur_offset + pos + trace_regblock_size, SEEK_SET);
4976 pos += trace_regblock_size;
4979 lseek (trace_fd, cur_offset + pos + 8, SEEK_SET);
4980 tfile_read ((gdb_byte *) &mlen, 2);
4981 mlen = (unsigned short)
4982 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
4984 (target_gdbarch ()));
4985 lseek (trace_fd, mlen, SEEK_CUR);
4986 pos += (8 + 2 + mlen);
4989 lseek (trace_fd, cur_offset + pos + 4 + 8, SEEK_SET);
4993 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4994 block_type, block_type);
5002 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
5003 position offset of a block of type TYPE_WANTED in the current trace
5004 frame, starting at POS. Returns -1 if no such block was found. */
5007 traceframe_find_block_type (char type_wanted, int pos)
5009 return traceframe_walk_blocks (match_blocktype, pos, &type_wanted);
5012 /* Look for a block of saved registers in the traceframe, and get the
5013 requested register from it. */
5016 tfile_fetch_registers (struct target_ops *ops,
5017 struct regcache *regcache, int regno)
5019 struct gdbarch *gdbarch = get_regcache_arch (regcache);
5020 int offset, regn, regsize, pc_regno;
5023 /* An uninitialized reg size says we're not going to be
5024 successful at getting register blocks. */
5025 if (!trace_regblock_size)
5028 regs = alloca (trace_regblock_size);
5030 if (traceframe_find_block_type ('R', 0) >= 0)
5032 tfile_read (regs, trace_regblock_size);
5034 /* Assume the block is laid out in GDB register number order,
5035 each register with the size that it has in GDB. */
5037 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
5039 regsize = register_size (gdbarch, regn);
5040 /* Make sure we stay within block bounds. */
5041 if (offset + regsize >= trace_regblock_size)
5043 if (regcache_register_status (regcache, regn) == REG_UNKNOWN)
5047 regcache_raw_supply (regcache, regno, regs + offset);
5050 else if (regno == -1)
5052 regcache_raw_supply (regcache, regn, regs + offset);
5060 /* We get here if no register data has been found. Mark registers
5062 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
5063 regcache_raw_supply (regcache, regn, NULL);
5065 /* We can often usefully guess that the PC is going to be the same
5066 as the address of the tracepoint. */
5067 pc_regno = gdbarch_pc_regnum (gdbarch);
5068 if (pc_regno >= 0 && (regno == -1 || regno == pc_regno))
5070 struct tracepoint *tp = get_tracepoint (tracepoint_number);
5072 if (tp && tp->base.loc)
5074 /* But don't try to guess if tracepoint is multi-location... */
5075 if (tp->base.loc->next)
5077 warning (_("Tracepoint %d has multiple "
5078 "locations, cannot infer $pc"),
5082 /* ... or does while-stepping. */
5083 if (tp->step_count > 0)
5085 warning (_("Tracepoint %d does while-stepping, "
5086 "cannot infer $pc"),
5091 store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
5092 gdbarch_byte_order (gdbarch),
5093 tp->base.loc->address);
5094 regcache_raw_supply (regcache, pc_regno, regs);
5100 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
5101 const char *annex, gdb_byte *readbuf,
5102 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
5104 /* We're only doing regular memory for now. */
5105 if (object != TARGET_OBJECT_MEMORY)
5108 if (readbuf == NULL)
5109 error (_("tfile_xfer_partial: trace file is read-only"));
5111 if (traceframe_number != -1)
5115 /* Iterate through the traceframe's blocks, looking for
5117 while ((pos = traceframe_find_block_type ('M', pos)) >= 0)
5119 ULONGEST maddr, amt;
5120 unsigned short mlen;
5121 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
5123 tfile_read ((gdb_byte *) &maddr, 8);
5124 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
5126 tfile_read ((gdb_byte *) &mlen, 2);
5127 mlen = (unsigned short)
5128 extract_unsigned_integer ((gdb_byte *) &mlen, 2, byte_order);
5130 /* If the block includes the first part of the desired
5131 range, return as much it has; GDB will re-request the
5132 remainder, which might be in a different block of this
5134 if (maddr <= offset && offset < (maddr + mlen))
5136 amt = (maddr + mlen) - offset;
5140 if (maddr != offset)
5141 lseek (trace_fd, offset - maddr, SEEK_CUR);
5142 tfile_read (readbuf, amt);
5146 /* Skip over this block. */
5147 pos += (8 + 2 + mlen);
5151 /* It's unduly pedantic to refuse to look at the executable for
5152 read-only pieces; so do the equivalent of readonly regions aka
5154 /* FIXME account for relocation at some point. */
5161 for (s = exec_bfd->sections; s; s = s->next)
5163 if ((s->flags & SEC_LOAD) == 0
5164 || (s->flags & SEC_READONLY) == 0)
5168 size = bfd_get_section_size (s);
5169 if (vma <= offset && offset < (vma + size))
5173 amt = (vma + size) - offset;
5177 amt = bfd_get_section_contents (exec_bfd, s,
5178 readbuf, offset - vma, amt);
5184 /* Indicate failure to find the requested memory block. */
5188 /* Iterate through the blocks of a trace frame, looking for a 'V'
5189 block with a matching tsv number. */
5192 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
5197 /* Iterate over blocks in current frame and find the last 'V'
5198 block in which tsv number is TSVNUM. In one trace frame, there
5199 may be multiple 'V' blocks created for a given trace variable,
5200 and the last matched 'V' block contains the updated value. */
5202 while ((pos = traceframe_find_block_type ('V', pos)) >= 0)
5206 tfile_read ((gdb_byte *) &vnum, 4);
5207 vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
5209 (target_gdbarch ()));
5212 tfile_read ((gdb_byte *) val, 8);
5213 *val = extract_signed_integer ((gdb_byte *) val, 8,
5215 (target_gdbarch ()));
5225 tfile_has_all_memory (struct target_ops *ops)
5231 tfile_has_memory (struct target_ops *ops)
5237 tfile_has_stack (struct target_ops *ops)
5239 return traceframe_number != -1;
5243 tfile_has_registers (struct target_ops *ops)
5245 return traceframe_number != -1;
5248 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
5249 object for the tfile target's current traceframe. */
5252 build_traceframe_info (char blocktype, void *data)
5254 struct traceframe_info *info = data;
5260 struct mem_range *r;
5262 unsigned short mlen;
5264 tfile_read ((gdb_byte *) &maddr, 8);
5265 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
5267 (target_gdbarch ()));
5268 tfile_read ((gdb_byte *) &mlen, 2);
5269 mlen = (unsigned short)
5270 extract_unsigned_integer ((gdb_byte *) &mlen,
5271 2, gdbarch_byte_order
5272 (target_gdbarch ()));
5274 r = VEC_safe_push (mem_range_s, info->memory, NULL);
5284 tfile_read ((gdb_byte *) &vnum, 4);
5285 VEC_safe_push (int, info->tvars, vnum);
5293 warning (_("Unhandled trace block type (%d) '%c ' "
5294 "while building trace frame info."),
5295 blocktype, blocktype);
5302 static struct traceframe_info *
5303 tfile_traceframe_info (void)
5305 struct traceframe_info *info = XCNEW (struct traceframe_info);
5307 traceframe_walk_blocks (build_traceframe_info, 0, info);
5312 init_tfile_ops (void)
5314 tfile_ops.to_shortname = "tfile";
5315 tfile_ops.to_longname = "Local trace dump file";
5317 = "Use a trace file as a target. Specify the filename of the trace file.";
5318 tfile_ops.to_open = tfile_open;
5319 tfile_ops.to_close = tfile_close;
5320 tfile_ops.to_fetch_registers = tfile_fetch_registers;
5321 tfile_ops.to_xfer_partial = tfile_xfer_partial;
5322 tfile_ops.to_files_info = tfile_files_info;
5323 tfile_ops.to_get_trace_status = tfile_get_trace_status;
5324 tfile_ops.to_get_tracepoint_status = tfile_get_tracepoint_status;
5325 tfile_ops.to_trace_find = tfile_trace_find;
5326 tfile_ops.to_get_trace_state_variable_value
5327 = tfile_get_trace_state_variable_value;
5328 tfile_ops.to_stratum = process_stratum;
5329 tfile_ops.to_has_all_memory = tfile_has_all_memory;
5330 tfile_ops.to_has_memory = tfile_has_memory;
5331 tfile_ops.to_has_stack = tfile_has_stack;
5332 tfile_ops.to_has_registers = tfile_has_registers;
5333 tfile_ops.to_traceframe_info = tfile_traceframe_info;
5334 tfile_ops.to_magic = OPS_MAGIC;
5338 free_current_marker (void *arg)
5340 struct static_tracepoint_marker **marker_p = arg;
5342 if (*marker_p != NULL)
5344 release_static_tracepoint_marker (*marker_p);
5351 /* Given a line of text defining a static tracepoint marker, parse it
5352 into a "static tracepoint marker" object. Throws an error is
5353 parsing fails. If PP is non-null, it points to one past the end of
5354 the parsed marker definition. */
5357 parse_static_tracepoint_marker_definition (char *line, char **pp,
5358 struct static_tracepoint_marker *marker)
5365 p = unpack_varlen_hex (p, &addr);
5366 p++; /* skip a colon */
5368 marker->gdbarch = target_gdbarch ();
5369 marker->address = (CORE_ADDR) addr;
5371 endp = strchr (p, ':');
5373 error (_("bad marker definition: %s"), line);
5375 marker->str_id = xmalloc (endp - p + 1);
5376 end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
5377 marker->str_id[end] = '\0';
5380 p++; /* skip a colon */
5382 marker->extra = xmalloc (strlen (p) + 1);
5383 end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
5384 marker->extra[end] = '\0';
5390 /* Release a static tracepoint marker's contents. Note that the
5391 object itself isn't released here. There objects are usually on
5395 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
5397 xfree (marker->str_id);
5398 marker->str_id = NULL;
5401 /* Print MARKER to gdb_stdout. */
5404 print_one_static_tracepoint_marker (int count,
5405 struct static_tracepoint_marker *marker)
5407 struct command_line *l;
5410 char wrap_indent[80];
5411 char extra_field_indent[80];
5412 struct ui_out *uiout = current_uiout;
5413 struct cleanup *bkpt_chain;
5414 VEC(breakpoint_p) *tracepoints;
5416 struct symtab_and_line sal;
5420 sal.pc = marker->address;
5422 tracepoints = static_tracepoints_here (marker->address);
5424 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
5426 /* A counter field to help readability. This is not a stable
5428 ui_out_field_int (uiout, "count", count);
5430 ui_out_field_string (uiout, "marker-id", marker->str_id);
5432 ui_out_field_fmt (uiout, "enabled", "%c",
5433 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
5434 ui_out_spaces (uiout, 2);
5436 strcpy (wrap_indent, " ");
5438 if (gdbarch_addr_bit (marker->gdbarch) <= 32)
5439 strcat (wrap_indent, " ");
5441 strcat (wrap_indent, " ");
5443 strcpy (extra_field_indent, " ");
5445 ui_out_field_core_addr (uiout, "addr", marker->gdbarch, marker->address);
5447 sal = find_pc_line (marker->address, 0);
5448 sym = find_pc_sect_function (marker->address, NULL);
5451 ui_out_text (uiout, "in ");
5452 ui_out_field_string (uiout, "func",
5453 SYMBOL_PRINT_NAME (sym));
5454 ui_out_wrap_hint (uiout, wrap_indent);
5455 ui_out_text (uiout, " at ");
5458 ui_out_field_skip (uiout, "func");
5460 if (sal.symtab != NULL)
5462 ui_out_field_string (uiout, "file",
5463 symtab_to_filename_for_display (sal.symtab));
5464 ui_out_text (uiout, ":");
5466 if (ui_out_is_mi_like_p (uiout))
5468 const char *fullname = symtab_to_fullname (sal.symtab);
5470 ui_out_field_string (uiout, "fullname", fullname);
5473 ui_out_field_skip (uiout, "fullname");
5475 ui_out_field_int (uiout, "line", sal.line);
5479 ui_out_field_skip (uiout, "fullname");
5480 ui_out_field_skip (uiout, "line");
5483 ui_out_text (uiout, "\n");
5484 ui_out_text (uiout, extra_field_indent);
5485 ui_out_text (uiout, _("Data: \""));
5486 ui_out_field_string (uiout, "extra-data", marker->extra);
5487 ui_out_text (uiout, "\"\n");
5489 if (!VEC_empty (breakpoint_p, tracepoints))
5491 struct cleanup *cleanup_chain;
5493 struct breakpoint *b;
5495 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
5498 ui_out_text (uiout, extra_field_indent);
5499 ui_out_text (uiout, _("Probed by static tracepoints: "));
5500 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
5503 ui_out_text (uiout, ", ");
5504 ui_out_text (uiout, "#");
5505 ui_out_field_int (uiout, "tracepoint-id", b->number);
5508 do_cleanups (cleanup_chain);
5510 if (ui_out_is_mi_like_p (uiout))
5511 ui_out_field_int (uiout, "number-of-tracepoints",
5512 VEC_length(breakpoint_p, tracepoints));
5514 ui_out_text (uiout, "\n");
5516 VEC_free (breakpoint_p, tracepoints);
5518 do_cleanups (bkpt_chain);
5522 info_static_tracepoint_markers_command (char *arg, int from_tty)
5524 VEC(static_tracepoint_marker_p) *markers;
5525 struct cleanup *old_chain;
5526 struct static_tracepoint_marker *marker;
5527 struct ui_out *uiout = current_uiout;
5530 /* We don't have to check target_can_use_agent and agent's capability on
5531 static tracepoint here, in order to be compatible with older GDBserver.
5532 We don't check USE_AGENT is true or not, because static tracepoints
5533 don't work without in-process agent, so we don't bother users to type
5534 `set agent on' when to use static tracepoint. */
5537 = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
5538 "StaticTracepointMarkersTable");
5540 ui_out_table_header (uiout, 7, ui_left, "counter", "Cnt");
5542 ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
5544 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
5545 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
5546 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
5548 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
5549 ui_out_table_header (uiout, 40, ui_noalign, "what", "What");
5551 ui_out_table_body (uiout);
5553 markers = target_static_tracepoint_markers_by_strid (NULL);
5554 make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
5557 VEC_iterate (static_tracepoint_marker_p,
5558 markers, i, marker);
5561 print_one_static_tracepoint_marker (i + 1, marker);
5562 release_static_tracepoint_marker (marker);
5565 do_cleanups (old_chain);
5568 /* The $_sdata convenience variable is a bit special. We don't know
5569 for sure type of the value until we actually have a chance to fetch
5570 the data --- the size of the object depends on what has been
5571 collected. We solve this by making $_sdata be an internalvar that
5572 creates a new value on access. */
5574 /* Return a new value with the correct type for the sdata object of
5575 the current trace frame. Return a void value if there's no object
5578 static struct value *
5579 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
5585 /* We need to read the whole object before we know its size. */
5586 size = target_read_alloc (¤t_target,
5587 TARGET_OBJECT_STATIC_TRACE_DATA,
5594 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
5596 v = allocate_value (type);
5597 memcpy (value_contents_raw (v), buf, size);
5602 return allocate_value (builtin_type (gdbarch)->builtin_void);
5605 #if !defined(HAVE_LIBEXPAT)
5607 struct traceframe_info *
5608 parse_traceframe_info (const char *tframe_info)
5610 static int have_warned;
5615 warning (_("Can not parse XML trace frame info; XML support "
5616 "was disabled at compile time"));
5622 #else /* HAVE_LIBEXPAT */
5624 #include "xml-support.h"
5626 /* Handle the start of a <memory> element. */
5629 traceframe_info_start_memory (struct gdb_xml_parser *parser,
5630 const struct gdb_xml_element *element,
5631 void *user_data, VEC(gdb_xml_value_s) *attributes)
5633 struct traceframe_info *info = user_data;
5634 struct mem_range *r = VEC_safe_push (mem_range_s, info->memory, NULL);
5635 ULONGEST *start_p, *length_p;
5637 start_p = xml_find_attribute (attributes, "start")->value;
5638 length_p = xml_find_attribute (attributes, "length")->value;
5640 r->start = *start_p;
5641 r->length = *length_p;
5644 /* Handle the start of a <tvar> element. */
5647 traceframe_info_start_tvar (struct gdb_xml_parser *parser,
5648 const struct gdb_xml_element *element,
5650 VEC(gdb_xml_value_s) *attributes)
5652 struct traceframe_info *info = user_data;
5653 const char *id_attrib = xml_find_attribute (attributes, "id")->value;
5654 int id = gdb_xml_parse_ulongest (parser, id_attrib);
5656 VEC_safe_push (int, info->tvars, id);
5659 /* Discard the constructed trace frame info (if an error occurs). */
5662 free_result (void *p)
5664 struct traceframe_info *result = p;
5666 free_traceframe_info (result);
5669 /* The allowed elements and attributes for an XML memory map. */
5671 static const struct gdb_xml_attribute memory_attributes[] = {
5672 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
5673 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
5674 { NULL, GDB_XML_AF_NONE, NULL, NULL }
5677 static const struct gdb_xml_attribute tvar_attributes[] = {
5678 { "id", GDB_XML_AF_NONE, NULL, NULL },
5679 { NULL, GDB_XML_AF_NONE, NULL, NULL }
5682 static const struct gdb_xml_element traceframe_info_children[] = {
5683 { "memory", memory_attributes, NULL,
5684 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
5685 traceframe_info_start_memory, NULL },
5686 { "tvar", tvar_attributes, NULL,
5687 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
5688 traceframe_info_start_tvar, NULL },
5689 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
5692 static const struct gdb_xml_element traceframe_info_elements[] = {
5693 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
5695 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
5698 /* Parse a traceframe-info XML document. */
5700 struct traceframe_info *
5701 parse_traceframe_info (const char *tframe_info)
5703 struct traceframe_info *result;
5704 struct cleanup *back_to;
5706 result = XCNEW (struct traceframe_info);
5707 back_to = make_cleanup (free_result, result);
5709 if (gdb_xml_parse_quick (_("trace frame info"),
5710 "traceframe-info.dtd", traceframe_info_elements,
5711 tframe_info, result) == 0)
5713 /* Parsed successfully, keep the result. */
5714 discard_cleanups (back_to);
5719 do_cleanups (back_to);
5723 #endif /* HAVE_LIBEXPAT */
5725 /* Returns the traceframe_info object for the current traceframe.
5726 This is where we avoid re-fetching the object from the target if we
5727 already have it cached. */
5729 struct traceframe_info *
5730 get_traceframe_info (void)
5732 if (traceframe_info == NULL)
5733 traceframe_info = target_traceframe_info ();
5735 return traceframe_info;
5738 /* If the target supports the query, return in RESULT the set of
5739 collected memory in the current traceframe, found within the LEN
5740 bytes range starting at MEMADDR. Returns true if the target
5741 supports the query, otherwise returns false, and RESULT is left
5745 traceframe_available_memory (VEC(mem_range_s) **result,
5746 CORE_ADDR memaddr, ULONGEST len)
5748 struct traceframe_info *info = get_traceframe_info ();
5752 struct mem_range *r;
5757 for (i = 0; VEC_iterate (mem_range_s, info->memory, i, r); i++)
5758 if (mem_ranges_overlap (r->start, r->length, memaddr, len))
5760 ULONGEST lo1, hi1, lo2, hi2;
5761 struct mem_range *nr;
5764 hi1 = memaddr + len;
5767 hi2 = r->start + r->length;
5769 nr = VEC_safe_push (mem_range_s, *result, NULL);
5771 nr->start = max (lo1, lo2);
5772 nr->length = min (hi1, hi2) - nr->start;
5775 normalize_mem_ranges (*result);
5782 /* Implementation of `sdata' variable. */
5784 static const struct internalvar_funcs sdata_funcs =
5791 /* module initialization */
5793 _initialize_tracepoint (void)
5795 struct cmd_list_element *c;
5797 /* Explicitly create without lookup, since that tries to create a
5798 value with a void typed value, and when we get here, gdbarch
5799 isn't initialized yet. At this point, we're quite sure there
5800 isn't another convenience variable of the same name. */
5801 create_internalvar_type_lazy ("_sdata", &sdata_funcs, NULL);
5803 traceframe_number = -1;
5804 tracepoint_number = -1;
5806 add_info ("scope", scope_info,
5807 _("List the variables local to a scope"));
5809 add_cmd ("tracepoints", class_trace, NULL,
5810 _("Tracing of program execution without stopping the program."),
5813 add_com ("tdump", class_trace, trace_dump_command,
5814 _("Print everything collected at the current tracepoint."));
5816 add_com ("tsave", class_trace, trace_save_command, _("\
5817 Save the trace data to a file.\n\
5818 Use the '-ctf' option to save the data to CTF format.\n\
5819 Use the '-r' option to direct the target to save directly to the file,\n\
5820 using its own filesystem."));
5822 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
5823 Define a trace state variable.\n\
5824 Argument is a $-prefixed name, optionally followed\n\
5825 by '=' and an expression that sets the initial value\n\
5826 at the start of tracing."));
5827 set_cmd_completer (c, expression_completer);
5829 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
5830 Delete one or more trace state variables.\n\
5831 Arguments are the names of the variables to delete.\n\
5832 If no arguments are supplied, delete all variables."), &deletelist);
5833 /* FIXME add a trace variable completer. */
5835 add_info ("tvariables", tvariables_info, _("\
5836 Status of trace state variables and their values.\n\
5839 add_info ("static-tracepoint-markers",
5840 info_static_tracepoint_markers_command, _("\
5841 List target static tracepoints markers.\n\
5844 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
5845 Select a trace frame;\n\
5846 No argument means forward by one frame; '-' means backward by one frame."),
5847 &tfindlist, "tfind ", 1, &cmdlist);
5849 add_cmd ("outside", class_trace, trace_find_outside_command, _("\
5850 Select a trace frame whose PC is outside the given range (exclusive).\n\
5851 Usage: tfind outside addr1, addr2"),
5854 add_cmd ("range", class_trace, trace_find_range_command, _("\
5855 Select a trace frame whose PC is in the given range (inclusive).\n\
5856 Usage: tfind range addr1,addr2"),
5859 add_cmd ("line", class_trace, trace_find_line_command, _("\
5860 Select a trace frame by source line.\n\
5861 Argument can be a line number (with optional source file),\n\
5862 a function name, or '*' followed by an address.\n\
5863 Default argument is 'the next source line that was traced'."),
5866 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
5867 Select a trace frame by tracepoint number.\n\
5868 Default is the tracepoint for the current trace frame."),
5871 add_cmd ("pc", class_trace, trace_find_pc_command, _("\
5872 Select a trace frame by PC.\n\
5873 Default is the current PC, or the PC of the current trace frame."),
5876 add_cmd ("end", class_trace, trace_find_end_command, _("\
5877 De-select any trace frame and resume 'live' debugging."),
5880 add_alias_cmd ("none", "end", class_trace, 0, &tfindlist);
5882 add_cmd ("start", class_trace, trace_find_start_command,
5883 _("Select the first trace frame in the trace buffer."),
5886 add_com ("tstatus", class_trace, trace_status_command,
5887 _("Display the status of the current trace data collection."));
5889 add_com ("tstop", class_trace, trace_stop_command, _("\
5890 Stop trace data collection.\n\
5891 Usage: tstop [ <notes> ... ]\n\
5892 Any arguments supplied are recorded with the trace as a stop reason and\n\
5893 reported by tstatus (if the target supports trace notes)."));
5895 add_com ("tstart", class_trace, trace_start_command, _("\
5896 Start trace data collection.\n\
5897 Usage: tstart [ <notes> ... ]\n\
5898 Any arguments supplied are recorded with the trace as a note and\n\
5899 reported by tstatus (if the target supports trace notes)."));
5901 add_com ("end", class_trace, end_actions_pseudocommand, _("\
5902 Ends a list of commands or actions.\n\
5903 Several GDB commands allow you to enter a list of commands or actions.\n\
5904 Entering \"end\" on a line by itself is the normal way to terminate\n\
5906 Note: the \"end\" command cannot be used at the gdb prompt."));
5908 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
5909 Specify single-stepping behavior at a tracepoint.\n\
5910 Argument is number of instructions to trace in single-step mode\n\
5911 following the tracepoint. This command is normally followed by\n\
5912 one or more \"collect\" commands, to specify what to collect\n\
5913 while single-stepping.\n\n\
5914 Note: this command can only be used in a tracepoint \"actions\" list."));
5916 add_com_alias ("ws", "while-stepping", class_alias, 0);
5917 add_com_alias ("stepping", "while-stepping", class_alias, 0);
5919 add_com ("collect", class_trace, collect_pseudocommand, _("\
5920 Specify one or more data items to be collected at a tracepoint.\n\
5921 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5922 collect all data (variables, registers) referenced by that expression.\n\
5923 Also accepts the following special arguments:\n\
5924 $regs -- all registers.\n\
5925 $args -- all function arguments.\n\
5926 $locals -- all variables local to the block/function scope.\n\
5927 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5928 Note: this command can only be used in a tracepoint \"actions\" list."));
5930 add_com ("teval", class_trace, teval_pseudocommand, _("\
5931 Specify one or more expressions to be evaluated at a tracepoint.\n\
5932 Accepts a comma-separated list of (one or more) expressions.\n\
5933 The result of each evaluation will be discarded.\n\
5934 Note: this command can only be used in a tracepoint \"actions\" list."));
5936 add_com ("actions", class_trace, trace_actions_command, _("\
5937 Specify the actions to be taken at a tracepoint.\n\
5938 Tracepoint actions may include collecting of specified data,\n\
5939 single-stepping, or enabling/disabling other tracepoints,\n\
5940 depending on target's capabilities."));
5942 default_collect = xstrdup ("");
5943 add_setshow_string_cmd ("default-collect", class_trace,
5944 &default_collect, _("\
5945 Set the list of expressions to collect by default"), _("\
5946 Show the list of expressions to collect by default"), NULL,
5948 &setlist, &showlist);
5950 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
5951 &disconnected_tracing, _("\
5952 Set whether tracing continues after GDB disconnects."), _("\
5953 Show whether tracing continues after GDB disconnects."), _("\
5954 Use this to continue a tracing run even if GDB disconnects\n\
5955 or detaches from the target. You can reconnect later and look at\n\
5956 trace data collected in the meantime."),
5957 set_disconnected_tracing,
5962 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
5963 &circular_trace_buffer, _("\
5964 Set target's use of circular trace buffer."), _("\
5965 Show target's use of circular trace buffer."), _("\
5966 Use this to make the trace buffer into a circular buffer,\n\
5967 which will discard traceframes (oldest first) instead of filling\n\
5968 up and stopping the trace run."),
5969 set_circular_trace_buffer,
5974 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class,
5975 &trace_buffer_size, _("\
5976 Set requested size of trace buffer."), _("\
5977 Show requested size of trace buffer."), _("\
5978 Use this to choose a size for the trace buffer. Some targets\n\
5979 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
5980 disables any attempt to set the buffer size and lets the target choose."),
5981 set_trace_buffer_size, NULL,
5982 &setlist, &showlist);
5984 add_setshow_string_cmd ("trace-user", class_trace,
5986 Set the user name to use for current and future trace runs"), _("\
5987 Show the user name to use for current and future trace runs"), NULL,
5988 set_trace_user, NULL,
5989 &setlist, &showlist);
5991 add_setshow_string_cmd ("trace-notes", class_trace,
5993 Set notes string to use for current and future trace runs"), _("\
5994 Show the notes string to use for current and future trace runs"), NULL,
5995 set_trace_notes, NULL,
5996 &setlist, &showlist);
5998 add_setshow_string_cmd ("trace-stop-notes", class_trace,
5999 &trace_stop_notes, _("\
6000 Set notes string to use for future tstop commands"), _("\
6001 Show the notes string to use for future tstop commands"), NULL,
6002 set_trace_stop_notes, NULL,
6003 &setlist, &showlist);
6007 add_target_with_completer (&tfile_ops, filename_completer);