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);
3232 if (ts->notes != NULL)
3234 char *buf = (char *) alloca (strlen (ts->notes) * 2 + 1);
3236 bin2hex ((gdb_byte *) ts->notes, buf, 0);
3237 fprintf (writer->fp, ";notes:%s", buf);
3239 if (ts->user_name != NULL)
3241 char *buf = (char *) alloca (strlen (ts->user_name) * 2 + 1);
3243 bin2hex ((gdb_byte *) ts->user_name, buf, 0);
3244 fprintf (writer->fp, ";username:%s", buf);
3246 fprintf (writer->fp, "\n");
3249 /* This is the implementation of trace_file_write_ops method
3250 write_uploaded_tsv. */
3253 tfile_write_uploaded_tsv (struct trace_file_writer *self,
3254 struct uploaded_tsv *utsv)
3257 struct tfile_trace_file_writer *writer
3258 = (struct tfile_trace_file_writer *) self;
3262 buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
3263 bin2hex ((gdb_byte *) (utsv->name), buf, 0);
3266 fprintf (writer->fp, "tsv %x:%s:%x:%s\n",
3267 utsv->number, phex_nz (utsv->initial_value, 8),
3268 utsv->builtin, buf);
3274 #define MAX_TRACE_UPLOAD 2000
3276 /* This is the implementation of trace_file_write_ops method
3277 write_uploaded_tp. */
3280 tfile_write_uploaded_tp (struct trace_file_writer *self,
3281 struct uploaded_tp *utp)
3283 struct tfile_trace_file_writer *writer
3284 = (struct tfile_trace_file_writer *) self;
3287 char buf[MAX_TRACE_UPLOAD];
3289 fprintf (writer->fp, "tp T%x:%s:%c:%x:%x",
3290 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
3291 (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
3292 if (utp->type == bp_fast_tracepoint)
3293 fprintf (writer->fp, ":F%x", utp->orig_size);
3295 fprintf (writer->fp,
3296 ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
3298 fprintf (writer->fp, "\n");
3299 for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
3300 fprintf (writer->fp, "tp A%x:%s:%s\n",
3301 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
3302 for (a = 0; VEC_iterate (char_ptr, utp->step_actions, a, act); ++a)
3303 fprintf (writer->fp, "tp S%x:%s:%s\n",
3304 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
3307 encode_source_string (utp->number, utp->addr,
3308 "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
3309 fprintf (writer->fp, "tp Z%s\n", buf);
3311 if (utp->cond_string)
3313 encode_source_string (utp->number, utp->addr,
3314 "cond", utp->cond_string,
3315 buf, MAX_TRACE_UPLOAD);
3316 fprintf (writer->fp, "tp Z%s\n", buf);
3318 for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
3320 encode_source_string (utp->number, utp->addr, "cmd", act,
3321 buf, MAX_TRACE_UPLOAD);
3322 fprintf (writer->fp, "tp Z%s\n", buf);
3324 fprintf (writer->fp, "tp V%x:%s:%x:%s\n",
3325 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
3327 phex_nz (utp->traceframe_usage,
3328 sizeof (utp->traceframe_usage)));
3331 /* This is the implementation of trace_file_write_ops method
3332 write_definition_end. */
3335 tfile_write_definition_end (struct trace_file_writer *self)
3337 struct tfile_trace_file_writer *writer
3338 = (struct tfile_trace_file_writer *) self;
3340 fprintf (writer->fp, "\n");
3343 /* This is the implementation of trace_file_write_ops method
3347 tfile_write_raw_data (struct trace_file_writer *self, gdb_byte *buf,
3350 struct tfile_trace_file_writer *writer
3351 = (struct tfile_trace_file_writer *) self;
3353 if (fwrite (buf, len, 1, writer->fp) < 1)
3354 perror_with_name (writer->pathname);
3357 /* This is the implementation of trace_file_write_ops method
3361 tfile_end (struct trace_file_writer *self)
3363 struct tfile_trace_file_writer *writer
3364 = (struct tfile_trace_file_writer *) self;
3365 uint32_t gotten = 0;
3367 /* Mark the end of trace data. */
3368 if (fwrite (&gotten, 4, 1, writer->fp) < 1)
3369 perror_with_name (writer->pathname);
3372 /* Operations to write trace buffers into TFILE format. */
3374 static const struct trace_file_write_ops tfile_write_ops =
3380 tfile_write_regblock_type,
3382 tfile_write_uploaded_tsv,
3383 tfile_write_uploaded_tp,
3384 tfile_write_definition_end,
3385 tfile_write_raw_data,
3390 /* Helper macros. */
3392 #define TRACE_WRITE_R_BLOCK(writer, buf, size) \
3393 writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
3394 #define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
3395 writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
3397 #define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
3398 writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
3400 #define TRACE_WRITE_V_BLOCK(writer, num, val) \
3401 writer->ops->frame_ops->write_v_block ((writer), (num), (val))
3403 /* Save tracepoint data to file named FILENAME through WRITER. WRITER
3404 determines the trace file format. If TARGET_DOES_SAVE is non-zero,
3405 the save is performed on the target, otherwise GDB obtains all trace
3406 data and saves it locally. */
3409 trace_save (const char *filename, struct trace_file_writer *writer,
3410 int target_does_save)
3412 struct trace_status *ts = current_trace_status ();
3414 struct uploaded_tp *uploaded_tps = NULL, *utp;
3415 struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
3417 ULONGEST offset = 0;
3418 gdb_byte buf[MAX_TRACE_UPLOAD];
3419 #define MAX_TRACE_UPLOAD 2000
3421 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
3423 /* If the target is to save the data to a file on its own, then just
3424 send the command and be done with it. */
3425 if (target_does_save)
3427 if (!writer->ops->target_save (writer, filename))
3428 error (_("Target failed to save trace data to '%s'."),
3433 /* Get the trace status first before opening the file, so if the
3434 target is losing, we can get out without touching files. */
3435 status = target_get_trace_status (ts);
3437 writer->ops->start (writer, filename);
3439 writer->ops->write_header (writer);
3441 /* Write descriptive info. */
3443 /* Write out the size of a register block. */
3444 writer->ops->write_regblock_type (writer, trace_regblock_size);
3446 /* Write out status of the tracing run (aka "tstatus" info). */
3447 writer->ops->write_status (writer, ts);
3449 /* Note that we want to upload tracepoints and save those, rather
3450 than simply writing out the local ones, because the user may have
3451 changed tracepoints in GDB in preparation for a future tracing
3452 run, or maybe just mass-deleted all types of breakpoints as part
3453 of cleaning up. So as not to contaminate the session, leave the
3454 data in its uploaded form, don't make into real tracepoints. */
3456 /* Get trace state variables first, they may be checked when parsing
3457 uploaded commands. */
3459 target_upload_trace_state_variables (&uploaded_tsvs);
3461 for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
3462 writer->ops->write_uploaded_tsv (writer, utsv);
3464 free_uploaded_tsvs (&uploaded_tsvs);
3466 target_upload_tracepoints (&uploaded_tps);
3468 for (utp = uploaded_tps; utp; utp = utp->next)
3469 target_get_tracepoint_status (NULL, utp);
3471 for (utp = uploaded_tps; utp; utp = utp->next)
3472 writer->ops->write_uploaded_tp (writer, utp);
3474 free_uploaded_tps (&uploaded_tps);
3476 /* Mark the end of the definition section. */
3477 writer->ops->write_definition_end (writer);
3479 /* Get and write the trace data proper. */
3484 /* The writer supports writing the contents of trace buffer
3485 directly to trace file. Don't parse the contents of trace
3487 if (writer->ops->write_trace_buffer != NULL)
3489 /* We ask for big blocks, in the hopes of efficiency, but
3490 will take less if the target has packet size limitations
3492 gotten = target_get_raw_trace_data (buf, offset,
3495 error (_("Failure to get requested trace buffer data"));
3496 /* No more data is forthcoming, we're done. */
3500 writer->ops->write_trace_buffer (writer, buf, gotten);
3508 /* Parse the trace buffers according to how data are stored
3509 in trace buffer in GDBserver. */
3511 gotten = target_get_raw_trace_data (buf, offset, 6);
3516 /* Read the first six bytes in, which is the tracepoint
3517 number and trace frame size. */
3519 extract_unsigned_integer (&buf[0], 2, byte_order);
3521 tf_size = (uint32_t)
3522 extract_unsigned_integer (&buf[2], 4, byte_order);
3524 writer->ops->frame_ops->start (writer, tp_num);
3533 for (block = 0; block < tf_size; )
3535 gdb_byte block_type;
3537 /* We'll fetch one block each time, in order to
3538 handle the extremely large 'M' block. We first
3539 fetch one byte to get the type of the block. */
3540 gotten = target_get_raw_trace_data (buf, offset, 1);
3542 error (_("Failure to get requested trace buffer data"));
3548 block_type = buf[0];
3553 = target_get_raw_trace_data (buf, offset,
3554 trace_regblock_size);
3555 if (gotten < trace_regblock_size)
3556 error (_("Failure to get requested trace"
3559 TRACE_WRITE_R_BLOCK (writer, buf,
3560 trace_regblock_size);
3564 unsigned short mlen;
3569 t = target_get_raw_trace_data (buf,offset, 10);
3571 error (_("Failure to get requested trace"
3579 extract_unsigned_integer (buf, 8,
3581 mlen = (unsigned short)
3582 extract_unsigned_integer (&buf[8], 2,
3585 TRACE_WRITE_M_BLOCK_HEADER (writer, addr,
3588 /* The memory contents in 'M' block may be
3589 very large. Fetch the data from the target
3590 and write them into file one by one. */
3591 for (j = 0; j < mlen; )
3593 unsigned int read_length;
3595 if (mlen - j > MAX_TRACE_UPLOAD)
3596 read_length = MAX_TRACE_UPLOAD;
3598 read_length = mlen - j;
3600 t = target_get_raw_trace_data (buf,
3603 if (t < read_length)
3604 error (_("Failure to get requested"
3605 " trace buffer data"));
3607 TRACE_WRITE_M_BLOCK_MEMORY (writer, buf,
3611 gotten += read_length;
3622 = target_get_raw_trace_data (buf, offset,
3625 error (_("Failure to get requested"
3626 " trace buffer data"));
3628 vnum = (int) extract_signed_integer (buf,
3632 = extract_signed_integer (&buf[4], 8,
3635 TRACE_WRITE_V_BLOCK (writer, vnum, val);
3639 error (_("Unknown block type '%c' (0x%x) in"
3641 block_type, block_type);
3651 writer->ops->frame_ops->end (writer);
3655 writer->ops->end (writer);
3658 /* Return a trace writer for TFILE format. */
3660 static struct trace_file_writer *
3661 tfile_trace_file_writer_new (void)
3663 struct tfile_trace_file_writer *writer
3664 = xmalloc (sizeof (struct tfile_trace_file_writer));
3666 writer->base.ops = &tfile_write_ops;
3668 writer->pathname = NULL;
3670 return (struct trace_file_writer *) writer;
3674 trace_save_command (char *args, int from_tty)
3676 int target_does_save = 0;
3678 char *filename = NULL;
3679 struct cleanup *back_to;
3680 int generate_ctf = 0;
3681 struct trace_file_writer *writer = NULL;
3684 error_no_arg (_("file in which to save trace data"));
3686 argv = gdb_buildargv (args);
3687 back_to = make_cleanup_freeargv (argv);
3689 for (; *argv; ++argv)
3691 if (strcmp (*argv, "-r") == 0)
3692 target_does_save = 1;
3693 if (strcmp (*argv, "-ctf") == 0)
3695 else if (**argv == '-')
3696 error (_("unknown option `%s'"), *argv);
3702 error_no_arg (_("file in which to save trace data"));
3705 writer = ctf_trace_file_writer_new ();
3707 writer = tfile_trace_file_writer_new ();
3709 make_cleanup (trace_file_writer_xfree, writer);
3711 trace_save (filename, writer, target_does_save);
3714 printf_filtered (_("Trace data saved to %s '%s'.\n"),
3715 generate_ctf ? "directory" : "file", filename);
3717 do_cleanups (back_to);
3720 /* Save the trace data to file FILENAME of tfile format. */
3723 trace_save_tfile (const char *filename, int target_does_save)
3725 struct trace_file_writer *writer;
3726 struct cleanup *back_to;
3728 writer = tfile_trace_file_writer_new ();
3729 back_to = make_cleanup (trace_file_writer_xfree, writer);
3730 trace_save (filename, writer, target_does_save);
3731 do_cleanups (back_to);
3734 /* Save the trace data to dir DIRNAME of ctf format. */
3737 trace_save_ctf (const char *dirname, int target_does_save)
3739 struct trace_file_writer *writer;
3740 struct cleanup *back_to;
3742 writer = ctf_trace_file_writer_new ();
3743 back_to = make_cleanup (trace_file_writer_xfree, writer);
3745 trace_save (dirname, writer, target_does_save);
3746 do_cleanups (back_to);
3749 /* Tell the target what to do with an ongoing tracing run if GDB
3750 disconnects for some reason. */
3753 set_disconnected_tracing (char *args, int from_tty,
3754 struct cmd_list_element *c)
3756 target_set_disconnected_tracing (disconnected_tracing);
3760 set_circular_trace_buffer (char *args, int from_tty,
3761 struct cmd_list_element *c)
3763 target_set_circular_trace_buffer (circular_trace_buffer);
3767 set_trace_buffer_size (char *args, int from_tty,
3768 struct cmd_list_element *c)
3770 target_set_trace_buffer_size (trace_buffer_size);
3774 set_trace_user (char *args, int from_tty,
3775 struct cmd_list_element *c)
3779 ret = target_set_trace_notes (trace_user, NULL, NULL);
3782 warning (_("Target does not support trace notes, user ignored"));
3786 set_trace_notes (char *args, int from_tty,
3787 struct cmd_list_element *c)
3791 ret = target_set_trace_notes (NULL, trace_notes, NULL);
3794 warning (_("Target does not support trace notes, note ignored"));
3798 set_trace_stop_notes (char *args, int from_tty,
3799 struct cmd_list_element *c)
3803 ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
3806 warning (_("Target does not support trace notes, stop note ignored"));
3809 /* Convert the memory pointed to by mem into hex, placing result in buf.
3810 * Return a pointer to the last char put in buf (null)
3811 * "stolen" from sparc-stub.c
3814 static const char hexchars[] = "0123456789abcdef";
3817 mem2hex (gdb_byte *mem, char *buf, int count)
3825 *buf++ = hexchars[ch >> 4];
3826 *buf++ = hexchars[ch & 0xf];
3835 get_traceframe_number (void)
3837 return traceframe_number;
3841 get_tracepoint_number (void)
3843 return tracepoint_number;
3846 /* Make the traceframe NUM be the current trace frame. Does nothing
3847 if NUM is already current. */
3850 set_current_traceframe (int num)
3854 if (traceframe_number == num)
3856 /* Nothing to do. */
3860 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
3863 warning (_("could not change traceframe"));
3865 set_traceframe_num (newnum);
3867 /* Changing the traceframe changes our view of registers and of the
3869 registers_changed ();
3871 clear_traceframe_info ();
3874 /* Make the traceframe NUM be the current trace frame, and do nothing
3878 set_traceframe_number (int num)
3880 traceframe_number = num;
3883 /* A cleanup used when switching away and back from tfind mode. */
3885 struct current_traceframe_cleanup
3887 /* The traceframe we were inspecting. */
3888 int traceframe_number;
3892 do_restore_current_traceframe_cleanup (void *arg)
3894 struct current_traceframe_cleanup *old = arg;
3896 set_current_traceframe (old->traceframe_number);
3900 restore_current_traceframe_cleanup_dtor (void *arg)
3902 struct current_traceframe_cleanup *old = arg;
3908 make_cleanup_restore_current_traceframe (void)
3910 struct current_traceframe_cleanup *old;
3912 old = xmalloc (sizeof (struct current_traceframe_cleanup));
3913 old->traceframe_number = traceframe_number;
3915 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
3916 restore_current_traceframe_cleanup_dtor);
3920 make_cleanup_restore_traceframe_number (void)
3922 return make_cleanup_restore_integer (&traceframe_number);
3925 /* Given a number and address, return an uploaded tracepoint with that
3926 number, creating if necessary. */
3928 struct uploaded_tp *
3929 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
3931 struct uploaded_tp *utp;
3933 for (utp = *utpp; utp; utp = utp->next)
3934 if (utp->number == num && utp->addr == addr)
3936 utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
3937 memset (utp, 0, sizeof (struct uploaded_tp));
3940 utp->actions = NULL;
3941 utp->step_actions = NULL;
3942 utp->cmd_strings = NULL;
3949 free_uploaded_tps (struct uploaded_tp **utpp)
3951 struct uploaded_tp *next_one;
3955 next_one = (*utpp)->next;
3961 /* Given a number and address, return an uploaded tracepoint with that
3962 number, creating if necessary. */
3964 struct uploaded_tsv *
3965 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3967 struct uploaded_tsv *utsv;
3969 for (utsv = *utsvp; utsv; utsv = utsv->next)
3970 if (utsv->number == num)
3972 utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
3973 memset (utsv, 0, sizeof (struct uploaded_tsv));
3975 utsv->next = *utsvp;
3981 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3983 struct uploaded_tsv *next_one;
3987 next_one = (*utsvp)->next;
3993 /* FIXME this function is heuristic and will miss the cases where the
3994 conditional is semantically identical but differs in whitespace,
3995 such as "x == 0" vs "x==0". */
3998 cond_string_is_same (char *str1, char *str2)
4000 if (str1 == NULL || str2 == NULL)
4001 return (str1 == str2);
4003 return (strcmp (str1, str2) == 0);
4006 /* Look for an existing tracepoint that seems similar enough to the
4007 uploaded one. Enablement isn't compared, because the user can
4008 toggle that freely, and may have done so in anticipation of the
4009 next trace run. Return the location of matched tracepoint. */
4011 static struct bp_location *
4012 find_matching_tracepoint_location (struct uploaded_tp *utp)
4014 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
4016 struct breakpoint *b;
4017 struct bp_location *loc;
4019 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
4021 struct tracepoint *t = (struct tracepoint *) b;
4023 if (b->type == utp->type
4024 && t->step_count == utp->step
4025 && t->pass_count == utp->pass
4026 && cond_string_is_same (t->base.cond_string, utp->cond_string)
4027 /* FIXME also test actions. */
4030 /* Scan the locations for an address match. */
4031 for (loc = b->loc; loc; loc = loc->next)
4033 if (loc->address == utp->addr)
4041 /* Given a list of tracepoints uploaded from a target, attempt to
4042 match them up with existing tracepoints, and create new ones if not
4046 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
4048 struct uploaded_tp *utp;
4049 /* A set of tracepoints which are modified. */
4050 VEC(breakpoint_p) *modified_tp = NULL;
4052 struct breakpoint *b;
4054 /* Look for GDB tracepoints that match up with our uploaded versions. */
4055 for (utp = *uploaded_tps; utp; utp = utp->next)
4057 struct bp_location *loc;
4058 struct tracepoint *t;
4060 loc = find_matching_tracepoint_location (utp);
4065 /* Mark this location as already inserted. */
4067 t = (struct tracepoint *) loc->owner;
4068 printf_filtered (_("Assuming tracepoint %d is same "
4069 "as target's tracepoint %d at %s.\n"),
4070 loc->owner->number, utp->number,
4071 paddress (loc->gdbarch, utp->addr));
4073 /* The tracepoint LOC->owner was modified (the location LOC
4074 was marked as inserted in the target). Save it in
4075 MODIFIED_TP if not there yet. The 'breakpoint-modified'
4076 observers will be notified later once for each tracepoint
4077 saved in MODIFIED_TP. */
4079 VEC_iterate (breakpoint_p, modified_tp, ix, b);
4081 if (b == loc->owner)
4087 VEC_safe_push (breakpoint_p, modified_tp, loc->owner);
4091 t = create_tracepoint_from_upload (utp);
4093 printf_filtered (_("Created tracepoint %d for "
4094 "target's tracepoint %d at %s.\n"),
4095 t->base.number, utp->number,
4096 paddress (get_current_arch (), utp->addr));
4098 printf_filtered (_("Failed to create tracepoint for target's "
4099 "tracepoint %d at %s, skipping it.\n"),
4101 paddress (get_current_arch (), utp->addr));
4103 /* Whether found or created, record the number used by the
4104 target, to help with mapping target tracepoints back to their
4105 counterparts here. */
4107 t->number_on_target = utp->number;
4110 /* Notify 'breakpoint-modified' observer that at least one of B's
4111 locations was changed. */
4112 for (ix = 0; VEC_iterate (breakpoint_p, modified_tp, ix, b); ix++)
4113 observer_notify_breakpoint_modified (b);
4115 VEC_free (breakpoint_p, modified_tp);
4116 free_uploaded_tps (uploaded_tps);
4119 /* Trace state variables don't have much to identify them beyond their
4120 name, so just use that to detect matches. */
4122 static struct trace_state_variable *
4123 find_matching_tsv (struct uploaded_tsv *utsv)
4128 return find_trace_state_variable (utsv->name);
4131 static struct trace_state_variable *
4132 create_tsv_from_upload (struct uploaded_tsv *utsv)
4134 const char *namebase;
4137 struct trace_state_variable *tsv;
4138 struct cleanup *old_chain;
4142 namebase = utsv->name;
4143 buf = xstrprintf ("%s", namebase);
4148 buf = xstrprintf ("%s_%d", namebase, try_num++);
4151 /* Fish for a name that is not in use. */
4152 /* (should check against all internal vars?) */
4153 while (find_trace_state_variable (buf))
4156 buf = xstrprintf ("%s_%d", namebase, try_num++);
4159 old_chain = make_cleanup (xfree, buf);
4161 /* We have an available name, create the variable. */
4162 tsv = create_trace_state_variable (buf);
4163 tsv->initial_value = utsv->initial_value;
4164 tsv->builtin = utsv->builtin;
4166 observer_notify_tsv_created (tsv);
4168 do_cleanups (old_chain);
4173 /* Given a list of uploaded trace state variables, try to match them
4174 up with existing variables, or create additional ones. */
4177 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
4180 struct uploaded_tsv *utsv;
4181 struct trace_state_variable *tsv;
4184 /* Most likely some numbers will have to be reassigned as part of
4185 the merge, so clear them all in anticipation. */
4186 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
4189 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
4191 tsv = find_matching_tsv (utsv);
4195 printf_filtered (_("Assuming trace state variable $%s "
4196 "is same as target's variable %d.\n"),
4197 tsv->name, utsv->number);
4201 tsv = create_tsv_from_upload (utsv);
4203 printf_filtered (_("Created trace state variable "
4204 "$%s for target's variable %d.\n"),
4205 tsv->name, utsv->number);
4207 /* Give precedence to numberings that come from the target. */
4209 tsv->number = utsv->number;
4212 /* Renumber everything that didn't get a target-assigned number. */
4214 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
4215 if (tsv->number > highest)
4216 highest = tsv->number;
4219 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
4220 if (tsv->number == 0)
4221 tsv->number = highest++;
4223 free_uploaded_tsvs (uploaded_tsvs);
4226 /* target tfile command */
4228 static struct target_ops tfile_ops;
4230 /* Fill in tfile_ops with its defined operations and properties. */
4232 #define TRACE_HEADER_SIZE 8
4234 static char *trace_filename;
4235 static int trace_fd = -1;
4236 static off_t trace_frames_offset;
4237 static off_t cur_offset;
4238 static int cur_data_size;
4239 int trace_regblock_size;
4241 static void tfile_interp_line (char *line,
4242 struct uploaded_tp **utpp,
4243 struct uploaded_tsv **utsvp);
4245 /* Read SIZE bytes into READBUF from the trace frame, starting at
4246 TRACE_FD's current position. Note that this call `read'
4247 underneath, hence it advances the file's seek position. Throws an
4248 error if the `read' syscall fails, or less than SIZE bytes are
4252 tfile_read (gdb_byte *readbuf, int size)
4256 gotten = read (trace_fd, readbuf, size);
4258 perror_with_name (trace_filename);
4259 else if (gotten < size)
4260 error (_("Premature end of file while reading trace file"));
4264 tfile_open (char *filename, int from_tty)
4266 volatile struct gdb_exception ex;
4268 struct cleanup *old_chain;
4271 char header[TRACE_HEADER_SIZE];
4272 char linebuf[1000]; /* Should be max remote packet size or so. */
4275 struct trace_status *ts;
4276 struct uploaded_tp *uploaded_tps = NULL;
4277 struct uploaded_tsv *uploaded_tsvs = NULL;
4279 target_preopen (from_tty);
4281 error (_("No trace file specified."));
4283 filename = tilde_expand (filename);
4284 if (!IS_ABSOLUTE_PATH(filename))
4286 temp = concat (current_directory, "/", filename, (char *) NULL);
4291 old_chain = make_cleanup (xfree, filename);
4293 flags = O_BINARY | O_LARGEFILE;
4295 scratch_chan = gdb_open_cloexec (filename, flags, 0);
4296 if (scratch_chan < 0)
4297 perror_with_name (filename);
4299 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
4301 discard_cleanups (old_chain); /* Don't free filename any more. */
4302 unpush_target (&tfile_ops);
4304 trace_filename = xstrdup (filename);
4305 trace_fd = scratch_chan;
4308 /* Read the file header and test for validity. */
4309 tfile_read ((gdb_byte *) &header, TRACE_HEADER_SIZE);
4311 bytes += TRACE_HEADER_SIZE;
4312 if (!(header[0] == 0x7f
4313 && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
4314 error (_("File is not a valid trace file."));
4316 push_target (&tfile_ops);
4318 trace_regblock_size = 0;
4319 ts = current_trace_status ();
4320 /* We know we're working with a file. Record its name. */
4321 ts->filename = trace_filename;
4322 /* Set defaults in case there is no status line. */
4323 ts->running_known = 0;
4324 ts->stop_reason = trace_stop_reason_unknown;
4325 ts->traceframe_count = -1;
4326 ts->buffer_free = 0;
4327 ts->disconnected_tracing = 0;
4328 ts->circular_buffer = 0;
4330 TRY_CATCH (ex, RETURN_MASK_ALL)
4332 /* Read through a section of newline-terminated lines that
4333 define things like tracepoints. */
4337 tfile_read (&byte, 1);
4342 /* Empty line marks end of the definition section. */
4347 tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
4350 linebuf[i++] = byte;
4352 error (_("Excessively long lines in trace file"));
4355 /* Record the starting offset of the binary trace data. */
4356 trace_frames_offset = bytes;
4358 /* If we don't have a blocksize, we can't interpret the
4360 if (trace_regblock_size == 0)
4361 error (_("No register block size recorded in trace file"));
4365 /* Pop the partially set up target. */
4367 throw_exception (ex);
4370 if (ts->traceframe_count <= 0)
4371 warning (_("No traceframes present in this file."));
4373 /* Add the file's tracepoints and variables into the current mix. */
4375 /* Get trace state variables first, they may be checked when parsing
4376 uploaded commands. */
4377 merge_uploaded_trace_state_variables (&uploaded_tsvs);
4379 merge_uploaded_tracepoints (&uploaded_tps);
4382 /* Interpret the given line from the definitions part of the trace
4386 tfile_interp_line (char *line, struct uploaded_tp **utpp,
4387 struct uploaded_tsv **utsvp)
4391 if (strncmp (p, "R ", strlen ("R ")) == 0)
4394 trace_regblock_size = strtol (p, &p, 16);
4396 else if (strncmp (p, "status ", strlen ("status ")) == 0)
4398 p += strlen ("status ");
4399 parse_trace_status (p, current_trace_status ());
4401 else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
4403 p += strlen ("tp ");
4404 parse_tracepoint_definition (p, utpp);
4406 else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
4408 p += strlen ("tsv ");
4409 parse_tsv_definition (p, utsvp);
4412 warning (_("Ignoring trace file definition \"%s\""), line);
4415 /* Parse the part of trace status syntax that is shared between
4416 the remote protocol and the trace file reader. */
4419 parse_trace_status (char *line, struct trace_status *ts)
4421 char *p = line, *p1, *p2, *p3, *p_temp;
4425 ts->running_known = 1;
4426 ts->running = (*p++ == '1');
4427 ts->stop_reason = trace_stop_reason_unknown;
4428 xfree (ts->stop_desc);
4429 ts->stop_desc = NULL;
4430 ts->traceframe_count = -1;
4431 ts->traceframes_created = -1;
4432 ts->buffer_free = -1;
4433 ts->buffer_size = -1;
4434 ts->disconnected_tracing = 0;
4435 ts->circular_buffer = 0;
4436 xfree (ts->user_name);
4437 ts->user_name = NULL;
4440 ts->start_time = ts->stop_time = 0;
4444 p1 = strchr (p, ':');
4446 error (_("Malformed trace status, at %s\n\
4447 Status line: '%s'\n"), p, line);
4448 p3 = strchr (p, ';');
4450 p3 = p + strlen (p);
4451 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
4453 p = unpack_varlen_hex (++p1, &val);
4454 ts->stop_reason = trace_buffer_full;
4456 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
4458 p = unpack_varlen_hex (++p1, &val);
4459 ts->stop_reason = trace_never_run;
4461 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
4464 p = unpack_varlen_hex (++p1, &val);
4465 ts->stop_reason = tracepoint_passcount;
4466 ts->stopping_tracepoint = val;
4468 else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
4470 p2 = strchr (++p1, ':');
4478 ts->stop_desc = xmalloc (strlen (line));
4479 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
4480 ts->stop_desc[end] = '\0';
4483 ts->stop_desc = xstrdup ("");
4485 p = unpack_varlen_hex (++p2, &val);
4486 ts->stop_reason = tstop_command;
4488 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
4490 p = unpack_varlen_hex (++p1, &val);
4491 ts->stop_reason = trace_disconnected;
4493 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
4495 p2 = strchr (++p1, ':');
4498 ts->stop_desc = xmalloc ((p2 - p1) / 2 + 1);
4499 end = hex2bin (p1, (gdb_byte *) ts->stop_desc, (p2 - p1) / 2);
4500 ts->stop_desc[end] = '\0';
4503 ts->stop_desc = xstrdup ("");
4505 p = unpack_varlen_hex (++p2, &val);
4506 ts->stopping_tracepoint = val;
4507 ts->stop_reason = tracepoint_error;
4509 else if (strncmp (p, "tframes", p1 - p) == 0)
4511 p = unpack_varlen_hex (++p1, &val);
4512 ts->traceframe_count = val;
4514 else if (strncmp (p, "tcreated", p1 - p) == 0)
4516 p = unpack_varlen_hex (++p1, &val);
4517 ts->traceframes_created = val;
4519 else if (strncmp (p, "tfree", p1 - p) == 0)
4521 p = unpack_varlen_hex (++p1, &val);
4522 ts->buffer_free = val;
4524 else if (strncmp (p, "tsize", p1 - p) == 0)
4526 p = unpack_varlen_hex (++p1, &val);
4527 ts->buffer_size = val;
4529 else if (strncmp (p, "disconn", p1 - p) == 0)
4531 p = unpack_varlen_hex (++p1, &val);
4532 ts->disconnected_tracing = val;
4534 else if (strncmp (p, "circular", p1 - p) == 0)
4536 p = unpack_varlen_hex (++p1, &val);
4537 ts->circular_buffer = val;
4539 else if (strncmp (p, "starttime", p1 - p) == 0)
4541 p = unpack_varlen_hex (++p1, &val);
4542 ts->start_time = val;
4544 else if (strncmp (p, "stoptime", p1 - p) == 0)
4546 p = unpack_varlen_hex (++p1, &val);
4547 ts->stop_time = val;
4549 else if (strncmp (p, "username", p1 - p) == 0)
4552 ts->user_name = xmalloc (strlen (p) / 2);
4553 end = hex2bin (p1, (gdb_byte *) ts->user_name, (p3 - p1) / 2);
4554 ts->user_name[end] = '\0';
4557 else if (strncmp (p, "notes", p1 - p) == 0)
4560 ts->notes = xmalloc (strlen (p) / 2);
4561 end = hex2bin (p1, (gdb_byte *) ts->notes, (p3 - p1) / 2);
4562 ts->notes[end] = '\0';
4567 /* Silently skip unknown optional info. */
4568 p_temp = strchr (p1 + 1, ';');
4572 /* Must be at the end. */
4579 parse_tracepoint_status (char *p, struct breakpoint *bp,
4580 struct uploaded_tp *utp)
4583 struct tracepoint *tp = (struct tracepoint *) bp;
4585 p = unpack_varlen_hex (p, &uval);
4587 tp->base.hit_count += uval;
4589 utp->hit_count += uval;
4590 p = unpack_varlen_hex (p + 1, &uval);
4592 tp->traceframe_usage += uval;
4594 utp->traceframe_usage += uval;
4595 /* Ignore any extra, allowing for future extensions. */
4598 /* Given a line of text defining a part of a tracepoint, parse it into
4599 an "uploaded tracepoint". */
4602 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
4606 ULONGEST num, addr, step, pass, orig_size, xlen, start;
4609 char *cond, *srctype, *buf;
4610 struct uploaded_tp *utp = NULL;
4613 /* Both tracepoint and action definitions start with the same number
4614 and address sequence. */
4616 p = unpack_varlen_hex (p, &num);
4617 p++; /* skip a colon */
4618 p = unpack_varlen_hex (p, &addr);
4619 p++; /* skip a colon */
4622 enabled = (*p++ == 'E');
4623 p++; /* skip a colon */
4624 p = unpack_varlen_hex (p, &step);
4625 p++; /* skip a colon */
4626 p = unpack_varlen_hex (p, &pass);
4627 type = bp_tracepoint;
4629 /* Thumb through optional fields. */
4632 p++; /* skip a colon */
4635 type = bp_fast_tracepoint;
4637 p = unpack_varlen_hex (p, &orig_size);
4641 type = bp_static_tracepoint;
4647 p = unpack_varlen_hex (p, &xlen);
4648 p++; /* skip a comma */
4649 cond = (char *) xmalloc (2 * xlen + 1);
4650 strncpy (cond, p, 2 * xlen);
4651 cond[2 * xlen] = '\0';
4655 warning (_("Unrecognized char '%c' in tracepoint "
4656 "definition, skipping rest"), *p);
4658 utp = get_uploaded_tp (num, addr, utpp);
4660 utp->enabled = enabled;
4665 else if (piece == 'A')
4667 utp = get_uploaded_tp (num, addr, utpp);
4668 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
4670 else if (piece == 'S')
4672 utp = get_uploaded_tp (num, addr, utpp);
4673 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
4675 else if (piece == 'Z')
4677 /* Parse a chunk of source form definition. */
4678 utp = get_uploaded_tp (num, addr, utpp);
4680 p = strchr (p, ':');
4681 p++; /* skip a colon */
4682 p = unpack_varlen_hex (p, &start);
4683 p++; /* skip a colon */
4684 p = unpack_varlen_hex (p, &xlen);
4685 p++; /* skip a colon */
4687 buf = alloca (strlen (line));
4689 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
4692 if (strncmp (srctype, "at:", strlen ("at:")) == 0)
4693 utp->at_string = xstrdup (buf);
4694 else if (strncmp (srctype, "cond:", strlen ("cond:")) == 0)
4695 utp->cond_string = xstrdup (buf);
4696 else if (strncmp (srctype, "cmd:", strlen ("cmd:")) == 0)
4697 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
4699 else if (piece == 'V')
4701 utp = get_uploaded_tp (num, addr, utpp);
4703 parse_tracepoint_status (p, NULL, utp);
4707 /* Don't error out, the target might be sending us optional
4708 info that we don't care about. */
4709 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
4713 /* Convert a textual description of a trace state variable into an
4717 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
4720 ULONGEST num, initval, builtin;
4722 struct uploaded_tsv *utsv = NULL;
4724 buf = alloca (strlen (line));
4727 p = unpack_varlen_hex (p, &num);
4728 p++; /* skip a colon */
4729 p = unpack_varlen_hex (p, &initval);
4730 p++; /* skip a colon */
4731 p = unpack_varlen_hex (p, &builtin);
4732 p++; /* skip a colon */
4733 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
4736 utsv = get_uploaded_tsv (num, utsvp);
4737 utsv->initial_value = initval;
4738 utsv->builtin = builtin;
4739 utsv->name = xstrdup (buf);
4742 /* Close the trace file and generally clean up. */
4754 xfree (trace_filename);
4755 trace_filename = NULL;
4757 trace_reset_local_state ();
4761 tfile_files_info (struct target_ops *t)
4763 printf_filtered ("\t`%s'\n", trace_filename);
4766 /* The trace status for a file is that tracing can never be run. */
4769 tfile_get_trace_status (struct trace_status *ts)
4771 /* Other bits of trace status were collected as part of opening the
4772 trace files, so nothing to do here. */
4778 tfile_get_tracepoint_status (struct breakpoint *tp, struct uploaded_tp *utp)
4780 /* Other bits of trace status were collected as part of opening the
4781 trace files, so nothing to do here. */
4784 /* Given the position of a traceframe in the file, figure out what
4785 address the frame was collected at. This would normally be the
4786 value of a collected PC register, but if not available, we
4790 tfile_get_traceframe_address (off_t tframe_offset)
4794 struct tracepoint *tp;
4795 off_t saved_offset = cur_offset;
4797 /* FIXME dig pc out of collected registers. */
4799 /* Fall back to using tracepoint address. */
4800 lseek (trace_fd, tframe_offset, SEEK_SET);
4801 tfile_read ((gdb_byte *) &tpnum, 2);
4802 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
4804 (target_gdbarch ()));
4806 tp = get_tracepoint_by_number_on_target (tpnum);
4807 /* FIXME this is a poor heuristic if multiple locations. */
4808 if (tp && tp->base.loc)
4809 addr = tp->base.loc->address;
4811 /* Restore our seek position. */
4812 cur_offset = saved_offset;
4813 lseek (trace_fd, cur_offset, SEEK_SET);
4817 /* Given a type of search and some parameters, scan the collection of
4818 traceframes in the file looking for a match. When found, return
4819 both the traceframe and tracepoint number, otherwise -1 for
4823 tfile_trace_find (enum trace_find_type type, int num,
4824 CORE_ADDR addr1, CORE_ADDR addr2, int *tpp)
4827 int tfnum = 0, found = 0;
4828 unsigned int data_size;
4829 struct tracepoint *tp;
4830 off_t offset, tframe_offset;
4840 lseek (trace_fd, trace_frames_offset, SEEK_SET);
4841 offset = trace_frames_offset;
4844 tframe_offset = offset;
4845 tfile_read ((gdb_byte *) &tpnum, 2);
4846 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
4848 (target_gdbarch ()));
4852 tfile_read ((gdb_byte *) &data_size, 4);
4853 data_size = (unsigned int) extract_unsigned_integer
4854 ((gdb_byte *) &data_size, 4,
4855 gdbarch_byte_order (target_gdbarch ()));
4858 if (type == tfind_number)
4860 /* Looking for a specific trace frame. */
4866 /* Start from the _next_ trace frame. */
4867 if (tfnum > traceframe_number)
4872 tfaddr = tfile_get_traceframe_address (tframe_offset);
4873 if (tfaddr == addr1)
4877 tp = get_tracepoint (num);
4878 if (tp && tpnum == tp->number_on_target)
4882 tfaddr = tfile_get_traceframe_address (tframe_offset);
4883 if (addr1 <= tfaddr && tfaddr <= addr2)
4887 tfaddr = tfile_get_traceframe_address (tframe_offset);
4888 if (!(addr1 <= tfaddr && tfaddr <= addr2))
4892 internal_error (__FILE__, __LINE__, _("unknown tfind type"));
4901 cur_offset = offset;
4902 cur_data_size = data_size;
4906 /* Skip past the traceframe's data. */
4907 lseek (trace_fd, data_size, SEEK_CUR);
4908 offset += data_size;
4909 /* Update our own count of traceframes. */
4912 /* Did not find what we were looking for. */
4918 /* Prototype of the callback passed to tframe_walk_blocks. */
4919 typedef int (*walk_blocks_callback_func) (char blocktype, void *data);
4921 /* Callback for traceframe_walk_blocks, used to find a given block
4922 type in a traceframe. */
4925 match_blocktype (char blocktype, void *data)
4927 char *wantedp = data;
4929 if (*wantedp == blocktype)
4935 /* Walk over all traceframe block starting at POS offset from
4936 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4937 unmodified. If CALLBACK returns true, this returns the position in
4938 the traceframe where the block is found, relative to the start of
4939 the traceframe (cur_offset). Returns -1 if no callback call
4940 returned true, indicating that all blocks have been walked. */
4943 traceframe_walk_blocks (walk_blocks_callback_func callback,
4944 int pos, void *data)
4946 /* Iterate through a traceframe's blocks, looking for a block of the
4949 lseek (trace_fd, cur_offset + pos, SEEK_SET);
4950 while (pos < cur_data_size)
4952 unsigned short mlen;
4955 tfile_read ((gdb_byte *) &block_type, 1);
4959 if ((*callback) (block_type, data))
4965 lseek (trace_fd, cur_offset + pos + trace_regblock_size, SEEK_SET);
4966 pos += trace_regblock_size;
4969 lseek (trace_fd, cur_offset + pos + 8, SEEK_SET);
4970 tfile_read ((gdb_byte *) &mlen, 2);
4971 mlen = (unsigned short)
4972 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
4974 (target_gdbarch ()));
4975 lseek (trace_fd, mlen, SEEK_CUR);
4976 pos += (8 + 2 + mlen);
4979 lseek (trace_fd, cur_offset + pos + 4 + 8, SEEK_SET);
4983 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4984 block_type, block_type);
4992 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4993 position offset of a block of type TYPE_WANTED in the current trace
4994 frame, starting at POS. Returns -1 if no such block was found. */
4997 traceframe_find_block_type (char type_wanted, int pos)
4999 return traceframe_walk_blocks (match_blocktype, pos, &type_wanted);
5002 /* Look for a block of saved registers in the traceframe, and get the
5003 requested register from it. */
5006 tfile_fetch_registers (struct target_ops *ops,
5007 struct regcache *regcache, int regno)
5009 struct gdbarch *gdbarch = get_regcache_arch (regcache);
5010 int offset, regn, regsize, pc_regno;
5013 /* An uninitialized reg size says we're not going to be
5014 successful at getting register blocks. */
5015 if (!trace_regblock_size)
5018 regs = alloca (trace_regblock_size);
5020 if (traceframe_find_block_type ('R', 0) >= 0)
5022 tfile_read (regs, trace_regblock_size);
5024 /* Assume the block is laid out in GDB register number order,
5025 each register with the size that it has in GDB. */
5027 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
5029 regsize = register_size (gdbarch, regn);
5030 /* Make sure we stay within block bounds. */
5031 if (offset + regsize >= trace_regblock_size)
5033 if (regcache_register_status (regcache, regn) == REG_UNKNOWN)
5037 regcache_raw_supply (regcache, regno, regs + offset);
5040 else if (regno == -1)
5042 regcache_raw_supply (regcache, regn, regs + offset);
5050 /* We get here if no register data has been found. Mark registers
5052 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
5053 regcache_raw_supply (regcache, regn, NULL);
5055 /* We can often usefully guess that the PC is going to be the same
5056 as the address of the tracepoint. */
5057 pc_regno = gdbarch_pc_regnum (gdbarch);
5058 if (pc_regno >= 0 && (regno == -1 || regno == pc_regno))
5060 struct tracepoint *tp = get_tracepoint (tracepoint_number);
5062 if (tp && tp->base.loc)
5064 /* But don't try to guess if tracepoint is multi-location... */
5065 if (tp->base.loc->next)
5067 warning (_("Tracepoint %d has multiple "
5068 "locations, cannot infer $pc"),
5072 /* ... or does while-stepping. */
5073 if (tp->step_count > 0)
5075 warning (_("Tracepoint %d does while-stepping, "
5076 "cannot infer $pc"),
5081 store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
5082 gdbarch_byte_order (gdbarch),
5083 tp->base.loc->address);
5084 regcache_raw_supply (regcache, pc_regno, regs);
5090 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
5091 const char *annex, gdb_byte *readbuf,
5092 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
5094 /* We're only doing regular memory for now. */
5095 if (object != TARGET_OBJECT_MEMORY)
5098 if (readbuf == NULL)
5099 error (_("tfile_xfer_partial: trace file is read-only"));
5101 if (traceframe_number != -1)
5105 /* Iterate through the traceframe's blocks, looking for
5107 while ((pos = traceframe_find_block_type ('M', pos)) >= 0)
5109 ULONGEST maddr, amt;
5110 unsigned short mlen;
5111 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
5113 tfile_read ((gdb_byte *) &maddr, 8);
5114 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
5116 tfile_read ((gdb_byte *) &mlen, 2);
5117 mlen = (unsigned short)
5118 extract_unsigned_integer ((gdb_byte *) &mlen, 2, byte_order);
5120 /* If the block includes the first part of the desired
5121 range, return as much it has; GDB will re-request the
5122 remainder, which might be in a different block of this
5124 if (maddr <= offset && offset < (maddr + mlen))
5126 amt = (maddr + mlen) - offset;
5130 if (maddr != offset)
5131 lseek (trace_fd, offset - maddr, SEEK_CUR);
5132 tfile_read (readbuf, amt);
5136 /* Skip over this block. */
5137 pos += (8 + 2 + mlen);
5141 /* It's unduly pedantic to refuse to look at the executable for
5142 read-only pieces; so do the equivalent of readonly regions aka
5144 /* FIXME account for relocation at some point. */
5151 for (s = exec_bfd->sections; s; s = s->next)
5153 if ((s->flags & SEC_LOAD) == 0
5154 || (s->flags & SEC_READONLY) == 0)
5158 size = bfd_get_section_size (s);
5159 if (vma <= offset && offset < (vma + size))
5163 amt = (vma + size) - offset;
5167 amt = bfd_get_section_contents (exec_bfd, s,
5168 readbuf, offset - vma, amt);
5174 /* Indicate failure to find the requested memory block. */
5178 /* Iterate through the blocks of a trace frame, looking for a 'V'
5179 block with a matching tsv number. */
5182 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
5187 /* Iterate over blocks in current frame and find the last 'V'
5188 block in which tsv number is TSVNUM. In one trace frame, there
5189 may be multiple 'V' blocks created for a given trace variable,
5190 and the last matched 'V' block contains the updated value. */
5192 while ((pos = traceframe_find_block_type ('V', pos)) >= 0)
5196 tfile_read ((gdb_byte *) &vnum, 4);
5197 vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
5199 (target_gdbarch ()));
5202 tfile_read ((gdb_byte *) val, 8);
5203 *val = extract_signed_integer ((gdb_byte *) val, 8,
5205 (target_gdbarch ()));
5215 tfile_has_all_memory (struct target_ops *ops)
5221 tfile_has_memory (struct target_ops *ops)
5227 tfile_has_stack (struct target_ops *ops)
5229 return traceframe_number != -1;
5233 tfile_has_registers (struct target_ops *ops)
5235 return traceframe_number != -1;
5238 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
5239 object for the tfile target's current traceframe. */
5242 build_traceframe_info (char blocktype, void *data)
5244 struct traceframe_info *info = data;
5250 struct mem_range *r;
5252 unsigned short mlen;
5254 tfile_read ((gdb_byte *) &maddr, 8);
5255 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
5257 (target_gdbarch ()));
5258 tfile_read ((gdb_byte *) &mlen, 2);
5259 mlen = (unsigned short)
5260 extract_unsigned_integer ((gdb_byte *) &mlen,
5261 2, gdbarch_byte_order
5262 (target_gdbarch ()));
5264 r = VEC_safe_push (mem_range_s, info->memory, NULL);
5274 tfile_read ((gdb_byte *) &vnum, 4);
5275 VEC_safe_push (int, info->tvars, vnum);
5283 warning (_("Unhandled trace block type (%d) '%c ' "
5284 "while building trace frame info."),
5285 blocktype, blocktype);
5292 static struct traceframe_info *
5293 tfile_traceframe_info (void)
5295 struct traceframe_info *info = XCNEW (struct traceframe_info);
5297 traceframe_walk_blocks (build_traceframe_info, 0, info);
5302 init_tfile_ops (void)
5304 tfile_ops.to_shortname = "tfile";
5305 tfile_ops.to_longname = "Local trace dump file";
5307 = "Use a trace file as a target. Specify the filename of the trace file.";
5308 tfile_ops.to_open = tfile_open;
5309 tfile_ops.to_close = tfile_close;
5310 tfile_ops.to_fetch_registers = tfile_fetch_registers;
5311 tfile_ops.to_xfer_partial = tfile_xfer_partial;
5312 tfile_ops.to_files_info = tfile_files_info;
5313 tfile_ops.to_get_trace_status = tfile_get_trace_status;
5314 tfile_ops.to_get_tracepoint_status = tfile_get_tracepoint_status;
5315 tfile_ops.to_trace_find = tfile_trace_find;
5316 tfile_ops.to_get_trace_state_variable_value
5317 = tfile_get_trace_state_variable_value;
5318 tfile_ops.to_stratum = process_stratum;
5319 tfile_ops.to_has_all_memory = tfile_has_all_memory;
5320 tfile_ops.to_has_memory = tfile_has_memory;
5321 tfile_ops.to_has_stack = tfile_has_stack;
5322 tfile_ops.to_has_registers = tfile_has_registers;
5323 tfile_ops.to_traceframe_info = tfile_traceframe_info;
5324 tfile_ops.to_magic = OPS_MAGIC;
5328 free_current_marker (void *arg)
5330 struct static_tracepoint_marker **marker_p = arg;
5332 if (*marker_p != NULL)
5334 release_static_tracepoint_marker (*marker_p);
5341 /* Given a line of text defining a static tracepoint marker, parse it
5342 into a "static tracepoint marker" object. Throws an error is
5343 parsing fails. If PP is non-null, it points to one past the end of
5344 the parsed marker definition. */
5347 parse_static_tracepoint_marker_definition (char *line, char **pp,
5348 struct static_tracepoint_marker *marker)
5355 p = unpack_varlen_hex (p, &addr);
5356 p++; /* skip a colon */
5358 marker->gdbarch = target_gdbarch ();
5359 marker->address = (CORE_ADDR) addr;
5361 endp = strchr (p, ':');
5363 error (_("bad marker definition: %s"), line);
5365 marker->str_id = xmalloc (endp - p + 1);
5366 end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
5367 marker->str_id[end] = '\0';
5370 p++; /* skip a colon */
5372 marker->extra = xmalloc (strlen (p) + 1);
5373 end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
5374 marker->extra[end] = '\0';
5380 /* Release a static tracepoint marker's contents. Note that the
5381 object itself isn't released here. There objects are usually on
5385 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
5387 xfree (marker->str_id);
5388 marker->str_id = NULL;
5391 /* Print MARKER to gdb_stdout. */
5394 print_one_static_tracepoint_marker (int count,
5395 struct static_tracepoint_marker *marker)
5397 struct command_line *l;
5400 char wrap_indent[80];
5401 char extra_field_indent[80];
5402 struct ui_out *uiout = current_uiout;
5403 struct cleanup *bkpt_chain;
5404 VEC(breakpoint_p) *tracepoints;
5406 struct symtab_and_line sal;
5410 sal.pc = marker->address;
5412 tracepoints = static_tracepoints_here (marker->address);
5414 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
5416 /* A counter field to help readability. This is not a stable
5418 ui_out_field_int (uiout, "count", count);
5420 ui_out_field_string (uiout, "marker-id", marker->str_id);
5422 ui_out_field_fmt (uiout, "enabled", "%c",
5423 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
5424 ui_out_spaces (uiout, 2);
5426 strcpy (wrap_indent, " ");
5428 if (gdbarch_addr_bit (marker->gdbarch) <= 32)
5429 strcat (wrap_indent, " ");
5431 strcat (wrap_indent, " ");
5433 strcpy (extra_field_indent, " ");
5435 ui_out_field_core_addr (uiout, "addr", marker->gdbarch, marker->address);
5437 sal = find_pc_line (marker->address, 0);
5438 sym = find_pc_sect_function (marker->address, NULL);
5441 ui_out_text (uiout, "in ");
5442 ui_out_field_string (uiout, "func",
5443 SYMBOL_PRINT_NAME (sym));
5444 ui_out_wrap_hint (uiout, wrap_indent);
5445 ui_out_text (uiout, " at ");
5448 ui_out_field_skip (uiout, "func");
5450 if (sal.symtab != NULL)
5452 ui_out_field_string (uiout, "file",
5453 symtab_to_filename_for_display (sal.symtab));
5454 ui_out_text (uiout, ":");
5456 if (ui_out_is_mi_like_p (uiout))
5458 const char *fullname = symtab_to_fullname (sal.symtab);
5460 ui_out_field_string (uiout, "fullname", fullname);
5463 ui_out_field_skip (uiout, "fullname");
5465 ui_out_field_int (uiout, "line", sal.line);
5469 ui_out_field_skip (uiout, "fullname");
5470 ui_out_field_skip (uiout, "line");
5473 ui_out_text (uiout, "\n");
5474 ui_out_text (uiout, extra_field_indent);
5475 ui_out_text (uiout, _("Data: \""));
5476 ui_out_field_string (uiout, "extra-data", marker->extra);
5477 ui_out_text (uiout, "\"\n");
5479 if (!VEC_empty (breakpoint_p, tracepoints))
5481 struct cleanup *cleanup_chain;
5483 struct breakpoint *b;
5485 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
5488 ui_out_text (uiout, extra_field_indent);
5489 ui_out_text (uiout, _("Probed by static tracepoints: "));
5490 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
5493 ui_out_text (uiout, ", ");
5494 ui_out_text (uiout, "#");
5495 ui_out_field_int (uiout, "tracepoint-id", b->number);
5498 do_cleanups (cleanup_chain);
5500 if (ui_out_is_mi_like_p (uiout))
5501 ui_out_field_int (uiout, "number-of-tracepoints",
5502 VEC_length(breakpoint_p, tracepoints));
5504 ui_out_text (uiout, "\n");
5506 VEC_free (breakpoint_p, tracepoints);
5508 do_cleanups (bkpt_chain);
5512 info_static_tracepoint_markers_command (char *arg, int from_tty)
5514 VEC(static_tracepoint_marker_p) *markers;
5515 struct cleanup *old_chain;
5516 struct static_tracepoint_marker *marker;
5517 struct ui_out *uiout = current_uiout;
5520 /* We don't have to check target_can_use_agent and agent's capability on
5521 static tracepoint here, in order to be compatible with older GDBserver.
5522 We don't check USE_AGENT is true or not, because static tracepoints
5523 don't work without in-process agent, so we don't bother users to type
5524 `set agent on' when to use static tracepoint. */
5527 = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
5528 "StaticTracepointMarkersTable");
5530 ui_out_table_header (uiout, 7, ui_left, "counter", "Cnt");
5532 ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
5534 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
5535 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
5536 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
5538 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
5539 ui_out_table_header (uiout, 40, ui_noalign, "what", "What");
5541 ui_out_table_body (uiout);
5543 markers = target_static_tracepoint_markers_by_strid (NULL);
5544 make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
5547 VEC_iterate (static_tracepoint_marker_p,
5548 markers, i, marker);
5551 print_one_static_tracepoint_marker (i + 1, marker);
5552 release_static_tracepoint_marker (marker);
5555 do_cleanups (old_chain);
5558 /* The $_sdata convenience variable is a bit special. We don't know
5559 for sure type of the value until we actually have a chance to fetch
5560 the data --- the size of the object depends on what has been
5561 collected. We solve this by making $_sdata be an internalvar that
5562 creates a new value on access. */
5564 /* Return a new value with the correct type for the sdata object of
5565 the current trace frame. Return a void value if there's no object
5568 static struct value *
5569 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
5575 /* We need to read the whole object before we know its size. */
5576 size = target_read_alloc (¤t_target,
5577 TARGET_OBJECT_STATIC_TRACE_DATA,
5584 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
5586 v = allocate_value (type);
5587 memcpy (value_contents_raw (v), buf, size);
5592 return allocate_value (builtin_type (gdbarch)->builtin_void);
5595 #if !defined(HAVE_LIBEXPAT)
5597 struct traceframe_info *
5598 parse_traceframe_info (const char *tframe_info)
5600 static int have_warned;
5605 warning (_("Can not parse XML trace frame info; XML support "
5606 "was disabled at compile time"));
5612 #else /* HAVE_LIBEXPAT */
5614 #include "xml-support.h"
5616 /* Handle the start of a <memory> element. */
5619 traceframe_info_start_memory (struct gdb_xml_parser *parser,
5620 const struct gdb_xml_element *element,
5621 void *user_data, VEC(gdb_xml_value_s) *attributes)
5623 struct traceframe_info *info = user_data;
5624 struct mem_range *r = VEC_safe_push (mem_range_s, info->memory, NULL);
5625 ULONGEST *start_p, *length_p;
5627 start_p = xml_find_attribute (attributes, "start")->value;
5628 length_p = xml_find_attribute (attributes, "length")->value;
5630 r->start = *start_p;
5631 r->length = *length_p;
5634 /* Handle the start of a <tvar> element. */
5637 traceframe_info_start_tvar (struct gdb_xml_parser *parser,
5638 const struct gdb_xml_element *element,
5640 VEC(gdb_xml_value_s) *attributes)
5642 struct traceframe_info *info = user_data;
5643 const char *id_attrib = xml_find_attribute (attributes, "id")->value;
5644 int id = gdb_xml_parse_ulongest (parser, id_attrib);
5646 VEC_safe_push (int, info->tvars, id);
5649 /* Discard the constructed trace frame info (if an error occurs). */
5652 free_result (void *p)
5654 struct traceframe_info *result = p;
5656 free_traceframe_info (result);
5659 /* The allowed elements and attributes for an XML memory map. */
5661 static const struct gdb_xml_attribute memory_attributes[] = {
5662 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
5663 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
5664 { NULL, GDB_XML_AF_NONE, NULL, NULL }
5667 static const struct gdb_xml_attribute tvar_attributes[] = {
5668 { "id", GDB_XML_AF_NONE, NULL, NULL },
5669 { NULL, GDB_XML_AF_NONE, NULL, NULL }
5672 static const struct gdb_xml_element traceframe_info_children[] = {
5673 { "memory", memory_attributes, NULL,
5674 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
5675 traceframe_info_start_memory, NULL },
5676 { "tvar", tvar_attributes, NULL,
5677 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
5678 traceframe_info_start_tvar, NULL },
5679 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
5682 static const struct gdb_xml_element traceframe_info_elements[] = {
5683 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
5685 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
5688 /* Parse a traceframe-info XML document. */
5690 struct traceframe_info *
5691 parse_traceframe_info (const char *tframe_info)
5693 struct traceframe_info *result;
5694 struct cleanup *back_to;
5696 result = XCNEW (struct traceframe_info);
5697 back_to = make_cleanup (free_result, result);
5699 if (gdb_xml_parse_quick (_("trace frame info"),
5700 "traceframe-info.dtd", traceframe_info_elements,
5701 tframe_info, result) == 0)
5703 /* Parsed successfully, keep the result. */
5704 discard_cleanups (back_to);
5709 do_cleanups (back_to);
5713 #endif /* HAVE_LIBEXPAT */
5715 /* Returns the traceframe_info object for the current traceframe.
5716 This is where we avoid re-fetching the object from the target if we
5717 already have it cached. */
5719 struct traceframe_info *
5720 get_traceframe_info (void)
5722 if (traceframe_info == NULL)
5723 traceframe_info = target_traceframe_info ();
5725 return traceframe_info;
5728 /* If the target supports the query, return in RESULT the set of
5729 collected memory in the current traceframe, found within the LEN
5730 bytes range starting at MEMADDR. Returns true if the target
5731 supports the query, otherwise returns false, and RESULT is left
5735 traceframe_available_memory (VEC(mem_range_s) **result,
5736 CORE_ADDR memaddr, ULONGEST len)
5738 struct traceframe_info *info = get_traceframe_info ();
5742 struct mem_range *r;
5747 for (i = 0; VEC_iterate (mem_range_s, info->memory, i, r); i++)
5748 if (mem_ranges_overlap (r->start, r->length, memaddr, len))
5750 ULONGEST lo1, hi1, lo2, hi2;
5751 struct mem_range *nr;
5754 hi1 = memaddr + len;
5757 hi2 = r->start + r->length;
5759 nr = VEC_safe_push (mem_range_s, *result, NULL);
5761 nr->start = max (lo1, lo2);
5762 nr->length = min (hi1, hi2) - nr->start;
5765 normalize_mem_ranges (*result);
5772 /* Implementation of `sdata' variable. */
5774 static const struct internalvar_funcs sdata_funcs =
5781 /* module initialization */
5783 _initialize_tracepoint (void)
5785 struct cmd_list_element *c;
5787 /* Explicitly create without lookup, since that tries to create a
5788 value with a void typed value, and when we get here, gdbarch
5789 isn't initialized yet. At this point, we're quite sure there
5790 isn't another convenience variable of the same name. */
5791 create_internalvar_type_lazy ("_sdata", &sdata_funcs, NULL);
5793 traceframe_number = -1;
5794 tracepoint_number = -1;
5796 add_info ("scope", scope_info,
5797 _("List the variables local to a scope"));
5799 add_cmd ("tracepoints", class_trace, NULL,
5800 _("Tracing of program execution without stopping the program."),
5803 add_com ("tdump", class_trace, trace_dump_command,
5804 _("Print everything collected at the current tracepoint."));
5806 add_com ("tsave", class_trace, trace_save_command, _("\
5807 Save the trace data to a file.\n\
5808 Use the '-ctf' option to save the data to CTF format.\n\
5809 Use the '-r' option to direct the target to save directly to the file,\n\
5810 using its own filesystem."));
5812 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
5813 Define a trace state variable.\n\
5814 Argument is a $-prefixed name, optionally followed\n\
5815 by '=' and an expression that sets the initial value\n\
5816 at the start of tracing."));
5817 set_cmd_completer (c, expression_completer);
5819 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
5820 Delete one or more trace state variables.\n\
5821 Arguments are the names of the variables to delete.\n\
5822 If no arguments are supplied, delete all variables."), &deletelist);
5823 /* FIXME add a trace variable completer. */
5825 add_info ("tvariables", tvariables_info, _("\
5826 Status of trace state variables and their values.\n\
5829 add_info ("static-tracepoint-markers",
5830 info_static_tracepoint_markers_command, _("\
5831 List target static tracepoints markers.\n\
5834 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
5835 Select a trace frame;\n\
5836 No argument means forward by one frame; '-' means backward by one frame."),
5837 &tfindlist, "tfind ", 1, &cmdlist);
5839 add_cmd ("outside", class_trace, trace_find_outside_command, _("\
5840 Select a trace frame whose PC is outside the given range (exclusive).\n\
5841 Usage: tfind outside addr1, addr2"),
5844 add_cmd ("range", class_trace, trace_find_range_command, _("\
5845 Select a trace frame whose PC is in the given range (inclusive).\n\
5846 Usage: tfind range addr1,addr2"),
5849 add_cmd ("line", class_trace, trace_find_line_command, _("\
5850 Select a trace frame by source line.\n\
5851 Argument can be a line number (with optional source file),\n\
5852 a function name, or '*' followed by an address.\n\
5853 Default argument is 'the next source line that was traced'."),
5856 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
5857 Select a trace frame by tracepoint number.\n\
5858 Default is the tracepoint for the current trace frame."),
5861 add_cmd ("pc", class_trace, trace_find_pc_command, _("\
5862 Select a trace frame by PC.\n\
5863 Default is the current PC, or the PC of the current trace frame."),
5866 add_cmd ("end", class_trace, trace_find_end_command, _("\
5867 De-select any trace frame and resume 'live' debugging."),
5870 add_alias_cmd ("none", "end", class_trace, 0, &tfindlist);
5872 add_cmd ("start", class_trace, trace_find_start_command,
5873 _("Select the first trace frame in the trace buffer."),
5876 add_com ("tstatus", class_trace, trace_status_command,
5877 _("Display the status of the current trace data collection."));
5879 add_com ("tstop", class_trace, trace_stop_command, _("\
5880 Stop trace data collection.\n\
5881 Usage: tstop [ <notes> ... ]\n\
5882 Any arguments supplied are recorded with the trace as a stop reason and\n\
5883 reported by tstatus (if the target supports trace notes)."));
5885 add_com ("tstart", class_trace, trace_start_command, _("\
5886 Start trace data collection.\n\
5887 Usage: tstart [ <notes> ... ]\n\
5888 Any arguments supplied are recorded with the trace as a note and\n\
5889 reported by tstatus (if the target supports trace notes)."));
5891 add_com ("end", class_trace, end_actions_pseudocommand, _("\
5892 Ends a list of commands or actions.\n\
5893 Several GDB commands allow you to enter a list of commands or actions.\n\
5894 Entering \"end\" on a line by itself is the normal way to terminate\n\
5896 Note: the \"end\" command cannot be used at the gdb prompt."));
5898 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
5899 Specify single-stepping behavior at a tracepoint.\n\
5900 Argument is number of instructions to trace in single-step mode\n\
5901 following the tracepoint. This command is normally followed by\n\
5902 one or more \"collect\" commands, to specify what to collect\n\
5903 while single-stepping.\n\n\
5904 Note: this command can only be used in a tracepoint \"actions\" list."));
5906 add_com_alias ("ws", "while-stepping", class_alias, 0);
5907 add_com_alias ("stepping", "while-stepping", class_alias, 0);
5909 add_com ("collect", class_trace, collect_pseudocommand, _("\
5910 Specify one or more data items to be collected at a tracepoint.\n\
5911 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5912 collect all data (variables, registers) referenced by that expression.\n\
5913 Also accepts the following special arguments:\n\
5914 $regs -- all registers.\n\
5915 $args -- all function arguments.\n\
5916 $locals -- all variables local to the block/function scope.\n\
5917 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5918 Note: this command can only be used in a tracepoint \"actions\" list."));
5920 add_com ("teval", class_trace, teval_pseudocommand, _("\
5921 Specify one or more expressions to be evaluated at a tracepoint.\n\
5922 Accepts a comma-separated list of (one or more) expressions.\n\
5923 The result of each evaluation will be discarded.\n\
5924 Note: this command can only be used in a tracepoint \"actions\" list."));
5926 add_com ("actions", class_trace, trace_actions_command, _("\
5927 Specify the actions to be taken at a tracepoint.\n\
5928 Tracepoint actions may include collecting of specified data,\n\
5929 single-stepping, or enabling/disabling other tracepoints,\n\
5930 depending on target's capabilities."));
5932 default_collect = xstrdup ("");
5933 add_setshow_string_cmd ("default-collect", class_trace,
5934 &default_collect, _("\
5935 Set the list of expressions to collect by default"), _("\
5936 Show the list of expressions to collect by default"), NULL,
5938 &setlist, &showlist);
5940 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
5941 &disconnected_tracing, _("\
5942 Set whether tracing continues after GDB disconnects."), _("\
5943 Show whether tracing continues after GDB disconnects."), _("\
5944 Use this to continue a tracing run even if GDB disconnects\n\
5945 or detaches from the target. You can reconnect later and look at\n\
5946 trace data collected in the meantime."),
5947 set_disconnected_tracing,
5952 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
5953 &circular_trace_buffer, _("\
5954 Set target's use of circular trace buffer."), _("\
5955 Show target's use of circular trace buffer."), _("\
5956 Use this to make the trace buffer into a circular buffer,\n\
5957 which will discard traceframes (oldest first) instead of filling\n\
5958 up and stopping the trace run."),
5959 set_circular_trace_buffer,
5964 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class,
5965 &trace_buffer_size, _("\
5966 Set requested size of trace buffer."), _("\
5967 Show requested size of trace buffer."), _("\
5968 Use this to choose a size for the trace buffer. Some targets\n\
5969 may have fixed or limited buffer sizes. Specifying \"unlimited\" or -1\n\
5970 disables any attempt to set the buffer size and lets the target choose."),
5971 set_trace_buffer_size, NULL,
5972 &setlist, &showlist);
5974 add_setshow_string_cmd ("trace-user", class_trace,
5976 Set the user name to use for current and future trace runs"), _("\
5977 Show the user name to use for current and future trace runs"), NULL,
5978 set_trace_user, NULL,
5979 &setlist, &showlist);
5981 add_setshow_string_cmd ("trace-notes", class_trace,
5983 Set notes string to use for current and future trace runs"), _("\
5984 Show the notes string to use for current and future trace runs"), NULL,
5985 set_trace_notes, NULL,
5986 &setlist, &showlist);
5988 add_setshow_string_cmd ("trace-stop-notes", class_trace,
5989 &trace_stop_notes, _("\
5990 Set notes string to use for future tstop commands"), _("\
5991 Show the notes string to use for future tstop commands"), NULL,
5992 set_trace_stop_notes, NULL,
5993 &setlist, &showlist);
5997 add_target_with_completer (&tfile_ops, filename_completer);