1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
4 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "arch-utils.h"
26 #include "expression.h"
31 #include "gdb_string.h"
33 #include "breakpoint.h"
34 #include "tracepoint.h"
37 #include "completer.h"
39 #include "dictionary.h"
41 #include "user-regs.h"
45 #include "filenames.h"
46 #include "gdbthread.h"
54 #include "exceptions.h"
56 /* readline include files */
57 #include "readline/readline.h"
58 #include "readline/history.h"
60 /* readline defines this. */
71 extern int hex2bin (const char *hex, gdb_byte *bin, int count);
72 extern int bin2hex (const gdb_byte *bin, char *hex, int count);
74 /* Maximum length of an agent aexpression.
75 This accounts for the fact that packets are limited to 400 bytes
76 (which includes everything -- including the checksum), and assumes
77 the worst case of maximum length for each of the pieces of a
80 NOTE: expressions get mem2hex'ed otherwise this would be twice as
81 large. (400 - 31)/2 == 184 */
82 #define MAX_AGENT_EXPR_LEN 184
86 /* A hook used to notify the UI of tracepoint operations. */
88 void (*deprecated_trace_find_hook) (char *arg, int from_tty);
89 void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
91 extern void (*deprecated_readline_begin_hook) (char *, ...);
92 extern char *(*deprecated_readline_hook) (char *);
93 extern void (*deprecated_readline_end_hook) (void);
95 /* GDB commands implemented in other modules:
98 extern void output_command (char *, int);
103 This module defines the following debugger commands:
104 trace : set a tracepoint on a function, line, or address.
105 info trace : list all debugger-defined tracepoints.
106 delete trace : delete one or more tracepoints.
107 enable trace : enable one or more tracepoints.
108 disable trace : disable one or more tracepoints.
109 actions : specify actions to be taken at a tracepoint.
110 passcount : specify a pass count for a tracepoint.
111 tstart : start a trace experiment.
112 tstop : stop a trace experiment.
113 tstatus : query the status of a trace experiment.
114 tfind : find a trace frame in the trace buffer.
115 tdump : print everything collected at the current tracepoint.
116 save-tracepoints : write tracepoint setup into a file.
118 This module defines the following user-visible debugger variables:
119 $trace_frame : sequence number of trace frame currently being debugged.
120 $trace_line : source line of trace frame currently being debugged.
121 $trace_file : source file of trace frame currently being debugged.
122 $tracepoint : tracepoint number of trace frame currently being debugged.
126 /* ======= Important global variables: ======= */
128 /* The list of all trace state variables. We don't retain pointers to
129 any of these for any reason - API is by name or number only - so it
130 works to have a vector of objects. */
132 typedef struct trace_state_variable tsv_s;
135 /* An object describing the contents of a traceframe. */
137 struct traceframe_info
139 /* Collected memory. */
140 VEC(mem_range_s) *memory;
143 static VEC(tsv_s) *tvariables;
145 /* The next integer to assign to a variable. */
147 static int next_tsv_number = 1;
149 /* Number of last traceframe collected. */
150 static int traceframe_number;
152 /* Tracepoint for last traceframe collected. */
153 static int tracepoint_number;
155 /* Symbol for function for last traceframe collected. */
156 static struct symbol *traceframe_fun;
158 /* Symtab and line for last traceframe collected. */
159 static struct symtab_and_line traceframe_sal;
161 /* The traceframe info of the current traceframe. NULL if we haven't
162 yet attempted to fetch it, or if the target does not support
163 fetching this object, or if we're not inspecting a traceframe
165 static struct traceframe_info *traceframe_info;
167 /* Tracing command lists. */
168 static struct cmd_list_element *tfindlist;
170 /* List of expressions to collect by default at each tracepoint hit. */
171 char *default_collect = "";
173 static int disconnected_tracing;
175 /* This variable controls whether we ask the target for a linear or
176 circular trace buffer. */
178 static int circular_trace_buffer;
180 /* ======= Important command functions: ======= */
181 static void trace_actions_command (char *, int);
182 static void trace_start_command (char *, int);
183 static void trace_stop_command (char *, int);
184 static void trace_status_command (char *, int);
185 static void trace_find_command (char *, int);
186 static void trace_find_pc_command (char *, int);
187 static void trace_find_tracepoint_command (char *, int);
188 static void trace_find_line_command (char *, int);
189 static void trace_find_range_command (char *, int);
190 static void trace_find_outside_command (char *, int);
191 static void trace_dump_command (char *, int);
193 /* support routines */
195 struct collection_list;
196 static void add_aexpr (struct collection_list *, struct agent_expr *);
197 static char *mem2hex (gdb_byte *, char *, int);
198 static void add_register (struct collection_list *collection,
201 extern void send_disconnected_tracing_value (int value);
203 static void free_uploaded_tps (struct uploaded_tp **utpp);
204 static void free_uploaded_tsvs (struct uploaded_tsv **utsvp);
207 extern void _initialize_tracepoint (void);
209 static struct trace_status trace_status;
211 char *stop_reason_names[] = {
221 struct trace_status *
222 current_trace_status (void)
224 return &trace_status;
230 free_traceframe_info (struct traceframe_info *info)
234 VEC_free (mem_range_s, info->memory);
240 /* Free and and clear the traceframe info cache of the current
244 clear_traceframe_info (void)
246 free_traceframe_info (traceframe_info);
247 traceframe_info = NULL;
250 /* Set traceframe number to NUM. */
252 set_traceframe_num (int num)
254 traceframe_number = num;
255 set_internalvar_integer (lookup_internalvar ("trace_frame"), num);
258 /* Set tracepoint number to NUM. */
260 set_tracepoint_num (int num)
262 tracepoint_number = num;
263 set_internalvar_integer (lookup_internalvar ("tracepoint"), num);
266 /* Set externally visible debug variables for querying/printing
267 the traceframe context (line, function, file). */
270 set_traceframe_context (struct frame_info *trace_frame)
274 /* Save as globals for internal use. */
275 if (trace_frame != NULL
276 && get_frame_pc_if_available (trace_frame, &trace_pc))
278 traceframe_sal = find_pc_line (trace_pc, 0);
279 traceframe_fun = find_pc_function (trace_pc);
281 /* Save linenumber as "$trace_line", a debugger variable visible to
283 set_internalvar_integer (lookup_internalvar ("trace_line"),
284 traceframe_sal.line);
288 init_sal (&traceframe_sal);
289 traceframe_fun = NULL;
290 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
293 /* Save func name as "$trace_func", a debugger variable visible to
295 if (traceframe_fun == NULL
296 || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
297 clear_internalvar (lookup_internalvar ("trace_func"));
299 set_internalvar_string (lookup_internalvar ("trace_func"),
300 SYMBOL_LINKAGE_NAME (traceframe_fun));
302 /* Save file name as "$trace_file", a debugger variable visible to
304 if (traceframe_sal.symtab == NULL
305 || traceframe_sal.symtab->filename == NULL)
306 clear_internalvar (lookup_internalvar ("trace_file"));
308 set_internalvar_string (lookup_internalvar ("trace_file"),
309 traceframe_sal.symtab->filename);
312 /* Create a new trace state variable with the given name. */
314 struct trace_state_variable *
315 create_trace_state_variable (const char *name)
317 struct trace_state_variable tsv;
319 memset (&tsv, 0, sizeof (tsv));
320 tsv.name = xstrdup (name);
321 tsv.number = next_tsv_number++;
322 return VEC_safe_push (tsv_s, tvariables, &tsv);
325 /* Look for a trace state variable of the given name. */
327 struct trace_state_variable *
328 find_trace_state_variable (const char *name)
330 struct trace_state_variable *tsv;
333 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
334 if (strcmp (name, tsv->name) == 0)
341 delete_trace_state_variable (const char *name)
343 struct trace_state_variable *tsv;
346 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
347 if (strcmp (name, tsv->name) == 0)
349 xfree ((void *)tsv->name);
350 VEC_unordered_remove (tsv_s, tvariables, ix);
354 warning (_("No trace variable named \"$%s\", not deleting"), name);
357 /* The 'tvariable' command collects a name and optional expression to
358 evaluate into an initial value. */
361 trace_variable_command (char *args, int from_tty)
363 struct expression *expr;
364 struct cleanup *old_chain;
365 struct internalvar *intvar = NULL;
367 struct trace_state_variable *tsv;
370 error_no_arg (_("trace state variable name"));
372 /* All the possible valid arguments are expressions. */
373 expr = parse_expression (args);
374 old_chain = make_cleanup (free_current_contents, &expr);
376 if (expr->nelts == 0)
377 error (_("No expression?"));
379 /* Only allow two syntaxes; "$name" and "$name=value". */
380 if (expr->elts[0].opcode == OP_INTERNALVAR)
382 intvar = expr->elts[1].internalvar;
384 else if (expr->elts[0].opcode == BINOP_ASSIGN
385 && expr->elts[1].opcode == OP_INTERNALVAR)
387 intvar = expr->elts[2].internalvar;
388 initval = value_as_long (evaluate_subexpression_type (expr, 4));
391 error (_("Syntax must be $NAME [ = EXPR ]"));
394 error (_("No name given"));
396 if (strlen (internalvar_name (intvar)) <= 0)
397 error (_("Must supply a non-empty variable name"));
399 /* If the variable already exists, just change its initial value. */
400 tsv = find_trace_state_variable (internalvar_name (intvar));
403 tsv->initial_value = initval;
404 printf_filtered (_("Trace state variable $%s "
405 "now has initial value %s.\n"),
406 tsv->name, plongest (tsv->initial_value));
407 do_cleanups (old_chain);
411 /* Create a new variable. */
412 tsv = create_trace_state_variable (internalvar_name (intvar));
413 tsv->initial_value = initval;
415 printf_filtered (_("Trace state variable $%s "
416 "created, with initial value %s.\n"),
417 tsv->name, plongest (tsv->initial_value));
419 do_cleanups (old_chain);
423 delete_trace_variable_command (char *args, int from_tty)
427 struct cleanup *back_to;
431 if (query (_("Delete all trace state variables? ")))
432 VEC_free (tsv_s, tvariables);
437 argv = gdb_buildargv (args);
438 back_to = make_cleanup_freeargv (argv);
440 for (ix = 0; argv[ix] != NULL; ix++)
442 if (*argv[ix] == '$')
443 delete_trace_state_variable (argv[ix] + 1);
445 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv[ix]);
448 do_cleanups (back_to);
454 tvariables_info_1 (void)
456 struct trace_state_variable *tsv;
459 struct cleanup *back_to;
461 if (VEC_length (tsv_s, tvariables) == 0 && !ui_out_is_mi_like_p (uiout))
463 printf_filtered (_("No trace state variables.\n"));
467 /* Try to acquire values from the target. */
468 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix, ++count)
469 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
472 back_to = make_cleanup_ui_out_table_begin_end (uiout, 3,
473 count, "trace-variables");
474 ui_out_table_header (uiout, 15, ui_left, "name", "Name");
475 ui_out_table_header (uiout, 11, ui_left, "initial", "Initial");
476 ui_out_table_header (uiout, 11, ui_left, "current", "Current");
478 ui_out_table_body (uiout);
480 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
482 struct cleanup *back_to2;
486 back_to2 = make_cleanup_ui_out_tuple_begin_end (uiout, "variable");
488 name = concat ("$", tsv->name, (char *) NULL);
489 make_cleanup (xfree, name);
490 ui_out_field_string (uiout, "name", name);
491 ui_out_field_string (uiout, "initial", plongest (tsv->initial_value));
493 if (tsv->value_known)
494 c = plongest (tsv->value);
495 else if (ui_out_is_mi_like_p (uiout))
496 /* For MI, we prefer not to use magic string constants, but rather
497 omit the field completely. The difference between unknown and
498 undefined does not seem important enough to represent. */
500 else if (current_trace_status ()->running || traceframe_number >= 0)
501 /* The value is/was defined, but we don't have it. */
504 /* It is not meaningful to ask about the value. */
507 ui_out_field_string (uiout, "current", c);
508 ui_out_text (uiout, "\n");
510 do_cleanups (back_to2);
513 do_cleanups (back_to);
516 /* List all the trace state variables. */
519 tvariables_info (char *args, int from_tty)
521 tvariables_info_1 ();
524 /* Stash definitions of tsvs into the given file. */
527 save_trace_state_variables (struct ui_file *fp)
529 struct trace_state_variable *tsv;
532 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
534 fprintf_unfiltered (fp, "tvariable $%s", tsv->name);
535 if (tsv->initial_value)
536 fprintf_unfiltered (fp, " = %s", plongest (tsv->initial_value));
537 fprintf_unfiltered (fp, "\n");
541 /* ACTIONS functions: */
543 /* The three functions:
544 collect_pseudocommand,
545 while_stepping_pseudocommand, and
546 end_actions_pseudocommand
547 are placeholders for "commands" that are actually ONLY to be used
548 within a tracepoint action list. If the actual function is ever called,
549 it means that somebody issued the "command" at the top level,
550 which is always an error. */
553 end_actions_pseudocommand (char *args, int from_tty)
555 error (_("This command cannot be used at the top level."));
559 while_stepping_pseudocommand (char *args, int from_tty)
561 error (_("This command can only be used in a tracepoint actions list."));
565 collect_pseudocommand (char *args, int from_tty)
567 error (_("This command can only be used in a tracepoint actions list."));
571 teval_pseudocommand (char *args, int from_tty)
573 error (_("This command can only be used in a tracepoint actions list."));
576 /* Enter a list of actions for a tracepoint. */
578 trace_actions_command (char *args, int from_tty)
580 struct breakpoint *t;
581 struct command_line *l;
583 t = get_tracepoint_by_number (&args, NULL, 1);
587 xstrprintf ("Enter actions for tracepoint %d, one per line.",
589 struct cleanup *cleanups = make_cleanup (xfree, tmpbuf);
591 l = read_command_lines (tmpbuf, from_tty, 1,
592 check_tracepoint_command, t);
593 do_cleanups (cleanups);
594 breakpoint_set_commands (t, l);
596 /* else just return */
599 /* Report the results of checking the agent expression, as errors or
603 report_agent_reqs_errors (struct agent_expr *aexpr)
605 /* All of the "flaws" are serious bytecode generation issues that
606 should never occur. */
607 if (aexpr->flaw != agent_flaw_none)
608 internal_error (__FILE__, __LINE__, _("expression is malformed"));
610 /* If analysis shows a stack underflow, GDB must have done something
611 badly wrong in its bytecode generation. */
612 if (aexpr->min_height < 0)
613 internal_error (__FILE__, __LINE__,
614 _("expression has min height < 0"));
616 /* Issue this error if the stack is predicted to get too deep. The
617 limit is rather arbitrary; a better scheme might be for the
618 target to report how much stack it will have available. The
619 depth roughly corresponds to parenthesization, so a limit of 20
620 amounts to 20 levels of expression nesting, which is actually
621 a pretty big hairy expression. */
622 if (aexpr->max_height > 20)
623 error (_("Expression is too complicated."));
626 /* worker function */
628 validate_actionline (char **line, struct breakpoint *t)
630 struct cmd_list_element *c;
631 struct expression *exp = NULL;
632 struct cleanup *old_chain = NULL;
634 struct bp_location *loc;
635 struct agent_expr *aexpr;
637 /* If EOF is typed, *line is NULL. */
641 for (p = *line; isspace ((int) *p);)
644 /* Symbol lookup etc. */
645 if (*p == '\0') /* empty line: just prompt for another line. */
648 if (*p == '#') /* comment line */
651 c = lookup_cmd (&p, cmdlist, "", -1, 1);
653 error (_("`%s' is not a tracepoint action, or is ambiguous."), p);
655 if (cmd_cfunc_eq (c, collect_pseudocommand))
658 { /* Repeat over a comma-separated list. */
659 QUIT; /* Allow user to bail out with ^C. */
660 while (isspace ((int) *p))
663 if (*p == '$') /* Look for special pseudo-symbols. */
665 if (0 == strncasecmp ("reg", p + 1, 3)
666 || 0 == strncasecmp ("arg", p + 1, 3)
667 || 0 == strncasecmp ("loc", p + 1, 3)
668 || 0 == strncasecmp ("_sdata", p + 1, 6))
673 /* else fall thru, treat p as an expression and parse it! */
676 for (loc = t->loc; loc; loc = loc->next)
679 exp = parse_exp_1 (&p, block_for_pc (loc->address), 1);
680 old_chain = make_cleanup (free_current_contents, &exp);
682 if (exp->elts[0].opcode == OP_VAR_VALUE)
684 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
686 error (_("constant `%s' (value %ld) "
687 "will not be collected."),
688 SYMBOL_PRINT_NAME (exp->elts[2].symbol),
689 SYMBOL_VALUE (exp->elts[2].symbol));
691 else if (SYMBOL_CLASS (exp->elts[2].symbol)
692 == LOC_OPTIMIZED_OUT)
694 error (_("`%s' is optimized away "
695 "and cannot be collected."),
696 SYMBOL_PRINT_NAME (exp->elts[2].symbol));
700 /* We have something to collect, make sure that the expr to
701 bytecode translator can handle it and that it's not too
703 aexpr = gen_trace_for_expr (loc->address, exp);
704 make_cleanup_free_agent_expr (aexpr);
706 if (aexpr->len > MAX_AGENT_EXPR_LEN)
707 error (_("Expression is too complicated."));
711 report_agent_reqs_errors (aexpr);
713 do_cleanups (old_chain);
716 while (p && *p++ == ',');
719 else if (cmd_cfunc_eq (c, teval_pseudocommand))
722 { /* Repeat over a comma-separated list. */
723 QUIT; /* Allow user to bail out with ^C. */
724 while (isspace ((int) *p))
728 for (loc = t->loc; loc; loc = loc->next)
731 /* Only expressions are allowed for this action. */
732 exp = parse_exp_1 (&p, block_for_pc (loc->address), 1);
733 old_chain = make_cleanup (free_current_contents, &exp);
735 /* We have something to evaluate, make sure that the expr to
736 bytecode translator can handle it and that it's not too
738 aexpr = gen_eval_for_expr (loc->address, exp);
739 make_cleanup_free_agent_expr (aexpr);
741 if (aexpr->len > MAX_AGENT_EXPR_LEN)
742 error (_("Expression is too complicated."));
745 report_agent_reqs_errors (aexpr);
747 do_cleanups (old_chain);
750 while (p && *p++ == ',');
753 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
755 char *steparg; /* In case warning is necessary. */
757 while (isspace ((int) *p))
761 if (*p == '\0' || (t->step_count = strtol (p, &p, 0)) == 0)
762 error (_("while-stepping step count `%s' is malformed."), *line);
765 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
769 error (_("`%s' is not a supported tracepoint action."), *line);
773 memrange_absolute = -1
778 int type; /* memrange_absolute for absolute memory range,
779 else basereg number. */
780 bfd_signed_vma start;
784 struct collection_list
786 unsigned char regs_mask[32]; /* room for up to 256 regs */
789 struct memrange *list;
790 long aexpr_listsize; /* size of array pointed to by expr_list elt */
792 struct agent_expr **aexpr_list;
794 /* True is the user requested a collection of "$_sdata", "static
798 tracepoint_list, stepping_list;
800 /* MEMRANGE functions: */
802 static int memrange_cmp (const void *, const void *);
804 /* Compare memranges for qsort. */
806 memrange_cmp (const void *va, const void *vb)
808 const struct memrange *a = va, *b = vb;
810 if (a->type < b->type)
812 if (a->type > b->type)
814 if (a->type == memrange_absolute)
816 if ((bfd_vma) a->start < (bfd_vma) b->start)
818 if ((bfd_vma) a->start > (bfd_vma) b->start)
823 if (a->start < b->start)
825 if (a->start > b->start)
831 /* Sort the memrange list using qsort, and merge adjacent memranges. */
833 memrange_sortmerge (struct collection_list *memranges)
837 qsort (memranges->list, memranges->next_memrange,
838 sizeof (struct memrange), memrange_cmp);
839 if (memranges->next_memrange > 0)
841 for (a = 0, b = 1; b < memranges->next_memrange; b++)
843 /* If memrange b overlaps or is adjacent to memrange a,
845 if (memranges->list[a].type == memranges->list[b].type
846 && memranges->list[b].start <= memranges->list[a].end)
848 if (memranges->list[b].end > memranges->list[a].end)
849 memranges->list[a].end = memranges->list[b].end;
850 continue; /* next b, same a */
854 memcpy (&memranges->list[a], &memranges->list[b],
855 sizeof (struct memrange));
857 memranges->next_memrange = a + 1;
861 /* Add a register to a collection list. */
863 add_register (struct collection_list *collection, unsigned int regno)
866 printf_filtered ("collect register %d\n", regno);
867 if (regno >= (8 * sizeof (collection->regs_mask)))
868 error (_("Internal: register number %d too large for tracepoint"),
870 collection->regs_mask[regno / 8] |= 1 << (regno % 8);
873 /* Add a memrange to a collection list. */
875 add_memrange (struct collection_list *memranges,
876 int type, bfd_signed_vma base,
881 printf_filtered ("(%d,", type);
883 printf_filtered (",%ld)\n", len);
886 /* type: memrange_absolute == memory, other n == basereg */
887 memranges->list[memranges->next_memrange].type = type;
888 /* base: addr if memory, offset if reg relative. */
889 memranges->list[memranges->next_memrange].start = base;
890 /* len: we actually save end (base + len) for convenience */
891 memranges->list[memranges->next_memrange].end = base + len;
892 memranges->next_memrange++;
893 if (memranges->next_memrange >= memranges->listsize)
895 memranges->listsize *= 2;
896 memranges->list = xrealloc (memranges->list,
897 memranges->listsize);
900 if (type != memrange_absolute) /* Better collect the base register! */
901 add_register (memranges, type);
904 /* Add a symbol to a collection list. */
906 collect_symbol (struct collection_list *collect,
908 struct gdbarch *gdbarch,
909 long frame_regno, long frame_offset,
914 bfd_signed_vma offset;
915 int treat_as_expr = 0;
917 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
918 switch (SYMBOL_CLASS (sym))
921 printf_filtered ("%s: don't know symbol class %d\n",
922 SYMBOL_PRINT_NAME (sym),
926 printf_filtered ("constant %s (value %ld) will not be collected.\n",
927 SYMBOL_PRINT_NAME (sym), SYMBOL_VALUE (sym));
930 offset = SYMBOL_VALUE_ADDRESS (sym);
935 sprintf_vma (tmp, offset);
936 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
937 SYMBOL_PRINT_NAME (sym), len,
940 /* A struct may be a C++ class with static fields, go to general
941 expression handling. */
942 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
945 add_memrange (collect, memrange_absolute, offset, len);
948 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
950 printf_filtered ("LOC_REG[parm] %s: ",
951 SYMBOL_PRINT_NAME (sym));
952 add_register (collect, reg);
953 /* Check for doubles stored in two registers. */
954 /* FIXME: how about larger types stored in 3 or more regs? */
955 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
956 len > register_size (gdbarch, reg))
957 add_register (collect, reg + 1);
960 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
961 printf_filtered (" (will not collect %s)\n",
962 SYMBOL_PRINT_NAME (sym));
966 offset = frame_offset + SYMBOL_VALUE (sym);
969 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
970 SYMBOL_PRINT_NAME (sym), len);
972 printf_filtered (" from frame ptr reg %d\n", reg);
974 add_memrange (collect, reg, offset, len);
976 case LOC_REGPARM_ADDR:
977 reg = SYMBOL_VALUE (sym);
981 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
982 SYMBOL_PRINT_NAME (sym), len);
984 printf_filtered (" from reg %d\n", reg);
986 add_memrange (collect, reg, offset, len);
990 offset = frame_offset + SYMBOL_VALUE (sym);
993 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
994 SYMBOL_PRINT_NAME (sym), len);
996 printf_filtered (" from frame ptr reg %d\n", reg);
998 add_memrange (collect, reg, offset, len);
1001 case LOC_UNRESOLVED:
1005 case LOC_OPTIMIZED_OUT:
1006 printf_filtered ("%s has been optimized out of existence.\n",
1007 SYMBOL_PRINT_NAME (sym));
1015 /* Expressions are the most general case. */
1018 struct agent_expr *aexpr;
1019 struct cleanup *old_chain1 = NULL;
1021 aexpr = gen_trace_for_var (scope, gdbarch, sym);
1023 /* It can happen that the symbol is recorded as a computed
1024 location, but it's been optimized away and doesn't actually
1025 have a location expression. */
1028 printf_filtered ("%s has been optimized out of existence.\n",
1029 SYMBOL_PRINT_NAME (sym));
1033 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1037 report_agent_reqs_errors (aexpr);
1039 discard_cleanups (old_chain1);
1040 add_aexpr (collect, aexpr);
1042 /* Take care of the registers. */
1043 if (aexpr->reg_mask_len > 0)
1047 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1049 QUIT; /* Allow user to bail out with ^C. */
1050 if (aexpr->reg_mask[ndx1] != 0)
1052 /* Assume chars have 8 bits. */
1053 for (ndx2 = 0; ndx2 < 8; ndx2++)
1054 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1055 /* It's used -- record it. */
1056 add_register (collect, ndx1 * 8 + ndx2);
1063 /* Data to be passed around in the calls to the locals and args
1066 struct add_local_symbols_data
1068 struct collection_list *collect;
1069 struct gdbarch *gdbarch;
1076 /* The callback for the locals and args iterators. */
1079 do_collect_symbol (const char *print_name,
1083 struct add_local_symbols_data *p = cb_data;
1085 collect_symbol (p->collect, sym, p->gdbarch, p->frame_regno,
1086 p->frame_offset, p->pc);
1090 /* Add all locals (or args) symbols to collection list. */
1092 add_local_symbols (struct collection_list *collect,
1093 struct gdbarch *gdbarch, CORE_ADDR pc,
1094 long frame_regno, long frame_offset, int type)
1096 struct block *block;
1097 struct add_local_symbols_data cb_data;
1099 cb_data.collect = collect;
1100 cb_data.gdbarch = gdbarch;
1102 cb_data.frame_regno = frame_regno;
1103 cb_data.frame_offset = frame_offset;
1108 block = block_for_pc (pc);
1111 warning (_("Can't collect locals; "
1112 "no symbol table info available.\n"));
1116 iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1117 if (cb_data.count == 0)
1118 warning (_("No locals found in scope."));
1122 pc = get_pc_function_start (pc);
1123 block = block_for_pc (pc);
1126 warning (_("Can't collect args; no symbol table info available."));
1130 iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1131 if (cb_data.count == 0)
1132 warning (_("No args found in scope."));
1137 add_static_trace_data (struct collection_list *collection)
1140 printf_filtered ("collect static trace data\n");
1141 collection->strace_data = 1;
1144 /* worker function */
1146 clear_collection_list (struct collection_list *list)
1150 list->next_memrange = 0;
1151 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1153 free_agent_expr (list->aexpr_list[ndx]);
1154 list->aexpr_list[ndx] = NULL;
1156 list->next_aexpr_elt = 0;
1157 memset (list->regs_mask, 0, sizeof (list->regs_mask));
1158 list->strace_data = 0;
1161 /* Reduce a collection list to string form (for gdb protocol). */
1163 stringify_collection_list (struct collection_list *list, char *string)
1165 char temp_buf[2048];
1169 char *(*str_list)[];
1173 count = 1 + 1 + list->next_memrange + list->next_aexpr_elt + 1;
1174 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1176 if (list->strace_data)
1179 printf_filtered ("\nCollecting static trace data\n");
1182 (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
1186 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1187 if (list->regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */
1189 if (list->regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
1192 printf_filtered ("\nCollecting registers (mask): 0x");
1197 QUIT; /* Allow user to bail out with ^C. */
1199 printf_filtered ("%02X", list->regs_mask[i]);
1200 sprintf (end, "%02X", list->regs_mask[i]);
1203 (*str_list)[ndx] = xstrdup (temp_buf);
1207 printf_filtered ("\n");
1208 if (list->next_memrange > 0 && info_verbose)
1209 printf_filtered ("Collecting memranges: \n");
1210 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1212 QUIT; /* Allow user to bail out with ^C. */
1213 sprintf_vma (tmp2, list->list[i].start);
1216 printf_filtered ("(%d, %s, %ld)\n",
1219 (long) (list->list[i].end - list->list[i].start));
1221 if (count + 27 > MAX_AGENT_EXPR_LEN)
1223 (*str_list)[ndx] = savestring (temp_buf, count);
1230 bfd_signed_vma length = list->list[i].end - list->list[i].start;
1232 /* The "%X" conversion specifier expects an unsigned argument,
1233 so passing -1 (memrange_absolute) to it directly gives you
1234 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1236 if (list->list[i].type == memrange_absolute)
1237 sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
1239 sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
1242 count += strlen (end);
1243 end = temp_buf + count;
1246 for (i = 0; i < list->next_aexpr_elt; i++)
1248 QUIT; /* Allow user to bail out with ^C. */
1249 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1251 (*str_list)[ndx] = savestring (temp_buf, count);
1256 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1257 end += 10; /* 'X' + 8 hex digits + ',' */
1260 end = mem2hex (list->aexpr_list[i]->buf,
1261 end, list->aexpr_list[i]->len);
1262 count += 2 * list->aexpr_list[i]->len;
1267 (*str_list)[ndx] = savestring (temp_buf, count);
1272 (*str_list)[ndx] = NULL;
1285 encode_actions_1 (struct command_line *action,
1286 struct breakpoint *t,
1287 struct bp_location *tloc,
1289 LONGEST frame_offset,
1290 struct collection_list *collect,
1291 struct collection_list *stepping_list)
1294 struct expression *exp = NULL;
1296 struct value *tempval;
1297 struct cmd_list_element *cmd;
1298 struct agent_expr *aexpr;
1300 for (; action; action = action->next)
1302 QUIT; /* Allow user to bail out with ^C. */
1303 action_exp = action->line;
1304 while (isspace ((int) *action_exp))
1307 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1309 error (_("Bad action list item: %s"), action_exp);
1311 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1314 { /* Repeat over a comma-separated list. */
1315 QUIT; /* Allow user to bail out with ^C. */
1316 while (isspace ((int) *action_exp))
1319 if (0 == strncasecmp ("$reg", action_exp, 4))
1321 for (i = 0; i < gdbarch_num_regs (t->gdbarch); i++)
1322 add_register (collect, i);
1323 action_exp = strchr (action_exp, ','); /* more? */
1325 else if (0 == strncasecmp ("$arg", action_exp, 4))
1327 add_local_symbols (collect,
1333 action_exp = strchr (action_exp, ','); /* more? */
1335 else if (0 == strncasecmp ("$loc", action_exp, 4))
1337 add_local_symbols (collect,
1343 action_exp = strchr (action_exp, ','); /* more? */
1345 else if (0 == strncasecmp ("$_sdata", action_exp, 7))
1347 add_static_trace_data (collect);
1348 action_exp = strchr (action_exp, ','); /* more? */
1352 unsigned long addr, len;
1353 struct cleanup *old_chain = NULL;
1354 struct cleanup *old_chain1 = NULL;
1356 exp = parse_exp_1 (&action_exp,
1357 block_for_pc (tloc->address), 1);
1358 old_chain = make_cleanup (free_current_contents, &exp);
1360 switch (exp->elts[0].opcode)
1364 const char *name = &exp->elts[2].string;
1366 i = user_reg_map_name_to_regnum (t->gdbarch,
1367 name, strlen (name));
1369 internal_error (__FILE__, __LINE__,
1370 _("Register $%s not available"),
1373 printf_filtered ("OP_REGISTER: ");
1374 add_register (collect, i);
1379 /* Safe because we know it's a simple expression. */
1380 tempval = evaluate_expression (exp);
1381 addr = value_address (tempval);
1382 len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
1383 add_memrange (collect, memrange_absolute, addr, len);
1387 collect_symbol (collect,
1388 exp->elts[2].symbol,
1395 default: /* Full-fledged expression. */
1396 aexpr = gen_trace_for_expr (tloc->address, exp);
1398 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1402 report_agent_reqs_errors (aexpr);
1404 discard_cleanups (old_chain1);
1405 add_aexpr (collect, aexpr);
1407 /* Take care of the registers. */
1408 if (aexpr->reg_mask_len > 0)
1413 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1415 QUIT; /* Allow user to bail out with ^C. */
1416 if (aexpr->reg_mask[ndx1] != 0)
1418 /* Assume chars have 8 bits. */
1419 for (ndx2 = 0; ndx2 < 8; ndx2++)
1420 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1421 /* It's used -- record it. */
1422 add_register (collect,
1429 do_cleanups (old_chain);
1432 while (action_exp && *action_exp++ == ',');
1434 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1437 { /* Repeat over a comma-separated list. */
1438 QUIT; /* Allow user to bail out with ^C. */
1439 while (isspace ((int) *action_exp))
1443 struct cleanup *old_chain = NULL;
1444 struct cleanup *old_chain1 = NULL;
1446 exp = parse_exp_1 (&action_exp,
1447 block_for_pc (tloc->address), 1);
1448 old_chain = make_cleanup (free_current_contents, &exp);
1450 aexpr = gen_eval_for_expr (tloc->address, exp);
1451 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1454 report_agent_reqs_errors (aexpr);
1456 discard_cleanups (old_chain1);
1457 /* Even though we're not officially collecting, add
1458 to the collect list anyway. */
1459 add_aexpr (collect, aexpr);
1461 do_cleanups (old_chain);
1464 while (action_exp && *action_exp++ == ',');
1466 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1468 /* We check against nested while-stepping when setting
1469 breakpoint action, so no way to run into nested
1471 gdb_assert (stepping_list);
1473 encode_actions_1 (action->body_list[0], t, tloc, frame_reg,
1474 frame_offset, stepping_list, NULL);
1477 error (_("Invalid tracepoint command '%s'"), action->line);
1481 /* Render all actions into gdb protocol. */
1483 encode_actions (struct breakpoint *t, struct bp_location *tloc,
1484 char ***tdp_actions, char ***stepping_actions)
1486 static char tdp_buff[2048], step_buff[2048];
1487 char *default_collect_line = NULL;
1488 struct command_line *actions;
1489 struct command_line *default_collect_action = NULL;
1491 LONGEST frame_offset;
1492 struct cleanup *back_to;
1494 back_to = make_cleanup (null_cleanup, NULL);
1496 clear_collection_list (&tracepoint_list);
1497 clear_collection_list (&stepping_list);
1499 *tdp_actions = NULL;
1500 *stepping_actions = NULL;
1502 gdbarch_virtual_frame_pointer (t->gdbarch,
1503 t->loc->address, &frame_reg, &frame_offset);
1505 actions = breakpoint_commands (t);
1507 /* If there are default expressions to collect, make up a collect
1508 action and prepend to the action list to encode. Note that since
1509 validation is per-tracepoint (local var "xyz" might be valid for
1510 one tracepoint and not another, etc), we make up the action on
1511 the fly, and don't cache it. */
1512 if (*default_collect)
1516 default_collect_line = xstrprintf ("collect %s", default_collect);
1517 make_cleanup (xfree, default_collect_line);
1519 line = default_collect_line;
1520 validate_actionline (&line, t);
1522 default_collect_action = xmalloc (sizeof (struct command_line));
1523 make_cleanup (xfree, default_collect_action);
1524 default_collect_action->next = actions;
1525 default_collect_action->line = line;
1526 actions = default_collect_action;
1528 encode_actions_1 (actions, t, tloc, frame_reg, frame_offset,
1529 &tracepoint_list, &stepping_list);
1531 memrange_sortmerge (&tracepoint_list);
1532 memrange_sortmerge (&stepping_list);
1534 *tdp_actions = stringify_collection_list (&tracepoint_list,
1536 *stepping_actions = stringify_collection_list (&stepping_list,
1539 do_cleanups (back_to);
1543 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1545 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1547 collect->aexpr_list =
1548 xrealloc (collect->aexpr_list,
1549 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1550 collect->aexpr_listsize *= 2;
1552 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1553 collect->next_aexpr_elt++;
1558 start_tracing (void)
1560 VEC(breakpoint_p) *tp_vec = NULL;
1562 struct breakpoint *t;
1563 struct trace_state_variable *tsv;
1564 int any_enabled = 0, num_to_download = 0;
1566 tp_vec = all_tracepoints ();
1568 /* No point in tracing without any tracepoints... */
1569 if (VEC_length (breakpoint_p, tp_vec) == 0)
1571 VEC_free (breakpoint_p, tp_vec);
1572 error (_("No tracepoints defined, not starting trace"));
1575 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1577 if (t->enable_state == bp_enabled)
1580 if ((t->type == bp_fast_tracepoint
1581 ? may_insert_fast_tracepoints
1582 : may_insert_tracepoints))
1585 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1586 (t->type == bp_fast_tracepoint ? "fast " : ""), t->number);
1589 /* No point in tracing with only disabled tracepoints. */
1592 VEC_free (breakpoint_p, tp_vec);
1593 error (_("No tracepoints enabled, not starting trace"));
1596 if (num_to_download <= 0)
1598 VEC_free (breakpoint_p, tp_vec);
1599 error (_("No tracepoints that may be downloaded, not starting trace"));
1602 target_trace_init ();
1604 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1606 if ((t->type == bp_fast_tracepoint
1607 ? !may_insert_fast_tracepoints
1608 : !may_insert_tracepoints))
1611 t->number_on_target = 0;
1612 target_download_tracepoint (t);
1613 t->number_on_target = t->number;
1615 VEC_free (breakpoint_p, tp_vec);
1617 /* Send down all the trace state variables too. */
1618 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1620 target_download_trace_state_variable (tsv);
1623 /* Tell target to treat text-like sections as transparent. */
1624 target_trace_set_readonly_regions ();
1625 /* Set some mode flags. */
1626 target_set_disconnected_tracing (disconnected_tracing);
1627 target_set_circular_trace_buffer (circular_trace_buffer);
1629 /* Now insert traps and begin collecting data. */
1630 target_trace_start ();
1632 /* Reset our local state. */
1633 set_traceframe_num (-1);
1634 set_tracepoint_num (-1);
1635 set_traceframe_context (NULL);
1636 current_trace_status()->running = 1;
1637 clear_traceframe_info ();
1642 Tell target to clear any previous trace experiment.
1643 Walk the list of tracepoints, and send them (and their actions)
1644 to the target. If no errors,
1645 Tell target to start a new trace experiment. */
1648 trace_start_command (char *args, int from_tty)
1650 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1652 if (current_trace_status ()->running)
1655 && !query (_("A trace is running already. Start a new run? ")))
1656 error (_("New trace run not started."));
1664 trace_stop_command (char *args, int from_tty)
1666 if (!current_trace_status ()->running)
1667 error (_("Trace is not running."));
1675 target_trace_stop ();
1676 /* Should change in response to reply? */
1677 current_trace_status ()->running = 0;
1680 /* tstatus command */
1682 trace_status_command (char *args, int from_tty)
1684 struct trace_status *ts = current_trace_status ();
1687 status = target_get_trace_status (ts);
1692 printf_filtered (_("Using a trace file.\n"));
1695 printf_filtered (_("Trace can not be run on this target.\n"));
1700 if (!ts->running_known)
1702 printf_filtered (_("Run/stop status is unknown.\n"));
1704 else if (ts->running)
1706 printf_filtered (_("Trace is running on the target.\n"));
1710 switch (ts->stop_reason)
1712 case trace_never_run:
1713 printf_filtered (_("No trace has been run on the target.\n"));
1716 printf_filtered (_("Trace stopped by a tstop command.\n"));
1718 case trace_buffer_full:
1719 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1721 case trace_disconnected:
1722 printf_filtered (_("Trace stopped because of disconnection.\n"));
1724 case tracepoint_passcount:
1725 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1726 ts->stopping_tracepoint);
1728 case tracepoint_error:
1729 if (ts->stopping_tracepoint)
1730 printf_filtered (_("Trace stopped by an "
1731 "error (%s, tracepoint %d).\n"),
1732 ts->error_desc, ts->stopping_tracepoint);
1734 printf_filtered (_("Trace stopped by an error (%s).\n"),
1737 case trace_stop_reason_unknown:
1738 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1741 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1747 if (ts->traceframes_created >= 0
1748 && ts->traceframe_count != ts->traceframes_created)
1750 printf_filtered (_("Buffer contains %d trace "
1751 "frames (of %d created total).\n"),
1752 ts->traceframe_count, ts->traceframes_created);
1754 else if (ts->traceframe_count >= 0)
1756 printf_filtered (_("Collected %d trace frames.\n"),
1757 ts->traceframe_count);
1760 if (ts->buffer_free >= 0)
1762 if (ts->buffer_size >= 0)
1764 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1765 ts->buffer_free, ts->buffer_size);
1766 if (ts->buffer_size > 0)
1767 printf_filtered (_(" (%d%% full)"),
1768 ((int) ((((long long) (ts->buffer_size
1769 - ts->buffer_free)) * 100)
1770 / ts->buffer_size)));
1771 printf_filtered (_(".\n"));
1774 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1778 if (ts->disconnected_tracing)
1779 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1781 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1783 if (ts->circular_buffer)
1784 printf_filtered (_("Trace buffer is circular.\n"));
1786 /* Now report on what we're doing with tfind. */
1787 if (traceframe_number >= 0)
1788 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1789 traceframe_number, tracepoint_number);
1791 printf_filtered (_("Not looking at any trace frame.\n"));
1794 /* Report the trace status to uiout, in a way suitable for MI, and not
1795 suitable for CLI. If ON_STOP is true, suppress a few fields that
1796 are not meaningful in the -trace-stop response.
1798 The implementation is essentially parallel to trace_status_command, but
1799 merging them will result in unreadable code. */
1801 trace_status_mi (int on_stop)
1803 struct trace_status *ts = current_trace_status ();
1806 status = target_get_trace_status (ts);
1808 if (status == -1 && !ts->from_file)
1810 ui_out_field_string (uiout, "supported", "0");
1815 ui_out_field_string (uiout, "supported", "file");
1817 ui_out_field_string (uiout, "supported", "1");
1819 gdb_assert (ts->running_known);
1823 ui_out_field_string (uiout, "running", "1");
1825 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1826 Given that the frontend gets the status either on -trace-stop, or from
1827 -trace-status after re-connection, it does not seem like this
1828 information is necessary for anything. It is not necessary for either
1829 figuring the vital state of the target nor for navigation of trace
1830 frames. If the frontend wants to show the current state is some
1831 configure dialog, it can request the value when such dialog is
1832 invoked by the user. */
1836 char *stop_reason = NULL;
1837 int stopping_tracepoint = -1;
1840 ui_out_field_string (uiout, "running", "0");
1842 if (ts->stop_reason != trace_stop_reason_unknown)
1844 switch (ts->stop_reason)
1847 stop_reason = "request";
1849 case trace_buffer_full:
1850 stop_reason = "overflow";
1852 case trace_disconnected:
1853 stop_reason = "disconnection";
1855 case tracepoint_passcount:
1856 stop_reason = "passcount";
1857 stopping_tracepoint = ts->stopping_tracepoint;
1859 case tracepoint_error:
1860 stop_reason = "error";
1861 stopping_tracepoint = ts->stopping_tracepoint;
1867 ui_out_field_string (uiout, "stop-reason", stop_reason);
1868 if (stopping_tracepoint != -1)
1869 ui_out_field_int (uiout, "stopping-tracepoint",
1870 stopping_tracepoint);
1871 if (ts->stop_reason == tracepoint_error)
1872 ui_out_field_string (uiout, "error-description",
1878 if (ts->traceframe_count != -1)
1879 ui_out_field_int (uiout, "frames", ts->traceframe_count);
1880 if (ts->traceframes_created != -1)
1881 ui_out_field_int (uiout, "frames-created", ts->traceframes_created);
1882 if (ts->buffer_size != -1)
1883 ui_out_field_int (uiout, "buffer-size", ts->buffer_size);
1884 if (ts->buffer_free != -1)
1885 ui_out_field_int (uiout, "buffer-free", ts->buffer_free);
1887 ui_out_field_int (uiout, "disconnected", ts->disconnected_tracing);
1888 ui_out_field_int (uiout, "circular", ts->circular_buffer);
1891 /* This function handles the details of what to do about an ongoing
1892 tracing run if the user has asked to detach or otherwise disconnect
1895 disconnect_tracing (int from_tty)
1897 /* It can happen that the target that was tracing went away on its
1898 own, and we didn't notice. Get a status update, and if the
1899 current target doesn't even do tracing, then assume it's not
1901 if (target_get_trace_status (current_trace_status ()) < 0)
1902 current_trace_status ()->running = 0;
1904 /* If running interactively, give the user the option to cancel and
1905 then decide what to do differently with the run. Scripts are
1906 just going to disconnect and let the target deal with it,
1907 according to how it's been instructed previously via
1908 disconnected-tracing. */
1909 if (current_trace_status ()->running && from_tty)
1911 if (current_trace_status ()->disconnected_tracing)
1913 if (!query (_("Trace is running and will "
1914 "continue after detach; detach anyway? ")))
1915 error (_("Not confirmed."));
1919 if (!query (_("Trace is running but will "
1920 "stop on detach; detach anyway? ")))
1921 error (_("Not confirmed."));
1925 /* Also we want to be out of tfind mode, otherwise things can get
1926 confusing upon reconnection. Just use these calls instead of
1927 full tfind_1 behavior because we're in the middle of detaching,
1928 and there's no point to updating current stack frame etc. */
1929 set_current_traceframe (-1);
1930 set_traceframe_context (NULL);
1933 /* Worker function for the various flavors of the tfind command. */
1935 tfind_1 (enum trace_find_type type, int num,
1936 ULONGEST addr1, ULONGEST addr2,
1939 int target_frameno = -1, target_tracept = -1;
1940 struct frame_id old_frame_id = null_frame_id;
1941 struct breakpoint *tp;
1943 /* Only try to get the current stack frame if we have a chance of
1944 succeeding. In particular, if we're trying to get a first trace
1945 frame while all threads are running, it's not going to succeed,
1946 so leave it with a default value and let the frame comparison
1947 below (correctly) decide to print out the source location of the
1949 if (!(type == tfind_number && num == -1)
1950 && (has_stack_frames () || traceframe_number >= 0))
1951 old_frame_id = get_frame_id (get_current_frame ());
1953 target_frameno = target_trace_find (type, num, addr1, addr2,
1956 if (type == tfind_number
1958 && target_frameno == -1)
1960 /* We told the target to get out of tfind mode, and it did. */
1962 else if (target_frameno == -1)
1964 /* A request for a non-existent trace frame has failed.
1965 Our response will be different, depending on FROM_TTY:
1967 If FROM_TTY is true, meaning that this command was
1968 typed interactively by the user, then give an error
1969 and DO NOT change the state of traceframe_number etc.
1971 However if FROM_TTY is false, meaning that we're either
1972 in a script, a loop, or a user-defined command, then
1973 DON'T give an error, but DO change the state of
1974 traceframe_number etc. to invalid.
1976 The rationalle is that if you typed the command, you
1977 might just have committed a typo or something, and you'd
1978 like to NOT lose your current debugging state. However
1979 if you're in a user-defined command or especially in a
1980 loop, then you need a way to detect that the command
1981 failed WITHOUT aborting. This allows you to write
1982 scripts that search thru the trace buffer until the end,
1983 and then continue on to do something else. */
1986 error (_("Target failed to find requested trace frame."));
1990 printf_filtered ("End of trace buffer.\n");
1991 #if 0 /* dubious now? */
1992 /* The following will not recurse, since it's
1994 trace_find_command ("-1", from_tty);
1999 tp = get_tracepoint_by_number_on_target (target_tracept);
2001 reinit_frame_cache ();
2002 registers_changed ();
2003 target_dcache_invalidate ();
2004 set_traceframe_num (target_frameno);
2005 clear_traceframe_info ();
2006 set_tracepoint_num (tp ? tp->number : target_tracept);
2007 if (target_frameno == -1)
2008 set_traceframe_context (NULL);
2010 set_traceframe_context (get_current_frame ());
2012 if (traceframe_number >= 0)
2014 /* Use different branches for MI and CLI to make CLI messages
2016 if (ui_out_is_mi_like_p (uiout))
2018 ui_out_field_string (uiout, "found", "1");
2019 ui_out_field_int (uiout, "tracepoint", tracepoint_number);
2020 ui_out_field_int (uiout, "traceframe", traceframe_number);
2024 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2025 traceframe_number, tracepoint_number);
2030 if (ui_out_is_mi_like_p (uiout))
2031 ui_out_field_string (uiout, "found", "0");
2032 else if (type == tfind_number && num == -1)
2033 printf_unfiltered (_("No longer looking at any trace frame\n"));
2034 else /* This case may never occur, check. */
2035 printf_unfiltered (_("No trace frame found\n"));
2038 /* If we're in nonstop mode and getting out of looking at trace
2039 frames, there won't be any current frame to go back to and
2042 && (has_stack_frames () || traceframe_number >= 0))
2044 enum print_what print_what;
2046 /* NOTE: in imitation of the step command, try to determine
2047 whether we have made a transition from one function to
2048 another. If so, we'll print the "stack frame" (ie. the new
2049 function and it's arguments) -- otherwise we'll just show the
2052 if (frame_id_eq (old_frame_id,
2053 get_frame_id (get_current_frame ())))
2054 print_what = SRC_LINE;
2056 print_what = SRC_AND_LOC;
2058 print_stack_frame (get_selected_frame (NULL), 1, print_what);
2063 /* trace_find_command takes a trace frame number n,
2064 sends "QTFrame:<n>" to the target,
2065 and accepts a reply that may contain several optional pieces
2066 of information: a frame number, a tracepoint number, and an
2067 indication of whether this is a trap frame or a stepping frame.
2069 The minimal response is just "OK" (which indicates that the
2070 target does not give us a frame number or a tracepoint number).
2071 Instead of that, the target may send us a string containing
2073 F<hexnum> (gives the selected frame number)
2074 T<hexnum> (gives the selected tracepoint number)
2079 trace_find_command (char *args, int from_tty)
2080 { /* This should only be called with a numeric argument. */
2083 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2084 error (_("May not look at trace frames while trace is running."));
2086 if (args == 0 || *args == 0)
2087 { /* TFIND with no args means find NEXT trace frame. */
2088 if (traceframe_number == -1)
2089 frameno = 0; /* "next" is first one. */
2091 frameno = traceframe_number + 1;
2093 else if (0 == strcmp (args, "-"))
2095 if (traceframe_number == -1)
2096 error (_("not debugging trace buffer"));
2097 else if (from_tty && traceframe_number == 0)
2098 error (_("already at start of trace buffer"));
2100 frameno = traceframe_number - 1;
2102 /* A hack to work around eval's need for fp to have been collected. */
2103 else if (0 == strcmp (args, "-1"))
2106 frameno = parse_and_eval_long (args);
2109 error (_("invalid input (%d is less than zero)"), frameno);
2111 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2116 trace_find_end_command (char *args, int from_tty)
2118 trace_find_command ("-1", from_tty);
2123 trace_find_none_command (char *args, int from_tty)
2125 trace_find_command ("-1", from_tty);
2130 trace_find_start_command (char *args, int from_tty)
2132 trace_find_command ("0", from_tty);
2135 /* tfind pc command */
2137 trace_find_pc_command (char *args, int from_tty)
2141 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2142 error (_("May not look at trace frames while trace is running."));
2144 if (args == 0 || *args == 0)
2145 pc = regcache_read_pc (get_current_regcache ());
2147 pc = parse_and_eval_address (args);
2149 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2152 /* tfind tracepoint command */
2154 trace_find_tracepoint_command (char *args, int from_tty)
2157 struct breakpoint *tp;
2159 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2160 error (_("May not look at trace frames while trace is running."));
2162 if (args == 0 || *args == 0)
2164 if (tracepoint_number == -1)
2165 error (_("No current tracepoint -- please supply an argument."));
2167 tdp = tracepoint_number; /* Default is current TDP. */
2170 tdp = parse_and_eval_long (args);
2172 /* If we have the tracepoint on hand, use the number that the
2173 target knows about (which may be different if we disconnected
2174 and reconnected). */
2175 tp = get_tracepoint (tdp);
2177 tdp = tp->number_on_target;
2179 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2182 /* TFIND LINE command:
2184 This command will take a sourceline for argument, just like BREAK
2185 or TRACE (ie. anything that "decode_line_1" can handle).
2187 With no argument, this command will find the next trace frame
2188 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2191 trace_find_line_command (char *args, int from_tty)
2193 static CORE_ADDR start_pc, end_pc;
2194 struct symtabs_and_lines sals;
2195 struct symtab_and_line sal;
2196 struct cleanup *old_chain;
2198 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2199 error (_("May not look at trace frames while trace is running."));
2201 if (args == 0 || *args == 0)
2203 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2205 sals.sals = (struct symtab_and_line *)
2206 xmalloc (sizeof (struct symtab_and_line));
2211 sals = decode_line_spec (args, 1);
2215 old_chain = make_cleanup (xfree, sals.sals);
2216 if (sal.symtab == 0)
2217 error (_("No line number information available."));
2219 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2221 if (start_pc == end_pc)
2223 printf_filtered ("Line %d of \"%s\"",
2224 sal.line, sal.symtab->filename);
2226 printf_filtered (" is at address ");
2227 print_address (get_current_arch (), start_pc, gdb_stdout);
2229 printf_filtered (" but contains no code.\n");
2230 sal = find_pc_line (start_pc, 0);
2232 && find_line_pc_range (sal, &start_pc, &end_pc)
2233 && start_pc != end_pc)
2234 printf_filtered ("Attempting to find line %d instead.\n",
2237 error (_("Cannot find a good line."));
2241 /* Is there any case in which we get here, and have an address
2242 which the user would want to see? If we have debugging
2243 symbols and no line numbers? */
2244 error (_("Line number %d is out of range for \"%s\"."),
2245 sal.line, sal.symtab->filename);
2247 /* Find within range of stated line. */
2249 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2251 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2252 do_cleanups (old_chain);
2255 /* tfind range command */
2257 trace_find_range_command (char *args, int from_tty)
2259 static CORE_ADDR start, stop;
2262 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2263 error (_("May not look at trace frames while trace is running."));
2265 if (args == 0 || *args == 0)
2266 { /* XXX FIXME: what should default behavior be? */
2267 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2271 if (0 != (tmp = strchr (args, ',')))
2273 *tmp++ = '\0'; /* Terminate start address. */
2274 while (isspace ((int) *tmp))
2276 start = parse_and_eval_address (args);
2277 stop = parse_and_eval_address (tmp);
2280 { /* No explicit end address? */
2281 start = parse_and_eval_address (args);
2282 stop = start + 1; /* ??? */
2285 tfind_1 (tfind_range, 0, start, stop, from_tty);
2288 /* tfind outside command */
2290 trace_find_outside_command (char *args, int from_tty)
2292 CORE_ADDR start, stop;
2295 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2296 error (_("May not look at trace frames while trace is running."));
2298 if (args == 0 || *args == 0)
2299 { /* XXX FIXME: what should default behavior be? */
2300 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2304 if (0 != (tmp = strchr (args, ',')))
2306 *tmp++ = '\0'; /* Terminate start address. */
2307 while (isspace ((int) *tmp))
2309 start = parse_and_eval_address (args);
2310 stop = parse_and_eval_address (tmp);
2313 { /* No explicit end address? */
2314 start = parse_and_eval_address (args);
2315 stop = start + 1; /* ??? */
2318 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2321 /* info scope command: list the locals for a scope. */
2323 scope_info (char *args, int from_tty)
2325 struct symtabs_and_lines sals;
2327 struct minimal_symbol *msym;
2328 struct block *block;
2329 char *symname, *save_args = args;
2330 struct dict_iterator iter;
2332 struct gdbarch *gdbarch;
2335 if (args == 0 || *args == 0)
2336 error (_("requires an argument (function, "
2337 "line or *addr) to define a scope"));
2339 sals = decode_line_1 (&args, 1, NULL, 0, NULL);
2340 if (sals.nelts == 0)
2341 return; /* Presumably decode_line_1 has already warned. */
2343 /* Resolve line numbers to PC. */
2344 resolve_sal_pc (&sals.sals[0]);
2345 block = block_for_pc (sals.sals[0].pc);
2349 QUIT; /* Allow user to bail out with ^C. */
2350 ALL_BLOCK_SYMBOLS (block, iter, sym)
2352 QUIT; /* Allow user to bail out with ^C. */
2354 printf_filtered ("Scope for %s:\n", save_args);
2357 symname = SYMBOL_PRINT_NAME (sym);
2358 if (symname == NULL || *symname == '\0')
2359 continue; /* Probably botched, certainly useless. */
2361 gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
2363 printf_filtered ("Symbol %s is ", symname);
2364 switch (SYMBOL_CLASS (sym))
2367 case LOC_UNDEF: /* Messed up symbol? */
2368 printf_filtered ("a bogus symbol, class %d.\n",
2369 SYMBOL_CLASS (sym));
2370 count--; /* Don't count this one. */
2373 printf_filtered ("a constant with value %ld (0x%lx)",
2374 SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
2376 case LOC_CONST_BYTES:
2377 printf_filtered ("constant bytes: ");
2378 if (SYMBOL_TYPE (sym))
2379 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2380 fprintf_filtered (gdb_stdout, " %02x",
2381 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2384 printf_filtered ("in static storage at address ");
2385 printf_filtered ("%s", paddress (gdbarch,
2386 SYMBOL_VALUE_ADDRESS (sym)));
2389 /* GDBARCH is the architecture associated with the objfile
2390 the symbol is defined in; the target architecture may be
2391 different, and may provide additional registers. However,
2392 we do not know the target architecture at this point.
2393 We assume the objfile architecture will contain all the
2394 standard registers that occur in debug info in that
2396 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2399 if (SYMBOL_IS_ARGUMENT (sym))
2400 printf_filtered ("an argument in register $%s",
2401 gdbarch_register_name (gdbarch, regno));
2403 printf_filtered ("a local variable in register $%s",
2404 gdbarch_register_name (gdbarch, regno));
2407 printf_filtered ("an argument at stack/frame offset %ld",
2408 SYMBOL_VALUE (sym));
2411 printf_filtered ("a local variable at frame offset %ld",
2412 SYMBOL_VALUE (sym));
2415 printf_filtered ("a reference argument at offset %ld",
2416 SYMBOL_VALUE (sym));
2418 case LOC_REGPARM_ADDR:
2419 /* Note comment at LOC_REGISTER. */
2420 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2422 printf_filtered ("the address of an argument, in register $%s",
2423 gdbarch_register_name (gdbarch, regno));
2426 printf_filtered ("a typedef.\n");
2429 printf_filtered ("a label at address ");
2430 printf_filtered ("%s", paddress (gdbarch,
2431 SYMBOL_VALUE_ADDRESS (sym)));
2434 printf_filtered ("a function at address ");
2435 printf_filtered ("%s",
2436 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2438 case LOC_UNRESOLVED:
2439 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2442 printf_filtered ("Unresolved Static");
2445 printf_filtered ("static storage at address ");
2446 printf_filtered ("%s",
2447 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msym)));
2450 case LOC_OPTIMIZED_OUT:
2451 printf_filtered ("optimized out.\n");
2454 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2455 BLOCK_START (block),
2459 if (SYMBOL_TYPE (sym))
2460 printf_filtered (", length %d.\n",
2461 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2463 if (BLOCK_FUNCTION (block))
2466 block = BLOCK_SUPERBLOCK (block);
2469 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2473 /* worker function (cleanup) */
2475 replace_comma (void *data)
2482 /* Helper for trace_dump_command. Dump the action list starting at
2483 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2484 actions of the body of a while-stepping action. STEPPING_FRAME is
2485 set if the current traceframe was determined to be a while-stepping
2489 trace_dump_actions (struct command_line *action,
2490 int stepping_actions, int stepping_frame,
2493 char *action_exp, *next_comma;
2495 for (; action != NULL; action = action->next)
2497 struct cmd_list_element *cmd;
2499 QUIT; /* Allow user to bail out with ^C. */
2500 action_exp = action->line;
2501 while (isspace ((int) *action_exp))
2504 /* The collection actions to be done while stepping are
2505 bracketed by the commands "while-stepping" and "end". */
2507 if (*action_exp == '#') /* comment line */
2510 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2512 error (_("Bad action list item: %s"), action_exp);
2514 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2518 for (i = 0; i < action->body_count; ++i)
2519 trace_dump_actions (action->body_list[i],
2520 1, stepping_frame, from_tty);
2522 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2524 /* Display the collected data.
2525 For the trap frame, display only what was collected at
2526 the trap. Likewise for stepping frames, display only
2527 what was collected while stepping. This means that the
2528 two boolean variables, STEPPING_FRAME and
2529 STEPPING_ACTIONS should be equal. */
2530 if (stepping_frame == stepping_actions)
2533 { /* Repeat over a comma-separated list. */
2534 QUIT; /* Allow user to bail out with ^C. */
2535 if (*action_exp == ',')
2537 while (isspace ((int) *action_exp))
2540 next_comma = strchr (action_exp, ',');
2542 if (0 == strncasecmp (action_exp, "$reg", 4))
2543 registers_info (NULL, from_tty);
2544 else if (0 == strncasecmp (action_exp, "$loc", 4))
2545 locals_info (NULL, from_tty);
2546 else if (0 == strncasecmp (action_exp, "$arg", 4))
2547 args_info (NULL, from_tty);
2552 make_cleanup (replace_comma, next_comma);
2555 printf_filtered ("%s = ", action_exp);
2556 output_command (action_exp, from_tty);
2557 printf_filtered ("\n");
2561 action_exp = next_comma;
2563 while (action_exp && *action_exp == ',');
2569 /* The tdump command. */
2572 trace_dump_command (char *args, int from_tty)
2574 struct regcache *regcache;
2575 struct breakpoint *t;
2576 int stepping_frame = 0;
2577 struct bp_location *loc;
2578 char *line, *default_collect_line = NULL;
2579 struct command_line *actions, *default_collect_action = NULL;
2580 struct cleanup *old_chain = NULL;
2582 if (tracepoint_number == -1)
2584 warning (_("No current trace frame."));
2588 t = get_tracepoint (tracepoint_number);
2591 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2594 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2595 tracepoint_number, traceframe_number);
2597 /* The current frame is a trap frame if the frame PC is equal
2598 to the tracepoint PC. If not, then the current frame was
2599 collected during single-stepping. */
2601 regcache = get_current_regcache ();
2603 /* If the traceframe's address matches any of the tracepoint's
2604 locations, assume it is a direct hit rather than a while-stepping
2605 frame. (FIXME this is not reliable, should record each frame's
2608 for (loc = t->loc; loc; loc = loc->next)
2609 if (loc->address == regcache_read_pc (regcache))
2612 actions = breakpoint_commands (t);
2614 /* If there is a default-collect list, make up a collect command,
2615 prepend to the tracepoint's commands, and pass the whole mess to
2616 the trace dump scanner. We need to validate because
2617 default-collect might have been junked since the trace run. */
2618 if (*default_collect)
2620 default_collect_line = xstrprintf ("collect %s", default_collect);
2621 old_chain = make_cleanup (xfree, default_collect_line);
2622 line = default_collect_line;
2623 validate_actionline (&line, t);
2624 default_collect_action = xmalloc (sizeof (struct command_line));
2625 make_cleanup (xfree, default_collect_action);
2626 default_collect_action->next = actions;
2627 default_collect_action->line = line;
2628 actions = default_collect_action;
2631 trace_dump_actions (actions, 0, stepping_frame, from_tty);
2633 if (*default_collect)
2634 do_cleanups (old_chain);
2637 /* Encode a piece of a tracepoint's source-level definition in a form
2638 that is suitable for both protocol and saving in files. */
2639 /* This version does not do multiple encodes for long strings; it should
2640 return an offset to the next piece to encode. FIXME */
2643 encode_source_string (int tpnum, ULONGEST addr,
2644 char *srctype, char *src, char *buf, int buf_size)
2646 if (80 + strlen (srctype) > buf_size)
2647 error (_("Buffer too small for source encoding"));
2648 sprintf (buf, "%x:%s:%s:%x:%x:",
2649 tpnum, phex_nz (addr, sizeof (addr)),
2650 srctype, 0, (int) strlen (src));
2651 if (strlen (buf) + strlen (src) * 2 >= buf_size)
2652 error (_("Source string too long for buffer"));
2653 bin2hex (src, buf + strlen (buf), 0);
2657 extern int trace_regblock_size;
2659 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2660 non-zero, the save is performed on the target, otherwise GDB obtains all
2661 trace data and saves it locally. */
2664 trace_save (const char *filename, int target_does_save)
2666 struct cleanup *cleanup;
2668 struct trace_status *ts = current_trace_status ();
2671 struct uploaded_tp *uploaded_tps = NULL, *utp;
2672 struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
2676 ULONGEST offset = 0;
2677 #define MAX_TRACE_UPLOAD 2000
2678 gdb_byte buf[MAX_TRACE_UPLOAD];
2681 /* If the target is to save the data to a file on its own, then just
2682 send the command and be done with it. */
2683 if (target_does_save)
2685 err = target_save_trace_data (filename);
2687 error (_("Target failed to save trace data to '%s'."),
2692 /* Get the trace status first before opening the file, so if the
2693 target is losing, we can get out without touching files. */
2694 status = target_get_trace_status (ts);
2696 pathname = tilde_expand (filename);
2697 cleanup = make_cleanup (xfree, pathname);
2699 fp = fopen (pathname, "wb");
2701 error (_("Unable to open file '%s' for saving trace data (%s)"),
2702 filename, safe_strerror (errno));
2703 make_cleanup_fclose (fp);
2705 /* Write a file header, with a high-bit-set char to indicate a
2706 binary file, plus a hint as what this file is, and a version
2707 number in case of future needs. */
2708 written = fwrite ("\x7fTRACE0\n", 8, 1, fp);
2710 perror_with_name (pathname);
2712 /* Write descriptive info. */
2714 /* Write out the size of a register block. */
2715 fprintf (fp, "R %x\n", trace_regblock_size);
2717 /* Write out status of the tracing run (aka "tstatus" info). */
2718 fprintf (fp, "status %c;%s",
2719 (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
2720 if (ts->stop_reason == tracepoint_error)
2722 char *buf = (char *) alloca (strlen (ts->error_desc) * 2 + 1);
2724 bin2hex ((gdb_byte *) ts->error_desc, buf, 0);
2725 fprintf (fp, ":%s", buf);
2727 fprintf (fp, ":%x", ts->stopping_tracepoint);
2728 if (ts->traceframe_count >= 0)
2729 fprintf (fp, ";tframes:%x", ts->traceframe_count);
2730 if (ts->traceframes_created >= 0)
2731 fprintf (fp, ";tcreated:%x", ts->traceframes_created);
2732 if (ts->buffer_free >= 0)
2733 fprintf (fp, ";tfree:%x", ts->buffer_free);
2734 if (ts->buffer_size >= 0)
2735 fprintf (fp, ";tsize:%x", ts->buffer_size);
2736 if (ts->disconnected_tracing)
2737 fprintf (fp, ";disconn:%x", ts->disconnected_tracing);
2738 if (ts->circular_buffer)
2739 fprintf (fp, ";circular:%x", ts->circular_buffer);
2742 /* Note that we want to upload tracepoints and save those, rather
2743 than simply writing out the local ones, because the user may have
2744 changed tracepoints in GDB in preparation for a future tracing
2745 run, or maybe just mass-deleted all types of breakpoints as part
2746 of cleaning up. So as not to contaminate the session, leave the
2747 data in its uploaded form, don't make into real tracepoints. */
2749 /* Get trace state variables first, they may be checked when parsing
2750 uploaded commands. */
2752 target_upload_trace_state_variables (&uploaded_tsvs);
2754 for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
2760 buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
2761 bin2hex ((gdb_byte *) (utsv->name), buf, 0);
2764 fprintf (fp, "tsv %x:%s:%x:%s\n",
2765 utsv->number, phex_nz (utsv->initial_value, 8),
2766 utsv->builtin, buf);
2772 free_uploaded_tsvs (&uploaded_tsvs);
2774 target_upload_tracepoints (&uploaded_tps);
2776 for (utp = uploaded_tps; utp; utp = utp->next)
2778 fprintf (fp, "tp T%x:%s:%c:%x:%x",
2779 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
2780 (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
2781 if (utp->type == bp_fast_tracepoint)
2782 fprintf (fp, ":F%x", utp->orig_size);
2784 fprintf (fp, ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
2787 for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
2788 fprintf (fp, "tp A%x:%s:%s\n",
2789 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
2790 for (a = 0; VEC_iterate (char_ptr, utp->step_actions, a, act); ++a)
2791 fprintf (fp, "tp S%x:%s:%s\n",
2792 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
2795 encode_source_string (utp->number, utp->addr,
2796 "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
2797 fprintf (fp, "tp Z%s\n", buf);
2799 if (utp->cond_string)
2801 encode_source_string (utp->number, utp->addr,
2802 "cond", utp->cond_string,
2803 buf, MAX_TRACE_UPLOAD);
2804 fprintf (fp, "tp Z%s\n", buf);
2806 for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
2808 encode_source_string (utp->number, utp->addr, "cmd", act,
2809 buf, MAX_TRACE_UPLOAD);
2810 fprintf (fp, "tp Z%s\n", buf);
2814 free_uploaded_tps (&uploaded_tps);
2816 /* Mark the end of the definition section. */
2819 /* Get and write the trace data proper. We ask for big blocks, in
2820 the hopes of efficiency, but will take less if the target has
2821 packet size limitations or some such. */
2824 gotten = target_get_raw_trace_data (buf, offset, MAX_TRACE_UPLOAD);
2826 error (_("Failure to get requested trace buffer data"));
2827 /* No more data is forthcoming, we're done. */
2830 written = fwrite (buf, gotten, 1, fp);
2832 perror_with_name (pathname);
2836 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
2837 written = fwrite (&gotten, 4, 1, fp);
2839 perror_with_name (pathname);
2841 do_cleanups (cleanup);
2845 trace_save_command (char *args, int from_tty)
2847 int target_does_save = 0;
2849 char *filename = NULL;
2850 struct cleanup *back_to;
2853 error_no_arg (_("file in which to save trace data"));
2855 argv = gdb_buildargv (args);
2856 back_to = make_cleanup_freeargv (argv);
2858 for (; *argv; ++argv)
2860 if (strcmp (*argv, "-r") == 0)
2861 target_does_save = 1;
2862 else if (**argv == '-')
2863 error (_("unknown option `%s'"), *argv);
2869 error_no_arg (_("file in which to save trace data"));
2871 trace_save (filename, target_does_save);
2874 printf_filtered (_("Trace data saved to file '%s'.\n"), args);
2876 do_cleanups (back_to);
2879 /* Tell the target what to do with an ongoing tracing run if GDB
2880 disconnects for some reason. */
2883 send_disconnected_tracing_value (int value)
2885 target_set_disconnected_tracing (value);
2889 set_disconnected_tracing (char *args, int from_tty,
2890 struct cmd_list_element *c)
2892 send_disconnected_tracing_value (disconnected_tracing);
2896 set_circular_trace_buffer (char *args, int from_tty,
2897 struct cmd_list_element *c)
2899 target_set_circular_trace_buffer (circular_trace_buffer);
2902 /* Convert the memory pointed to by mem into hex, placing result in buf.
2903 * Return a pointer to the last char put in buf (null)
2904 * "stolen" from sparc-stub.c
2907 static const char hexchars[] = "0123456789abcdef";
2910 mem2hex (gdb_byte *mem, char *buf, int count)
2918 *buf++ = hexchars[ch >> 4];
2919 *buf++ = hexchars[ch & 0xf];
2928 get_traceframe_number (void)
2930 return traceframe_number;
2933 /* Make the traceframe NUM be the current trace frame. Does nothing
2934 if NUM is already current. */
2937 set_current_traceframe (int num)
2941 if (traceframe_number == num)
2943 /* Nothing to do. */
2947 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
2950 warning (_("could not change traceframe"));
2952 traceframe_number = newnum;
2954 /* Changing the traceframe changes our view of registers and of the
2956 registers_changed ();
2958 clear_traceframe_info ();
2961 /* Make the traceframe NUM be the current trace frame, and do nothing
2965 set_traceframe_number (int num)
2967 traceframe_number = num;
2970 /* A cleanup used when switching away and back from tfind mode. */
2972 struct current_traceframe_cleanup
2974 /* The traceframe we were inspecting. */
2975 int traceframe_number;
2979 do_restore_current_traceframe_cleanup (void *arg)
2981 struct current_traceframe_cleanup *old = arg;
2983 set_current_traceframe (old->traceframe_number);
2987 restore_current_traceframe_cleanup_dtor (void *arg)
2989 struct current_traceframe_cleanup *old = arg;
2995 make_cleanup_restore_current_traceframe (void)
2997 struct current_traceframe_cleanup *old;
2999 old = xmalloc (sizeof (struct current_traceframe_cleanup));
3000 old->traceframe_number = traceframe_number;
3002 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
3003 restore_current_traceframe_cleanup_dtor);
3007 make_cleanup_restore_traceframe_number (void)
3009 return make_cleanup_restore_integer (&traceframe_number);
3012 /* Given a number and address, return an uploaded tracepoint with that
3013 number, creating if necessary. */
3015 struct uploaded_tp *
3016 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
3018 struct uploaded_tp *utp;
3020 for (utp = *utpp; utp; utp = utp->next)
3021 if (utp->number == num && utp->addr == addr)
3023 utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
3024 memset (utp, 0, sizeof (struct uploaded_tp));
3027 utp->actions = NULL;
3028 utp->step_actions = NULL;
3029 utp->cmd_strings = NULL;
3036 free_uploaded_tps (struct uploaded_tp **utpp)
3038 struct uploaded_tp *next_one;
3042 next_one = (*utpp)->next;
3048 /* Given a number and address, return an uploaded tracepoint with that
3049 number, creating if necessary. */
3051 struct uploaded_tsv *
3052 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3054 struct uploaded_tsv *utsv;
3056 for (utsv = *utsvp; utsv; utsv = utsv->next)
3057 if (utsv->number == num)
3059 utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
3060 memset (utsv, 0, sizeof (struct uploaded_tsv));
3062 utsv->next = *utsvp;
3068 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3070 struct uploaded_tsv *next_one;
3074 next_one = (*utsvp)->next;
3080 /* Look for an existing tracepoint that seems similar enough to the
3081 uploaded one. Enablement isn't compared, because the user can
3082 toggle that freely, and may have done so in anticipation of the
3086 find_matching_tracepoint (struct uploaded_tp *utp)
3088 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
3090 struct breakpoint *t;
3091 struct bp_location *loc;
3093 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
3095 if (t->type == utp->type
3096 && t->step_count == utp->step
3097 && t->pass_count == utp->pass
3098 /* FIXME also test conditionals and actions. */
3101 /* Scan the locations for an address match. */
3102 for (loc = t->loc; loc; loc = loc->next)
3104 if (loc->address == utp->addr)
3112 /* Given a list of tracepoints uploaded from a target, attempt to
3113 match them up with existing tracepoints, and create new ones if not
3117 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3119 struct uploaded_tp *utp;
3120 struct breakpoint *t;
3122 /* Look for GDB tracepoints that match up with our uploaded versions. */
3123 for (utp = *uploaded_tps; utp; utp = utp->next)
3125 t = find_matching_tracepoint (utp);
3127 printf_filtered (_("Assuming tracepoint %d is same "
3128 "as target's tracepoint %d at %s.\n"),
3129 t->number, utp->number,
3130 paddress (get_current_arch (), utp->addr));
3133 t = create_tracepoint_from_upload (utp);
3135 printf_filtered (_("Created tracepoint %d for "
3136 "target's tracepoint %d at %s.\n"),
3137 t->number, utp->number,
3138 paddress (get_current_arch (), utp->addr));
3140 printf_filtered (_("Failed to create tracepoint for target's "
3141 "tracepoint %d at %s, skipping it.\n"),
3143 paddress (get_current_arch (), utp->addr));
3145 /* Whether found or created, record the number used by the
3146 target, to help with mapping target tracepoints back to their
3147 counterparts here. */
3149 t->number_on_target = utp->number;
3152 free_uploaded_tps (uploaded_tps);
3155 /* Trace state variables don't have much to identify them beyond their
3156 name, so just use that to detect matches. */
3158 struct trace_state_variable *
3159 find_matching_tsv (struct uploaded_tsv *utsv)
3164 return find_trace_state_variable (utsv->name);
3167 struct trace_state_variable *
3168 create_tsv_from_upload (struct uploaded_tsv *utsv)
3170 const char *namebase;
3173 struct trace_state_variable *tsv;
3177 namebase = utsv->name;
3178 sprintf (buf, "%s", namebase);
3183 sprintf (buf, "%s_%d", namebase, try_num++);
3186 /* Fish for a name that is not in use. */
3187 /* (should check against all internal vars?) */
3188 while (find_trace_state_variable (buf))
3189 sprintf (buf, "%s_%d", namebase, try_num++);
3191 /* We have an available name, create the variable. */
3192 tsv = create_trace_state_variable (buf);
3193 tsv->initial_value = utsv->initial_value;
3194 tsv->builtin = utsv->builtin;
3199 /* Given a list of uploaded trace state variables, try to match them
3200 up with existing variables, or create additional ones. */
3203 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
3206 struct uploaded_tsv *utsv;
3207 struct trace_state_variable *tsv;
3210 /* Most likely some numbers will have to be reassigned as part of
3211 the merge, so clear them all in anticipation. */
3212 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3215 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
3217 tsv = find_matching_tsv (utsv);
3221 printf_filtered (_("Assuming trace state variable $%s "
3222 "is same as target's variable %d.\n"),
3223 tsv->name, utsv->number);
3227 tsv = create_tsv_from_upload (utsv);
3229 printf_filtered (_("Created trace state variable "
3230 "$%s for target's variable %d.\n"),
3231 tsv->name, utsv->number);
3233 /* Give precedence to numberings that come from the target. */
3235 tsv->number = utsv->number;
3238 /* Renumber everything that didn't get a target-assigned number. */
3240 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3241 if (tsv->number > highest)
3242 highest = tsv->number;
3245 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3246 if (tsv->number == 0)
3247 tsv->number = highest++;
3249 free_uploaded_tsvs (uploaded_tsvs);
3252 /* target tfile command */
3254 struct target_ops tfile_ops;
3256 /* Fill in tfile_ops with its defined operations and properties. */
3258 #define TRACE_HEADER_SIZE 8
3260 char *trace_filename;
3262 off_t trace_frames_offset;
3264 int cur_traceframe_number;
3266 int trace_regblock_size;
3268 static void tfile_interp_line (char *line,
3269 struct uploaded_tp **utpp,
3270 struct uploaded_tsv **utsvp);
3272 /* Read SIZE bytes into READBUF from the trace frame, starting at
3273 TRACE_FD's current position. Note that this call `read'
3274 underneath, hence it advances the file's seek position. Throws an
3275 error if the `read' syscall fails, or less than SIZE bytes are
3279 tfile_read (gdb_byte *readbuf, int size)
3283 gotten = read (trace_fd, readbuf, size);
3285 perror_with_name (trace_filename);
3286 else if (gotten < size)
3287 error (_("Premature end of file while reading trace file"));
3291 tfile_open (char *filename, int from_tty)
3293 volatile struct gdb_exception ex;
3295 struct cleanup *old_chain;
3298 char header[TRACE_HEADER_SIZE];
3299 char linebuf[1000]; /* Should be max remote packet size or so. */
3302 struct trace_status *ts;
3303 struct uploaded_tp *uploaded_tps = NULL;
3304 struct uploaded_tsv *uploaded_tsvs = NULL;
3306 target_preopen (from_tty);
3308 error (_("No trace file specified."));
3310 filename = tilde_expand (filename);
3311 if (!IS_ABSOLUTE_PATH(filename))
3313 temp = concat (current_directory, "/", filename, (char *) NULL);
3318 old_chain = make_cleanup (xfree, filename);
3320 flags = O_BINARY | O_LARGEFILE;
3322 scratch_chan = open (filename, flags, 0);
3323 if (scratch_chan < 0)
3324 perror_with_name (filename);
3326 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3328 discard_cleanups (old_chain); /* Don't free filename any more. */
3329 unpush_target (&tfile_ops);
3331 trace_filename = xstrdup (filename);
3332 trace_fd = scratch_chan;
3335 /* Read the file header and test for validity. */
3336 tfile_read ((gdb_byte *) &header, TRACE_HEADER_SIZE);
3338 bytes += TRACE_HEADER_SIZE;
3339 if (!(header[0] == 0x7f
3340 && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
3341 error (_("File is not a valid trace file."));
3343 push_target (&tfile_ops);
3345 trace_regblock_size = 0;
3346 ts = current_trace_status ();
3347 /* We know we're working with a file. */
3349 /* Set defaults in case there is no status line. */
3350 ts->running_known = 0;
3351 ts->stop_reason = trace_stop_reason_unknown;
3352 ts->traceframe_count = -1;
3353 ts->buffer_free = 0;
3354 ts->disconnected_tracing = 0;
3355 ts->circular_buffer = 0;
3357 cur_traceframe_number = -1;
3359 TRY_CATCH (ex, RETURN_MASK_ALL)
3361 /* Read through a section of newline-terminated lines that
3362 define things like tracepoints. */
3366 tfile_read (&byte, 1);
3371 /* Empty line marks end of the definition section. */
3376 tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
3379 linebuf[i++] = byte;
3381 error (_("Excessively long lines in trace file"));
3384 /* Record the starting offset of the binary trace data. */
3385 trace_frames_offset = bytes;
3387 /* If we don't have a blocksize, we can't interpret the
3389 if (trace_regblock_size == 0)
3390 error (_("No register block size recorded in trace file"));
3394 /* Pop the partially set up target. */
3396 throw_exception (ex);
3399 inferior_appeared (current_inferior (), TFILE_PID);
3400 inferior_ptid = pid_to_ptid (TFILE_PID);
3401 add_thread_silent (inferior_ptid);
3403 if (ts->traceframe_count <= 0)
3404 warning (_("No traceframes present in this file."));
3406 /* Add the file's tracepoints and variables into the current mix. */
3408 /* Get trace state variables first, they may be checked when parsing
3409 uploaded commands. */
3410 merge_uploaded_trace_state_variables (&uploaded_tsvs);
3412 merge_uploaded_tracepoints (&uploaded_tps);
3414 post_create_inferior (&tfile_ops, from_tty);
3417 /* Interpret the given line from the definitions part of the trace
3421 tfile_interp_line (char *line,
3422 struct uploaded_tp **utpp, struct uploaded_tsv **utsvp)
3426 if (strncmp (p, "R ", strlen ("R ")) == 0)
3429 trace_regblock_size = strtol (p, &p, 16);
3431 else if (strncmp (p, "status ", strlen ("status ")) == 0)
3433 p += strlen ("status ");
3434 parse_trace_status (p, current_trace_status ());
3436 else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
3438 p += strlen ("tp ");
3439 parse_tracepoint_definition (p, utpp);
3441 else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
3443 p += strlen ("tsv ");
3444 parse_tsv_definition (p, utsvp);
3447 warning (_("Ignoring trace file definition \"%s\""), line);
3450 /* Parse the part of trace status syntax that is shared between
3451 the remote protocol and the trace file reader. */
3454 parse_trace_status (char *line, struct trace_status *ts)
3456 char *p = line, *p1, *p2, *p_temp;
3459 ts->running_known = 1;
3460 ts->running = (*p++ == '1');
3461 ts->stop_reason = trace_stop_reason_unknown;
3462 xfree (ts->error_desc);
3463 ts->error_desc = NULL;
3464 ts->traceframe_count = -1;
3465 ts->traceframes_created = -1;
3466 ts->buffer_free = -1;
3467 ts->buffer_size = -1;
3468 ts->disconnected_tracing = 0;
3469 ts->circular_buffer = 0;
3473 p1 = strchr (p, ':');
3475 error (_("Malformed trace status, at %s\n\
3476 Status line: '%s'\n"), p, line);
3477 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3479 p = unpack_varlen_hex (++p1, &val);
3480 ts->stop_reason = trace_buffer_full;
3482 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3484 p = unpack_varlen_hex (++p1, &val);
3485 ts->stop_reason = trace_never_run;
3487 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
3490 p = unpack_varlen_hex (++p1, &val);
3491 ts->stop_reason = tracepoint_passcount;
3492 ts->stopping_tracepoint = val;
3494 else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
3496 p = unpack_varlen_hex (++p1, &val);
3497 ts->stop_reason = tstop_command;
3499 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3501 p = unpack_varlen_hex (++p1, &val);
3502 ts->stop_reason = trace_disconnected;
3504 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3506 p2 = strchr (++p1, ':');
3511 ts->error_desc = xmalloc ((p2 - p1) / 2 + 1);
3512 end = hex2bin (p1, ts->error_desc, (p2 - p1) / 2);
3513 ts->error_desc[end] = '\0';
3516 ts->error_desc = xstrdup ("");
3518 p = unpack_varlen_hex (++p2, &val);
3519 ts->stopping_tracepoint = val;
3520 ts->stop_reason = tracepoint_error;
3522 else if (strncmp (p, "tframes", p1 - p) == 0)
3524 p = unpack_varlen_hex (++p1, &val);
3525 ts->traceframe_count = val;
3527 else if (strncmp (p, "tcreated", p1 - p) == 0)
3529 p = unpack_varlen_hex (++p1, &val);
3530 ts->traceframes_created = val;
3532 else if (strncmp (p, "tfree", p1 - p) == 0)
3534 p = unpack_varlen_hex (++p1, &val);
3535 ts->buffer_free = val;
3537 else if (strncmp (p, "tsize", p1 - p) == 0)
3539 p = unpack_varlen_hex (++p1, &val);
3540 ts->buffer_size = val;
3542 else if (strncmp (p, "disconn", p1 - p) == 0)
3544 p = unpack_varlen_hex (++p1, &val);
3545 ts->disconnected_tracing = val;
3547 else if (strncmp (p, "circular", p1 - p) == 0)
3549 p = unpack_varlen_hex (++p1, &val);
3550 ts->circular_buffer = val;
3554 /* Silently skip unknown optional info. */
3555 p_temp = strchr (p1 + 1, ';');
3559 /* Must be at the end. */
3565 /* Given a line of text defining a part of a tracepoint, parse it into
3566 an "uploaded tracepoint". */
3569 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
3573 ULONGEST num, addr, step, pass, orig_size, xlen, start;
3576 char *cond, *srctype, *buf;
3577 struct uploaded_tp *utp = NULL;
3580 /* Both tracepoint and action definitions start with the same number
3581 and address sequence. */
3583 p = unpack_varlen_hex (p, &num);
3584 p++; /* skip a colon */
3585 p = unpack_varlen_hex (p, &addr);
3586 p++; /* skip a colon */
3589 enabled = (*p++ == 'E');
3590 p++; /* skip a colon */
3591 p = unpack_varlen_hex (p, &step);
3592 p++; /* skip a colon */
3593 p = unpack_varlen_hex (p, &pass);
3594 type = bp_tracepoint;
3596 /* Thumb through optional fields. */
3599 p++; /* skip a colon */
3602 type = bp_fast_tracepoint;
3604 p = unpack_varlen_hex (p, &orig_size);
3608 type = bp_static_tracepoint;
3614 p = unpack_varlen_hex (p, &xlen);
3615 p++; /* skip a comma */
3616 cond = (char *) xmalloc (2 * xlen + 1);
3617 strncpy (cond, p, 2 * xlen);
3618 cond[2 * xlen] = '\0';
3622 warning (_("Unrecognized char '%c' in tracepoint "
3623 "definition, skipping rest"), *p);
3625 utp = get_uploaded_tp (num, addr, utpp);
3627 utp->enabled = enabled;
3632 else if (piece == 'A')
3634 utp = get_uploaded_tp (num, addr, utpp);
3635 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
3637 else if (piece == 'S')
3639 utp = get_uploaded_tp (num, addr, utpp);
3640 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
3642 else if (piece == 'Z')
3644 /* Parse a chunk of source form definition. */
3645 utp = get_uploaded_tp (num, addr, utpp);
3647 p = strchr (p, ':');
3648 p++; /* skip a colon */
3649 p = unpack_varlen_hex (p, &start);
3650 p++; /* skip a colon */
3651 p = unpack_varlen_hex (p, &xlen);
3652 p++; /* skip a colon */
3654 buf = alloca (strlen (line));
3656 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3659 if (strncmp (srctype, "at:", strlen ("at:")) == 0)
3660 utp->at_string = xstrdup (buf);
3661 else if (strncmp (srctype, "cond:", strlen ("cond:")) == 0)
3662 utp->cond_string = xstrdup (buf);
3663 else if (strncmp (srctype, "cmd:", strlen ("cmd:")) == 0)
3664 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
3668 /* Don't error out, the target might be sending us optional
3669 info that we don't care about. */
3670 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
3674 /* Convert a textual description of a trace state variable into an
3678 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
3681 ULONGEST num, initval, builtin;
3683 struct uploaded_tsv *utsv = NULL;
3685 buf = alloca (strlen (line));
3688 p = unpack_varlen_hex (p, &num);
3689 p++; /* skip a colon */
3690 p = unpack_varlen_hex (p, &initval);
3691 p++; /* skip a colon */
3692 p = unpack_varlen_hex (p, &builtin);
3693 p++; /* skip a colon */
3694 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3697 utsv = get_uploaded_tsv (num, utsvp);
3698 utsv->initial_value = initval;
3699 utsv->builtin = builtin;
3700 utsv->name = xstrdup (buf);
3703 /* Close the trace file and generally clean up. */
3706 tfile_close (int quitting)
3713 pid = ptid_get_pid (inferior_ptid);
3714 inferior_ptid = null_ptid; /* Avoid confusion from thread stuff. */
3715 exit_inferior_silent (pid);
3719 xfree (trace_filename);
3720 trace_filename = NULL;
3724 tfile_files_info (struct target_ops *t)
3726 /* (it would be useful to mention the name of the file). */
3727 printf_filtered ("Looking at a trace file.\n");
3730 /* The trace status for a file is that tracing can never be run. */
3733 tfile_get_trace_status (struct trace_status *ts)
3735 /* Other bits of trace status were collected as part of opening the
3736 trace files, so nothing to do here. */
3741 /* Given the position of a traceframe in the file, figure out what
3742 address the frame was collected at. This would normally be the
3743 value of a collected PC register, but if not available, we
3747 tfile_get_traceframe_address (off_t tframe_offset)
3751 struct breakpoint *tp;
3752 off_t saved_offset = cur_offset;
3754 /* FIXME dig pc out of collected registers. */
3756 /* Fall back to using tracepoint address. */
3757 lseek (trace_fd, tframe_offset, SEEK_SET);
3758 tfile_read ((gdb_byte *) &tpnum, 2);
3759 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
3763 tp = get_tracepoint_by_number_on_target (tpnum);
3764 /* FIXME this is a poor heuristic if multiple locations. */
3766 addr = tp->loc->address;
3768 /* Restore our seek position. */
3769 cur_offset = saved_offset;
3770 lseek (trace_fd, cur_offset, SEEK_SET);
3774 /* Make tfile's selected traceframe match GDB's selected
3778 set_tfile_traceframe (void)
3782 if (cur_traceframe_number == get_traceframe_number ())
3785 /* Avoid recursion, tfile_trace_find calls us again. */
3786 cur_traceframe_number = get_traceframe_number ();
3788 newnum = target_trace_find (tfind_number,
3789 get_traceframe_number (), 0, 0, NULL);
3791 /* Should not happen. If it does, all bets are off. */
3792 if (newnum != get_traceframe_number ())
3793 warning (_("could not set tfile's traceframe"));
3796 /* Given a type of search and some parameters, scan the collection of
3797 traceframes in the file looking for a match. When found, return
3798 both the traceframe and tracepoint number, otherwise -1 for
3802 tfile_trace_find (enum trace_find_type type, int num,
3803 ULONGEST addr1, ULONGEST addr2, int *tpp)
3806 int tfnum = 0, found = 0;
3807 unsigned int data_size;
3808 struct breakpoint *tp;
3809 off_t offset, tframe_offset;
3812 /* Lookups other than by absolute frame number depend on the current
3813 trace selected, so make sure it is correct on the tfile end
3815 if (type != tfind_number)
3816 set_tfile_traceframe ();
3824 lseek (trace_fd, trace_frames_offset, SEEK_SET);
3825 offset = trace_frames_offset;
3828 tframe_offset = offset;
3829 tfile_read ((gdb_byte *) &tpnum, 2);
3830 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
3836 tfile_read ((gdb_byte *) &data_size, 4);
3837 data_size = (unsigned int) extract_unsigned_integer
3838 ((gdb_byte *) &data_size, 4,
3839 gdbarch_byte_order (target_gdbarch));
3848 tfaddr = tfile_get_traceframe_address (tframe_offset);
3849 if (tfaddr == addr1)
3853 tp = get_tracepoint (num);
3854 if (tp && tpnum == tp->number_on_target)
3858 tfaddr = tfile_get_traceframe_address (tframe_offset);
3859 if (addr1 <= tfaddr && tfaddr <= addr2)
3863 tfaddr = tfile_get_traceframe_address (tframe_offset);
3864 if (!(addr1 <= tfaddr && tfaddr <= addr2))
3868 internal_error (__FILE__, __LINE__, _("unknown tfind type"));
3874 cur_offset = offset;
3875 cur_data_size = data_size;
3876 cur_traceframe_number = tfnum;
3879 /* Skip past the traceframe's data. */
3880 lseek (trace_fd, data_size, SEEK_CUR);
3881 offset += data_size;
3882 /* Update our own count of traceframes. */
3885 /* Did not find what we were looking for. */
3891 /* Prototype of the callback passed to tframe_walk_blocks. */
3892 typedef int (*walk_blocks_callback_func) (char blocktype, void *data);
3894 /* Callback for traceframe_walk_blocks, used to find a given block
3895 type in a traceframe. */
3898 match_blocktype (char blocktype, void *data)
3900 char *wantedp = data;
3902 if (*wantedp == blocktype)
3908 /* Walk over all traceframe block starting at POS offset from
3909 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
3910 unmodified. If CALLBACK returns true, this returns the position in
3911 the traceframe where the block is found, relative to the start of
3912 the traceframe (cur_offset). Returns -1 if no callback call
3913 returned true, indicating that all blocks have been walked. */
3916 traceframe_walk_blocks (walk_blocks_callback_func callback,
3917 int pos, void *data)
3919 /* Iterate through a traceframe's blocks, looking for a block of the
3922 lseek (trace_fd, cur_offset + pos, SEEK_SET);
3923 while (pos < cur_data_size)
3925 unsigned short mlen;
3928 tfile_read (&block_type, 1);
3932 if ((*callback) (block_type, data))
3938 lseek (trace_fd, cur_offset + pos + trace_regblock_size, SEEK_SET);
3939 pos += trace_regblock_size;
3942 lseek (trace_fd, cur_offset + pos + 8, SEEK_SET);
3943 tfile_read ((gdb_byte *) &mlen, 2);
3944 mlen = (unsigned short)
3945 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
3948 lseek (trace_fd, mlen, SEEK_CUR);
3949 pos += (8 + 2 + mlen);
3952 lseek (trace_fd, cur_offset + pos + 4 + 8, SEEK_SET);
3956 error (_("Unknown block type '%c' (0x%x) in trace frame"),
3957 block_type, block_type);
3965 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
3966 position offset of a block of type TYPE_WANTED in the current trace
3967 frame, starting at POS. Returns -1 if no such block was found. */
3970 traceframe_find_block_type (char type_wanted, int pos)
3972 return traceframe_walk_blocks (match_blocktype, pos, &type_wanted);
3975 /* Look for a block of saved registers in the traceframe, and get the
3976 requested register from it. */
3979 tfile_fetch_registers (struct target_ops *ops,
3980 struct regcache *regcache, int regno)
3982 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3984 int pos, offset, regn, regsize, pc_regno;
3985 unsigned short mlen;
3988 /* An uninitialized reg size says we're not going to be
3989 successful at getting register blocks. */
3990 if (!trace_regblock_size)
3993 set_tfile_traceframe ();
3995 regs = alloca (trace_regblock_size);
3997 if (traceframe_find_block_type ('R', 0) >= 0)
3999 tfile_read (regs, trace_regblock_size);
4001 /* Assume the block is laid out in GDB register number order,
4002 each register with the size that it has in GDB. */
4004 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4006 regsize = register_size (gdbarch, regn);
4007 /* Make sure we stay within block bounds. */
4008 if (offset + regsize >= trace_regblock_size)
4010 if (regcache_register_status (regcache, regn) == REG_UNKNOWN)
4014 regcache_raw_supply (regcache, regno, regs + offset);
4017 else if (regno == -1)
4019 regcache_raw_supply (regcache, regn, regs + offset);
4027 /* We get here if no register data has been found. Mark registers
4029 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4030 regcache_raw_supply (regcache, regn, NULL);
4032 /* We can often usefully guess that the PC is going to be the same
4033 as the address of the tracepoint. */
4034 pc_regno = gdbarch_pc_regnum (gdbarch);
4035 if (pc_regno >= 0 && (regno == -1 || regno == pc_regno))
4037 struct breakpoint *tp = get_tracepoint (tracepoint_number);
4041 /* But don't try to guess if tracepoint is multi-location... */
4044 warning (_("Tracepoint %d has multiple "
4045 "locations, cannot infer $pc"),
4049 /* ... or does while-stepping. */
4050 if (tp->step_count > 0)
4052 warning (_("Tracepoint %d does while-stepping, "
4053 "cannot infer $pc"),
4058 store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
4059 gdbarch_byte_order (gdbarch),
4061 regcache_raw_supply (regcache, pc_regno, regs);
4067 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
4068 const char *annex, gdb_byte *readbuf,
4069 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
4071 /* We're only doing regular memory for now. */
4072 if (object != TARGET_OBJECT_MEMORY)
4075 if (readbuf == NULL)
4076 error (_("tfile_xfer_partial: trace file is read-only"));
4078 set_tfile_traceframe ();
4080 if (traceframe_number != -1)
4084 /* Iterate through the traceframe's blocks, looking for
4086 while ((pos = traceframe_find_block_type ('M', pos)) >= 0)
4088 ULONGEST maddr, amt;
4089 unsigned short mlen;
4090 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
4092 tfile_read ((gdb_byte *) &maddr, 8);
4093 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
4095 tfile_read ((gdb_byte *) &mlen, 2);
4096 mlen = (unsigned short)
4097 extract_unsigned_integer ((gdb_byte *) &mlen, 2, byte_order);
4099 /* If the block includes the first part of the desired
4100 range, return as much it has; GDB will re-request the
4101 remainder, which might be in a different block of this
4103 if (maddr <= offset && offset < (maddr + mlen))
4105 amt = (maddr + mlen) - offset;
4109 tfile_read (readbuf, amt);
4113 /* Skip over this block. */
4114 pos += (8 + 2 + mlen);
4118 /* It's unduly pedantic to refuse to look at the executable for
4119 read-only pieces; so do the equivalent of readonly regions aka
4121 /* FIXME account for relocation at some point. */
4128 for (s = exec_bfd->sections; s; s = s->next)
4130 if ((s->flags & SEC_LOAD) == 0
4131 || (s->flags & SEC_READONLY) == 0)
4135 size = bfd_get_section_size (s);
4136 if (vma <= offset && offset < (vma + size))
4140 amt = (vma + size) - offset;
4144 amt = bfd_get_section_contents (exec_bfd, s,
4145 readbuf, offset - vma, amt);
4151 /* Indicate failure to find the requested memory block. */
4155 /* Iterate through the blocks of a trace frame, looking for a 'V'
4156 block with a matching tsv number. */
4159 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
4163 set_tfile_traceframe ();
4166 while ((pos = traceframe_find_block_type ('V', pos)) >= 0)
4170 tfile_read ((gdb_byte *) &vnum, 4);
4171 vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
4176 tfile_read ((gdb_byte *) val, 8);
4177 *val = extract_signed_integer ((gdb_byte *) val, 8,
4185 /* Didn't find anything. */
4190 tfile_has_all_memory (struct target_ops *ops)
4196 tfile_has_memory (struct target_ops *ops)
4202 tfile_has_stack (struct target_ops *ops)
4204 return traceframe_number != -1;
4208 tfile_has_registers (struct target_ops *ops)
4210 return traceframe_number != -1;
4214 tfile_thread_alive (struct target_ops *ops, ptid_t ptid)
4219 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
4220 object for the tfile target's current traceframe. */
4223 build_traceframe_info (char blocktype, void *data)
4225 struct traceframe_info *info = data;
4231 struct mem_range *r;
4233 unsigned short mlen;
4235 tfile_read ((gdb_byte *) &maddr, 8);
4236 tfile_read ((gdb_byte *) &mlen, 2);
4238 r = VEC_safe_push (mem_range_s, info->memory, NULL);
4251 warning (_("Unhandled trace block type (%d) '%c ' "
4252 "while building trace frame info."),
4253 blocktype, blocktype);
4260 static struct traceframe_info *
4261 tfile_traceframe_info (void)
4263 struct traceframe_info *info = XCNEW (struct traceframe_info);
4265 traceframe_walk_blocks (build_traceframe_info, 0, info);
4270 init_tfile_ops (void)
4272 tfile_ops.to_shortname = "tfile";
4273 tfile_ops.to_longname = "Local trace dump file";
4275 = "Use a trace file as a target. Specify the filename of the trace file.";
4276 tfile_ops.to_open = tfile_open;
4277 tfile_ops.to_close = tfile_close;
4278 tfile_ops.to_fetch_registers = tfile_fetch_registers;
4279 tfile_ops.to_xfer_partial = tfile_xfer_partial;
4280 tfile_ops.to_files_info = tfile_files_info;
4281 tfile_ops.to_get_trace_status = tfile_get_trace_status;
4282 tfile_ops.to_trace_find = tfile_trace_find;
4283 tfile_ops.to_get_trace_state_variable_value
4284 = tfile_get_trace_state_variable_value;
4285 tfile_ops.to_stratum = process_stratum;
4286 tfile_ops.to_has_all_memory = tfile_has_all_memory;
4287 tfile_ops.to_has_memory = tfile_has_memory;
4288 tfile_ops.to_has_stack = tfile_has_stack;
4289 tfile_ops.to_has_registers = tfile_has_registers;
4290 tfile_ops.to_traceframe_info = tfile_traceframe_info;
4291 tfile_ops.to_thread_alive = tfile_thread_alive;
4292 tfile_ops.to_magic = OPS_MAGIC;
4295 /* Given a line of text defining a static tracepoint marker, parse it
4296 into a "static tracepoint marker" object. Throws an error is
4297 parsing fails. If PP is non-null, it points to one past the end of
4298 the parsed marker definition. */
4301 parse_static_tracepoint_marker_definition (char *line, char **pp,
4302 struct static_tracepoint_marker *marker)
4309 p = unpack_varlen_hex (p, &addr);
4310 p++; /* skip a colon */
4312 marker->gdbarch = target_gdbarch;
4313 marker->address = (CORE_ADDR) addr;
4315 endp = strchr (p, ':');
4317 error (_("bad marker definition: %s"), line);
4319 marker->str_id = xmalloc (endp - p + 1);
4320 end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
4321 marker->str_id[end] = '\0';
4324 p++; /* skip a colon */
4326 marker->extra = xmalloc (strlen (p) + 1);
4327 end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
4328 marker->extra[end] = '\0';
4334 /* Release a static tracepoint marker's contents. Note that the
4335 object itself isn't released here. There objects are usually on
4339 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
4341 xfree (marker->str_id);
4342 marker->str_id = NULL;
4345 /* Print MARKER to gdb_stdout. */
4348 print_one_static_tracepoint_marker (int count,
4349 struct static_tracepoint_marker *marker)
4351 struct command_line *l;
4354 char wrap_indent[80];
4355 char extra_field_indent[80];
4356 struct ui_stream *stb = ui_out_stream_new (uiout);
4357 struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb);
4358 struct cleanup *bkpt_chain;
4359 VEC(breakpoint_p) *tracepoints;
4361 struct symtab_and_line sal;
4365 sal.pc = marker->address;
4367 tracepoints = static_tracepoints_here (marker->address);
4369 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
4371 /* A counter field to help readability. This is not a stable
4373 ui_out_field_int (uiout, "count", count);
4375 ui_out_field_string (uiout, "marker-id", marker->str_id);
4377 ui_out_field_fmt (uiout, "enabled", "%c",
4378 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
4379 ui_out_spaces (uiout, 2);
4381 strcpy (wrap_indent, " ");
4383 if (gdbarch_addr_bit (marker->gdbarch) <= 32)
4384 strcat (wrap_indent, " ");
4386 strcat (wrap_indent, " ");
4388 strcpy (extra_field_indent, " ");
4390 ui_out_field_core_addr (uiout, "addr", marker->gdbarch, marker->address);
4392 sal = find_pc_line (marker->address, 0);
4393 sym = find_pc_sect_function (marker->address, NULL);
4396 ui_out_text (uiout, "in ");
4397 ui_out_field_string (uiout, "func",
4398 SYMBOL_PRINT_NAME (sym));
4399 ui_out_wrap_hint (uiout, wrap_indent);
4400 ui_out_text (uiout, " at ");
4403 ui_out_field_skip (uiout, "func");
4405 if (sal.symtab != NULL)
4407 ui_out_field_string (uiout, "file", sal.symtab->filename);
4408 ui_out_text (uiout, ":");
4410 if (ui_out_is_mi_like_p (uiout))
4412 char *fullname = symtab_to_fullname (sal.symtab);
4415 ui_out_field_string (uiout, "fullname", fullname);
4418 ui_out_field_skip (uiout, "fullname");
4420 ui_out_field_int (uiout, "line", sal.line);
4424 ui_out_field_skip (uiout, "fullname");
4425 ui_out_field_skip (uiout, "line");
4428 ui_out_text (uiout, "\n");
4429 ui_out_text (uiout, extra_field_indent);
4430 ui_out_text (uiout, _("Data: \""));
4431 ui_out_field_string (uiout, "extra-data", marker->extra);
4432 ui_out_text (uiout, "\"\n");
4434 if (!VEC_empty (breakpoint_p, tracepoints))
4436 struct cleanup *cleanup_chain;
4438 struct breakpoint *b;
4440 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
4443 ui_out_text (uiout, extra_field_indent);
4444 ui_out_text (uiout, _("Probed by static tracepoints: "));
4445 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
4448 ui_out_text (uiout, ", ");
4449 ui_out_text (uiout, "#");
4450 ui_out_field_int (uiout, "tracepoint-id", b->number);
4453 do_cleanups (cleanup_chain);
4455 if (ui_out_is_mi_like_p (uiout))
4456 ui_out_field_int (uiout, "number-of-tracepoints",
4457 VEC_length(breakpoint_p, tracepoints));
4459 ui_out_text (uiout, "\n");
4461 VEC_free (breakpoint_p, tracepoints);
4463 do_cleanups (bkpt_chain);
4464 do_cleanups (old_chain);
4468 info_static_tracepoint_markers_command (char *arg, int from_tty)
4470 VEC(static_tracepoint_marker_p) *markers;
4471 struct cleanup *old_chain;
4472 struct static_tracepoint_marker *marker;
4476 = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
4477 "StaticTracepointMarkersTable");
4479 ui_out_table_header (uiout, 7, ui_left, "counter", "Cnt");
4481 ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
4483 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
4484 if (gdbarch_addr_bit (target_gdbarch) <= 32)
4485 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
4487 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
4488 ui_out_table_header (uiout, 40, ui_noalign, "what", "What");
4490 ui_out_table_body (uiout);
4492 markers = target_static_tracepoint_markers_by_strid (NULL);
4493 make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
4496 VEC_iterate (static_tracepoint_marker_p,
4497 markers, i, marker);
4500 print_one_static_tracepoint_marker (i + 1, marker);
4501 release_static_tracepoint_marker (marker);
4504 do_cleanups (old_chain);
4507 /* The $_sdata convenience variable is a bit special. We don't know
4508 for sure type of the value until we actually have a chance to fetch
4509 the data --- the size of the object depends on what has been
4510 collected. We solve this by making $_sdata be an internalvar that
4511 creates a new value on access. */
4513 /* Return a new value with the correct type for the sdata object of
4514 the current trace frame. Return a void value if there's no object
4517 static struct value *
4518 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var)
4523 /* We need to read the whole object before we know its size. */
4524 size = target_read_alloc (¤t_target,
4525 TARGET_OBJECT_STATIC_TRACE_DATA,
4532 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
4534 v = allocate_value (type);
4535 memcpy (value_contents_raw (v), buf, size);
4540 return allocate_value (builtin_type (gdbarch)->builtin_void);
4543 #if !defined(HAVE_LIBEXPAT)
4545 struct traceframe_info *
4546 parse_traceframe_info (const char *tframe_info)
4548 static int have_warned;
4553 warning (_("Can not parse XML trace frame info; XML support "
4554 "was disabled at compile time"));
4560 #else /* HAVE_LIBEXPAT */
4562 #include "xml-support.h"
4564 /* Handle the start of a <memory> element. */
4567 traceframe_info_start_memory (struct gdb_xml_parser *parser,
4568 const struct gdb_xml_element *element,
4569 void *user_data, VEC(gdb_xml_value_s) *attributes)
4571 struct traceframe_info *info = user_data;
4572 struct mem_range *r = VEC_safe_push (mem_range_s, info->memory, NULL);
4573 ULONGEST *start_p, *length_p;
4575 start_p = xml_find_attribute (attributes, "start")->value;
4576 length_p = xml_find_attribute (attributes, "length")->value;
4578 r->start = *start_p;
4579 r->length = *length_p;
4582 /* Discard the constructed trace frame info (if an error occurs). */
4585 free_result (void *p)
4587 struct traceframe_info *result = p;
4589 free_traceframe_info (result);
4592 /* The allowed elements and attributes for an XML memory map. */
4594 static const struct gdb_xml_attribute memory_attributes[] = {
4595 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4596 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4597 { NULL, GDB_XML_AF_NONE, NULL, NULL }
4600 static const struct gdb_xml_element traceframe_info_children[] = {
4601 { "memory", memory_attributes, NULL,
4602 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
4603 traceframe_info_start_memory, NULL },
4604 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4607 static const struct gdb_xml_element traceframe_info_elements[] = {
4608 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
4610 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4613 /* Parse a traceframe-info XML document. */
4615 struct traceframe_info *
4616 parse_traceframe_info (const char *tframe_info)
4618 struct traceframe_info *result;
4619 struct cleanup *back_to;
4621 result = XCNEW (struct traceframe_info);
4622 back_to = make_cleanup (free_result, result);
4624 if (gdb_xml_parse_quick (_("trace frame info"),
4625 "traceframe-info.dtd", traceframe_info_elements,
4626 tframe_info, result) == 0)
4628 /* Parsed successfully, keep the result. */
4629 discard_cleanups (back_to);
4634 do_cleanups (back_to);
4638 #endif /* HAVE_LIBEXPAT */
4640 /* Returns the traceframe_info object for the current traceframe.
4641 This is where we avoid re-fetching the object from the target if we
4642 already have it cached. */
4644 struct traceframe_info *
4645 get_traceframe_info (void)
4647 if (traceframe_info == NULL)
4648 traceframe_info = target_traceframe_info ();
4650 return traceframe_info;
4653 /* If the target supports the query, return in RESULT the set of
4654 collected memory in the current traceframe, found within the LEN
4655 bytes range starting at MEMADDR. Returns true if the target
4656 supports the query, otherwise returns false, and RESULT is left
4660 traceframe_available_memory (VEC(mem_range_s) **result,
4661 CORE_ADDR memaddr, ULONGEST len)
4663 struct traceframe_info *info = get_traceframe_info ();
4667 struct mem_range *r;
4672 for (i = 0; VEC_iterate (mem_range_s, info->memory, i, r); i++)
4673 if (mem_ranges_overlap (r->start, r->length, memaddr, len))
4675 ULONGEST lo1, hi1, lo2, hi2;
4676 struct mem_range *nr;
4679 hi1 = memaddr + len;
4682 hi2 = r->start + r->length;
4684 nr = VEC_safe_push (mem_range_s, *result, NULL);
4686 nr->start = max (lo1, lo2);
4687 nr->length = min (hi1, hi2) - nr->start;
4690 normalize_mem_ranges (*result);
4697 /* module initialization */
4699 _initialize_tracepoint (void)
4701 struct cmd_list_element *c;
4703 /* Explicitly create without lookup, since that tries to create a
4704 value with a void typed value, and when we get here, gdbarch
4705 isn't initialized yet. At this point, we're quite sure there
4706 isn't another convenience variable of the same name. */
4707 create_internalvar_type_lazy ("_sdata", sdata_make_value);
4709 traceframe_number = -1;
4710 tracepoint_number = -1;
4712 if (tracepoint_list.list == NULL)
4714 tracepoint_list.listsize = 128;
4715 tracepoint_list.list = xmalloc
4716 (tracepoint_list.listsize * sizeof (struct memrange));
4718 if (tracepoint_list.aexpr_list == NULL)
4720 tracepoint_list.aexpr_listsize = 128;
4721 tracepoint_list.aexpr_list = xmalloc
4722 (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
4725 if (stepping_list.list == NULL)
4727 stepping_list.listsize = 128;
4728 stepping_list.list = xmalloc
4729 (stepping_list.listsize * sizeof (struct memrange));
4732 if (stepping_list.aexpr_list == NULL)
4734 stepping_list.aexpr_listsize = 128;
4735 stepping_list.aexpr_list = xmalloc
4736 (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
4739 add_info ("scope", scope_info,
4740 _("List the variables local to a scope"));
4742 add_cmd ("tracepoints", class_trace, NULL,
4743 _("Tracing of program execution without stopping the program."),
4746 add_com ("tdump", class_trace, trace_dump_command,
4747 _("Print everything collected at the current tracepoint."));
4749 add_com ("tsave", class_trace, trace_save_command, _("\
4750 Save the trace data to a file.\n\
4751 Use the '-r' option to direct the target to save directly to the file,\n\
4752 using its own filesystem."));
4754 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
4755 Define a trace state variable.\n\
4756 Argument is a $-prefixed name, optionally followed\n\
4757 by '=' and an expression that sets the initial value\n\
4758 at the start of tracing."));
4759 set_cmd_completer (c, expression_completer);
4761 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
4762 Delete one or more trace state variables.\n\
4763 Arguments are the names of the variables to delete.\n\
4764 If no arguments are supplied, delete all variables."), &deletelist);
4765 /* FIXME add a trace variable completer. */
4767 add_info ("tvariables", tvariables_info, _("\
4768 Status of trace state variables and their values.\n\
4771 add_info ("static-tracepoint-markers",
4772 info_static_tracepoint_markers_command, _("\
4773 List target static tracepoints markers.\n\
4776 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
4777 Select a trace frame;\n\
4778 No argument means forward by one frame; '-' means backward by one frame."),
4779 &tfindlist, "tfind ", 1, &cmdlist);
4781 add_cmd ("outside", class_trace, trace_find_outside_command, _("\
4782 Select a trace frame whose PC is outside the given range (exclusive).\n\
4783 Usage: tfind outside addr1, addr2"),
4786 add_cmd ("range", class_trace, trace_find_range_command, _("\
4787 Select a trace frame whose PC is in the given range (inclusive).\n\
4788 Usage: tfind range addr1,addr2"),
4791 add_cmd ("line", class_trace, trace_find_line_command, _("\
4792 Select a trace frame by source line.\n\
4793 Argument can be a line number (with optional source file),\n\
4794 a function name, or '*' followed by an address.\n\
4795 Default argument is 'the next source line that was traced'."),
4798 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
4799 Select a trace frame by tracepoint number.\n\
4800 Default is the tracepoint for the current trace frame."),
4803 add_cmd ("pc", class_trace, trace_find_pc_command, _("\
4804 Select a trace frame by PC.\n\
4805 Default is the current PC, or the PC of the current trace frame."),
4808 add_cmd ("end", class_trace, trace_find_end_command, _("\
4809 Synonym for 'none'.\n\
4810 De-select any trace frame and resume 'live' debugging."),
4813 add_cmd ("none", class_trace, trace_find_none_command,
4814 _("De-select any trace frame and resume 'live' debugging."),
4817 add_cmd ("start", class_trace, trace_find_start_command,
4818 _("Select the first trace frame in the trace buffer."),
4821 add_com ("tstatus", class_trace, trace_status_command,
4822 _("Display the status of the current trace data collection."));
4824 add_com ("tstop", class_trace, trace_stop_command,
4825 _("Stop trace data collection."));
4827 add_com ("tstart", class_trace, trace_start_command,
4828 _("Start trace data collection."));
4830 add_com ("end", class_trace, end_actions_pseudocommand, _("\
4831 Ends a list of commands or actions.\n\
4832 Several GDB commands allow you to enter a list of commands or actions.\n\
4833 Entering \"end\" on a line by itself is the normal way to terminate\n\
4835 Note: the \"end\" command cannot be used at the gdb prompt."));
4837 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
4838 Specify single-stepping behavior at a tracepoint.\n\
4839 Argument is number of instructions to trace in single-step mode\n\
4840 following the tracepoint. This command is normally followed by\n\
4841 one or more \"collect\" commands, to specify what to collect\n\
4842 while single-stepping.\n\n\
4843 Note: this command can only be used in a tracepoint \"actions\" list."));
4845 add_com_alias ("ws", "while-stepping", class_alias, 0);
4846 add_com_alias ("stepping", "while-stepping", class_alias, 0);
4848 add_com ("collect", class_trace, collect_pseudocommand, _("\
4849 Specify one or more data items to be collected at a tracepoint.\n\
4850 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4851 collect all data (variables, registers) referenced by that expression.\n\
4852 Also accepts the following special arguments:\n\
4853 $regs -- all registers.\n\
4854 $args -- all function arguments.\n\
4855 $locals -- all variables local to the block/function scope.\n\
4856 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4857 Note: this command can only be used in a tracepoint \"actions\" list."));
4859 add_com ("teval", class_trace, teval_pseudocommand, _("\
4860 Specify one or more expressions to be evaluated at a tracepoint.\n\
4861 Accepts a comma-separated list of (one or more) expressions.\n\
4862 The result of each evaluation will be discarded.\n\
4863 Note: this command can only be used in a tracepoint \"actions\" list."));
4865 add_com ("actions", class_trace, trace_actions_command, _("\
4866 Specify the actions to be taken at a tracepoint.\n\
4867 Tracepoint actions may include collecting of specified data,\n\
4868 single-stepping, or enabling/disabling other tracepoints,\n\
4869 depending on target's capabilities."));
4871 default_collect = xstrdup ("");
4872 add_setshow_string_cmd ("default-collect", class_trace,
4873 &default_collect, _("\
4874 Set the list of expressions to collect by default"), _("\
4875 Show the list of expressions to collect by default"), NULL,
4877 &setlist, &showlist);
4879 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
4880 &disconnected_tracing, _("\
4881 Set whether tracing continues after GDB disconnects."), _("\
4882 Show whether tracing continues after GDB disconnects."), _("\
4883 Use this to continue a tracing run even if GDB disconnects\n\
4884 or detaches from the target. You can reconnect later and look at\n\
4885 trace data collected in the meantime."),
4886 set_disconnected_tracing,
4891 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
4892 &circular_trace_buffer, _("\
4893 Set target's use of circular trace buffer."), _("\
4894 Show target's use of circular trace buffer."), _("\
4895 Use this to make the trace buffer into a circular buffer,\n\
4896 which will discard traceframes (oldest first) instead of filling\n\
4897 up and stopping the trace run."),
4898 set_circular_trace_buffer,
4905 add_target (&tfile_ops);