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 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 tracepoint *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->base, 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 *b)
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;
636 struct tracepoint *t = (struct tracepoint *) b;
638 /* If EOF is typed, *line is NULL. */
642 for (p = *line; isspace ((int) *p);)
645 /* Symbol lookup etc. */
646 if (*p == '\0') /* empty line: just prompt for another line. */
649 if (*p == '#') /* comment line */
652 c = lookup_cmd (&p, cmdlist, "", -1, 1);
654 error (_("`%s' is not a tracepoint action, or is ambiguous."), p);
656 if (cmd_cfunc_eq (c, collect_pseudocommand))
659 { /* Repeat over a comma-separated list. */
660 QUIT; /* Allow user to bail out with ^C. */
661 while (isspace ((int) *p))
664 if (*p == '$') /* Look for special pseudo-symbols. */
666 if (0 == strncasecmp ("reg", p + 1, 3)
667 || 0 == strncasecmp ("arg", p + 1, 3)
668 || 0 == strncasecmp ("loc", p + 1, 3)
669 || 0 == strncasecmp ("_sdata", p + 1, 6))
674 /* else fall thru, treat p as an expression and parse it! */
677 for (loc = t->base.loc; loc; loc = loc->next)
680 exp = parse_exp_1 (&p, block_for_pc (loc->address), 1);
681 old_chain = make_cleanup (free_current_contents, &exp);
683 if (exp->elts[0].opcode == OP_VAR_VALUE)
685 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
687 error (_("constant `%s' (value %ld) "
688 "will not be collected."),
689 SYMBOL_PRINT_NAME (exp->elts[2].symbol),
690 SYMBOL_VALUE (exp->elts[2].symbol));
692 else if (SYMBOL_CLASS (exp->elts[2].symbol)
693 == LOC_OPTIMIZED_OUT)
695 error (_("`%s' is optimized away "
696 "and cannot be collected."),
697 SYMBOL_PRINT_NAME (exp->elts[2].symbol));
701 /* We have something to collect, make sure that the expr to
702 bytecode translator can handle it and that it's not too
704 aexpr = gen_trace_for_expr (loc->address, exp);
705 make_cleanup_free_agent_expr (aexpr);
707 if (aexpr->len > MAX_AGENT_EXPR_LEN)
708 error (_("Expression is too complicated."));
712 report_agent_reqs_errors (aexpr);
714 do_cleanups (old_chain);
717 while (p && *p++ == ',');
720 else if (cmd_cfunc_eq (c, teval_pseudocommand))
723 { /* Repeat over a comma-separated list. */
724 QUIT; /* Allow user to bail out with ^C. */
725 while (isspace ((int) *p))
729 for (loc = t->base.loc; loc; loc = loc->next)
732 /* Only expressions are allowed for this action. */
733 exp = parse_exp_1 (&p, block_for_pc (loc->address), 1);
734 old_chain = make_cleanup (free_current_contents, &exp);
736 /* We have something to evaluate, make sure that the expr to
737 bytecode translator can handle it and that it's not too
739 aexpr = gen_eval_for_expr (loc->address, exp);
740 make_cleanup_free_agent_expr (aexpr);
742 if (aexpr->len > MAX_AGENT_EXPR_LEN)
743 error (_("Expression is too complicated."));
746 report_agent_reqs_errors (aexpr);
748 do_cleanups (old_chain);
751 while (p && *p++ == ',');
754 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
756 char *steparg; /* In case warning is necessary. */
758 while (isspace ((int) *p))
762 if (*p == '\0' || (t->step_count = strtol (p, &p, 0)) == 0)
763 error (_("while-stepping step count `%s' is malformed."), *line);
766 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
770 error (_("`%s' is not a supported tracepoint action."), *line);
774 memrange_absolute = -1
779 int type; /* memrange_absolute for absolute memory range,
780 else basereg number. */
781 bfd_signed_vma start;
785 struct collection_list
787 unsigned char regs_mask[32]; /* room for up to 256 regs */
790 struct memrange *list;
791 long aexpr_listsize; /* size of array pointed to by expr_list elt */
793 struct agent_expr **aexpr_list;
795 /* True is the user requested a collection of "$_sdata", "static
799 tracepoint_list, stepping_list;
801 /* MEMRANGE functions: */
803 static int memrange_cmp (const void *, const void *);
805 /* Compare memranges for qsort. */
807 memrange_cmp (const void *va, const void *vb)
809 const struct memrange *a = va, *b = vb;
811 if (a->type < b->type)
813 if (a->type > b->type)
815 if (a->type == memrange_absolute)
817 if ((bfd_vma) a->start < (bfd_vma) b->start)
819 if ((bfd_vma) a->start > (bfd_vma) b->start)
824 if (a->start < b->start)
826 if (a->start > b->start)
832 /* Sort the memrange list using qsort, and merge adjacent memranges. */
834 memrange_sortmerge (struct collection_list *memranges)
838 qsort (memranges->list, memranges->next_memrange,
839 sizeof (struct memrange), memrange_cmp);
840 if (memranges->next_memrange > 0)
842 for (a = 0, b = 1; b < memranges->next_memrange; b++)
844 /* If memrange b overlaps or is adjacent to memrange a,
846 if (memranges->list[a].type == memranges->list[b].type
847 && memranges->list[b].start <= memranges->list[a].end)
849 if (memranges->list[b].end > memranges->list[a].end)
850 memranges->list[a].end = memranges->list[b].end;
851 continue; /* next b, same a */
855 memcpy (&memranges->list[a], &memranges->list[b],
856 sizeof (struct memrange));
858 memranges->next_memrange = a + 1;
862 /* Add a register to a collection list. */
864 add_register (struct collection_list *collection, unsigned int regno)
867 printf_filtered ("collect register %d\n", regno);
868 if (regno >= (8 * sizeof (collection->regs_mask)))
869 error (_("Internal: register number %d too large for tracepoint"),
871 collection->regs_mask[regno / 8] |= 1 << (regno % 8);
874 /* Add a memrange to a collection list. */
876 add_memrange (struct collection_list *memranges,
877 int type, bfd_signed_vma base,
882 printf_filtered ("(%d,", type);
884 printf_filtered (",%ld)\n", len);
887 /* type: memrange_absolute == memory, other n == basereg */
888 memranges->list[memranges->next_memrange].type = type;
889 /* base: addr if memory, offset if reg relative. */
890 memranges->list[memranges->next_memrange].start = base;
891 /* len: we actually save end (base + len) for convenience */
892 memranges->list[memranges->next_memrange].end = base + len;
893 memranges->next_memrange++;
894 if (memranges->next_memrange >= memranges->listsize)
896 memranges->listsize *= 2;
897 memranges->list = xrealloc (memranges->list,
898 memranges->listsize);
901 if (type != memrange_absolute) /* Better collect the base register! */
902 add_register (memranges, type);
905 /* Add a symbol to a collection list. */
907 collect_symbol (struct collection_list *collect,
909 struct gdbarch *gdbarch,
910 long frame_regno, long frame_offset,
915 bfd_signed_vma offset;
916 int treat_as_expr = 0;
918 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
919 switch (SYMBOL_CLASS (sym))
922 printf_filtered ("%s: don't know symbol class %d\n",
923 SYMBOL_PRINT_NAME (sym),
927 printf_filtered ("constant %s (value %ld) will not be collected.\n",
928 SYMBOL_PRINT_NAME (sym), SYMBOL_VALUE (sym));
931 offset = SYMBOL_VALUE_ADDRESS (sym);
936 sprintf_vma (tmp, offset);
937 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
938 SYMBOL_PRINT_NAME (sym), len,
941 /* A struct may be a C++ class with static fields, go to general
942 expression handling. */
943 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
946 add_memrange (collect, memrange_absolute, offset, len);
949 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
951 printf_filtered ("LOC_REG[parm] %s: ",
952 SYMBOL_PRINT_NAME (sym));
953 add_register (collect, reg);
954 /* Check for doubles stored in two registers. */
955 /* FIXME: how about larger types stored in 3 or more regs? */
956 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
957 len > register_size (gdbarch, reg))
958 add_register (collect, reg + 1);
961 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
962 printf_filtered (" (will not collect %s)\n",
963 SYMBOL_PRINT_NAME (sym));
967 offset = frame_offset + SYMBOL_VALUE (sym);
970 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
971 SYMBOL_PRINT_NAME (sym), len);
973 printf_filtered (" from frame ptr reg %d\n", reg);
975 add_memrange (collect, reg, offset, len);
977 case LOC_REGPARM_ADDR:
978 reg = SYMBOL_VALUE (sym);
982 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
983 SYMBOL_PRINT_NAME (sym), len);
985 printf_filtered (" from reg %d\n", reg);
987 add_memrange (collect, reg, offset, len);
991 offset = frame_offset + SYMBOL_VALUE (sym);
994 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
995 SYMBOL_PRINT_NAME (sym), len);
997 printf_filtered (" from frame ptr reg %d\n", reg);
999 add_memrange (collect, reg, offset, len);
1002 case LOC_UNRESOLVED:
1006 case LOC_OPTIMIZED_OUT:
1007 printf_filtered ("%s has been optimized out of existence.\n",
1008 SYMBOL_PRINT_NAME (sym));
1016 /* Expressions are the most general case. */
1019 struct agent_expr *aexpr;
1020 struct cleanup *old_chain1 = NULL;
1022 aexpr = gen_trace_for_var (scope, gdbarch, sym);
1024 /* It can happen that the symbol is recorded as a computed
1025 location, but it's been optimized away and doesn't actually
1026 have a location expression. */
1029 printf_filtered ("%s has been optimized out of existence.\n",
1030 SYMBOL_PRINT_NAME (sym));
1034 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1038 report_agent_reqs_errors (aexpr);
1040 discard_cleanups (old_chain1);
1041 add_aexpr (collect, aexpr);
1043 /* Take care of the registers. */
1044 if (aexpr->reg_mask_len > 0)
1048 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1050 QUIT; /* Allow user to bail out with ^C. */
1051 if (aexpr->reg_mask[ndx1] != 0)
1053 /* Assume chars have 8 bits. */
1054 for (ndx2 = 0; ndx2 < 8; ndx2++)
1055 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1056 /* It's used -- record it. */
1057 add_register (collect, ndx1 * 8 + ndx2);
1064 /* Data to be passed around in the calls to the locals and args
1067 struct add_local_symbols_data
1069 struct collection_list *collect;
1070 struct gdbarch *gdbarch;
1077 /* The callback for the locals and args iterators. */
1080 do_collect_symbol (const char *print_name,
1084 struct add_local_symbols_data *p = cb_data;
1086 collect_symbol (p->collect, sym, p->gdbarch, p->frame_regno,
1087 p->frame_offset, p->pc);
1091 /* Add all locals (or args) symbols to collection list. */
1093 add_local_symbols (struct collection_list *collect,
1094 struct gdbarch *gdbarch, CORE_ADDR pc,
1095 long frame_regno, long frame_offset, int type)
1097 struct block *block;
1098 struct add_local_symbols_data cb_data;
1100 cb_data.collect = collect;
1101 cb_data.gdbarch = gdbarch;
1103 cb_data.frame_regno = frame_regno;
1104 cb_data.frame_offset = frame_offset;
1109 block = block_for_pc (pc);
1112 warning (_("Can't collect locals; "
1113 "no symbol table info available.\n"));
1117 iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1118 if (cb_data.count == 0)
1119 warning (_("No locals found in scope."));
1123 pc = get_pc_function_start (pc);
1124 block = block_for_pc (pc);
1127 warning (_("Can't collect args; no symbol table info available."));
1131 iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1132 if (cb_data.count == 0)
1133 warning (_("No args found in scope."));
1138 add_static_trace_data (struct collection_list *collection)
1141 printf_filtered ("collect static trace data\n");
1142 collection->strace_data = 1;
1145 /* worker function */
1147 clear_collection_list (struct collection_list *list)
1151 list->next_memrange = 0;
1152 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1154 free_agent_expr (list->aexpr_list[ndx]);
1155 list->aexpr_list[ndx] = NULL;
1157 list->next_aexpr_elt = 0;
1158 memset (list->regs_mask, 0, sizeof (list->regs_mask));
1159 list->strace_data = 0;
1162 /* Reduce a collection list to string form (for gdb protocol). */
1164 stringify_collection_list (struct collection_list *list, char *string)
1166 char temp_buf[2048];
1170 char *(*str_list)[];
1174 count = 1 + 1 + list->next_memrange + list->next_aexpr_elt + 1;
1175 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1177 if (list->strace_data)
1180 printf_filtered ("\nCollecting static trace data\n");
1183 (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
1187 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1188 if (list->regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */
1190 if (list->regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
1193 printf_filtered ("\nCollecting registers (mask): 0x");
1198 QUIT; /* Allow user to bail out with ^C. */
1200 printf_filtered ("%02X", list->regs_mask[i]);
1201 sprintf (end, "%02X", list->regs_mask[i]);
1204 (*str_list)[ndx] = xstrdup (temp_buf);
1208 printf_filtered ("\n");
1209 if (list->next_memrange > 0 && info_verbose)
1210 printf_filtered ("Collecting memranges: \n");
1211 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1213 QUIT; /* Allow user to bail out with ^C. */
1214 sprintf_vma (tmp2, list->list[i].start);
1217 printf_filtered ("(%d, %s, %ld)\n",
1220 (long) (list->list[i].end - list->list[i].start));
1222 if (count + 27 > MAX_AGENT_EXPR_LEN)
1224 (*str_list)[ndx] = savestring (temp_buf, count);
1231 bfd_signed_vma length = list->list[i].end - list->list[i].start;
1233 /* The "%X" conversion specifier expects an unsigned argument,
1234 so passing -1 (memrange_absolute) to it directly gives you
1235 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1237 if (list->list[i].type == memrange_absolute)
1238 sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
1240 sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
1243 count += strlen (end);
1244 end = temp_buf + count;
1247 for (i = 0; i < list->next_aexpr_elt; i++)
1249 QUIT; /* Allow user to bail out with ^C. */
1250 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1252 (*str_list)[ndx] = savestring (temp_buf, count);
1257 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1258 end += 10; /* 'X' + 8 hex digits + ',' */
1261 end = mem2hex (list->aexpr_list[i]->buf,
1262 end, list->aexpr_list[i]->len);
1263 count += 2 * list->aexpr_list[i]->len;
1268 (*str_list)[ndx] = savestring (temp_buf, count);
1273 (*str_list)[ndx] = NULL;
1286 encode_actions_1 (struct command_line *action,
1287 struct breakpoint *t,
1288 struct bp_location *tloc,
1290 LONGEST frame_offset,
1291 struct collection_list *collect,
1292 struct collection_list *stepping_list)
1295 struct expression *exp = NULL;
1297 struct value *tempval;
1298 struct cmd_list_element *cmd;
1299 struct agent_expr *aexpr;
1301 for (; action; action = action->next)
1303 QUIT; /* Allow user to bail out with ^C. */
1304 action_exp = action->line;
1305 while (isspace ((int) *action_exp))
1308 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1310 error (_("Bad action list item: %s"), action_exp);
1312 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1315 { /* Repeat over a comma-separated list. */
1316 QUIT; /* Allow user to bail out with ^C. */
1317 while (isspace ((int) *action_exp))
1320 if (0 == strncasecmp ("$reg", action_exp, 4))
1322 for (i = 0; i < gdbarch_num_regs (t->gdbarch); i++)
1323 add_register (collect, i);
1324 action_exp = strchr (action_exp, ','); /* more? */
1326 else if (0 == strncasecmp ("$arg", action_exp, 4))
1328 add_local_symbols (collect,
1334 action_exp = strchr (action_exp, ','); /* more? */
1336 else if (0 == strncasecmp ("$loc", action_exp, 4))
1338 add_local_symbols (collect,
1344 action_exp = strchr (action_exp, ','); /* more? */
1346 else if (0 == strncasecmp ("$_sdata", action_exp, 7))
1348 add_static_trace_data (collect);
1349 action_exp = strchr (action_exp, ','); /* more? */
1353 unsigned long addr, len;
1354 struct cleanup *old_chain = NULL;
1355 struct cleanup *old_chain1 = NULL;
1357 exp = parse_exp_1 (&action_exp,
1358 block_for_pc (tloc->address), 1);
1359 old_chain = make_cleanup (free_current_contents, &exp);
1361 switch (exp->elts[0].opcode)
1365 const char *name = &exp->elts[2].string;
1367 i = user_reg_map_name_to_regnum (t->gdbarch,
1368 name, strlen (name));
1370 internal_error (__FILE__, __LINE__,
1371 _("Register $%s not available"),
1374 printf_filtered ("OP_REGISTER: ");
1375 add_register (collect, i);
1380 /* Safe because we know it's a simple expression. */
1381 tempval = evaluate_expression (exp);
1382 addr = value_address (tempval);
1383 len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
1384 add_memrange (collect, memrange_absolute, addr, len);
1388 collect_symbol (collect,
1389 exp->elts[2].symbol,
1396 default: /* Full-fledged expression. */
1397 aexpr = gen_trace_for_expr (tloc->address, exp);
1399 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1403 report_agent_reqs_errors (aexpr);
1405 discard_cleanups (old_chain1);
1406 add_aexpr (collect, aexpr);
1408 /* Take care of the registers. */
1409 if (aexpr->reg_mask_len > 0)
1414 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1416 QUIT; /* Allow user to bail out with ^C. */
1417 if (aexpr->reg_mask[ndx1] != 0)
1419 /* Assume chars have 8 bits. */
1420 for (ndx2 = 0; ndx2 < 8; ndx2++)
1421 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1422 /* It's used -- record it. */
1423 add_register (collect,
1430 do_cleanups (old_chain);
1433 while (action_exp && *action_exp++ == ',');
1435 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1438 { /* Repeat over a comma-separated list. */
1439 QUIT; /* Allow user to bail out with ^C. */
1440 while (isspace ((int) *action_exp))
1444 struct cleanup *old_chain = NULL;
1445 struct cleanup *old_chain1 = NULL;
1447 exp = parse_exp_1 (&action_exp,
1448 block_for_pc (tloc->address), 1);
1449 old_chain = make_cleanup (free_current_contents, &exp);
1451 aexpr = gen_eval_for_expr (tloc->address, exp);
1452 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1455 report_agent_reqs_errors (aexpr);
1457 discard_cleanups (old_chain1);
1458 /* Even though we're not officially collecting, add
1459 to the collect list anyway. */
1460 add_aexpr (collect, aexpr);
1462 do_cleanups (old_chain);
1465 while (action_exp && *action_exp++ == ',');
1467 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1469 /* We check against nested while-stepping when setting
1470 breakpoint action, so no way to run into nested
1472 gdb_assert (stepping_list);
1474 encode_actions_1 (action->body_list[0], t, tloc, frame_reg,
1475 frame_offset, stepping_list, NULL);
1478 error (_("Invalid tracepoint command '%s'"), action->line);
1482 /* Render all actions into gdb protocol. */
1484 encode_actions (struct breakpoint *t, struct bp_location *tloc,
1485 char ***tdp_actions, char ***stepping_actions)
1487 static char tdp_buff[2048], step_buff[2048];
1488 char *default_collect_line = NULL;
1489 struct command_line *actions;
1490 struct command_line *default_collect_action = NULL;
1492 LONGEST frame_offset;
1493 struct cleanup *back_to;
1495 back_to = make_cleanup (null_cleanup, NULL);
1497 clear_collection_list (&tracepoint_list);
1498 clear_collection_list (&stepping_list);
1500 *tdp_actions = NULL;
1501 *stepping_actions = NULL;
1503 gdbarch_virtual_frame_pointer (t->gdbarch,
1504 t->loc->address, &frame_reg, &frame_offset);
1506 actions = breakpoint_commands (t);
1508 /* If there are default expressions to collect, make up a collect
1509 action and prepend to the action list to encode. Note that since
1510 validation is per-tracepoint (local var "xyz" might be valid for
1511 one tracepoint and not another, etc), we make up the action on
1512 the fly, and don't cache it. */
1513 if (*default_collect)
1517 default_collect_line = xstrprintf ("collect %s", default_collect);
1518 make_cleanup (xfree, default_collect_line);
1520 line = default_collect_line;
1521 validate_actionline (&line, t);
1523 default_collect_action = xmalloc (sizeof (struct command_line));
1524 make_cleanup (xfree, default_collect_action);
1525 default_collect_action->next = actions;
1526 default_collect_action->line = line;
1527 actions = default_collect_action;
1529 encode_actions_1 (actions, t, tloc, frame_reg, frame_offset,
1530 &tracepoint_list, &stepping_list);
1532 memrange_sortmerge (&tracepoint_list);
1533 memrange_sortmerge (&stepping_list);
1535 *tdp_actions = stringify_collection_list (&tracepoint_list,
1537 *stepping_actions = stringify_collection_list (&stepping_list,
1540 do_cleanups (back_to);
1544 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1546 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1548 collect->aexpr_list =
1549 xrealloc (collect->aexpr_list,
1550 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1551 collect->aexpr_listsize *= 2;
1553 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1554 collect->next_aexpr_elt++;
1559 start_tracing (void)
1561 VEC(breakpoint_p) *tp_vec = NULL;
1563 struct breakpoint *b;
1564 struct trace_state_variable *tsv;
1565 int any_enabled = 0, num_to_download = 0;
1567 tp_vec = all_tracepoints ();
1569 /* No point in tracing without any tracepoints... */
1570 if (VEC_length (breakpoint_p, tp_vec) == 0)
1572 VEC_free (breakpoint_p, tp_vec);
1573 error (_("No tracepoints defined, not starting trace"));
1576 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1578 struct tracepoint *t = (struct tracepoint *) b;
1580 if (b->enable_state == bp_enabled)
1583 if ((b->type == bp_fast_tracepoint
1584 ? may_insert_fast_tracepoints
1585 : may_insert_tracepoints))
1588 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1589 (b->type == bp_fast_tracepoint ? "fast " : ""), b->number);
1594 if (target_supports_enable_disable_tracepoint ())
1595 warning (_("No tracepoints enabled"));
1598 /* No point in tracing with only disabled tracepoints that
1599 cannot be re-enabled. */
1600 VEC_free (breakpoint_p, tp_vec);
1601 error (_("No tracepoints enabled, not starting trace"));
1605 if (num_to_download <= 0)
1607 VEC_free (breakpoint_p, tp_vec);
1608 error (_("No tracepoints that may be downloaded, not starting trace"));
1611 target_trace_init ();
1613 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1615 struct tracepoint *t = (struct tracepoint *) b;
1617 if ((b->type == bp_fast_tracepoint
1618 ? !may_insert_fast_tracepoints
1619 : !may_insert_tracepoints))
1622 t->number_on_target = 0;
1623 target_download_tracepoint (b);
1624 t->number_on_target = b->number;
1626 VEC_free (breakpoint_p, tp_vec);
1628 /* Send down all the trace state variables too. */
1629 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1631 target_download_trace_state_variable (tsv);
1634 /* Tell target to treat text-like sections as transparent. */
1635 target_trace_set_readonly_regions ();
1636 /* Set some mode flags. */
1637 target_set_disconnected_tracing (disconnected_tracing);
1638 target_set_circular_trace_buffer (circular_trace_buffer);
1640 /* Now insert traps and begin collecting data. */
1641 target_trace_start ();
1643 /* Reset our local state. */
1644 set_traceframe_num (-1);
1645 set_tracepoint_num (-1);
1646 set_traceframe_context (NULL);
1647 current_trace_status()->running = 1;
1648 clear_traceframe_info ();
1653 Tell target to clear any previous trace experiment.
1654 Walk the list of tracepoints, and send them (and their actions)
1655 to the target. If no errors,
1656 Tell target to start a new trace experiment. */
1659 trace_start_command (char *args, int from_tty)
1661 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1663 if (current_trace_status ()->running)
1666 && !query (_("A trace is running already. Start a new run? ")))
1667 error (_("New trace run not started."));
1675 trace_stop_command (char *args, int from_tty)
1677 if (!current_trace_status ()->running)
1678 error (_("Trace is not running."));
1686 target_trace_stop ();
1687 /* Should change in response to reply? */
1688 current_trace_status ()->running = 0;
1691 /* tstatus command */
1693 trace_status_command (char *args, int from_tty)
1695 struct trace_status *ts = current_trace_status ();
1698 status = target_get_trace_status (ts);
1703 printf_filtered (_("Using a trace file.\n"));
1706 printf_filtered (_("Trace can not be run on this target.\n"));
1711 if (!ts->running_known)
1713 printf_filtered (_("Run/stop status is unknown.\n"));
1715 else if (ts->running)
1717 printf_filtered (_("Trace is running on the target.\n"));
1721 switch (ts->stop_reason)
1723 case trace_never_run:
1724 printf_filtered (_("No trace has been run on the target.\n"));
1727 printf_filtered (_("Trace stopped by a tstop command.\n"));
1729 case trace_buffer_full:
1730 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1732 case trace_disconnected:
1733 printf_filtered (_("Trace stopped because of disconnection.\n"));
1735 case tracepoint_passcount:
1736 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1737 ts->stopping_tracepoint);
1739 case tracepoint_error:
1740 if (ts->stopping_tracepoint)
1741 printf_filtered (_("Trace stopped by an "
1742 "error (%s, tracepoint %d).\n"),
1743 ts->error_desc, ts->stopping_tracepoint);
1745 printf_filtered (_("Trace stopped by an error (%s).\n"),
1748 case trace_stop_reason_unknown:
1749 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1752 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1758 if (ts->traceframes_created >= 0
1759 && ts->traceframe_count != ts->traceframes_created)
1761 printf_filtered (_("Buffer contains %d trace "
1762 "frames (of %d created total).\n"),
1763 ts->traceframe_count, ts->traceframes_created);
1765 else if (ts->traceframe_count >= 0)
1767 printf_filtered (_("Collected %d trace frames.\n"),
1768 ts->traceframe_count);
1771 if (ts->buffer_free >= 0)
1773 if (ts->buffer_size >= 0)
1775 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1776 ts->buffer_free, ts->buffer_size);
1777 if (ts->buffer_size > 0)
1778 printf_filtered (_(" (%d%% full)"),
1779 ((int) ((((long long) (ts->buffer_size
1780 - ts->buffer_free)) * 100)
1781 / ts->buffer_size)));
1782 printf_filtered (_(".\n"));
1785 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1789 if (ts->disconnected_tracing)
1790 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1792 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1794 if (ts->circular_buffer)
1795 printf_filtered (_("Trace buffer is circular.\n"));
1797 /* Now report on what we're doing with tfind. */
1798 if (traceframe_number >= 0)
1799 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1800 traceframe_number, tracepoint_number);
1802 printf_filtered (_("Not looking at any trace frame.\n"));
1805 /* Report the trace status to uiout, in a way suitable for MI, and not
1806 suitable for CLI. If ON_STOP is true, suppress a few fields that
1807 are not meaningful in the -trace-stop response.
1809 The implementation is essentially parallel to trace_status_command, but
1810 merging them will result in unreadable code. */
1812 trace_status_mi (int on_stop)
1814 struct trace_status *ts = current_trace_status ();
1817 status = target_get_trace_status (ts);
1819 if (status == -1 && !ts->from_file)
1821 ui_out_field_string (uiout, "supported", "0");
1826 ui_out_field_string (uiout, "supported", "file");
1828 ui_out_field_string (uiout, "supported", "1");
1830 gdb_assert (ts->running_known);
1834 ui_out_field_string (uiout, "running", "1");
1836 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1837 Given that the frontend gets the status either on -trace-stop, or from
1838 -trace-status after re-connection, it does not seem like this
1839 information is necessary for anything. It is not necessary for either
1840 figuring the vital state of the target nor for navigation of trace
1841 frames. If the frontend wants to show the current state is some
1842 configure dialog, it can request the value when such dialog is
1843 invoked by the user. */
1847 char *stop_reason = NULL;
1848 int stopping_tracepoint = -1;
1851 ui_out_field_string (uiout, "running", "0");
1853 if (ts->stop_reason != trace_stop_reason_unknown)
1855 switch (ts->stop_reason)
1858 stop_reason = "request";
1860 case trace_buffer_full:
1861 stop_reason = "overflow";
1863 case trace_disconnected:
1864 stop_reason = "disconnection";
1866 case tracepoint_passcount:
1867 stop_reason = "passcount";
1868 stopping_tracepoint = ts->stopping_tracepoint;
1870 case tracepoint_error:
1871 stop_reason = "error";
1872 stopping_tracepoint = ts->stopping_tracepoint;
1878 ui_out_field_string (uiout, "stop-reason", stop_reason);
1879 if (stopping_tracepoint != -1)
1880 ui_out_field_int (uiout, "stopping-tracepoint",
1881 stopping_tracepoint);
1882 if (ts->stop_reason == tracepoint_error)
1883 ui_out_field_string (uiout, "error-description",
1889 if (ts->traceframe_count != -1)
1890 ui_out_field_int (uiout, "frames", ts->traceframe_count);
1891 if (ts->traceframes_created != -1)
1892 ui_out_field_int (uiout, "frames-created", ts->traceframes_created);
1893 if (ts->buffer_size != -1)
1894 ui_out_field_int (uiout, "buffer-size", ts->buffer_size);
1895 if (ts->buffer_free != -1)
1896 ui_out_field_int (uiout, "buffer-free", ts->buffer_free);
1898 ui_out_field_int (uiout, "disconnected", ts->disconnected_tracing);
1899 ui_out_field_int (uiout, "circular", ts->circular_buffer);
1902 /* This function handles the details of what to do about an ongoing
1903 tracing run if the user has asked to detach or otherwise disconnect
1906 disconnect_tracing (int from_tty)
1908 /* It can happen that the target that was tracing went away on its
1909 own, and we didn't notice. Get a status update, and if the
1910 current target doesn't even do tracing, then assume it's not
1912 if (target_get_trace_status (current_trace_status ()) < 0)
1913 current_trace_status ()->running = 0;
1915 /* If running interactively, give the user the option to cancel and
1916 then decide what to do differently with the run. Scripts are
1917 just going to disconnect and let the target deal with it,
1918 according to how it's been instructed previously via
1919 disconnected-tracing. */
1920 if (current_trace_status ()->running && from_tty)
1922 if (current_trace_status ()->disconnected_tracing)
1924 if (!query (_("Trace is running and will "
1925 "continue after detach; detach anyway? ")))
1926 error (_("Not confirmed."));
1930 if (!query (_("Trace is running but will "
1931 "stop on detach; detach anyway? ")))
1932 error (_("Not confirmed."));
1936 /* Also we want to be out of tfind mode, otherwise things can get
1937 confusing upon reconnection. Just use these calls instead of
1938 full tfind_1 behavior because we're in the middle of detaching,
1939 and there's no point to updating current stack frame etc. */
1940 set_current_traceframe (-1);
1941 set_traceframe_context (NULL);
1944 /* Worker function for the various flavors of the tfind command. */
1946 tfind_1 (enum trace_find_type type, int num,
1947 ULONGEST addr1, ULONGEST addr2,
1950 int target_frameno = -1, target_tracept = -1;
1951 struct frame_id old_frame_id = null_frame_id;
1952 struct tracepoint *tp;
1954 /* Only try to get the current stack frame if we have a chance of
1955 succeeding. In particular, if we're trying to get a first trace
1956 frame while all threads are running, it's not going to succeed,
1957 so leave it with a default value and let the frame comparison
1958 below (correctly) decide to print out the source location of the
1960 if (!(type == tfind_number && num == -1)
1961 && (has_stack_frames () || traceframe_number >= 0))
1962 old_frame_id = get_frame_id (get_current_frame ());
1964 target_frameno = target_trace_find (type, num, addr1, addr2,
1967 if (type == tfind_number
1969 && target_frameno == -1)
1971 /* We told the target to get out of tfind mode, and it did. */
1973 else if (target_frameno == -1)
1975 /* A request for a non-existent trace frame has failed.
1976 Our response will be different, depending on FROM_TTY:
1978 If FROM_TTY is true, meaning that this command was
1979 typed interactively by the user, then give an error
1980 and DO NOT change the state of traceframe_number etc.
1982 However if FROM_TTY is false, meaning that we're either
1983 in a script, a loop, or a user-defined command, then
1984 DON'T give an error, but DO change the state of
1985 traceframe_number etc. to invalid.
1987 The rationalle is that if you typed the command, you
1988 might just have committed a typo or something, and you'd
1989 like to NOT lose your current debugging state. However
1990 if you're in a user-defined command or especially in a
1991 loop, then you need a way to detect that the command
1992 failed WITHOUT aborting. This allows you to write
1993 scripts that search thru the trace buffer until the end,
1994 and then continue on to do something else. */
1997 error (_("Target failed to find requested trace frame."));
2001 printf_filtered ("End of trace buffer.\n");
2002 #if 0 /* dubious now? */
2003 /* The following will not recurse, since it's
2005 trace_find_command ("-1", from_tty);
2010 tp = get_tracepoint_by_number_on_target (target_tracept);
2012 reinit_frame_cache ();
2013 registers_changed ();
2014 target_dcache_invalidate ();
2015 set_traceframe_num (target_frameno);
2016 clear_traceframe_info ();
2017 set_tracepoint_num (tp ? tp->base.number : target_tracept);
2018 if (target_frameno == -1)
2019 set_traceframe_context (NULL);
2021 set_traceframe_context (get_current_frame ());
2023 if (traceframe_number >= 0)
2025 /* Use different branches for MI and CLI to make CLI messages
2027 if (ui_out_is_mi_like_p (uiout))
2029 ui_out_field_string (uiout, "found", "1");
2030 ui_out_field_int (uiout, "tracepoint", tracepoint_number);
2031 ui_out_field_int (uiout, "traceframe", traceframe_number);
2035 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2036 traceframe_number, tracepoint_number);
2041 if (ui_out_is_mi_like_p (uiout))
2042 ui_out_field_string (uiout, "found", "0");
2043 else if (type == tfind_number && num == -1)
2044 printf_unfiltered (_("No longer looking at any trace frame\n"));
2045 else /* This case may never occur, check. */
2046 printf_unfiltered (_("No trace frame found\n"));
2049 /* If we're in nonstop mode and getting out of looking at trace
2050 frames, there won't be any current frame to go back to and
2053 && (has_stack_frames () || traceframe_number >= 0))
2055 enum print_what print_what;
2057 /* NOTE: in imitation of the step command, try to determine
2058 whether we have made a transition from one function to
2059 another. If so, we'll print the "stack frame" (ie. the new
2060 function and it's arguments) -- otherwise we'll just show the
2063 if (frame_id_eq (old_frame_id,
2064 get_frame_id (get_current_frame ())))
2065 print_what = SRC_LINE;
2067 print_what = SRC_AND_LOC;
2069 print_stack_frame (get_selected_frame (NULL), 1, print_what);
2074 /* trace_find_command takes a trace frame number n,
2075 sends "QTFrame:<n>" to the target,
2076 and accepts a reply that may contain several optional pieces
2077 of information: a frame number, a tracepoint number, and an
2078 indication of whether this is a trap frame or a stepping frame.
2080 The minimal response is just "OK" (which indicates that the
2081 target does not give us a frame number or a tracepoint number).
2082 Instead of that, the target may send us a string containing
2084 F<hexnum> (gives the selected frame number)
2085 T<hexnum> (gives the selected tracepoint number)
2090 trace_find_command (char *args, int from_tty)
2091 { /* This should only be called with a numeric argument. */
2094 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2095 error (_("May not look at trace frames while trace is running."));
2097 if (args == 0 || *args == 0)
2098 { /* TFIND with no args means find NEXT trace frame. */
2099 if (traceframe_number == -1)
2100 frameno = 0; /* "next" is first one. */
2102 frameno = traceframe_number + 1;
2104 else if (0 == strcmp (args, "-"))
2106 if (traceframe_number == -1)
2107 error (_("not debugging trace buffer"));
2108 else if (from_tty && traceframe_number == 0)
2109 error (_("already at start of trace buffer"));
2111 frameno = traceframe_number - 1;
2113 /* A hack to work around eval's need for fp to have been collected. */
2114 else if (0 == strcmp (args, "-1"))
2117 frameno = parse_and_eval_long (args);
2120 error (_("invalid input (%d is less than zero)"), frameno);
2122 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2127 trace_find_end_command (char *args, int from_tty)
2129 trace_find_command ("-1", from_tty);
2134 trace_find_none_command (char *args, int from_tty)
2136 trace_find_command ("-1", from_tty);
2141 trace_find_start_command (char *args, int from_tty)
2143 trace_find_command ("0", from_tty);
2146 /* tfind pc command */
2148 trace_find_pc_command (char *args, int from_tty)
2152 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2153 error (_("May not look at trace frames while trace is running."));
2155 if (args == 0 || *args == 0)
2156 pc = regcache_read_pc (get_current_regcache ());
2158 pc = parse_and_eval_address (args);
2160 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2163 /* tfind tracepoint command */
2165 trace_find_tracepoint_command (char *args, int from_tty)
2168 struct tracepoint *tp;
2170 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2171 error (_("May not look at trace frames while trace is running."));
2173 if (args == 0 || *args == 0)
2175 if (tracepoint_number == -1)
2176 error (_("No current tracepoint -- please supply an argument."));
2178 tdp = tracepoint_number; /* Default is current TDP. */
2181 tdp = parse_and_eval_long (args);
2183 /* If we have the tracepoint on hand, use the number that the
2184 target knows about (which may be different if we disconnected
2185 and reconnected). */
2186 tp = get_tracepoint (tdp);
2188 tdp = tp->number_on_target;
2190 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2193 /* TFIND LINE command:
2195 This command will take a sourceline for argument, just like BREAK
2196 or TRACE (ie. anything that "decode_line_1" can handle).
2198 With no argument, this command will find the next trace frame
2199 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2202 trace_find_line_command (char *args, int from_tty)
2204 static CORE_ADDR start_pc, end_pc;
2205 struct symtabs_and_lines sals;
2206 struct symtab_and_line sal;
2207 struct cleanup *old_chain;
2209 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2210 error (_("May not look at trace frames while trace is running."));
2212 if (args == 0 || *args == 0)
2214 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2216 sals.sals = (struct symtab_and_line *)
2217 xmalloc (sizeof (struct symtab_and_line));
2222 sals = decode_line_spec (args, 1);
2226 old_chain = make_cleanup (xfree, sals.sals);
2227 if (sal.symtab == 0)
2228 error (_("No line number information available."));
2230 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2232 if (start_pc == end_pc)
2234 printf_filtered ("Line %d of \"%s\"",
2235 sal.line, sal.symtab->filename);
2237 printf_filtered (" is at address ");
2238 print_address (get_current_arch (), start_pc, gdb_stdout);
2240 printf_filtered (" but contains no code.\n");
2241 sal = find_pc_line (start_pc, 0);
2243 && find_line_pc_range (sal, &start_pc, &end_pc)
2244 && start_pc != end_pc)
2245 printf_filtered ("Attempting to find line %d instead.\n",
2248 error (_("Cannot find a good line."));
2252 /* Is there any case in which we get here, and have an address
2253 which the user would want to see? If we have debugging
2254 symbols and no line numbers? */
2255 error (_("Line number %d is out of range for \"%s\"."),
2256 sal.line, sal.symtab->filename);
2258 /* Find within range of stated line. */
2260 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2262 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2263 do_cleanups (old_chain);
2266 /* tfind range command */
2268 trace_find_range_command (char *args, int from_tty)
2270 static CORE_ADDR start, stop;
2273 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2274 error (_("May not look at trace frames while trace is running."));
2276 if (args == 0 || *args == 0)
2277 { /* XXX FIXME: what should default behavior be? */
2278 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2282 if (0 != (tmp = strchr (args, ',')))
2284 *tmp++ = '\0'; /* Terminate start address. */
2285 while (isspace ((int) *tmp))
2287 start = parse_and_eval_address (args);
2288 stop = parse_and_eval_address (tmp);
2291 { /* No explicit end address? */
2292 start = parse_and_eval_address (args);
2293 stop = start + 1; /* ??? */
2296 tfind_1 (tfind_range, 0, start, stop, from_tty);
2299 /* tfind outside command */
2301 trace_find_outside_command (char *args, int from_tty)
2303 CORE_ADDR start, stop;
2306 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2307 error (_("May not look at trace frames while trace is running."));
2309 if (args == 0 || *args == 0)
2310 { /* XXX FIXME: what should default behavior be? */
2311 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2315 if (0 != (tmp = strchr (args, ',')))
2317 *tmp++ = '\0'; /* Terminate start address. */
2318 while (isspace ((int) *tmp))
2320 start = parse_and_eval_address (args);
2321 stop = parse_and_eval_address (tmp);
2324 { /* No explicit end address? */
2325 start = parse_and_eval_address (args);
2326 stop = start + 1; /* ??? */
2329 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2332 /* info scope command: list the locals for a scope. */
2334 scope_info (char *args, int from_tty)
2336 struct symtabs_and_lines sals;
2338 struct minimal_symbol *msym;
2339 struct block *block;
2340 char *symname, *save_args = args;
2341 struct dict_iterator iter;
2343 struct gdbarch *gdbarch;
2346 if (args == 0 || *args == 0)
2347 error (_("requires an argument (function, "
2348 "line or *addr) to define a scope"));
2350 sals = decode_line_1 (&args, 1, NULL, 0, NULL);
2351 if (sals.nelts == 0)
2352 return; /* Presumably decode_line_1 has already warned. */
2354 /* Resolve line numbers to PC. */
2355 resolve_sal_pc (&sals.sals[0]);
2356 block = block_for_pc (sals.sals[0].pc);
2360 QUIT; /* Allow user to bail out with ^C. */
2361 ALL_BLOCK_SYMBOLS (block, iter, sym)
2363 QUIT; /* Allow user to bail out with ^C. */
2365 printf_filtered ("Scope for %s:\n", save_args);
2368 symname = SYMBOL_PRINT_NAME (sym);
2369 if (symname == NULL || *symname == '\0')
2370 continue; /* Probably botched, certainly useless. */
2372 gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
2374 printf_filtered ("Symbol %s is ", symname);
2375 switch (SYMBOL_CLASS (sym))
2378 case LOC_UNDEF: /* Messed up symbol? */
2379 printf_filtered ("a bogus symbol, class %d.\n",
2380 SYMBOL_CLASS (sym));
2381 count--; /* Don't count this one. */
2384 printf_filtered ("a constant with value %ld (0x%lx)",
2385 SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
2387 case LOC_CONST_BYTES:
2388 printf_filtered ("constant bytes: ");
2389 if (SYMBOL_TYPE (sym))
2390 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2391 fprintf_filtered (gdb_stdout, " %02x",
2392 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2395 printf_filtered ("in static storage at address ");
2396 printf_filtered ("%s", paddress (gdbarch,
2397 SYMBOL_VALUE_ADDRESS (sym)));
2400 /* GDBARCH is the architecture associated with the objfile
2401 the symbol is defined in; the target architecture may be
2402 different, and may provide additional registers. However,
2403 we do not know the target architecture at this point.
2404 We assume the objfile architecture will contain all the
2405 standard registers that occur in debug info in that
2407 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2410 if (SYMBOL_IS_ARGUMENT (sym))
2411 printf_filtered ("an argument in register $%s",
2412 gdbarch_register_name (gdbarch, regno));
2414 printf_filtered ("a local variable in register $%s",
2415 gdbarch_register_name (gdbarch, regno));
2418 printf_filtered ("an argument at stack/frame offset %ld",
2419 SYMBOL_VALUE (sym));
2422 printf_filtered ("a local variable at frame offset %ld",
2423 SYMBOL_VALUE (sym));
2426 printf_filtered ("a reference argument at offset %ld",
2427 SYMBOL_VALUE (sym));
2429 case LOC_REGPARM_ADDR:
2430 /* Note comment at LOC_REGISTER. */
2431 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2433 printf_filtered ("the address of an argument, in register $%s",
2434 gdbarch_register_name (gdbarch, regno));
2437 printf_filtered ("a typedef.\n");
2440 printf_filtered ("a label at address ");
2441 printf_filtered ("%s", paddress (gdbarch,
2442 SYMBOL_VALUE_ADDRESS (sym)));
2445 printf_filtered ("a function at address ");
2446 printf_filtered ("%s",
2447 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2449 case LOC_UNRESOLVED:
2450 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2453 printf_filtered ("Unresolved Static");
2456 printf_filtered ("static storage at address ");
2457 printf_filtered ("%s",
2458 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msym)));
2461 case LOC_OPTIMIZED_OUT:
2462 printf_filtered ("optimized out.\n");
2465 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2466 BLOCK_START (block),
2470 if (SYMBOL_TYPE (sym))
2471 printf_filtered (", length %d.\n",
2472 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2474 if (BLOCK_FUNCTION (block))
2477 block = BLOCK_SUPERBLOCK (block);
2480 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2484 /* worker function (cleanup) */
2486 replace_comma (void *data)
2493 /* Helper for trace_dump_command. Dump the action list starting at
2494 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2495 actions of the body of a while-stepping action. STEPPING_FRAME is
2496 set if the current traceframe was determined to be a while-stepping
2500 trace_dump_actions (struct command_line *action,
2501 int stepping_actions, int stepping_frame,
2504 char *action_exp, *next_comma;
2506 for (; action != NULL; action = action->next)
2508 struct cmd_list_element *cmd;
2510 QUIT; /* Allow user to bail out with ^C. */
2511 action_exp = action->line;
2512 while (isspace ((int) *action_exp))
2515 /* The collection actions to be done while stepping are
2516 bracketed by the commands "while-stepping" and "end". */
2518 if (*action_exp == '#') /* comment line */
2521 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2523 error (_("Bad action list item: %s"), action_exp);
2525 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2529 for (i = 0; i < action->body_count; ++i)
2530 trace_dump_actions (action->body_list[i],
2531 1, stepping_frame, from_tty);
2533 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2535 /* Display the collected data.
2536 For the trap frame, display only what was collected at
2537 the trap. Likewise for stepping frames, display only
2538 what was collected while stepping. This means that the
2539 two boolean variables, STEPPING_FRAME and
2540 STEPPING_ACTIONS should be equal. */
2541 if (stepping_frame == stepping_actions)
2544 { /* Repeat over a comma-separated list. */
2545 QUIT; /* Allow user to bail out with ^C. */
2546 if (*action_exp == ',')
2548 while (isspace ((int) *action_exp))
2551 next_comma = strchr (action_exp, ',');
2553 if (0 == strncasecmp (action_exp, "$reg", 4))
2554 registers_info (NULL, from_tty);
2555 else if (0 == strncasecmp (action_exp, "$loc", 4))
2556 locals_info (NULL, from_tty);
2557 else if (0 == strncasecmp (action_exp, "$arg", 4))
2558 args_info (NULL, from_tty);
2563 make_cleanup (replace_comma, next_comma);
2566 printf_filtered ("%s = ", action_exp);
2567 output_command (action_exp, from_tty);
2568 printf_filtered ("\n");
2572 action_exp = next_comma;
2574 while (action_exp && *action_exp == ',');
2580 /* The tdump command. */
2583 trace_dump_command (char *args, int from_tty)
2585 struct regcache *regcache;
2586 struct tracepoint *t;
2587 int stepping_frame = 0;
2588 struct bp_location *loc;
2589 char *line, *default_collect_line = NULL;
2590 struct command_line *actions, *default_collect_action = NULL;
2591 struct cleanup *old_chain = NULL;
2593 if (tracepoint_number == -1)
2595 warning (_("No current trace frame."));
2599 t = get_tracepoint (tracepoint_number);
2602 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2605 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2606 tracepoint_number, traceframe_number);
2608 /* The current frame is a trap frame if the frame PC is equal
2609 to the tracepoint PC. If not, then the current frame was
2610 collected during single-stepping. */
2612 regcache = get_current_regcache ();
2614 /* If the traceframe's address matches any of the tracepoint's
2615 locations, assume it is a direct hit rather than a while-stepping
2616 frame. (FIXME this is not reliable, should record each frame's
2619 for (loc = t->base.loc; loc; loc = loc->next)
2620 if (loc->address == regcache_read_pc (regcache))
2623 actions = breakpoint_commands (&t->base);
2625 /* If there is a default-collect list, make up a collect command,
2626 prepend to the tracepoint's commands, and pass the whole mess to
2627 the trace dump scanner. We need to validate because
2628 default-collect might have been junked since the trace run. */
2629 if (*default_collect)
2631 default_collect_line = xstrprintf ("collect %s", default_collect);
2632 old_chain = make_cleanup (xfree, default_collect_line);
2633 line = default_collect_line;
2634 validate_actionline (&line, &t->base);
2635 default_collect_action = xmalloc (sizeof (struct command_line));
2636 make_cleanup (xfree, default_collect_action);
2637 default_collect_action->next = actions;
2638 default_collect_action->line = line;
2639 actions = default_collect_action;
2642 trace_dump_actions (actions, 0, stepping_frame, from_tty);
2644 if (*default_collect)
2645 do_cleanups (old_chain);
2648 /* Encode a piece of a tracepoint's source-level definition in a form
2649 that is suitable for both protocol and saving in files. */
2650 /* This version does not do multiple encodes for long strings; it should
2651 return an offset to the next piece to encode. FIXME */
2654 encode_source_string (int tpnum, ULONGEST addr,
2655 char *srctype, char *src, char *buf, int buf_size)
2657 if (80 + strlen (srctype) > buf_size)
2658 error (_("Buffer too small for source encoding"));
2659 sprintf (buf, "%x:%s:%s:%x:%x:",
2660 tpnum, phex_nz (addr, sizeof (addr)),
2661 srctype, 0, (int) strlen (src));
2662 if (strlen (buf) + strlen (src) * 2 >= buf_size)
2663 error (_("Source string too long for buffer"));
2664 bin2hex (src, buf + strlen (buf), 0);
2668 extern int trace_regblock_size;
2670 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2671 non-zero, the save is performed on the target, otherwise GDB obtains all
2672 trace data and saves it locally. */
2675 trace_save (const char *filename, int target_does_save)
2677 struct cleanup *cleanup;
2679 struct trace_status *ts = current_trace_status ();
2682 struct uploaded_tp *uploaded_tps = NULL, *utp;
2683 struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
2687 ULONGEST offset = 0;
2688 #define MAX_TRACE_UPLOAD 2000
2689 gdb_byte buf[MAX_TRACE_UPLOAD];
2692 /* If the target is to save the data to a file on its own, then just
2693 send the command and be done with it. */
2694 if (target_does_save)
2696 err = target_save_trace_data (filename);
2698 error (_("Target failed to save trace data to '%s'."),
2703 /* Get the trace status first before opening the file, so if the
2704 target is losing, we can get out without touching files. */
2705 status = target_get_trace_status (ts);
2707 pathname = tilde_expand (filename);
2708 cleanup = make_cleanup (xfree, pathname);
2710 fp = fopen (pathname, "wb");
2712 error (_("Unable to open file '%s' for saving trace data (%s)"),
2713 filename, safe_strerror (errno));
2714 make_cleanup_fclose (fp);
2716 /* Write a file header, with a high-bit-set char to indicate a
2717 binary file, plus a hint as what this file is, and a version
2718 number in case of future needs. */
2719 written = fwrite ("\x7fTRACE0\n", 8, 1, fp);
2721 perror_with_name (pathname);
2723 /* Write descriptive info. */
2725 /* Write out the size of a register block. */
2726 fprintf (fp, "R %x\n", trace_regblock_size);
2728 /* Write out status of the tracing run (aka "tstatus" info). */
2729 fprintf (fp, "status %c;%s",
2730 (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
2731 if (ts->stop_reason == tracepoint_error)
2733 char *buf = (char *) alloca (strlen (ts->error_desc) * 2 + 1);
2735 bin2hex ((gdb_byte *) ts->error_desc, buf, 0);
2736 fprintf (fp, ":%s", buf);
2738 fprintf (fp, ":%x", ts->stopping_tracepoint);
2739 if (ts->traceframe_count >= 0)
2740 fprintf (fp, ";tframes:%x", ts->traceframe_count);
2741 if (ts->traceframes_created >= 0)
2742 fprintf (fp, ";tcreated:%x", ts->traceframes_created);
2743 if (ts->buffer_free >= 0)
2744 fprintf (fp, ";tfree:%x", ts->buffer_free);
2745 if (ts->buffer_size >= 0)
2746 fprintf (fp, ";tsize:%x", ts->buffer_size);
2747 if (ts->disconnected_tracing)
2748 fprintf (fp, ";disconn:%x", ts->disconnected_tracing);
2749 if (ts->circular_buffer)
2750 fprintf (fp, ";circular:%x", ts->circular_buffer);
2753 /* Note that we want to upload tracepoints and save those, rather
2754 than simply writing out the local ones, because the user may have
2755 changed tracepoints in GDB in preparation for a future tracing
2756 run, or maybe just mass-deleted all types of breakpoints as part
2757 of cleaning up. So as not to contaminate the session, leave the
2758 data in its uploaded form, don't make into real tracepoints. */
2760 /* Get trace state variables first, they may be checked when parsing
2761 uploaded commands. */
2763 target_upload_trace_state_variables (&uploaded_tsvs);
2765 for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
2771 buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
2772 bin2hex ((gdb_byte *) (utsv->name), buf, 0);
2775 fprintf (fp, "tsv %x:%s:%x:%s\n",
2776 utsv->number, phex_nz (utsv->initial_value, 8),
2777 utsv->builtin, buf);
2783 free_uploaded_tsvs (&uploaded_tsvs);
2785 target_upload_tracepoints (&uploaded_tps);
2787 for (utp = uploaded_tps; utp; utp = utp->next)
2789 fprintf (fp, "tp T%x:%s:%c:%x:%x",
2790 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
2791 (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
2792 if (utp->type == bp_fast_tracepoint)
2793 fprintf (fp, ":F%x", utp->orig_size);
2795 fprintf (fp, ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
2798 for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
2799 fprintf (fp, "tp A%x:%s:%s\n",
2800 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
2801 for (a = 0; VEC_iterate (char_ptr, utp->step_actions, a, act); ++a)
2802 fprintf (fp, "tp S%x:%s:%s\n",
2803 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
2806 encode_source_string (utp->number, utp->addr,
2807 "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
2808 fprintf (fp, "tp Z%s\n", buf);
2810 if (utp->cond_string)
2812 encode_source_string (utp->number, utp->addr,
2813 "cond", utp->cond_string,
2814 buf, MAX_TRACE_UPLOAD);
2815 fprintf (fp, "tp Z%s\n", buf);
2817 for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
2819 encode_source_string (utp->number, utp->addr, "cmd", act,
2820 buf, MAX_TRACE_UPLOAD);
2821 fprintf (fp, "tp Z%s\n", buf);
2825 free_uploaded_tps (&uploaded_tps);
2827 /* Mark the end of the definition section. */
2830 /* Get and write the trace data proper. We ask for big blocks, in
2831 the hopes of efficiency, but will take less if the target has
2832 packet size limitations or some such. */
2835 gotten = target_get_raw_trace_data (buf, offset, MAX_TRACE_UPLOAD);
2837 error (_("Failure to get requested trace buffer data"));
2838 /* No more data is forthcoming, we're done. */
2841 written = fwrite (buf, gotten, 1, fp);
2843 perror_with_name (pathname);
2847 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
2848 written = fwrite (&gotten, 4, 1, fp);
2850 perror_with_name (pathname);
2852 do_cleanups (cleanup);
2856 trace_save_command (char *args, int from_tty)
2858 int target_does_save = 0;
2860 char *filename = NULL;
2861 struct cleanup *back_to;
2864 error_no_arg (_("file in which to save trace data"));
2866 argv = gdb_buildargv (args);
2867 back_to = make_cleanup_freeargv (argv);
2869 for (; *argv; ++argv)
2871 if (strcmp (*argv, "-r") == 0)
2872 target_does_save = 1;
2873 else if (**argv == '-')
2874 error (_("unknown option `%s'"), *argv);
2880 error_no_arg (_("file in which to save trace data"));
2882 trace_save (filename, target_does_save);
2885 printf_filtered (_("Trace data saved to file '%s'.\n"), args);
2887 do_cleanups (back_to);
2890 /* Tell the target what to do with an ongoing tracing run if GDB
2891 disconnects for some reason. */
2894 send_disconnected_tracing_value (int value)
2896 target_set_disconnected_tracing (value);
2900 set_disconnected_tracing (char *args, int from_tty,
2901 struct cmd_list_element *c)
2903 send_disconnected_tracing_value (disconnected_tracing);
2907 set_circular_trace_buffer (char *args, int from_tty,
2908 struct cmd_list_element *c)
2910 target_set_circular_trace_buffer (circular_trace_buffer);
2913 /* Convert the memory pointed to by mem into hex, placing result in buf.
2914 * Return a pointer to the last char put in buf (null)
2915 * "stolen" from sparc-stub.c
2918 static const char hexchars[] = "0123456789abcdef";
2921 mem2hex (gdb_byte *mem, char *buf, int count)
2929 *buf++ = hexchars[ch >> 4];
2930 *buf++ = hexchars[ch & 0xf];
2939 get_traceframe_number (void)
2941 return traceframe_number;
2944 /* Make the traceframe NUM be the current trace frame. Does nothing
2945 if NUM is already current. */
2948 set_current_traceframe (int num)
2952 if (traceframe_number == num)
2954 /* Nothing to do. */
2958 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
2961 warning (_("could not change traceframe"));
2963 traceframe_number = newnum;
2965 /* Changing the traceframe changes our view of registers and of the
2967 registers_changed ();
2969 clear_traceframe_info ();
2972 /* Make the traceframe NUM be the current trace frame, and do nothing
2976 set_traceframe_number (int num)
2978 traceframe_number = num;
2981 /* A cleanup used when switching away and back from tfind mode. */
2983 struct current_traceframe_cleanup
2985 /* The traceframe we were inspecting. */
2986 int traceframe_number;
2990 do_restore_current_traceframe_cleanup (void *arg)
2992 struct current_traceframe_cleanup *old = arg;
2994 set_current_traceframe (old->traceframe_number);
2998 restore_current_traceframe_cleanup_dtor (void *arg)
3000 struct current_traceframe_cleanup *old = arg;
3006 make_cleanup_restore_current_traceframe (void)
3008 struct current_traceframe_cleanup *old;
3010 old = xmalloc (sizeof (struct current_traceframe_cleanup));
3011 old->traceframe_number = traceframe_number;
3013 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
3014 restore_current_traceframe_cleanup_dtor);
3018 make_cleanup_restore_traceframe_number (void)
3020 return make_cleanup_restore_integer (&traceframe_number);
3023 /* Given a number and address, return an uploaded tracepoint with that
3024 number, creating if necessary. */
3026 struct uploaded_tp *
3027 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
3029 struct uploaded_tp *utp;
3031 for (utp = *utpp; utp; utp = utp->next)
3032 if (utp->number == num && utp->addr == addr)
3034 utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
3035 memset (utp, 0, sizeof (struct uploaded_tp));
3038 utp->actions = NULL;
3039 utp->step_actions = NULL;
3040 utp->cmd_strings = NULL;
3047 free_uploaded_tps (struct uploaded_tp **utpp)
3049 struct uploaded_tp *next_one;
3053 next_one = (*utpp)->next;
3059 /* Given a number and address, return an uploaded tracepoint with that
3060 number, creating if necessary. */
3062 struct uploaded_tsv *
3063 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3065 struct uploaded_tsv *utsv;
3067 for (utsv = *utsvp; utsv; utsv = utsv->next)
3068 if (utsv->number == num)
3070 utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
3071 memset (utsv, 0, sizeof (struct uploaded_tsv));
3073 utsv->next = *utsvp;
3079 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3081 struct uploaded_tsv *next_one;
3085 next_one = (*utsvp)->next;
3091 /* Look for an existing tracepoint that seems similar enough to the
3092 uploaded one. Enablement isn't compared, because the user can
3093 toggle that freely, and may have done so in anticipation of the
3097 find_matching_tracepoint (struct uploaded_tp *utp)
3099 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
3101 struct breakpoint *b;
3102 struct bp_location *loc;
3104 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
3106 struct tracepoint *t = (struct tracepoint *) b;
3108 if (b->type == utp->type
3109 && t->step_count == utp->step
3110 && t->pass_count == utp->pass
3111 /* FIXME also test conditionals and actions. */
3114 /* Scan the locations for an address match. */
3115 for (loc = b->loc; loc; loc = loc->next)
3117 if (loc->address == utp->addr)
3125 /* Given a list of tracepoints uploaded from a target, attempt to
3126 match them up with existing tracepoints, and create new ones if not
3130 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3132 struct uploaded_tp *utp;
3133 struct tracepoint *t;
3135 /* Look for GDB tracepoints that match up with our uploaded versions. */
3136 for (utp = *uploaded_tps; utp; utp = utp->next)
3138 t = find_matching_tracepoint (utp);
3140 printf_filtered (_("Assuming tracepoint %d is same "
3141 "as target's tracepoint %d at %s.\n"),
3142 t->base.number, utp->number,
3143 paddress (get_current_arch (), utp->addr));
3146 t = create_tracepoint_from_upload (utp);
3148 printf_filtered (_("Created tracepoint %d for "
3149 "target's tracepoint %d at %s.\n"),
3150 t->base.number, utp->number,
3151 paddress (get_current_arch (), utp->addr));
3153 printf_filtered (_("Failed to create tracepoint for target's "
3154 "tracepoint %d at %s, skipping it.\n"),
3156 paddress (get_current_arch (), utp->addr));
3158 /* Whether found or created, record the number used by the
3159 target, to help with mapping target tracepoints back to their
3160 counterparts here. */
3162 t->number_on_target = utp->number;
3165 free_uploaded_tps (uploaded_tps);
3168 /* Trace state variables don't have much to identify them beyond their
3169 name, so just use that to detect matches. */
3171 struct trace_state_variable *
3172 find_matching_tsv (struct uploaded_tsv *utsv)
3177 return find_trace_state_variable (utsv->name);
3180 struct trace_state_variable *
3181 create_tsv_from_upload (struct uploaded_tsv *utsv)
3183 const char *namebase;
3186 struct trace_state_variable *tsv;
3190 namebase = utsv->name;
3191 sprintf (buf, "%s", namebase);
3196 sprintf (buf, "%s_%d", namebase, try_num++);
3199 /* Fish for a name that is not in use. */
3200 /* (should check against all internal vars?) */
3201 while (find_trace_state_variable (buf))
3202 sprintf (buf, "%s_%d", namebase, try_num++);
3204 /* We have an available name, create the variable. */
3205 tsv = create_trace_state_variable (buf);
3206 tsv->initial_value = utsv->initial_value;
3207 tsv->builtin = utsv->builtin;
3212 /* Given a list of uploaded trace state variables, try to match them
3213 up with existing variables, or create additional ones. */
3216 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
3219 struct uploaded_tsv *utsv;
3220 struct trace_state_variable *tsv;
3223 /* Most likely some numbers will have to be reassigned as part of
3224 the merge, so clear them all in anticipation. */
3225 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3228 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
3230 tsv = find_matching_tsv (utsv);
3234 printf_filtered (_("Assuming trace state variable $%s "
3235 "is same as target's variable %d.\n"),
3236 tsv->name, utsv->number);
3240 tsv = create_tsv_from_upload (utsv);
3242 printf_filtered (_("Created trace state variable "
3243 "$%s for target's variable %d.\n"),
3244 tsv->name, utsv->number);
3246 /* Give precedence to numberings that come from the target. */
3248 tsv->number = utsv->number;
3251 /* Renumber everything that didn't get a target-assigned number. */
3253 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3254 if (tsv->number > highest)
3255 highest = tsv->number;
3258 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3259 if (tsv->number == 0)
3260 tsv->number = highest++;
3262 free_uploaded_tsvs (uploaded_tsvs);
3265 /* target tfile command */
3267 struct target_ops tfile_ops;
3269 /* Fill in tfile_ops with its defined operations and properties. */
3271 #define TRACE_HEADER_SIZE 8
3273 char *trace_filename;
3275 off_t trace_frames_offset;
3277 int cur_traceframe_number;
3279 int trace_regblock_size;
3281 static void tfile_interp_line (char *line,
3282 struct uploaded_tp **utpp,
3283 struct uploaded_tsv **utsvp);
3285 /* Read SIZE bytes into READBUF from the trace frame, starting at
3286 TRACE_FD's current position. Note that this call `read'
3287 underneath, hence it advances the file's seek position. Throws an
3288 error if the `read' syscall fails, or less than SIZE bytes are
3292 tfile_read (gdb_byte *readbuf, int size)
3296 gotten = read (trace_fd, readbuf, size);
3298 perror_with_name (trace_filename);
3299 else if (gotten < size)
3300 error (_("Premature end of file while reading trace file"));
3304 tfile_open (char *filename, int from_tty)
3306 volatile struct gdb_exception ex;
3308 struct cleanup *old_chain;
3311 char header[TRACE_HEADER_SIZE];
3312 char linebuf[1000]; /* Should be max remote packet size or so. */
3315 struct trace_status *ts;
3316 struct uploaded_tp *uploaded_tps = NULL;
3317 struct uploaded_tsv *uploaded_tsvs = NULL;
3319 target_preopen (from_tty);
3321 error (_("No trace file specified."));
3323 filename = tilde_expand (filename);
3324 if (!IS_ABSOLUTE_PATH(filename))
3326 temp = concat (current_directory, "/", filename, (char *) NULL);
3331 old_chain = make_cleanup (xfree, filename);
3333 flags = O_BINARY | O_LARGEFILE;
3335 scratch_chan = open (filename, flags, 0);
3336 if (scratch_chan < 0)
3337 perror_with_name (filename);
3339 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3341 discard_cleanups (old_chain); /* Don't free filename any more. */
3342 unpush_target (&tfile_ops);
3344 trace_filename = xstrdup (filename);
3345 trace_fd = scratch_chan;
3348 /* Read the file header and test for validity. */
3349 tfile_read ((gdb_byte *) &header, TRACE_HEADER_SIZE);
3351 bytes += TRACE_HEADER_SIZE;
3352 if (!(header[0] == 0x7f
3353 && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
3354 error (_("File is not a valid trace file."));
3356 push_target (&tfile_ops);
3358 trace_regblock_size = 0;
3359 ts = current_trace_status ();
3360 /* We know we're working with a file. */
3362 /* Set defaults in case there is no status line. */
3363 ts->running_known = 0;
3364 ts->stop_reason = trace_stop_reason_unknown;
3365 ts->traceframe_count = -1;
3366 ts->buffer_free = 0;
3367 ts->disconnected_tracing = 0;
3368 ts->circular_buffer = 0;
3370 cur_traceframe_number = -1;
3372 TRY_CATCH (ex, RETURN_MASK_ALL)
3374 /* Read through a section of newline-terminated lines that
3375 define things like tracepoints. */
3379 tfile_read (&byte, 1);
3384 /* Empty line marks end of the definition section. */
3389 tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
3392 linebuf[i++] = byte;
3394 error (_("Excessively long lines in trace file"));
3397 /* Record the starting offset of the binary trace data. */
3398 trace_frames_offset = bytes;
3400 /* If we don't have a blocksize, we can't interpret the
3402 if (trace_regblock_size == 0)
3403 error (_("No register block size recorded in trace file"));
3407 /* Pop the partially set up target. */
3409 throw_exception (ex);
3412 inferior_appeared (current_inferior (), TFILE_PID);
3413 inferior_ptid = pid_to_ptid (TFILE_PID);
3414 add_thread_silent (inferior_ptid);
3416 if (ts->traceframe_count <= 0)
3417 warning (_("No traceframes present in this file."));
3419 /* Add the file's tracepoints and variables into the current mix. */
3421 /* Get trace state variables first, they may be checked when parsing
3422 uploaded commands. */
3423 merge_uploaded_trace_state_variables (&uploaded_tsvs);
3425 merge_uploaded_tracepoints (&uploaded_tps);
3427 post_create_inferior (&tfile_ops, from_tty);
3430 /* Interpret the given line from the definitions part of the trace
3434 tfile_interp_line (char *line,
3435 struct uploaded_tp **utpp, struct uploaded_tsv **utsvp)
3439 if (strncmp (p, "R ", strlen ("R ")) == 0)
3442 trace_regblock_size = strtol (p, &p, 16);
3444 else if (strncmp (p, "status ", strlen ("status ")) == 0)
3446 p += strlen ("status ");
3447 parse_trace_status (p, current_trace_status ());
3449 else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
3451 p += strlen ("tp ");
3452 parse_tracepoint_definition (p, utpp);
3454 else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
3456 p += strlen ("tsv ");
3457 parse_tsv_definition (p, utsvp);
3460 warning (_("Ignoring trace file definition \"%s\""), line);
3463 /* Parse the part of trace status syntax that is shared between
3464 the remote protocol and the trace file reader. */
3467 parse_trace_status (char *line, struct trace_status *ts)
3469 char *p = line, *p1, *p2, *p_temp;
3472 ts->running_known = 1;
3473 ts->running = (*p++ == '1');
3474 ts->stop_reason = trace_stop_reason_unknown;
3475 xfree (ts->error_desc);
3476 ts->error_desc = NULL;
3477 ts->traceframe_count = -1;
3478 ts->traceframes_created = -1;
3479 ts->buffer_free = -1;
3480 ts->buffer_size = -1;
3481 ts->disconnected_tracing = 0;
3482 ts->circular_buffer = 0;
3486 p1 = strchr (p, ':');
3488 error (_("Malformed trace status, at %s\n\
3489 Status line: '%s'\n"), p, line);
3490 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3492 p = unpack_varlen_hex (++p1, &val);
3493 ts->stop_reason = trace_buffer_full;
3495 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3497 p = unpack_varlen_hex (++p1, &val);
3498 ts->stop_reason = trace_never_run;
3500 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
3503 p = unpack_varlen_hex (++p1, &val);
3504 ts->stop_reason = tracepoint_passcount;
3505 ts->stopping_tracepoint = val;
3507 else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
3509 p = unpack_varlen_hex (++p1, &val);
3510 ts->stop_reason = tstop_command;
3512 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3514 p = unpack_varlen_hex (++p1, &val);
3515 ts->stop_reason = trace_disconnected;
3517 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3519 p2 = strchr (++p1, ':');
3524 ts->error_desc = xmalloc ((p2 - p1) / 2 + 1);
3525 end = hex2bin (p1, ts->error_desc, (p2 - p1) / 2);
3526 ts->error_desc[end] = '\0';
3529 ts->error_desc = xstrdup ("");
3531 p = unpack_varlen_hex (++p2, &val);
3532 ts->stopping_tracepoint = val;
3533 ts->stop_reason = tracepoint_error;
3535 else if (strncmp (p, "tframes", p1 - p) == 0)
3537 p = unpack_varlen_hex (++p1, &val);
3538 ts->traceframe_count = val;
3540 else if (strncmp (p, "tcreated", p1 - p) == 0)
3542 p = unpack_varlen_hex (++p1, &val);
3543 ts->traceframes_created = val;
3545 else if (strncmp (p, "tfree", p1 - p) == 0)
3547 p = unpack_varlen_hex (++p1, &val);
3548 ts->buffer_free = val;
3550 else if (strncmp (p, "tsize", p1 - p) == 0)
3552 p = unpack_varlen_hex (++p1, &val);
3553 ts->buffer_size = val;
3555 else if (strncmp (p, "disconn", p1 - p) == 0)
3557 p = unpack_varlen_hex (++p1, &val);
3558 ts->disconnected_tracing = val;
3560 else if (strncmp (p, "circular", p1 - p) == 0)
3562 p = unpack_varlen_hex (++p1, &val);
3563 ts->circular_buffer = val;
3567 /* Silently skip unknown optional info. */
3568 p_temp = strchr (p1 + 1, ';');
3572 /* Must be at the end. */
3578 /* Given a line of text defining a part of a tracepoint, parse it into
3579 an "uploaded tracepoint". */
3582 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
3586 ULONGEST num, addr, step, pass, orig_size, xlen, start;
3589 char *cond, *srctype, *buf;
3590 struct uploaded_tp *utp = NULL;
3593 /* Both tracepoint and action definitions start with the same number
3594 and address sequence. */
3596 p = unpack_varlen_hex (p, &num);
3597 p++; /* skip a colon */
3598 p = unpack_varlen_hex (p, &addr);
3599 p++; /* skip a colon */
3602 enabled = (*p++ == 'E');
3603 p++; /* skip a colon */
3604 p = unpack_varlen_hex (p, &step);
3605 p++; /* skip a colon */
3606 p = unpack_varlen_hex (p, &pass);
3607 type = bp_tracepoint;
3609 /* Thumb through optional fields. */
3612 p++; /* skip a colon */
3615 type = bp_fast_tracepoint;
3617 p = unpack_varlen_hex (p, &orig_size);
3621 type = bp_static_tracepoint;
3627 p = unpack_varlen_hex (p, &xlen);
3628 p++; /* skip a comma */
3629 cond = (char *) xmalloc (2 * xlen + 1);
3630 strncpy (cond, p, 2 * xlen);
3631 cond[2 * xlen] = '\0';
3635 warning (_("Unrecognized char '%c' in tracepoint "
3636 "definition, skipping rest"), *p);
3638 utp = get_uploaded_tp (num, addr, utpp);
3640 utp->enabled = enabled;
3645 else if (piece == 'A')
3647 utp = get_uploaded_tp (num, addr, utpp);
3648 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
3650 else if (piece == 'S')
3652 utp = get_uploaded_tp (num, addr, utpp);
3653 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
3655 else if (piece == 'Z')
3657 /* Parse a chunk of source form definition. */
3658 utp = get_uploaded_tp (num, addr, utpp);
3660 p = strchr (p, ':');
3661 p++; /* skip a colon */
3662 p = unpack_varlen_hex (p, &start);
3663 p++; /* skip a colon */
3664 p = unpack_varlen_hex (p, &xlen);
3665 p++; /* skip a colon */
3667 buf = alloca (strlen (line));
3669 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3672 if (strncmp (srctype, "at:", strlen ("at:")) == 0)
3673 utp->at_string = xstrdup (buf);
3674 else if (strncmp (srctype, "cond:", strlen ("cond:")) == 0)
3675 utp->cond_string = xstrdup (buf);
3676 else if (strncmp (srctype, "cmd:", strlen ("cmd:")) == 0)
3677 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
3681 /* Don't error out, the target might be sending us optional
3682 info that we don't care about. */
3683 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
3687 /* Convert a textual description of a trace state variable into an
3691 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
3694 ULONGEST num, initval, builtin;
3696 struct uploaded_tsv *utsv = NULL;
3698 buf = alloca (strlen (line));
3701 p = unpack_varlen_hex (p, &num);
3702 p++; /* skip a colon */
3703 p = unpack_varlen_hex (p, &initval);
3704 p++; /* skip a colon */
3705 p = unpack_varlen_hex (p, &builtin);
3706 p++; /* skip a colon */
3707 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3710 utsv = get_uploaded_tsv (num, utsvp);
3711 utsv->initial_value = initval;
3712 utsv->builtin = builtin;
3713 utsv->name = xstrdup (buf);
3716 /* Close the trace file and generally clean up. */
3719 tfile_close (int quitting)
3726 pid = ptid_get_pid (inferior_ptid);
3727 inferior_ptid = null_ptid; /* Avoid confusion from thread stuff. */
3728 exit_inferior_silent (pid);
3732 xfree (trace_filename);
3733 trace_filename = NULL;
3737 tfile_files_info (struct target_ops *t)
3739 /* (it would be useful to mention the name of the file). */
3740 printf_filtered ("Looking at a trace file.\n");
3743 /* The trace status for a file is that tracing can never be run. */
3746 tfile_get_trace_status (struct trace_status *ts)
3748 /* Other bits of trace status were collected as part of opening the
3749 trace files, so nothing to do here. */
3754 /* Given the position of a traceframe in the file, figure out what
3755 address the frame was collected at. This would normally be the
3756 value of a collected PC register, but if not available, we
3760 tfile_get_traceframe_address (off_t tframe_offset)
3764 struct tracepoint *tp;
3765 off_t saved_offset = cur_offset;
3767 /* FIXME dig pc out of collected registers. */
3769 /* Fall back to using tracepoint address. */
3770 lseek (trace_fd, tframe_offset, SEEK_SET);
3771 tfile_read ((gdb_byte *) &tpnum, 2);
3772 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
3776 tp = get_tracepoint_by_number_on_target (tpnum);
3777 /* FIXME this is a poor heuristic if multiple locations. */
3778 if (tp && tp->base.loc)
3779 addr = tp->base.loc->address;
3781 /* Restore our seek position. */
3782 cur_offset = saved_offset;
3783 lseek (trace_fd, cur_offset, SEEK_SET);
3787 /* Make tfile's selected traceframe match GDB's selected
3791 set_tfile_traceframe (void)
3795 if (cur_traceframe_number == get_traceframe_number ())
3798 /* Avoid recursion, tfile_trace_find calls us again. */
3799 cur_traceframe_number = get_traceframe_number ();
3801 newnum = target_trace_find (tfind_number,
3802 get_traceframe_number (), 0, 0, NULL);
3804 /* Should not happen. If it does, all bets are off. */
3805 if (newnum != get_traceframe_number ())
3806 warning (_("could not set tfile's traceframe"));
3809 /* Given a type of search and some parameters, scan the collection of
3810 traceframes in the file looking for a match. When found, return
3811 both the traceframe and tracepoint number, otherwise -1 for
3815 tfile_trace_find (enum trace_find_type type, int num,
3816 ULONGEST addr1, ULONGEST addr2, int *tpp)
3819 int tfnum = 0, found = 0;
3820 unsigned int data_size;
3821 struct tracepoint *tp;
3822 off_t offset, tframe_offset;
3825 /* Lookups other than by absolute frame number depend on the current
3826 trace selected, so make sure it is correct on the tfile end
3828 if (type != tfind_number)
3829 set_tfile_traceframe ();
3837 lseek (trace_fd, trace_frames_offset, SEEK_SET);
3838 offset = trace_frames_offset;
3841 tframe_offset = offset;
3842 tfile_read ((gdb_byte *) &tpnum, 2);
3843 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
3849 tfile_read ((gdb_byte *) &data_size, 4);
3850 data_size = (unsigned int) extract_unsigned_integer
3851 ((gdb_byte *) &data_size, 4,
3852 gdbarch_byte_order (target_gdbarch));
3861 tfaddr = tfile_get_traceframe_address (tframe_offset);
3862 if (tfaddr == addr1)
3866 tp = get_tracepoint (num);
3867 if (tp && tpnum == tp->number_on_target)
3871 tfaddr = tfile_get_traceframe_address (tframe_offset);
3872 if (addr1 <= tfaddr && tfaddr <= addr2)
3876 tfaddr = tfile_get_traceframe_address (tframe_offset);
3877 if (!(addr1 <= tfaddr && tfaddr <= addr2))
3881 internal_error (__FILE__, __LINE__, _("unknown tfind type"));
3887 cur_offset = offset;
3888 cur_data_size = data_size;
3889 cur_traceframe_number = tfnum;
3892 /* Skip past the traceframe's data. */
3893 lseek (trace_fd, data_size, SEEK_CUR);
3894 offset += data_size;
3895 /* Update our own count of traceframes. */
3898 /* Did not find what we were looking for. */
3904 /* Prototype of the callback passed to tframe_walk_blocks. */
3905 typedef int (*walk_blocks_callback_func) (char blocktype, void *data);
3907 /* Callback for traceframe_walk_blocks, used to find a given block
3908 type in a traceframe. */
3911 match_blocktype (char blocktype, void *data)
3913 char *wantedp = data;
3915 if (*wantedp == blocktype)
3921 /* Walk over all traceframe block starting at POS offset from
3922 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
3923 unmodified. If CALLBACK returns true, this returns the position in
3924 the traceframe where the block is found, relative to the start of
3925 the traceframe (cur_offset). Returns -1 if no callback call
3926 returned true, indicating that all blocks have been walked. */
3929 traceframe_walk_blocks (walk_blocks_callback_func callback,
3930 int pos, void *data)
3932 /* Iterate through a traceframe's blocks, looking for a block of the
3935 lseek (trace_fd, cur_offset + pos, SEEK_SET);
3936 while (pos < cur_data_size)
3938 unsigned short mlen;
3941 tfile_read (&block_type, 1);
3945 if ((*callback) (block_type, data))
3951 lseek (trace_fd, cur_offset + pos + trace_regblock_size, SEEK_SET);
3952 pos += trace_regblock_size;
3955 lseek (trace_fd, cur_offset + pos + 8, SEEK_SET);
3956 tfile_read ((gdb_byte *) &mlen, 2);
3957 mlen = (unsigned short)
3958 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
3961 lseek (trace_fd, mlen, SEEK_CUR);
3962 pos += (8 + 2 + mlen);
3965 lseek (trace_fd, cur_offset + pos + 4 + 8, SEEK_SET);
3969 error (_("Unknown block type '%c' (0x%x) in trace frame"),
3970 block_type, block_type);
3978 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
3979 position offset of a block of type TYPE_WANTED in the current trace
3980 frame, starting at POS. Returns -1 if no such block was found. */
3983 traceframe_find_block_type (char type_wanted, int pos)
3985 return traceframe_walk_blocks (match_blocktype, pos, &type_wanted);
3988 /* Look for a block of saved registers in the traceframe, and get the
3989 requested register from it. */
3992 tfile_fetch_registers (struct target_ops *ops,
3993 struct regcache *regcache, int regno)
3995 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3997 int pos, offset, regn, regsize, pc_regno;
3998 unsigned short mlen;
4001 /* An uninitialized reg size says we're not going to be
4002 successful at getting register blocks. */
4003 if (!trace_regblock_size)
4006 set_tfile_traceframe ();
4008 regs = alloca (trace_regblock_size);
4010 if (traceframe_find_block_type ('R', 0) >= 0)
4012 tfile_read (regs, trace_regblock_size);
4014 /* Assume the block is laid out in GDB register number order,
4015 each register with the size that it has in GDB. */
4017 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4019 regsize = register_size (gdbarch, regn);
4020 /* Make sure we stay within block bounds. */
4021 if (offset + regsize >= trace_regblock_size)
4023 if (regcache_register_status (regcache, regn) == REG_UNKNOWN)
4027 regcache_raw_supply (regcache, regno, regs + offset);
4030 else if (regno == -1)
4032 regcache_raw_supply (regcache, regn, regs + offset);
4040 /* We get here if no register data has been found. Mark registers
4042 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4043 regcache_raw_supply (regcache, regn, NULL);
4045 /* We can often usefully guess that the PC is going to be the same
4046 as the address of the tracepoint. */
4047 pc_regno = gdbarch_pc_regnum (gdbarch);
4048 if (pc_regno >= 0 && (regno == -1 || regno == pc_regno))
4050 struct tracepoint *tp = get_tracepoint (tracepoint_number);
4052 if (tp && tp->base.loc)
4054 /* But don't try to guess if tracepoint is multi-location... */
4055 if (tp->base.loc->next)
4057 warning (_("Tracepoint %d has multiple "
4058 "locations, cannot infer $pc"),
4062 /* ... or does while-stepping. */
4063 if (tp->step_count > 0)
4065 warning (_("Tracepoint %d does while-stepping, "
4066 "cannot infer $pc"),
4071 store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
4072 gdbarch_byte_order (gdbarch),
4073 tp->base.loc->address);
4074 regcache_raw_supply (regcache, pc_regno, regs);
4080 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
4081 const char *annex, gdb_byte *readbuf,
4082 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
4084 /* We're only doing regular memory for now. */
4085 if (object != TARGET_OBJECT_MEMORY)
4088 if (readbuf == NULL)
4089 error (_("tfile_xfer_partial: trace file is read-only"));
4091 set_tfile_traceframe ();
4093 if (traceframe_number != -1)
4097 /* Iterate through the traceframe's blocks, looking for
4099 while ((pos = traceframe_find_block_type ('M', pos)) >= 0)
4101 ULONGEST maddr, amt;
4102 unsigned short mlen;
4103 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
4105 tfile_read ((gdb_byte *) &maddr, 8);
4106 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
4108 tfile_read ((gdb_byte *) &mlen, 2);
4109 mlen = (unsigned short)
4110 extract_unsigned_integer ((gdb_byte *) &mlen, 2, byte_order);
4112 /* If the block includes the first part of the desired
4113 range, return as much it has; GDB will re-request the
4114 remainder, which might be in a different block of this
4116 if (maddr <= offset && offset < (maddr + mlen))
4118 amt = (maddr + mlen) - offset;
4122 tfile_read (readbuf, amt);
4126 /* Skip over this block. */
4127 pos += (8 + 2 + mlen);
4131 /* It's unduly pedantic to refuse to look at the executable for
4132 read-only pieces; so do the equivalent of readonly regions aka
4134 /* FIXME account for relocation at some point. */
4141 for (s = exec_bfd->sections; s; s = s->next)
4143 if ((s->flags & SEC_LOAD) == 0
4144 || (s->flags & SEC_READONLY) == 0)
4148 size = bfd_get_section_size (s);
4149 if (vma <= offset && offset < (vma + size))
4153 amt = (vma + size) - offset;
4157 amt = bfd_get_section_contents (exec_bfd, s,
4158 readbuf, offset - vma, amt);
4164 /* Indicate failure to find the requested memory block. */
4168 /* Iterate through the blocks of a trace frame, looking for a 'V'
4169 block with a matching tsv number. */
4172 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
4176 set_tfile_traceframe ();
4179 while ((pos = traceframe_find_block_type ('V', pos)) >= 0)
4183 tfile_read ((gdb_byte *) &vnum, 4);
4184 vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
4189 tfile_read ((gdb_byte *) val, 8);
4190 *val = extract_signed_integer ((gdb_byte *) val, 8,
4198 /* Didn't find anything. */
4203 tfile_has_all_memory (struct target_ops *ops)
4209 tfile_has_memory (struct target_ops *ops)
4215 tfile_has_stack (struct target_ops *ops)
4217 return traceframe_number != -1;
4221 tfile_has_registers (struct target_ops *ops)
4223 return traceframe_number != -1;
4227 tfile_thread_alive (struct target_ops *ops, ptid_t ptid)
4232 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
4233 object for the tfile target's current traceframe. */
4236 build_traceframe_info (char blocktype, void *data)
4238 struct traceframe_info *info = data;
4244 struct mem_range *r;
4246 unsigned short mlen;
4248 tfile_read ((gdb_byte *) &maddr, 8);
4249 tfile_read ((gdb_byte *) &mlen, 2);
4251 r = VEC_safe_push (mem_range_s, info->memory, NULL);
4264 warning (_("Unhandled trace block type (%d) '%c ' "
4265 "while building trace frame info."),
4266 blocktype, blocktype);
4273 static struct traceframe_info *
4274 tfile_traceframe_info (void)
4276 struct traceframe_info *info = XCNEW (struct traceframe_info);
4278 traceframe_walk_blocks (build_traceframe_info, 0, info);
4283 init_tfile_ops (void)
4285 tfile_ops.to_shortname = "tfile";
4286 tfile_ops.to_longname = "Local trace dump file";
4288 = "Use a trace file as a target. Specify the filename of the trace file.";
4289 tfile_ops.to_open = tfile_open;
4290 tfile_ops.to_close = tfile_close;
4291 tfile_ops.to_fetch_registers = tfile_fetch_registers;
4292 tfile_ops.to_xfer_partial = tfile_xfer_partial;
4293 tfile_ops.to_files_info = tfile_files_info;
4294 tfile_ops.to_get_trace_status = tfile_get_trace_status;
4295 tfile_ops.to_trace_find = tfile_trace_find;
4296 tfile_ops.to_get_trace_state_variable_value
4297 = tfile_get_trace_state_variable_value;
4298 tfile_ops.to_stratum = process_stratum;
4299 tfile_ops.to_has_all_memory = tfile_has_all_memory;
4300 tfile_ops.to_has_memory = tfile_has_memory;
4301 tfile_ops.to_has_stack = tfile_has_stack;
4302 tfile_ops.to_has_registers = tfile_has_registers;
4303 tfile_ops.to_traceframe_info = tfile_traceframe_info;
4304 tfile_ops.to_thread_alive = tfile_thread_alive;
4305 tfile_ops.to_magic = OPS_MAGIC;
4308 /* Given a line of text defining a static tracepoint marker, parse it
4309 into a "static tracepoint marker" object. Throws an error is
4310 parsing fails. If PP is non-null, it points to one past the end of
4311 the parsed marker definition. */
4314 parse_static_tracepoint_marker_definition (char *line, char **pp,
4315 struct static_tracepoint_marker *marker)
4322 p = unpack_varlen_hex (p, &addr);
4323 p++; /* skip a colon */
4325 marker->gdbarch = target_gdbarch;
4326 marker->address = (CORE_ADDR) addr;
4328 endp = strchr (p, ':');
4330 error (_("bad marker definition: %s"), line);
4332 marker->str_id = xmalloc (endp - p + 1);
4333 end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
4334 marker->str_id[end] = '\0';
4337 p++; /* skip a colon */
4339 marker->extra = xmalloc (strlen (p) + 1);
4340 end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
4341 marker->extra[end] = '\0';
4347 /* Release a static tracepoint marker's contents. Note that the
4348 object itself isn't released here. There objects are usually on
4352 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
4354 xfree (marker->str_id);
4355 marker->str_id = NULL;
4358 /* Print MARKER to gdb_stdout. */
4361 print_one_static_tracepoint_marker (int count,
4362 struct static_tracepoint_marker *marker)
4364 struct command_line *l;
4367 char wrap_indent[80];
4368 char extra_field_indent[80];
4369 struct ui_stream *stb = ui_out_stream_new (uiout);
4370 struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb);
4371 struct cleanup *bkpt_chain;
4372 VEC(breakpoint_p) *tracepoints;
4374 struct symtab_and_line sal;
4378 sal.pc = marker->address;
4380 tracepoints = static_tracepoints_here (marker->address);
4382 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
4384 /* A counter field to help readability. This is not a stable
4386 ui_out_field_int (uiout, "count", count);
4388 ui_out_field_string (uiout, "marker-id", marker->str_id);
4390 ui_out_field_fmt (uiout, "enabled", "%c",
4391 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
4392 ui_out_spaces (uiout, 2);
4394 strcpy (wrap_indent, " ");
4396 if (gdbarch_addr_bit (marker->gdbarch) <= 32)
4397 strcat (wrap_indent, " ");
4399 strcat (wrap_indent, " ");
4401 strcpy (extra_field_indent, " ");
4403 ui_out_field_core_addr (uiout, "addr", marker->gdbarch, marker->address);
4405 sal = find_pc_line (marker->address, 0);
4406 sym = find_pc_sect_function (marker->address, NULL);
4409 ui_out_text (uiout, "in ");
4410 ui_out_field_string (uiout, "func",
4411 SYMBOL_PRINT_NAME (sym));
4412 ui_out_wrap_hint (uiout, wrap_indent);
4413 ui_out_text (uiout, " at ");
4416 ui_out_field_skip (uiout, "func");
4418 if (sal.symtab != NULL)
4420 ui_out_field_string (uiout, "file", sal.symtab->filename);
4421 ui_out_text (uiout, ":");
4423 if (ui_out_is_mi_like_p (uiout))
4425 char *fullname = symtab_to_fullname (sal.symtab);
4428 ui_out_field_string (uiout, "fullname", fullname);
4431 ui_out_field_skip (uiout, "fullname");
4433 ui_out_field_int (uiout, "line", sal.line);
4437 ui_out_field_skip (uiout, "fullname");
4438 ui_out_field_skip (uiout, "line");
4441 ui_out_text (uiout, "\n");
4442 ui_out_text (uiout, extra_field_indent);
4443 ui_out_text (uiout, _("Data: \""));
4444 ui_out_field_string (uiout, "extra-data", marker->extra);
4445 ui_out_text (uiout, "\"\n");
4447 if (!VEC_empty (breakpoint_p, tracepoints))
4449 struct cleanup *cleanup_chain;
4451 struct breakpoint *b;
4453 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
4456 ui_out_text (uiout, extra_field_indent);
4457 ui_out_text (uiout, _("Probed by static tracepoints: "));
4458 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
4461 ui_out_text (uiout, ", ");
4462 ui_out_text (uiout, "#");
4463 ui_out_field_int (uiout, "tracepoint-id", b->number);
4466 do_cleanups (cleanup_chain);
4468 if (ui_out_is_mi_like_p (uiout))
4469 ui_out_field_int (uiout, "number-of-tracepoints",
4470 VEC_length(breakpoint_p, tracepoints));
4472 ui_out_text (uiout, "\n");
4474 VEC_free (breakpoint_p, tracepoints);
4476 do_cleanups (bkpt_chain);
4477 do_cleanups (old_chain);
4481 info_static_tracepoint_markers_command (char *arg, int from_tty)
4483 VEC(static_tracepoint_marker_p) *markers;
4484 struct cleanup *old_chain;
4485 struct static_tracepoint_marker *marker;
4489 = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
4490 "StaticTracepointMarkersTable");
4492 ui_out_table_header (uiout, 7, ui_left, "counter", "Cnt");
4494 ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
4496 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
4497 if (gdbarch_addr_bit (target_gdbarch) <= 32)
4498 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
4500 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
4501 ui_out_table_header (uiout, 40, ui_noalign, "what", "What");
4503 ui_out_table_body (uiout);
4505 markers = target_static_tracepoint_markers_by_strid (NULL);
4506 make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
4509 VEC_iterate (static_tracepoint_marker_p,
4510 markers, i, marker);
4513 print_one_static_tracepoint_marker (i + 1, marker);
4514 release_static_tracepoint_marker (marker);
4517 do_cleanups (old_chain);
4520 /* The $_sdata convenience variable is a bit special. We don't know
4521 for sure type of the value until we actually have a chance to fetch
4522 the data --- the size of the object depends on what has been
4523 collected. We solve this by making $_sdata be an internalvar that
4524 creates a new value on access. */
4526 /* Return a new value with the correct type for the sdata object of
4527 the current trace frame. Return a void value if there's no object
4530 static struct value *
4531 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var)
4536 /* We need to read the whole object before we know its size. */
4537 size = target_read_alloc (¤t_target,
4538 TARGET_OBJECT_STATIC_TRACE_DATA,
4545 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
4547 v = allocate_value (type);
4548 memcpy (value_contents_raw (v), buf, size);
4553 return allocate_value (builtin_type (gdbarch)->builtin_void);
4556 #if !defined(HAVE_LIBEXPAT)
4558 struct traceframe_info *
4559 parse_traceframe_info (const char *tframe_info)
4561 static int have_warned;
4566 warning (_("Can not parse XML trace frame info; XML support "
4567 "was disabled at compile time"));
4573 #else /* HAVE_LIBEXPAT */
4575 #include "xml-support.h"
4577 /* Handle the start of a <memory> element. */
4580 traceframe_info_start_memory (struct gdb_xml_parser *parser,
4581 const struct gdb_xml_element *element,
4582 void *user_data, VEC(gdb_xml_value_s) *attributes)
4584 struct traceframe_info *info = user_data;
4585 struct mem_range *r = VEC_safe_push (mem_range_s, info->memory, NULL);
4586 ULONGEST *start_p, *length_p;
4588 start_p = xml_find_attribute (attributes, "start")->value;
4589 length_p = xml_find_attribute (attributes, "length")->value;
4591 r->start = *start_p;
4592 r->length = *length_p;
4595 /* Discard the constructed trace frame info (if an error occurs). */
4598 free_result (void *p)
4600 struct traceframe_info *result = p;
4602 free_traceframe_info (result);
4605 /* The allowed elements and attributes for an XML memory map. */
4607 static const struct gdb_xml_attribute memory_attributes[] = {
4608 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4609 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4610 { NULL, GDB_XML_AF_NONE, NULL, NULL }
4613 static const struct gdb_xml_element traceframe_info_children[] = {
4614 { "memory", memory_attributes, NULL,
4615 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
4616 traceframe_info_start_memory, NULL },
4617 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4620 static const struct gdb_xml_element traceframe_info_elements[] = {
4621 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
4623 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4626 /* Parse a traceframe-info XML document. */
4628 struct traceframe_info *
4629 parse_traceframe_info (const char *tframe_info)
4631 struct traceframe_info *result;
4632 struct cleanup *back_to;
4634 result = XCNEW (struct traceframe_info);
4635 back_to = make_cleanup (free_result, result);
4637 if (gdb_xml_parse_quick (_("trace frame info"),
4638 "traceframe-info.dtd", traceframe_info_elements,
4639 tframe_info, result) == 0)
4641 /* Parsed successfully, keep the result. */
4642 discard_cleanups (back_to);
4647 do_cleanups (back_to);
4651 #endif /* HAVE_LIBEXPAT */
4653 /* Returns the traceframe_info object for the current traceframe.
4654 This is where we avoid re-fetching the object from the target if we
4655 already have it cached. */
4657 struct traceframe_info *
4658 get_traceframe_info (void)
4660 if (traceframe_info == NULL)
4661 traceframe_info = target_traceframe_info ();
4663 return traceframe_info;
4666 /* If the target supports the query, return in RESULT the set of
4667 collected memory in the current traceframe, found within the LEN
4668 bytes range starting at MEMADDR. Returns true if the target
4669 supports the query, otherwise returns false, and RESULT is left
4673 traceframe_available_memory (VEC(mem_range_s) **result,
4674 CORE_ADDR memaddr, ULONGEST len)
4676 struct traceframe_info *info = get_traceframe_info ();
4680 struct mem_range *r;
4685 for (i = 0; VEC_iterate (mem_range_s, info->memory, i, r); i++)
4686 if (mem_ranges_overlap (r->start, r->length, memaddr, len))
4688 ULONGEST lo1, hi1, lo2, hi2;
4689 struct mem_range *nr;
4692 hi1 = memaddr + len;
4695 hi2 = r->start + r->length;
4697 nr = VEC_safe_push (mem_range_s, *result, NULL);
4699 nr->start = max (lo1, lo2);
4700 nr->length = min (hi1, hi2) - nr->start;
4703 normalize_mem_ranges (*result);
4710 /* module initialization */
4712 _initialize_tracepoint (void)
4714 struct cmd_list_element *c;
4716 /* Explicitly create without lookup, since that tries to create a
4717 value with a void typed value, and when we get here, gdbarch
4718 isn't initialized yet. At this point, we're quite sure there
4719 isn't another convenience variable of the same name. */
4720 create_internalvar_type_lazy ("_sdata", sdata_make_value);
4722 traceframe_number = -1;
4723 tracepoint_number = -1;
4725 if (tracepoint_list.list == NULL)
4727 tracepoint_list.listsize = 128;
4728 tracepoint_list.list = xmalloc
4729 (tracepoint_list.listsize * sizeof (struct memrange));
4731 if (tracepoint_list.aexpr_list == NULL)
4733 tracepoint_list.aexpr_listsize = 128;
4734 tracepoint_list.aexpr_list = xmalloc
4735 (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
4738 if (stepping_list.list == NULL)
4740 stepping_list.listsize = 128;
4741 stepping_list.list = xmalloc
4742 (stepping_list.listsize * sizeof (struct memrange));
4745 if (stepping_list.aexpr_list == NULL)
4747 stepping_list.aexpr_listsize = 128;
4748 stepping_list.aexpr_list = xmalloc
4749 (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
4752 add_info ("scope", scope_info,
4753 _("List the variables local to a scope"));
4755 add_cmd ("tracepoints", class_trace, NULL,
4756 _("Tracing of program execution without stopping the program."),
4759 add_com ("tdump", class_trace, trace_dump_command,
4760 _("Print everything collected at the current tracepoint."));
4762 add_com ("tsave", class_trace, trace_save_command, _("\
4763 Save the trace data to a file.\n\
4764 Use the '-r' option to direct the target to save directly to the file,\n\
4765 using its own filesystem."));
4767 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
4768 Define a trace state variable.\n\
4769 Argument is a $-prefixed name, optionally followed\n\
4770 by '=' and an expression that sets the initial value\n\
4771 at the start of tracing."));
4772 set_cmd_completer (c, expression_completer);
4774 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
4775 Delete one or more trace state variables.\n\
4776 Arguments are the names of the variables to delete.\n\
4777 If no arguments are supplied, delete all variables."), &deletelist);
4778 /* FIXME add a trace variable completer. */
4780 add_info ("tvariables", tvariables_info, _("\
4781 Status of trace state variables and their values.\n\
4784 add_info ("static-tracepoint-markers",
4785 info_static_tracepoint_markers_command, _("\
4786 List target static tracepoints markers.\n\
4789 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
4790 Select a trace frame;\n\
4791 No argument means forward by one frame; '-' means backward by one frame."),
4792 &tfindlist, "tfind ", 1, &cmdlist);
4794 add_cmd ("outside", class_trace, trace_find_outside_command, _("\
4795 Select a trace frame whose PC is outside the given range (exclusive).\n\
4796 Usage: tfind outside addr1, addr2"),
4799 add_cmd ("range", class_trace, trace_find_range_command, _("\
4800 Select a trace frame whose PC is in the given range (inclusive).\n\
4801 Usage: tfind range addr1,addr2"),
4804 add_cmd ("line", class_trace, trace_find_line_command, _("\
4805 Select a trace frame by source line.\n\
4806 Argument can be a line number (with optional source file),\n\
4807 a function name, or '*' followed by an address.\n\
4808 Default argument is 'the next source line that was traced'."),
4811 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
4812 Select a trace frame by tracepoint number.\n\
4813 Default is the tracepoint for the current trace frame."),
4816 add_cmd ("pc", class_trace, trace_find_pc_command, _("\
4817 Select a trace frame by PC.\n\
4818 Default is the current PC, or the PC of the current trace frame."),
4821 add_cmd ("end", class_trace, trace_find_end_command, _("\
4822 Synonym for 'none'.\n\
4823 De-select any trace frame and resume 'live' debugging."),
4826 add_cmd ("none", class_trace, trace_find_none_command,
4827 _("De-select any trace frame and resume 'live' debugging."),
4830 add_cmd ("start", class_trace, trace_find_start_command,
4831 _("Select the first trace frame in the trace buffer."),
4834 add_com ("tstatus", class_trace, trace_status_command,
4835 _("Display the status of the current trace data collection."));
4837 add_com ("tstop", class_trace, trace_stop_command,
4838 _("Stop trace data collection."));
4840 add_com ("tstart", class_trace, trace_start_command,
4841 _("Start trace data collection."));
4843 add_com ("end", class_trace, end_actions_pseudocommand, _("\
4844 Ends a list of commands or actions.\n\
4845 Several GDB commands allow you to enter a list of commands or actions.\n\
4846 Entering \"end\" on a line by itself is the normal way to terminate\n\
4848 Note: the \"end\" command cannot be used at the gdb prompt."));
4850 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
4851 Specify single-stepping behavior at a tracepoint.\n\
4852 Argument is number of instructions to trace in single-step mode\n\
4853 following the tracepoint. This command is normally followed by\n\
4854 one or more \"collect\" commands, to specify what to collect\n\
4855 while single-stepping.\n\n\
4856 Note: this command can only be used in a tracepoint \"actions\" list."));
4858 add_com_alias ("ws", "while-stepping", class_alias, 0);
4859 add_com_alias ("stepping", "while-stepping", class_alias, 0);
4861 add_com ("collect", class_trace, collect_pseudocommand, _("\
4862 Specify one or more data items to be collected at a tracepoint.\n\
4863 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4864 collect all data (variables, registers) referenced by that expression.\n\
4865 Also accepts the following special arguments:\n\
4866 $regs -- all registers.\n\
4867 $args -- all function arguments.\n\
4868 $locals -- all variables local to the block/function scope.\n\
4869 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4870 Note: this command can only be used in a tracepoint \"actions\" list."));
4872 add_com ("teval", class_trace, teval_pseudocommand, _("\
4873 Specify one or more expressions to be evaluated at a tracepoint.\n\
4874 Accepts a comma-separated list of (one or more) expressions.\n\
4875 The result of each evaluation will be discarded.\n\
4876 Note: this command can only be used in a tracepoint \"actions\" list."));
4878 add_com ("actions", class_trace, trace_actions_command, _("\
4879 Specify the actions to be taken at a tracepoint.\n\
4880 Tracepoint actions may include collecting of specified data,\n\
4881 single-stepping, or enabling/disabling other tracepoints,\n\
4882 depending on target's capabilities."));
4884 default_collect = xstrdup ("");
4885 add_setshow_string_cmd ("default-collect", class_trace,
4886 &default_collect, _("\
4887 Set the list of expressions to collect by default"), _("\
4888 Show the list of expressions to collect by default"), NULL,
4890 &setlist, &showlist);
4892 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
4893 &disconnected_tracing, _("\
4894 Set whether tracing continues after GDB disconnects."), _("\
4895 Show whether tracing continues after GDB disconnects."), _("\
4896 Use this to continue a tracing run even if GDB disconnects\n\
4897 or detaches from the target. You can reconnect later and look at\n\
4898 trace data collected in the meantime."),
4899 set_disconnected_tracing,
4904 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
4905 &circular_trace_buffer, _("\
4906 Set target's use of circular trace buffer."), _("\
4907 Show target's use of circular trace buffer."), _("\
4908 Use this to make the trace buffer into a circular buffer,\n\
4909 which will discard traceframes (oldest first) instead of filling\n\
4910 up and stopping the trace run."),
4911 set_circular_trace_buffer,
4918 add_target (&tfile_ops);