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"
55 /* readline include files */
56 #include "readline/readline.h"
57 #include "readline/history.h"
59 /* readline defines this. */
70 extern int hex2bin (const char *hex, gdb_byte *bin, int count);
71 extern int bin2hex (const gdb_byte *bin, char *hex, int count);
73 extern void stop_tracing ();
75 /* Maximum length of an agent aexpression.
76 This accounts for the fact that packets are limited to 400 bytes
77 (which includes everything -- including the checksum), and assumes
78 the worst case of maximum length for each of the pieces of a
81 NOTE: expressions get mem2hex'ed otherwise this would be twice as
82 large. (400 - 31)/2 == 184 */
83 #define MAX_AGENT_EXPR_LEN 184
85 /* A hook used to notify the UI of tracepoint operations. */
87 void (*deprecated_trace_find_hook) (char *arg, int from_tty);
88 void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
90 extern void (*deprecated_readline_begin_hook) (char *, ...);
91 extern char *(*deprecated_readline_hook) (char *);
92 extern void (*deprecated_readline_end_hook) (void);
94 /* GDB commands implemented in other modules:
97 extern void output_command (char *, int);
102 This module defines the following debugger commands:
103 trace : set a tracepoint on a function, line, or address.
104 info trace : list all debugger-defined tracepoints.
105 delete trace : delete one or more tracepoints.
106 enable trace : enable one or more tracepoints.
107 disable trace : disable one or more tracepoints.
108 actions : specify actions to be taken at a tracepoint.
109 passcount : specify a pass count for a tracepoint.
110 tstart : start a trace experiment.
111 tstop : stop a trace experiment.
112 tstatus : query the status of a trace experiment.
113 tfind : find a trace frame in the trace buffer.
114 tdump : print everything collected at the current tracepoint.
115 save-tracepoints : write tracepoint setup into a file.
117 This module defines the following user-visible debugger variables:
118 $trace_frame : sequence number of trace frame currently being debugged.
119 $trace_line : source line of trace frame currently being debugged.
120 $trace_file : source file of trace frame currently being debugged.
121 $tracepoint : tracepoint number of trace frame currently being debugged.
125 /* ======= Important global variables: ======= */
127 /* The list of all trace state variables. We don't retain pointers to
128 any of these for any reason - API is by name or number only - so it
129 works to have a vector of objects. */
131 typedef struct trace_state_variable tsv_s;
134 /* An object describing the contents of a traceframe. */
136 struct traceframe_info
138 /* Collected memory. */
139 VEC(mem_range_s) *memory;
142 static VEC(tsv_s) *tvariables;
144 /* The next integer to assign to a variable. */
146 static int next_tsv_number = 1;
148 /* Number of last traceframe collected. */
149 static int traceframe_number;
151 /* Tracepoint for last traceframe collected. */
152 static int tracepoint_number;
154 /* Symbol for function for last traceframe collected. */
155 static struct symbol *traceframe_fun;
157 /* Symtab and line for last traceframe collected. */
158 static struct symtab_and_line traceframe_sal;
160 /* The traceframe info of the current traceframe. NULL if we haven't
161 yet attempted to fetch it, or if the target does not support
162 fetching this object, or if we're not inspecting a traceframe
164 static struct traceframe_info *traceframe_info;
166 /* Tracing command lists. */
167 static struct cmd_list_element *tfindlist;
169 /* List of expressions to collect by default at each tracepoint hit. */
170 char *default_collect = "";
172 static int disconnected_tracing;
174 /* This variable controls whether we ask the target for a linear or
175 circular trace buffer. */
177 static int circular_trace_buffer;
179 /* ======= Important command functions: ======= */
180 static void trace_actions_command (char *, int);
181 static void trace_start_command (char *, int);
182 static void trace_stop_command (char *, int);
183 static void trace_status_command (char *, int);
184 static void trace_find_command (char *, int);
185 static void trace_find_pc_command (char *, int);
186 static void trace_find_tracepoint_command (char *, int);
187 static void trace_find_line_command (char *, int);
188 static void trace_find_range_command (char *, int);
189 static void trace_find_outside_command (char *, int);
190 static void trace_dump_command (char *, int);
192 /* support routines */
194 struct collection_list;
195 static void add_aexpr (struct collection_list *, struct agent_expr *);
196 static char *mem2hex (gdb_byte *, char *, int);
197 static void add_register (struct collection_list *collection,
200 extern void send_disconnected_tracing_value (int value);
202 static void free_uploaded_tps (struct uploaded_tp **utpp);
203 static void free_uploaded_tsvs (struct uploaded_tsv **utsvp);
206 extern void _initialize_tracepoint (void);
208 static struct trace_status trace_status;
210 char *stop_reason_names[] = {
220 struct trace_status *
221 current_trace_status ()
223 return &trace_status;
229 free_traceframe_info (struct traceframe_info *info)
233 VEC_free (mem_range_s, info->memory);
239 /* Free and and clear the traceframe info cache of the current
243 clear_traceframe_info (void)
245 free_traceframe_info (traceframe_info);
246 traceframe_info = NULL;
249 /* Set traceframe number to NUM. */
251 set_traceframe_num (int num)
253 traceframe_number = num;
254 set_internalvar_integer (lookup_internalvar ("trace_frame"), num);
257 /* Set tracepoint number to NUM. */
259 set_tracepoint_num (int num)
261 tracepoint_number = num;
262 set_internalvar_integer (lookup_internalvar ("tracepoint"), num);
265 /* Set externally visible debug variables for querying/printing
266 the traceframe context (line, function, file). */
269 set_traceframe_context (struct frame_info *trace_frame)
273 if (trace_frame == NULL) /* Cease debugging any trace buffers. */
276 traceframe_sal.pc = traceframe_sal.line = 0;
277 traceframe_sal.symtab = NULL;
278 clear_internalvar (lookup_internalvar ("trace_func"));
279 clear_internalvar (lookup_internalvar ("trace_file"));
280 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
284 /* Save as globals for internal use. */
285 trace_pc = get_frame_pc (trace_frame);
286 traceframe_sal = find_pc_line (trace_pc, 0);
287 traceframe_fun = find_pc_function (trace_pc);
289 /* Save linenumber as "$trace_line", a debugger variable visible to
291 set_internalvar_integer (lookup_internalvar ("trace_line"),
292 traceframe_sal.line);
294 /* Save func name as "$trace_func", a debugger variable visible to
296 if (traceframe_fun == NULL
297 || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
298 clear_internalvar (lookup_internalvar ("trace_func"));
300 set_internalvar_string (lookup_internalvar ("trace_func"),
301 SYMBOL_LINKAGE_NAME (traceframe_fun));
303 /* Save file name as "$trace_file", a debugger variable visible to
305 if (traceframe_sal.symtab == NULL
306 || traceframe_sal.symtab->filename == NULL)
307 clear_internalvar (lookup_internalvar ("trace_file"));
309 set_internalvar_string (lookup_internalvar ("trace_file"),
310 traceframe_sal.symtab->filename);
313 /* Create a new trace state variable with the given name. */
315 struct trace_state_variable *
316 create_trace_state_variable (const char *name)
318 struct trace_state_variable tsv;
320 memset (&tsv, 0, sizeof (tsv));
321 tsv.name = xstrdup (name);
322 tsv.number = next_tsv_number++;
323 return VEC_safe_push (tsv_s, tvariables, &tsv);
326 /* Look for a trace state variable of the given name. */
328 struct trace_state_variable *
329 find_trace_state_variable (const char *name)
331 struct trace_state_variable *tsv;
334 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
335 if (strcmp (name, tsv->name) == 0)
342 delete_trace_state_variable (const char *name)
344 struct trace_state_variable *tsv;
347 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
348 if (strcmp (name, tsv->name) == 0)
350 xfree ((void *)tsv->name);
351 VEC_unordered_remove (tsv_s, tvariables, ix);
355 warning (_("No trace variable named \"$%s\", not deleting"), name);
358 /* The 'tvariable' command collects a name and optional expression to
359 evaluate into an initial value. */
362 trace_variable_command (char *args, int from_tty)
364 struct expression *expr;
365 struct cleanup *old_chain;
366 struct internalvar *intvar = NULL;
368 struct trace_state_variable *tsv;
371 error_no_arg (_("trace state variable name"));
373 /* All the possible valid arguments are expressions. */
374 expr = parse_expression (args);
375 old_chain = make_cleanup (free_current_contents, &expr);
377 if (expr->nelts == 0)
378 error (_("No expression?"));
380 /* Only allow two syntaxes; "$name" and "$name=value". */
381 if (expr->elts[0].opcode == OP_INTERNALVAR)
383 intvar = expr->elts[1].internalvar;
385 else if (expr->elts[0].opcode == BINOP_ASSIGN
386 && expr->elts[1].opcode == OP_INTERNALVAR)
388 intvar = expr->elts[2].internalvar;
389 initval = value_as_long (evaluate_subexpression_type (expr, 4));
392 error (_("Syntax must be $NAME [ = EXPR ]"));
395 error (_("No name given"));
397 if (strlen (internalvar_name (intvar)) <= 0)
398 error (_("Must supply a non-empty variable name"));
400 /* If the variable already exists, just change its initial value. */
401 tsv = find_trace_state_variable (internalvar_name (intvar));
404 tsv->initial_value = initval;
405 printf_filtered (_("Trace state variable $%s "
406 "now has initial value %s.\n"),
407 tsv->name, plongest (tsv->initial_value));
408 do_cleanups (old_chain);
412 /* Create a new variable. */
413 tsv = create_trace_state_variable (internalvar_name (intvar));
414 tsv->initial_value = initval;
416 printf_filtered (_("Trace state variable $%s "
417 "created, with initial value %s.\n"),
418 tsv->name, plongest (tsv->initial_value));
420 do_cleanups (old_chain);
424 delete_trace_variable_command (char *args, int from_tty)
428 struct cleanup *back_to;
432 if (query (_("Delete all trace state variables? ")))
433 VEC_free (tsv_s, tvariables);
438 argv = gdb_buildargv (args);
439 back_to = make_cleanup_freeargv (argv);
441 for (ix = 0; argv[ix] != NULL; ix++)
443 if (*argv[ix] == '$')
444 delete_trace_state_variable (argv[ix] + 1);
446 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv[ix]);
449 do_cleanups (back_to);
455 tvariables_info_1 (void)
457 struct trace_state_variable *tsv;
460 struct cleanup *back_to;
462 if (VEC_length (tsv_s, tvariables) == 0 && !ui_out_is_mi_like_p (uiout))
464 printf_filtered (_("No trace state variables.\n"));
468 /* Try to acquire values from the target. */
469 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix, ++count)
470 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
473 back_to = make_cleanup_ui_out_table_begin_end (uiout, 3,
474 count, "trace-variables");
475 ui_out_table_header (uiout, 15, ui_left, "name", "Name");
476 ui_out_table_header (uiout, 11, ui_left, "initial", "Initial");
477 ui_out_table_header (uiout, 11, ui_left, "current", "Current");
479 ui_out_table_body (uiout);
481 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
483 struct cleanup *back_to2;
487 back_to2 = make_cleanup_ui_out_tuple_begin_end (uiout, "variable");
489 name = concat ("$", tsv->name, (char *) NULL);
490 make_cleanup (xfree, name);
491 ui_out_field_string (uiout, "name", name);
492 ui_out_field_string (uiout, "initial", plongest (tsv->initial_value));
494 if (tsv->value_known)
495 c = plongest (tsv->value);
496 else if (ui_out_is_mi_like_p (uiout))
497 /* For MI, we prefer not to use magic string constants, but rather
498 omit the field completely. The difference between unknown and
499 undefined does not seem important enough to represent. */
501 else if (current_trace_status ()->running || traceframe_number >= 0)
502 /* The value is/was defined, but we don't have it. */
505 /* It is not meaningful to ask about the value. */
508 ui_out_field_string (uiout, "current", c);
509 ui_out_text (uiout, "\n");
511 do_cleanups (back_to2);
514 do_cleanups (back_to);
517 /* List all the trace state variables. */
520 tvariables_info (char *args, int from_tty)
522 tvariables_info_1 ();
525 /* Stash definitions of tsvs into the given file. */
528 save_trace_state_variables (struct ui_file *fp)
530 struct trace_state_variable *tsv;
533 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
535 fprintf_unfiltered (fp, "tvariable $%s", tsv->name);
536 if (tsv->initial_value)
537 fprintf_unfiltered (fp, " = %s", plongest (tsv->initial_value));
538 fprintf_unfiltered (fp, "\n");
542 /* ACTIONS functions: */
544 /* The three functions:
545 collect_pseudocommand,
546 while_stepping_pseudocommand, and
547 end_actions_pseudocommand
548 are placeholders for "commands" that are actually ONLY to be used
549 within a tracepoint action list. If the actual function is ever called,
550 it means that somebody issued the "command" at the top level,
551 which is always an error. */
554 end_actions_pseudocommand (char *args, int from_tty)
556 error (_("This command cannot be used at the top level."));
560 while_stepping_pseudocommand (char *args, int from_tty)
562 error (_("This command can only be used in a tracepoint actions list."));
566 collect_pseudocommand (char *args, int from_tty)
568 error (_("This command can only be used in a tracepoint actions list."));
572 teval_pseudocommand (char *args, int from_tty)
574 error (_("This command can only be used in a tracepoint actions list."));
577 /* Enter a list of actions for a tracepoint. */
579 trace_actions_command (char *args, int from_tty)
581 struct breakpoint *t;
582 struct command_line *l;
584 t = get_tracepoint_by_number (&args, 0, 1);
588 xstrprintf ("Enter actions for tracepoint %d, one per line.",
590 struct cleanup *cleanups = make_cleanup (xfree, tmpbuf);
592 l = read_command_lines (tmpbuf, from_tty, 1,
593 check_tracepoint_command, t);
594 do_cleanups (cleanups);
595 breakpoint_set_commands (t, l);
597 /* else just return */
600 /* Report the results of checking the agent expression, as errors or
604 report_agent_reqs_errors (struct agent_expr *aexpr)
606 /* All of the "flaws" are serious bytecode generation issues that
607 should never occur. */
608 if (aexpr->flaw != agent_flaw_none)
609 internal_error (__FILE__, __LINE__, _("expression is malformed"));
611 /* If analysis shows a stack underflow, GDB must have done something
612 badly wrong in its bytecode generation. */
613 if (aexpr->min_height < 0)
614 internal_error (__FILE__, __LINE__,
615 _("expression has min height < 0"));
617 /* Issue this error if the stack is predicted to get too deep. The
618 limit is rather arbitrary; a better scheme might be for the
619 target to report how much stack it will have available. The
620 depth roughly corresponds to parenthesization, so a limit of 20
621 amounts to 20 levels of expression nesting, which is actually
622 a pretty big hairy expression. */
623 if (aexpr->max_height > 20)
624 error (_("Expression is too complicated."));
627 /* worker function */
629 validate_actionline (char **line, struct breakpoint *t)
631 struct cmd_list_element *c;
632 struct expression *exp = NULL;
633 struct cleanup *old_chain = NULL;
635 struct bp_location *loc;
636 struct agent_expr *aexpr;
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->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->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 memranges->list[a].end = memranges->list[b].end;
850 continue; /* next b, same a */
854 memcpy (&memranges->list[a], &memranges->list[b],
855 sizeof (struct memrange));
857 memranges->next_memrange = a + 1;
861 /* Add a register to a collection list. */
863 add_register (struct collection_list *collection, unsigned int regno)
866 printf_filtered ("collect register %d\n", regno);
867 if (regno >= (8 * sizeof (collection->regs_mask)))
868 error (_("Internal: register number %d too large for tracepoint"),
870 collection->regs_mask[regno / 8] |= 1 << (regno % 8);
873 /* Add a memrange to a collection list. */
875 add_memrange (struct collection_list *memranges,
876 int type, bfd_signed_vma base,
881 printf_filtered ("(%d,", type);
883 printf_filtered (",%ld)\n", len);
886 /* type: memrange_absolute == memory, other n == basereg */
887 memranges->list[memranges->next_memrange].type = type;
888 /* base: addr if memory, offset if reg relative. */
889 memranges->list[memranges->next_memrange].start = base;
890 /* len: we actually save end (base + len) for convenience */
891 memranges->list[memranges->next_memrange].end = base + len;
892 memranges->next_memrange++;
893 if (memranges->next_memrange >= memranges->listsize)
895 memranges->listsize *= 2;
896 memranges->list = xrealloc (memranges->list,
897 memranges->listsize);
900 if (type != memrange_absolute) /* Better collect the base register! */
901 add_register (memranges, type);
904 /* Add a symbol to a collection list. */
906 collect_symbol (struct collection_list *collect,
908 struct gdbarch *gdbarch,
909 long frame_regno, long frame_offset,
914 bfd_signed_vma offset;
915 int treat_as_expr = 0;
917 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
918 switch (SYMBOL_CLASS (sym))
921 printf_filtered ("%s: don't know symbol class %d\n",
922 SYMBOL_PRINT_NAME (sym),
926 printf_filtered ("constant %s (value %ld) will not be collected.\n",
927 SYMBOL_PRINT_NAME (sym), SYMBOL_VALUE (sym));
930 offset = SYMBOL_VALUE_ADDRESS (sym);
935 sprintf_vma (tmp, offset);
936 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
937 SYMBOL_PRINT_NAME (sym), len,
940 /* A struct may be a C++ class with static fields, go to general
941 expression handling. */
942 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
945 add_memrange (collect, memrange_absolute, offset, len);
948 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
950 printf_filtered ("LOC_REG[parm] %s: ",
951 SYMBOL_PRINT_NAME (sym));
952 add_register (collect, reg);
953 /* Check for doubles stored in two registers. */
954 /* FIXME: how about larger types stored in 3 or more regs? */
955 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
956 len > register_size (gdbarch, reg))
957 add_register (collect, reg + 1);
960 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
961 printf_filtered (" (will not collect %s)\n",
962 SYMBOL_PRINT_NAME (sym));
966 offset = frame_offset + SYMBOL_VALUE (sym);
969 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
970 SYMBOL_PRINT_NAME (sym), len);
972 printf_filtered (" from frame ptr reg %d\n", reg);
974 add_memrange (collect, reg, offset, len);
976 case LOC_REGPARM_ADDR:
977 reg = SYMBOL_VALUE (sym);
981 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
982 SYMBOL_PRINT_NAME (sym), len);
984 printf_filtered (" from reg %d\n", reg);
986 add_memrange (collect, reg, offset, len);
990 offset = frame_offset + SYMBOL_VALUE (sym);
993 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
994 SYMBOL_PRINT_NAME (sym), len);
996 printf_filtered (" from frame ptr reg %d\n", reg);
998 add_memrange (collect, reg, offset, len);
1001 case LOC_UNRESOLVED:
1005 case LOC_OPTIMIZED_OUT:
1006 printf_filtered ("%s has been optimized out of existence.\n",
1007 SYMBOL_PRINT_NAME (sym));
1015 /* Expressions are the most general case. */
1018 struct agent_expr *aexpr;
1019 struct cleanup *old_chain1 = NULL;
1021 aexpr = gen_trace_for_var (scope, gdbarch, sym);
1023 /* It can happen that the symbol is recorded as a computed
1024 location, but it's been optimized away and doesn't actually
1025 have a location expression. */
1028 printf_filtered ("%s has been optimized out of existence.\n",
1029 SYMBOL_PRINT_NAME (sym));
1033 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1037 report_agent_reqs_errors (aexpr);
1039 discard_cleanups (old_chain1);
1040 add_aexpr (collect, aexpr);
1042 /* Take care of the registers. */
1043 if (aexpr->reg_mask_len > 0)
1047 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1049 QUIT; /* Allow user to bail out with ^C. */
1050 if (aexpr->reg_mask[ndx1] != 0)
1052 /* Assume chars have 8 bits. */
1053 for (ndx2 = 0; ndx2 < 8; ndx2++)
1054 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1055 /* It's used -- record it. */
1056 add_register (collect, ndx1 * 8 + ndx2);
1063 /* Data to be passed around in the calls to the locals and args
1066 struct add_local_symbols_data
1068 struct collection_list *collect;
1069 struct gdbarch *gdbarch;
1076 /* The callback for the locals and args iterators. */
1079 do_collect_symbol (const char *print_name,
1083 struct add_local_symbols_data *p = cb_data;
1085 collect_symbol (p->collect, sym, p->gdbarch, p->frame_regno,
1086 p->frame_offset, p->pc);
1090 /* Add all locals (or args) symbols to collection list. */
1092 add_local_symbols (struct collection_list *collect,
1093 struct gdbarch *gdbarch, CORE_ADDR pc,
1094 long frame_regno, long frame_offset, int type)
1096 struct block *block;
1097 struct add_local_symbols_data cb_data;
1099 cb_data.collect = collect;
1100 cb_data.gdbarch = gdbarch;
1102 cb_data.frame_regno = frame_regno;
1103 cb_data.frame_offset = frame_offset;
1108 block = block_for_pc (pc);
1111 warning (_("Can't collect locals; "
1112 "no symbol table info available.\n"));
1116 iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1117 if (cb_data.count == 0)
1118 warning (_("No locals found in scope."));
1122 pc = get_pc_function_start (pc);
1123 block = block_for_pc (pc);
1126 warning (_("Can't collect args; no symbol table info available.\n"));
1130 iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1131 if (cb_data.count == 0)
1132 warning (_("No args found in scope."));
1137 add_static_trace_data (struct collection_list *collection)
1140 printf_filtered ("collect static trace data\n");
1141 collection->strace_data = 1;
1144 /* worker function */
1146 clear_collection_list (struct collection_list *list)
1150 list->next_memrange = 0;
1151 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1153 free_agent_expr (list->aexpr_list[ndx]);
1154 list->aexpr_list[ndx] = NULL;
1156 list->next_aexpr_elt = 0;
1157 memset (list->regs_mask, 0, sizeof (list->regs_mask));
1158 list->strace_data = 0;
1161 /* Reduce a collection list to string form (for gdb protocol). */
1163 stringify_collection_list (struct collection_list *list, char *string)
1165 char temp_buf[2048];
1169 char *(*str_list)[];
1173 count = 1 + 1 + list->next_memrange + list->next_aexpr_elt + 1;
1174 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1176 if (list->strace_data)
1179 printf_filtered ("\nCollecting static trace data\n");
1182 (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
1186 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1187 if (list->regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */
1189 if (list->regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
1192 printf_filtered ("\nCollecting registers (mask): 0x");
1197 QUIT; /* Allow user to bail out with ^C. */
1199 printf_filtered ("%02X", list->regs_mask[i]);
1200 sprintf (end, "%02X", list->regs_mask[i]);
1203 (*str_list)[ndx] = xstrdup (temp_buf);
1207 printf_filtered ("\n");
1208 if (list->next_memrange > 0 && info_verbose)
1209 printf_filtered ("Collecting memranges: \n");
1210 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1212 QUIT; /* Allow user to bail out with ^C. */
1213 sprintf_vma (tmp2, list->list[i].start);
1216 printf_filtered ("(%d, %s, %ld)\n",
1219 (long) (list->list[i].end - list->list[i].start));
1221 if (count + 27 > MAX_AGENT_EXPR_LEN)
1223 (*str_list)[ndx] = savestring (temp_buf, count);
1230 bfd_signed_vma length = list->list[i].end - list->list[i].start;
1232 /* The "%X" conversion specifier expects an unsigned argument,
1233 so passing -1 (memrange_absolute) to it directly gives you
1234 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1236 if (list->list[i].type == memrange_absolute)
1237 sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
1239 sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
1242 count += strlen (end);
1243 end = temp_buf + count;
1246 for (i = 0; i < list->next_aexpr_elt; i++)
1248 QUIT; /* Allow user to bail out with ^C. */
1249 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1251 (*str_list)[ndx] = savestring (temp_buf, count);
1256 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1257 end += 10; /* 'X' + 8 hex digits + ',' */
1260 end = mem2hex (list->aexpr_list[i]->buf,
1261 end, list->aexpr_list[i]->len);
1262 count += 2 * list->aexpr_list[i]->len;
1267 (*str_list)[ndx] = savestring (temp_buf, count);
1272 (*str_list)[ndx] = NULL;
1285 encode_actions_1 (struct command_line *action,
1286 struct breakpoint *t,
1287 struct bp_location *tloc,
1289 LONGEST frame_offset,
1290 struct collection_list *collect,
1291 struct collection_list *stepping_list)
1294 struct expression *exp = NULL;
1296 struct value *tempval;
1297 struct cmd_list_element *cmd;
1298 struct agent_expr *aexpr;
1300 for (; action; action = action->next)
1302 QUIT; /* Allow user to bail out with ^C. */
1303 action_exp = action->line;
1304 while (isspace ((int) *action_exp))
1307 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1309 error (_("Bad action list item: %s"), action_exp);
1311 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1314 { /* Repeat over a comma-separated list. */
1315 QUIT; /* Allow user to bail out with ^C. */
1316 while (isspace ((int) *action_exp))
1319 if (0 == strncasecmp ("$reg", action_exp, 4))
1321 for (i = 0; i < gdbarch_num_regs (t->gdbarch); i++)
1322 add_register (collect, i);
1323 action_exp = strchr (action_exp, ','); /* more? */
1325 else if (0 == strncasecmp ("$arg", action_exp, 4))
1327 add_local_symbols (collect,
1333 action_exp = strchr (action_exp, ','); /* more? */
1335 else if (0 == strncasecmp ("$loc", action_exp, 4))
1337 add_local_symbols (collect,
1343 action_exp = strchr (action_exp, ','); /* more? */
1345 else if (0 == strncasecmp ("$_sdata", action_exp, 7))
1347 add_static_trace_data (collect);
1348 action_exp = strchr (action_exp, ','); /* more? */
1352 unsigned long addr, len;
1353 struct cleanup *old_chain = NULL;
1354 struct cleanup *old_chain1 = NULL;
1356 exp = parse_exp_1 (&action_exp,
1357 block_for_pc (tloc->address), 1);
1358 old_chain = make_cleanup (free_current_contents, &exp);
1360 switch (exp->elts[0].opcode)
1364 const char *name = &exp->elts[2].string;
1366 i = user_reg_map_name_to_regnum (t->gdbarch,
1367 name, strlen (name));
1369 internal_error (__FILE__, __LINE__,
1370 _("Register $%s not available"),
1373 printf_filtered ("OP_REGISTER: ");
1374 add_register (collect, i);
1379 /* Safe because we know it's a simple expression. */
1380 tempval = evaluate_expression (exp);
1381 addr = value_address (tempval);
1382 len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
1383 add_memrange (collect, memrange_absolute, addr, len);
1387 collect_symbol (collect,
1388 exp->elts[2].symbol,
1395 default: /* Full-fledged expression. */
1396 aexpr = gen_trace_for_expr (tloc->address, exp);
1398 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1402 report_agent_reqs_errors (aexpr);
1404 discard_cleanups (old_chain1);
1405 add_aexpr (collect, aexpr);
1407 /* Take care of the registers. */
1408 if (aexpr->reg_mask_len > 0)
1413 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1415 QUIT; /* Allow user to bail out with ^C. */
1416 if (aexpr->reg_mask[ndx1] != 0)
1418 /* Assume chars have 8 bits. */
1419 for (ndx2 = 0; ndx2 < 8; ndx2++)
1420 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1421 /* It's used -- record it. */
1422 add_register (collect,
1429 do_cleanups (old_chain);
1432 while (action_exp && *action_exp++ == ',');
1434 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1437 { /* Repeat over a comma-separated list. */
1438 QUIT; /* Allow user to bail out with ^C. */
1439 while (isspace ((int) *action_exp))
1443 struct cleanup *old_chain = NULL;
1444 struct cleanup *old_chain1 = NULL;
1446 exp = parse_exp_1 (&action_exp,
1447 block_for_pc (tloc->address), 1);
1448 old_chain = make_cleanup (free_current_contents, &exp);
1450 aexpr = gen_eval_for_expr (tloc->address, exp);
1451 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1454 report_agent_reqs_errors (aexpr);
1456 discard_cleanups (old_chain1);
1457 /* Even though we're not officially collecting, add
1458 to the collect list anyway. */
1459 add_aexpr (collect, aexpr);
1461 do_cleanups (old_chain);
1464 while (action_exp && *action_exp++ == ',');
1466 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1468 /* We check against nested while-stepping when setting
1469 breakpoint action, so no way to run into nested
1471 gdb_assert (stepping_list);
1473 encode_actions_1 (action->body_list[0], t, tloc, frame_reg,
1474 frame_offset, stepping_list, NULL);
1477 error (_("Invalid tracepoint command '%s'"), action->line);
1481 /* Render all actions into gdb protocol. */
1483 encode_actions (struct breakpoint *t, struct bp_location *tloc,
1484 char ***tdp_actions, char ***stepping_actions)
1486 static char tdp_buff[2048], step_buff[2048];
1487 char *default_collect_line = NULL;
1488 struct command_line *actions;
1489 struct command_line *default_collect_action = NULL;
1491 LONGEST frame_offset;
1492 struct cleanup *back_to;
1494 back_to = make_cleanup (null_cleanup, NULL);
1496 clear_collection_list (&tracepoint_list);
1497 clear_collection_list (&stepping_list);
1499 *tdp_actions = NULL;
1500 *stepping_actions = NULL;
1502 gdbarch_virtual_frame_pointer (t->gdbarch,
1503 t->loc->address, &frame_reg, &frame_offset);
1505 actions = breakpoint_commands (t);
1507 /* If there are default expressions to collect, make up a collect
1508 action and prepend to the action list to encode. Note that since
1509 validation is per-tracepoint (local var "xyz" might be valid for
1510 one tracepoint and not another, etc), we make up the action on
1511 the fly, and don't cache it. */
1512 if (*default_collect)
1516 default_collect_line = xstrprintf ("collect %s", default_collect);
1517 make_cleanup (xfree, default_collect_line);
1519 line = default_collect_line;
1520 validate_actionline (&line, t);
1522 default_collect_action = xmalloc (sizeof (struct command_line));
1523 make_cleanup (xfree, default_collect_action);
1524 default_collect_action->next = actions;
1525 default_collect_action->line = line;
1526 actions = default_collect_action;
1528 encode_actions_1 (actions, t, tloc, frame_reg, frame_offset,
1529 &tracepoint_list, &stepping_list);
1531 memrange_sortmerge (&tracepoint_list);
1532 memrange_sortmerge (&stepping_list);
1534 *tdp_actions = stringify_collection_list (&tracepoint_list,
1536 *stepping_actions = stringify_collection_list (&stepping_list,
1539 do_cleanups (back_to);
1543 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1545 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1547 collect->aexpr_list =
1548 xrealloc (collect->aexpr_list,
1549 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1550 collect->aexpr_listsize *= 2;
1552 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1553 collect->next_aexpr_elt++;
1558 start_tracing (void)
1560 VEC(breakpoint_p) *tp_vec = NULL;
1562 struct breakpoint *t;
1563 struct trace_state_variable *tsv;
1564 int any_enabled = 0, num_to_download = 0;
1566 tp_vec = all_tracepoints ();
1568 /* No point in tracing without any tracepoints... */
1569 if (VEC_length (breakpoint_p, tp_vec) == 0)
1571 VEC_free (breakpoint_p, tp_vec);
1572 error (_("No tracepoints defined, not starting trace"));
1575 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1577 if (t->enable_state == bp_enabled)
1580 if ((t->type == bp_fast_tracepoint
1581 ? may_insert_fast_tracepoints
1582 : may_insert_tracepoints))
1585 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1586 (t->type == bp_fast_tracepoint ? "fast " : ""), t->number);
1589 /* No point in tracing with only disabled tracepoints. */
1592 VEC_free (breakpoint_p, tp_vec);
1593 error (_("No tracepoints enabled, not starting trace"));
1596 if (num_to_download <= 0)
1598 VEC_free (breakpoint_p, tp_vec);
1599 error (_("No tracepoints that may be downloaded, not starting trace"));
1602 target_trace_init ();
1604 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1606 if ((t->type == bp_fast_tracepoint
1607 ? !may_insert_fast_tracepoints
1608 : !may_insert_tracepoints))
1611 t->number_on_target = 0;
1612 target_download_tracepoint (t);
1613 t->number_on_target = t->number;
1615 VEC_free (breakpoint_p, tp_vec);
1617 /* Send down all the trace state variables too. */
1618 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1620 target_download_trace_state_variable (tsv);
1623 /* Tell target to treat text-like sections as transparent. */
1624 target_trace_set_readonly_regions ();
1625 /* Set some mode flags. */
1626 target_set_disconnected_tracing (disconnected_tracing);
1627 target_set_circular_trace_buffer (circular_trace_buffer);
1629 /* Now insert traps and begin collecting data. */
1630 target_trace_start ();
1632 /* Reset our local state. */
1633 set_traceframe_num (-1);
1634 set_tracepoint_num (-1);
1635 set_traceframe_context (NULL);
1636 current_trace_status()->running = 1;
1637 clear_traceframe_info ();
1642 Tell target to clear any previous trace experiment.
1643 Walk the list of tracepoints, and send them (and their actions)
1644 to the target. If no errors,
1645 Tell target to start a new trace experiment. */
1648 trace_start_command (char *args, int from_tty)
1650 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1652 if (current_trace_status ()->running)
1655 && !query (_("A trace is running already. Start a new run? ")))
1656 error (_("New trace run not started."));
1664 trace_stop_command (char *args, int from_tty)
1666 if (!current_trace_status ()->running)
1667 error (_("Trace is not running."));
1675 target_trace_stop ();
1676 /* Should change in response to reply? */
1677 current_trace_status ()->running = 0;
1680 /* tstatus command */
1682 trace_status_command (char *args, int from_tty)
1684 struct trace_status *ts = current_trace_status ();
1687 status = target_get_trace_status (ts);
1692 printf_filtered (_("Using a trace file.\n"));
1695 printf_filtered (_("Trace can not be run on this target.\n"));
1700 if (!ts->running_known)
1702 printf_filtered (_("Run/stop status is unknown.\n"));
1704 else if (ts->running)
1706 printf_filtered (_("Trace is running on the target.\n"));
1710 switch (ts->stop_reason)
1712 case trace_never_run:
1713 printf_filtered (_("No trace has been run on the target.\n"));
1716 printf_filtered (_("Trace stopped by a tstop command.\n"));
1718 case trace_buffer_full:
1719 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1721 case trace_disconnected:
1722 printf_filtered (_("Trace stopped because of disconnection.\n"));
1724 case tracepoint_passcount:
1725 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1726 ts->stopping_tracepoint);
1728 case tracepoint_error:
1729 if (ts->stopping_tracepoint)
1730 printf_filtered (_("Trace stopped by an "
1731 "error (%s, tracepoint %d).\n"),
1732 ts->error_desc, ts->stopping_tracepoint);
1734 printf_filtered (_("Trace stopped by an error (%s).\n"),
1737 case trace_stop_reason_unknown:
1738 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1741 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1747 if (ts->traceframes_created >= 0
1748 && ts->traceframe_count != ts->traceframes_created)
1750 printf_filtered (_("Buffer contains %d trace "
1751 "frames (of %d created total).\n"),
1752 ts->traceframe_count, ts->traceframes_created);
1754 else if (ts->traceframe_count >= 0)
1756 printf_filtered (_("Collected %d trace frames.\n"),
1757 ts->traceframe_count);
1760 if (ts->buffer_free >= 0)
1762 if (ts->buffer_size >= 0)
1764 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1765 ts->buffer_free, ts->buffer_size);
1766 if (ts->buffer_size > 0)
1767 printf_filtered (_(" (%d%% full)"),
1768 ((int) ((((long long) (ts->buffer_size
1769 - ts->buffer_free)) * 100)
1770 / ts->buffer_size)));
1771 printf_filtered (_(".\n"));
1774 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1778 if (ts->disconnected_tracing)
1779 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1781 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1783 if (ts->circular_buffer)
1784 printf_filtered (_("Trace buffer is circular.\n"));
1786 /* Now report on what we're doing with tfind. */
1787 if (traceframe_number >= 0)
1788 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1789 traceframe_number, tracepoint_number);
1791 printf_filtered (_("Not looking at any trace frame.\n"));
1794 /* Report the trace status to uiout, in a way suitable for MI, and not
1795 suitable for CLI. If ON_STOP is true, suppress a few fields that
1796 are not meaningful in the -trace-stop response.
1798 The implementation is essentially parallel to trace_status_command, but
1799 merging them will result in unreadable code. */
1801 trace_status_mi (int on_stop)
1803 struct trace_status *ts = current_trace_status ();
1806 status = target_get_trace_status (ts);
1808 if (status == -1 && !ts->from_file)
1810 ui_out_field_string (uiout, "supported", "0");
1815 ui_out_field_string (uiout, "supported", "file");
1817 ui_out_field_string (uiout, "supported", "1");
1819 gdb_assert (ts->running_known);
1823 ui_out_field_string (uiout, "running", "1");
1825 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1826 Given that the frontend gets the status either on -trace-stop, or from
1827 -trace-status after re-connection, it does not seem like this
1828 information is necessary for anything. It is not necessary for either
1829 figuring the vital state of the target nor for navigation of trace
1830 frames. If the frontend wants to show the current state is some
1831 configure dialog, it can request the value when such dialog is
1832 invoked by the user. */
1836 char *stop_reason = NULL;
1837 int stopping_tracepoint = -1;
1840 ui_out_field_string (uiout, "running", "0");
1842 if (ts->stop_reason != trace_stop_reason_unknown)
1844 switch (ts->stop_reason)
1847 stop_reason = "request";
1849 case trace_buffer_full:
1850 stop_reason = "overflow";
1852 case trace_disconnected:
1853 stop_reason = "disconnection";
1855 case tracepoint_passcount:
1856 stop_reason = "passcount";
1857 stopping_tracepoint = ts->stopping_tracepoint;
1859 case tracepoint_error:
1860 stop_reason = "error";
1861 stopping_tracepoint = ts->stopping_tracepoint;
1867 ui_out_field_string (uiout, "stop-reason", stop_reason);
1868 if (stopping_tracepoint != -1)
1869 ui_out_field_int (uiout, "stopping-tracepoint",
1870 stopping_tracepoint);
1871 if (ts->stop_reason == tracepoint_error)
1872 ui_out_field_string (uiout, "error-description",
1878 if (ts->traceframe_count != -1)
1879 ui_out_field_int (uiout, "frames", ts->traceframe_count);
1880 if (ts->traceframes_created != -1)
1881 ui_out_field_int (uiout, "frames-created", ts->traceframes_created);
1882 if (ts->buffer_size != -1)
1883 ui_out_field_int (uiout, "buffer-size", ts->buffer_size);
1884 if (ts->buffer_free != -1)
1885 ui_out_field_int (uiout, "buffer-free", ts->buffer_free);
1887 ui_out_field_int (uiout, "disconnected", ts->disconnected_tracing);
1888 ui_out_field_int (uiout, "circular", ts->circular_buffer);
1891 /* This function handles the details of what to do about an ongoing
1892 tracing run if the user has asked to detach or otherwise disconnect
1895 disconnect_tracing (int from_tty)
1897 /* It can happen that the target that was tracing went away on its
1898 own, and we didn't notice. Get a status update, and if the
1899 current target doesn't even do tracing, then assume it's not
1901 if (target_get_trace_status (current_trace_status ()) < 0)
1902 current_trace_status ()->running = 0;
1904 /* If running interactively, give the user the option to cancel and
1905 then decide what to do differently with the run. Scripts are
1906 just going to disconnect and let the target deal with it,
1907 according to how it's been instructed previously via
1908 disconnected-tracing. */
1909 if (current_trace_status ()->running && from_tty)
1911 if (current_trace_status ()->disconnected_tracing)
1913 if (!query (_("Trace is running and will "
1914 "continue after detach; detach anyway? ")))
1915 error (_("Not confirmed."));
1919 if (!query (_("Trace is running but will "
1920 "stop on detach; detach anyway? ")))
1921 error (_("Not confirmed."));
1925 /* Also we want to be out of tfind mode, otherwise things can get
1926 confusing upon reconnection. Just use these calls instead of
1927 full tfind_1 behavior because we're in the middle of detaching,
1928 and there's no point to updating current stack frame etc. */
1929 set_current_traceframe (-1);
1930 set_traceframe_context (NULL);
1933 /* Worker function for the various flavors of the tfind command. */
1935 tfind_1 (enum trace_find_type type, int num,
1936 ULONGEST addr1, ULONGEST addr2,
1939 int target_frameno = -1, target_tracept = -1;
1940 struct frame_id old_frame_id = null_frame_id;
1941 struct breakpoint *tp;
1943 /* Only try to get the current stack frame if we have a chance of
1944 succeeding. In particular, if we're trying to get a first trace
1945 frame while all threads are running, it's not going to succeed,
1946 so leave it with a default value and let the frame comparison
1947 below (correctly) decide to print out the source location of the
1949 if (!(type == tfind_number && num == -1)
1950 && (has_stack_frames () || traceframe_number >= 0))
1951 old_frame_id = get_frame_id (get_current_frame ());
1953 target_frameno = target_trace_find (type, num, addr1, addr2,
1956 if (type == tfind_number
1958 && target_frameno == -1)
1960 /* We told the target to get out of tfind mode, and it did. */
1962 else if (target_frameno == -1)
1964 /* A request for a non-existent trace frame has failed.
1965 Our response will be different, depending on FROM_TTY:
1967 If FROM_TTY is true, meaning that this command was
1968 typed interactively by the user, then give an error
1969 and DO NOT change the state of traceframe_number etc.
1971 However if FROM_TTY is false, meaning that we're either
1972 in a script, a loop, or a user-defined command, then
1973 DON'T give an error, but DO change the state of
1974 traceframe_number etc. to invalid.
1976 The rationalle is that if you typed the command, you
1977 might just have committed a typo or something, and you'd
1978 like to NOT lose your current debugging state. However
1979 if you're in a user-defined command or especially in a
1980 loop, then you need a way to detect that the command
1981 failed WITHOUT aborting. This allows you to write
1982 scripts that search thru the trace buffer until the end,
1983 and then continue on to do something else. */
1986 error (_("Target failed to find requested trace frame."));
1990 printf_filtered ("End of trace buffer.\n");
1991 #if 0 /* dubious now? */
1992 /* The following will not recurse, since it's
1994 trace_find_command ("-1", from_tty);
1999 tp = get_tracepoint_by_number_on_target (target_tracept);
2001 reinit_frame_cache ();
2002 registers_changed ();
2003 target_dcache_invalidate ();
2004 set_traceframe_num (target_frameno);
2005 clear_traceframe_info ();
2006 set_tracepoint_num (tp ? tp->number : target_tracept);
2007 if (target_frameno == -1)
2008 set_traceframe_context (NULL);
2010 set_traceframe_context (get_current_frame ());
2012 if (traceframe_number >= 0)
2014 /* Use different branches for MI and CLI to make CLI messages
2016 if (ui_out_is_mi_like_p (uiout))
2018 ui_out_field_string (uiout, "found", "1");
2019 ui_out_field_int (uiout, "tracepoint", tracepoint_number);
2020 ui_out_field_int (uiout, "traceframe", traceframe_number);
2024 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2025 traceframe_number, tracepoint_number);
2030 if (ui_out_is_mi_like_p (uiout))
2031 ui_out_field_string (uiout, "found", "0");
2032 else if (type == tfind_number && num == -1)
2033 printf_unfiltered (_("No longer looking at any trace frame\n"));
2034 else /* This case may never occur, check. */
2035 printf_unfiltered (_("No trace frame found\n"));
2038 /* If we're in nonstop mode and getting out of looking at trace
2039 frames, there won't be any current frame to go back to and
2042 && (has_stack_frames () || traceframe_number >= 0))
2044 enum print_what print_what;
2046 /* NOTE: in imitation of the step command, try to determine
2047 whether we have made a transition from one function to
2048 another. If so, we'll print the "stack frame" (ie. the new
2049 function and it's arguments) -- otherwise we'll just show the
2052 if (frame_id_eq (old_frame_id,
2053 get_frame_id (get_current_frame ())))
2054 print_what = SRC_LINE;
2056 print_what = SRC_AND_LOC;
2058 print_stack_frame (get_selected_frame (NULL), 1, print_what);
2063 /* trace_find_command takes a trace frame number n,
2064 sends "QTFrame:<n>" to the target,
2065 and accepts a reply that may contain several optional pieces
2066 of information: a frame number, a tracepoint number, and an
2067 indication of whether this is a trap frame or a stepping frame.
2069 The minimal response is just "OK" (which indicates that the
2070 target does not give us a frame number or a tracepoint number).
2071 Instead of that, the target may send us a string containing
2073 F<hexnum> (gives the selected frame number)
2074 T<hexnum> (gives the selected tracepoint number)
2079 trace_find_command (char *args, int from_tty)
2080 { /* This should only be called with a numeric argument. */
2083 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2084 error (_("May not look at trace frames while trace is running."));
2086 if (args == 0 || *args == 0)
2087 { /* TFIND with no args means find NEXT trace frame. */
2088 if (traceframe_number == -1)
2089 frameno = 0; /* "next" is first one. */
2091 frameno = traceframe_number + 1;
2093 else if (0 == strcmp (args, "-"))
2095 if (traceframe_number == -1)
2096 error (_("not debugging trace buffer"));
2097 else if (from_tty && traceframe_number == 0)
2098 error (_("already at start of trace buffer"));
2100 frameno = traceframe_number - 1;
2102 /* A hack to work around eval's need for fp to have been collected. */
2103 else if (0 == strcmp (args, "-1"))
2106 frameno = parse_and_eval_long (args);
2109 error (_("invalid input (%d is less than zero)"), frameno);
2111 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2116 trace_find_end_command (char *args, int from_tty)
2118 trace_find_command ("-1", from_tty);
2123 trace_find_none_command (char *args, int from_tty)
2125 trace_find_command ("-1", from_tty);
2130 trace_find_start_command (char *args, int from_tty)
2132 trace_find_command ("0", from_tty);
2135 /* tfind pc command */
2137 trace_find_pc_command (char *args, int from_tty)
2141 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2142 error (_("May not look at trace frames while trace is running."));
2144 if (args == 0 || *args == 0)
2145 pc = regcache_read_pc (get_current_regcache ());
2147 pc = parse_and_eval_address (args);
2149 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2152 /* tfind tracepoint command */
2154 trace_find_tracepoint_command (char *args, int from_tty)
2157 struct breakpoint *tp;
2159 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2160 error (_("May not look at trace frames while trace is running."));
2162 if (args == 0 || *args == 0)
2164 if (tracepoint_number == -1)
2165 error (_("No current tracepoint -- please supply an argument."));
2167 tdp = tracepoint_number; /* Default is current TDP. */
2170 tdp = parse_and_eval_long (args);
2172 /* If we have the tracepoint on hand, use the number that the
2173 target knows about (which may be different if we disconnected
2174 and reconnected). */
2175 tp = get_tracepoint (tdp);
2177 tdp = tp->number_on_target;
2179 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2182 /* TFIND LINE command:
2184 This command will take a sourceline for argument, just like BREAK
2185 or TRACE (ie. anything that "decode_line_1" can handle).
2187 With no argument, this command will find the next trace frame
2188 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2191 trace_find_line_command (char *args, int from_tty)
2193 static CORE_ADDR start_pc, end_pc;
2194 struct symtabs_and_lines sals;
2195 struct symtab_and_line sal;
2196 struct cleanup *old_chain;
2198 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2199 error (_("May not look at trace frames while trace is running."));
2201 if (args == 0 || *args == 0)
2203 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2205 sals.sals = (struct symtab_and_line *)
2206 xmalloc (sizeof (struct symtab_and_line));
2211 sals = decode_line_spec (args, 1);
2215 old_chain = make_cleanup (xfree, sals.sals);
2216 if (sal.symtab == 0)
2217 error (_("No line number information available."));
2219 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2221 if (start_pc == end_pc)
2223 printf_filtered ("Line %d of \"%s\"",
2224 sal.line, sal.symtab->filename);
2226 printf_filtered (" is at address ");
2227 print_address (get_current_arch (), start_pc, gdb_stdout);
2229 printf_filtered (" but contains no code.\n");
2230 sal = find_pc_line (start_pc, 0);
2232 && find_line_pc_range (sal, &start_pc, &end_pc)
2233 && start_pc != end_pc)
2234 printf_filtered ("Attempting to find line %d instead.\n",
2237 error (_("Cannot find a good line."));
2241 /* Is there any case in which we get here, and have an address
2242 which the user would want to see? If we have debugging
2243 symbols and no line numbers? */
2244 error (_("Line number %d is out of range for \"%s\"."),
2245 sal.line, sal.symtab->filename);
2247 /* Find within range of stated line. */
2249 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2251 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2252 do_cleanups (old_chain);
2255 /* tfind range command */
2257 trace_find_range_command (char *args, int from_tty)
2259 static CORE_ADDR start, stop;
2262 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2263 error (_("May not look at trace frames while trace is running."));
2265 if (args == 0 || *args == 0)
2266 { /* XXX FIXME: what should default behavior be? */
2267 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2271 if (0 != (tmp = strchr (args, ',')))
2273 *tmp++ = '\0'; /* Terminate start address. */
2274 while (isspace ((int) *tmp))
2276 start = parse_and_eval_address (args);
2277 stop = parse_and_eval_address (tmp);
2280 { /* No explicit end address? */
2281 start = parse_and_eval_address (args);
2282 stop = start + 1; /* ??? */
2285 tfind_1 (tfind_range, 0, start, stop, from_tty);
2288 /* tfind outside command */
2290 trace_find_outside_command (char *args, int from_tty)
2292 CORE_ADDR start, stop;
2295 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2296 error (_("May not look at trace frames while trace is running."));
2298 if (args == 0 || *args == 0)
2299 { /* XXX FIXME: what should default behavior be? */
2300 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2304 if (0 != (tmp = strchr (args, ',')))
2306 *tmp++ = '\0'; /* Terminate start address. */
2307 while (isspace ((int) *tmp))
2309 start = parse_and_eval_address (args);
2310 stop = parse_and_eval_address (tmp);
2313 { /* No explicit end address? */
2314 start = parse_and_eval_address (args);
2315 stop = start + 1; /* ??? */
2318 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2321 /* info scope command: list the locals for a scope. */
2323 scope_info (char *args, int from_tty)
2325 struct symtabs_and_lines sals;
2327 struct minimal_symbol *msym;
2328 struct block *block;
2329 char **canonical, *symname, *save_args = args;
2330 struct dict_iterator iter;
2332 struct gdbarch *gdbarch;
2335 if (args == 0 || *args == 0)
2336 error (_("requires an argument (function, "
2337 "line or *addr) to define a scope"));
2339 sals = decode_line_1 (&args, 1, NULL, 0, &canonical, NULL);
2340 if (sals.nelts == 0)
2341 return; /* Presumably decode_line_1 has already warned. */
2343 /* Resolve line numbers to PC. */
2344 resolve_sal_pc (&sals.sals[0]);
2345 block = block_for_pc (sals.sals[0].pc);
2349 QUIT; /* Allow user to bail out with ^C. */
2350 ALL_BLOCK_SYMBOLS (block, iter, sym)
2352 QUIT; /* Allow user to bail out with ^C. */
2354 printf_filtered ("Scope for %s:\n", save_args);
2357 symname = SYMBOL_PRINT_NAME (sym);
2358 if (symname == NULL || *symname == '\0')
2359 continue; /* Probably botched, certainly useless. */
2361 gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
2363 printf_filtered ("Symbol %s is ", symname);
2364 switch (SYMBOL_CLASS (sym))
2367 case LOC_UNDEF: /* Messed up symbol? */
2368 printf_filtered ("a bogus symbol, class %d.\n",
2369 SYMBOL_CLASS (sym));
2370 count--; /* Don't count this one. */
2373 printf_filtered ("a constant with value %ld (0x%lx)",
2374 SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
2376 case LOC_CONST_BYTES:
2377 printf_filtered ("constant bytes: ");
2378 if (SYMBOL_TYPE (sym))
2379 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2380 fprintf_filtered (gdb_stdout, " %02x",
2381 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2384 printf_filtered ("in static storage at address ");
2385 printf_filtered ("%s", paddress (gdbarch,
2386 SYMBOL_VALUE_ADDRESS (sym)));
2389 /* GDBARCH is the architecture associated with the objfile
2390 the symbol is defined in; the target architecture may be
2391 different, and may provide additional registers. However,
2392 we do not know the target architecture at this point.
2393 We assume the objfile architecture will contain all the
2394 standard registers that occur in debug info in that
2396 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2399 if (SYMBOL_IS_ARGUMENT (sym))
2400 printf_filtered ("an argument in register $%s",
2401 gdbarch_register_name (gdbarch, regno));
2403 printf_filtered ("a local variable in register $%s",
2404 gdbarch_register_name (gdbarch, regno));
2407 printf_filtered ("an argument at stack/frame offset %ld",
2408 SYMBOL_VALUE (sym));
2411 printf_filtered ("a local variable at frame offset %ld",
2412 SYMBOL_VALUE (sym));
2415 printf_filtered ("a reference argument at offset %ld",
2416 SYMBOL_VALUE (sym));
2418 case LOC_REGPARM_ADDR:
2419 /* Note comment at LOC_REGISTER. */
2420 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2422 printf_filtered ("the address of an argument, in register $%s",
2423 gdbarch_register_name (gdbarch, regno));
2426 printf_filtered ("a typedef.\n");
2429 printf_filtered ("a label at address ");
2430 printf_filtered ("%s", paddress (gdbarch,
2431 SYMBOL_VALUE_ADDRESS (sym)));
2434 printf_filtered ("a function at address ");
2435 printf_filtered ("%s",
2436 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2438 case LOC_UNRESOLVED:
2439 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2442 printf_filtered ("Unresolved Static");
2445 printf_filtered ("static storage at address ");
2446 printf_filtered ("%s",
2447 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msym)));
2450 case LOC_OPTIMIZED_OUT:
2451 printf_filtered ("optimized out.\n");
2454 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2455 BLOCK_START (block),
2459 if (SYMBOL_TYPE (sym))
2460 printf_filtered (", length %d.\n",
2461 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2463 if (BLOCK_FUNCTION (block))
2466 block = BLOCK_SUPERBLOCK (block);
2469 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2473 /* worker function (cleanup) */
2475 replace_comma (void *data)
2482 /* Helper for trace_dump_command. Dump the action list starting at
2483 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2484 actions of the body of a while-stepping action. STEPPING_FRAME is
2485 set if the current traceframe was determined to be a while-stepping
2489 trace_dump_actions (struct command_line *action,
2490 int stepping_actions, int stepping_frame,
2493 char *action_exp, *next_comma;
2495 for (; action != NULL; action = action->next)
2497 struct cmd_list_element *cmd;
2499 QUIT; /* Allow user to bail out with ^C. */
2500 action_exp = action->line;
2501 while (isspace ((int) *action_exp))
2504 /* The collection actions to be done while stepping are
2505 bracketed by the commands "while-stepping" and "end". */
2507 if (*action_exp == '#') /* comment line */
2510 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2512 error (_("Bad action list item: %s"), action_exp);
2514 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2518 for (i = 0; i < action->body_count; ++i)
2519 trace_dump_actions (action->body_list[i],
2520 1, stepping_frame, from_tty);
2522 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2524 /* Display the collected data.
2525 For the trap frame, display only what was collected at
2526 the trap. Likewise for stepping frames, display only
2527 what was collected while stepping. This means that the
2528 two boolean variables, STEPPING_FRAME and
2529 STEPPING_ACTIONS should be equal. */
2530 if (stepping_frame == stepping_actions)
2533 { /* Repeat over a comma-separated list. */
2534 QUIT; /* Allow user to bail out with ^C. */
2535 if (*action_exp == ',')
2537 while (isspace ((int) *action_exp))
2540 next_comma = strchr (action_exp, ',');
2542 if (0 == strncasecmp (action_exp, "$reg", 4))
2543 registers_info (NULL, from_tty);
2544 else if (0 == strncasecmp (action_exp, "$loc", 4))
2545 locals_info (NULL, from_tty);
2546 else if (0 == strncasecmp (action_exp, "$arg", 4))
2547 args_info (NULL, from_tty);
2552 make_cleanup (replace_comma, next_comma);
2555 printf_filtered ("%s = ", action_exp);
2556 output_command (action_exp, from_tty);
2557 printf_filtered ("\n");
2561 action_exp = next_comma;
2563 while (action_exp && *action_exp == ',');
2569 /* The tdump command. */
2572 trace_dump_command (char *args, int from_tty)
2574 struct regcache *regcache;
2575 struct breakpoint *t;
2576 int stepping_frame = 0;
2577 struct bp_location *loc;
2578 char *line, *default_collect_line = NULL;
2579 struct command_line *actions, *default_collect_action = NULL;
2580 struct cleanup *old_chain = NULL;
2582 if (tracepoint_number == -1)
2584 warning (_("No current trace frame."));
2588 t = get_tracepoint (tracepoint_number);
2591 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2594 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2595 tracepoint_number, traceframe_number);
2597 /* The current frame is a trap frame if the frame PC is equal
2598 to the tracepoint PC. If not, then the current frame was
2599 collected during single-stepping. */
2601 regcache = get_current_regcache ();
2603 /* If the traceframe's address matches any of the tracepoint's
2604 locations, assume it is a direct hit rather than a while-stepping
2605 frame. (FIXME this is not reliable, should record each frame's
2608 for (loc = t->loc; loc; loc = loc->next)
2609 if (loc->address == regcache_read_pc (regcache))
2612 actions = breakpoint_commands (t);
2614 /* If there is a default-collect list, make up a collect command,
2615 prepend to the tracepoint's commands, and pass the whole mess to
2616 the trace dump scanner. We need to validate because
2617 default-collect might have been junked since the trace run. */
2618 if (*default_collect)
2620 default_collect_line = xstrprintf ("collect %s", default_collect);
2621 old_chain = make_cleanup (xfree, default_collect_line);
2622 line = default_collect_line;
2623 validate_actionline (&line, t);
2624 default_collect_action = xmalloc (sizeof (struct command_line));
2625 make_cleanup (xfree, default_collect_action);
2626 default_collect_action->next = actions;
2627 default_collect_action->line = line;
2628 actions = default_collect_action;
2631 trace_dump_actions (actions, 0, stepping_frame, from_tty);
2633 if (*default_collect)
2634 do_cleanups (old_chain);
2637 /* Encode a piece of a tracepoint's source-level definition in a form
2638 that is suitable for both protocol and saving in files. */
2639 /* This version does not do multiple encodes for long strings; it should
2640 return an offset to the next piece to encode. FIXME */
2643 encode_source_string (int tpnum, ULONGEST addr,
2644 char *srctype, char *src, char *buf, int buf_size)
2646 if (80 + strlen (srctype) > buf_size)
2647 error (_("Buffer too small for source encoding"));
2648 sprintf (buf, "%x:%s:%s:%x:%x:",
2649 tpnum, phex_nz (addr, sizeof (addr)),
2650 srctype, 0, (int) strlen (src));
2651 if (strlen (buf) + strlen (src) * 2 >= buf_size)
2652 error (_("Source string too long for buffer"));
2653 bin2hex (src, buf + strlen (buf), 0);
2657 extern int trace_regblock_size;
2659 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2660 non-zero, the save is performed on the target, otherwise GDB obtains all
2661 trace data and saves it locally. */
2664 trace_save (const char *filename, int target_does_save)
2666 struct cleanup *cleanup;
2668 struct trace_status *ts = current_trace_status ();
2671 struct uploaded_tp *uploaded_tps = NULL, *utp;
2672 struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
2676 ULONGEST offset = 0;
2677 #define MAX_TRACE_UPLOAD 2000
2678 gdb_byte buf[MAX_TRACE_UPLOAD];
2681 /* If the target is to save the data to a file on its own, then just
2682 send the command and be done with it. */
2683 if (target_does_save)
2685 err = target_save_trace_data (filename);
2687 error (_("Target failed to save trace data to '%s'."),
2692 /* Get the trace status first before opening the file, so if the
2693 target is losing, we can get out without touching files. */
2694 status = target_get_trace_status (ts);
2696 pathname = tilde_expand (filename);
2697 cleanup = make_cleanup (xfree, pathname);
2699 fp = fopen (pathname, "wb");
2701 error (_("Unable to open file '%s' for saving trace data (%s)"),
2702 filename, safe_strerror (errno));
2703 make_cleanup_fclose (fp);
2705 /* Write a file header, with a high-bit-set char to indicate a
2706 binary file, plus a hint as what this file is, and a version
2707 number in case of future needs. */
2708 written = fwrite ("\x7fTRACE0\n", 8, 1, fp);
2710 perror_with_name (pathname);
2712 /* Write descriptive info. */
2714 /* Write out the size of a register block. */
2715 fprintf (fp, "R %x\n", trace_regblock_size);
2717 /* Write out status of the tracing run (aka "tstatus" info). */
2718 fprintf (fp, "status %c;%s",
2719 (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
2720 if (ts->stop_reason == tracepoint_error)
2722 char *buf = (char *) alloca (strlen (ts->error_desc) * 2 + 1);
2724 bin2hex ((gdb_byte *) ts->error_desc, buf, 0);
2725 fprintf (fp, ":%s", buf);
2727 fprintf (fp, ":%x", ts->stopping_tracepoint);
2728 if (ts->traceframe_count >= 0)
2729 fprintf (fp, ";tframes:%x", ts->traceframe_count);
2730 if (ts->traceframes_created >= 0)
2731 fprintf (fp, ";tcreated:%x", ts->traceframes_created);
2732 if (ts->buffer_free >= 0)
2733 fprintf (fp, ";tfree:%x", ts->buffer_free);
2734 if (ts->buffer_size >= 0)
2735 fprintf (fp, ";tsize:%x", ts->buffer_size);
2736 if (ts->disconnected_tracing)
2737 fprintf (fp, ";disconn:%x", ts->disconnected_tracing);
2738 if (ts->circular_buffer)
2739 fprintf (fp, ";circular:%x", ts->circular_buffer);
2742 /* Note that we want to upload tracepoints and save those, rather
2743 than simply writing out the local ones, because the user may have
2744 changed tracepoints in GDB in preparation for a future tracing
2745 run, or maybe just mass-deleted all types of breakpoints as part
2746 of cleaning up. So as not to contaminate the session, leave the
2747 data in its uploaded form, don't make into real tracepoints. */
2749 /* Get trace state variables first, they may be checked when parsing
2750 uploaded commands. */
2752 target_upload_trace_state_variables (&uploaded_tsvs);
2754 for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
2760 buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
2761 bin2hex ((gdb_byte *) (utsv->name), buf, 0);
2764 fprintf (fp, "tsv %x:%s:%x:%s\n",
2765 utsv->number, phex_nz (utsv->initial_value, 8),
2766 utsv->builtin, buf);
2772 free_uploaded_tsvs (&uploaded_tsvs);
2774 target_upload_tracepoints (&uploaded_tps);
2776 for (utp = uploaded_tps; utp; utp = utp->next)
2778 fprintf (fp, "tp T%x:%s:%c:%x:%x",
2779 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
2780 (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
2781 if (utp->type == bp_fast_tracepoint)
2782 fprintf (fp, ":F%x", utp->orig_size);
2784 fprintf (fp, ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
2787 for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
2788 fprintf (fp, "tp A%x:%s:%s\n",
2789 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
2790 for (a = 0; VEC_iterate (char_ptr, utp->step_actions, a, act); ++a)
2791 fprintf (fp, "tp S%x:%s:%s\n",
2792 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
2795 encode_source_string (utp->number, utp->addr,
2796 "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
2797 fprintf (fp, "tp Z%s\n", buf);
2799 if (utp->cond_string)
2801 encode_source_string (utp->number, utp->addr,
2802 "cond", utp->cond_string,
2803 buf, MAX_TRACE_UPLOAD);
2804 fprintf (fp, "tp Z%s\n", buf);
2806 for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
2808 encode_source_string (utp->number, utp->addr, "cmd", act,
2809 buf, MAX_TRACE_UPLOAD);
2810 fprintf (fp, "tp Z%s\n", buf);
2814 free_uploaded_tps (&uploaded_tps);
2816 /* Mark the end of the definition section. */
2819 /* Get and write the trace data proper. We ask for big blocks, in
2820 the hopes of efficiency, but will take less if the target has
2821 packet size limitations or some such. */
2824 gotten = target_get_raw_trace_data (buf, offset, MAX_TRACE_UPLOAD);
2826 error (_("Failure to get requested trace buffer data"));
2827 /* No more data is forthcoming, we're done. */
2830 written = fwrite (buf, gotten, 1, fp);
2832 perror_with_name (pathname);
2836 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
2837 written = fwrite (&gotten, 4, 1, fp);
2839 perror_with_name (pathname);
2841 do_cleanups (cleanup);
2845 trace_save_command (char *args, int from_tty)
2847 int target_does_save = 0;
2849 char *filename = NULL;
2850 struct cleanup *back_to;
2853 error_no_arg (_("file in which to save trace data"));
2855 argv = gdb_buildargv (args);
2856 back_to = make_cleanup_freeargv (argv);
2858 for (; *argv; ++argv)
2860 if (strcmp (*argv, "-r") == 0)
2861 target_does_save = 1;
2862 else if (**argv == '-')
2863 error (_("unknown option `%s'"), *argv);
2869 error_no_arg (_("file in which to save trace data"));
2871 trace_save (filename, target_does_save);
2874 printf_filtered (_("Trace data saved to file '%s'.\n"), args);
2876 do_cleanups (back_to);
2879 /* Tell the target what to do with an ongoing tracing run if GDB
2880 disconnects for some reason. */
2883 send_disconnected_tracing_value (int value)
2885 target_set_disconnected_tracing (value);
2889 set_disconnected_tracing (char *args, int from_tty,
2890 struct cmd_list_element *c)
2892 send_disconnected_tracing_value (disconnected_tracing);
2896 set_circular_trace_buffer (char *args, int from_tty,
2897 struct cmd_list_element *c)
2899 target_set_circular_trace_buffer (circular_trace_buffer);
2902 /* Convert the memory pointed to by mem into hex, placing result in buf.
2903 * Return a pointer to the last char put in buf (null)
2904 * "stolen" from sparc-stub.c
2907 static const char hexchars[] = "0123456789abcdef";
2910 mem2hex (gdb_byte *mem, char *buf, int count)
2918 *buf++ = hexchars[ch >> 4];
2919 *buf++ = hexchars[ch & 0xf];
2928 get_traceframe_number (void)
2930 return traceframe_number;
2933 /* Make the traceframe NUM be the current trace frame. Does nothing
2934 if NUM is already current. */
2937 set_current_traceframe (int num)
2941 if (traceframe_number == num)
2943 /* Nothing to do. */
2947 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
2950 warning (_("could not change traceframe"));
2952 traceframe_number = newnum;
2954 /* Changing the traceframe changes our view of registers and of the
2956 registers_changed ();
2958 clear_traceframe_info ();
2961 /* Make the traceframe NUM be the current trace frame, and do nothing
2965 set_traceframe_number (int num)
2967 traceframe_number = num;
2970 /* A cleanup used when switching away and back from tfind mode. */
2972 struct current_traceframe_cleanup
2974 /* The traceframe we were inspecting. */
2975 int traceframe_number;
2979 do_restore_current_traceframe_cleanup (void *arg)
2981 struct current_traceframe_cleanup *old = arg;
2983 set_current_traceframe (old->traceframe_number);
2987 restore_current_traceframe_cleanup_dtor (void *arg)
2989 struct current_traceframe_cleanup *old = arg;
2995 make_cleanup_restore_current_traceframe (void)
2997 struct current_traceframe_cleanup *old;
2999 old = xmalloc (sizeof (struct current_traceframe_cleanup));
3000 old->traceframe_number = traceframe_number;
3002 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
3003 restore_current_traceframe_cleanup_dtor);
3007 make_cleanup_restore_traceframe_number (void)
3009 return make_cleanup_restore_integer (&traceframe_number);
3012 /* Given a number and address, return an uploaded tracepoint with that
3013 number, creating if necessary. */
3015 struct uploaded_tp *
3016 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
3018 struct uploaded_tp *utp;
3020 for (utp = *utpp; utp; utp = utp->next)
3021 if (utp->number == num && utp->addr == addr)
3023 utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
3024 memset (utp, 0, sizeof (struct uploaded_tp));
3027 utp->actions = NULL;
3028 utp->step_actions = NULL;
3029 utp->cmd_strings = NULL;
3036 free_uploaded_tps (struct uploaded_tp **utpp)
3038 struct uploaded_tp *next_one;
3042 next_one = (*utpp)->next;
3048 /* Given a number and address, return an uploaded tracepoint with that
3049 number, creating if necessary. */
3051 struct uploaded_tsv *
3052 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3054 struct uploaded_tsv *utsv;
3056 for (utsv = *utsvp; utsv; utsv = utsv->next)
3057 if (utsv->number == num)
3059 utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
3060 memset (utsv, 0, sizeof (struct uploaded_tsv));
3062 utsv->next = *utsvp;
3068 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3070 struct uploaded_tsv *next_one;
3074 next_one = (*utsvp)->next;
3080 /* Look for an existing tracepoint that seems similar enough to the
3081 uploaded one. Enablement isn't compared, because the user can
3082 toggle that freely, and may have done so in anticipation of the
3086 find_matching_tracepoint (struct uploaded_tp *utp)
3088 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
3090 struct breakpoint *t;
3091 struct bp_location *loc;
3093 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
3095 if (t->type == utp->type
3096 && t->step_count == utp->step
3097 && t->pass_count == utp->pass
3098 /* FIXME also test conditionals and actions. */
3101 /* Scan the locations for an address match. */
3102 for (loc = t->loc; loc; loc = loc->next)
3104 if (loc->address == utp->addr)
3112 /* Given a list of tracepoints uploaded from a target, attempt to
3113 match them up with existing tracepoints, and create new ones if not
3117 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3119 struct uploaded_tp *utp;
3120 struct breakpoint *t;
3122 /* Look for GDB tracepoints that match up with our uploaded versions. */
3123 for (utp = *uploaded_tps; utp; utp = utp->next)
3125 t = find_matching_tracepoint (utp);
3127 printf_filtered (_("Assuming tracepoint %d is same "
3128 "as target's tracepoint %d at %s.\n"),
3129 t->number, utp->number,
3130 paddress (get_current_arch (), utp->addr));
3133 t = create_tracepoint_from_upload (utp);
3135 printf_filtered (_("Created tracepoint %d for "
3136 "target's tracepoint %d at %s.\n"),
3137 t->number, utp->number,
3138 paddress (get_current_arch (), utp->addr));
3140 printf_filtered (_("Failed to create tracepoint for target's "
3141 "tracepoint %d at %s, skipping it.\n"),
3143 paddress (get_current_arch (), utp->addr));
3145 /* Whether found or created, record the number used by the
3146 target, to help with mapping target tracepoints back to their
3147 counterparts here. */
3149 t->number_on_target = utp->number;
3152 free_uploaded_tps (uploaded_tps);
3155 /* Trace state variables don't have much to identify them beyond their
3156 name, so just use that to detect matches. */
3158 struct trace_state_variable *
3159 find_matching_tsv (struct uploaded_tsv *utsv)
3164 return find_trace_state_variable (utsv->name);
3167 struct trace_state_variable *
3168 create_tsv_from_upload (struct uploaded_tsv *utsv)
3170 const char *namebase;
3173 struct trace_state_variable *tsv;
3177 namebase = utsv->name;
3178 sprintf (buf, "%s", namebase);
3183 sprintf (buf, "%s_%d", namebase, try_num++);
3186 /* Fish for a name that is not in use. */
3187 /* (should check against all internal vars?) */
3188 while (find_trace_state_variable (buf))
3189 sprintf (buf, "%s_%d", namebase, try_num++);
3191 /* We have an available name, create the variable. */
3192 tsv = create_trace_state_variable (xstrdup (buf));
3193 tsv->initial_value = utsv->initial_value;
3194 tsv->builtin = utsv->builtin;
3199 /* Given a list of uploaded trace state variables, try to match them
3200 up with existing variables, or create additional ones. */
3203 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
3206 struct uploaded_tsv *utsv;
3207 struct trace_state_variable *tsv;
3210 /* Most likely some numbers will have to be reassigned as part of
3211 the merge, so clear them all in anticipation. */
3212 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3215 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
3217 tsv = find_matching_tsv (utsv);
3221 printf_filtered (_("Assuming trace state variable $%s "
3222 "is same as target's variable %d.\n"),
3223 tsv->name, utsv->number);
3227 tsv = create_tsv_from_upload (utsv);
3229 printf_filtered (_("Created trace state variable "
3230 "$%s for target's variable %d.\n"),
3231 tsv->name, utsv->number);
3233 /* Give precedence to numberings that come from the target. */
3235 tsv->number = utsv->number;
3238 /* Renumber everything that didn't get a target-assigned number. */
3240 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3241 if (tsv->number > highest)
3242 highest = tsv->number;
3245 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3246 if (tsv->number == 0)
3247 tsv->number = highest++;
3249 free_uploaded_tsvs (uploaded_tsvs);
3252 /* target tfile command */
3254 struct target_ops tfile_ops;
3256 /* Fill in tfile_ops with its defined operations and properties. */
3258 #define TRACE_HEADER_SIZE 8
3260 char *trace_filename;
3262 off_t trace_frames_offset;
3264 int cur_traceframe_number;
3266 int trace_regblock_size;
3268 static void tfile_interp_line (char *line,
3269 struct uploaded_tp **utpp,
3270 struct uploaded_tsv **utsvp);
3272 /* Read SIZE bytes into READBUF from the trace frame, starting at
3273 TRACE_FD's current position. Note that this call `read'
3274 underneath, hence it advances the file's seek position. Throws an
3275 error if the `read' syscall fails, or less than SIZE bytes are
3279 tfile_read (gdb_byte *readbuf, int size)
3283 gotten = read (trace_fd, readbuf, size);
3285 perror_with_name (trace_filename);
3286 else if (gotten < size)
3287 error (_("Premature end of file while reading trace file"));
3291 tfile_open (char *filename, int from_tty)
3294 struct cleanup *old_chain;
3297 char header[TRACE_HEADER_SIZE];
3298 char linebuf[1000]; /* Should be max remote packet size or so. */
3301 struct trace_status *ts;
3302 struct uploaded_tp *uploaded_tps = NULL;
3303 struct uploaded_tsv *uploaded_tsvs = NULL;
3305 target_preopen (from_tty);
3307 error (_("No trace file specified."));
3309 filename = tilde_expand (filename);
3310 if (!IS_ABSOLUTE_PATH(filename))
3312 temp = concat (current_directory, "/", filename, (char *) NULL);
3317 old_chain = make_cleanup (xfree, filename);
3319 flags = O_BINARY | O_LARGEFILE;
3321 scratch_chan = open (filename, flags, 0);
3322 if (scratch_chan < 0)
3323 perror_with_name (filename);
3325 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3327 discard_cleanups (old_chain); /* Don't free filename any more. */
3328 unpush_target (&tfile_ops);
3330 push_target (&tfile_ops);
3332 trace_filename = xstrdup (filename);
3333 trace_fd = scratch_chan;
3336 /* Read the file header and test for validity. */
3337 tfile_read ((gdb_byte *) &header, TRACE_HEADER_SIZE);
3339 bytes += TRACE_HEADER_SIZE;
3340 if (!(header[0] == 0x7f
3341 && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
3342 error (_("File is not a valid trace file."));
3344 trace_regblock_size = 0;
3345 ts = current_trace_status ();
3346 /* We know we're working with a file. */
3348 /* Set defaults in case there is no status line. */
3349 ts->running_known = 0;
3350 ts->stop_reason = trace_stop_reason_unknown;
3351 ts->traceframe_count = -1;
3352 ts->buffer_free = 0;
3353 ts->disconnected_tracing = 0;
3354 ts->circular_buffer = 0;
3356 cur_traceframe_number = -1;
3358 /* Read through a section of newline-terminated lines that
3359 define things like tracepoints. */
3363 tfile_read (&byte, 1);
3368 /* Empty line marks end of the definition section. */
3373 tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
3376 linebuf[i++] = byte;
3378 error (_("Excessively long lines in trace file"));
3381 /* Add the file's tracepoints and variables into the current mix. */
3383 /* Get trace state variables first, they may be checked when parsing
3384 uploaded commands. */
3385 merge_uploaded_trace_state_variables (&uploaded_tsvs);
3387 merge_uploaded_tracepoints (&uploaded_tps);
3389 /* Record the starting offset of the binary trace data. */
3390 trace_frames_offset = bytes;
3392 /* If we don't have a blocksize, we can't interpret the
3394 if (trace_regblock_size == 0)
3395 error (_("No register block size recorded in trace file"));
3396 if (ts->traceframe_count <= 0)
3398 warning (_("No traceframes present in this file."));
3402 #define TFILE_PID (1)
3403 inferior_appeared (current_inferior (), TFILE_PID);
3404 inferior_ptid = pid_to_ptid (TFILE_PID);
3405 add_thread_silent (inferior_ptid);
3407 post_create_inferior (&tfile_ops, from_tty);
3410 /* FIXME this will get defined in MI patch submission. */
3411 tfind_1 (tfind_number, 0, 0, 0, 0);
3415 /* Interpret the given line from the definitions part of the trace
3419 tfile_interp_line (char *line,
3420 struct uploaded_tp **utpp, struct uploaded_tsv **utsvp)
3424 if (strncmp (p, "R ", strlen ("R ")) == 0)
3427 trace_regblock_size = strtol (p, &p, 16);
3429 else if (strncmp (p, "status ", strlen ("status ")) == 0)
3431 p += strlen ("status ");
3432 parse_trace_status (p, current_trace_status ());
3434 else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
3436 p += strlen ("tp ");
3437 parse_tracepoint_definition (p, utpp);
3439 else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
3441 p += strlen ("tsv ");
3442 parse_tsv_definition (p, utsvp);
3445 warning (_("Ignoring trace file definition \"%s\""), line);
3448 /* Parse the part of trace status syntax that is shared between
3449 the remote protocol and the trace file reader. */
3452 parse_trace_status (char *line, struct trace_status *ts)
3454 char *p = line, *p1, *p2, *p_temp;
3457 ts->running_known = 1;
3458 ts->running = (*p++ == '1');
3459 ts->stop_reason = trace_stop_reason_unknown;
3460 xfree (ts->error_desc);
3461 ts->error_desc = NULL;
3462 ts->traceframe_count = -1;
3463 ts->traceframes_created = -1;
3464 ts->buffer_free = -1;
3465 ts->buffer_size = -1;
3466 ts->disconnected_tracing = 0;
3467 ts->circular_buffer = 0;
3471 p1 = strchr (p, ':');
3473 error (_("Malformed trace status, at %s\n\
3474 Status line: '%s'\n"), p, line);
3475 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3477 p = unpack_varlen_hex (++p1, &val);
3478 ts->stop_reason = trace_buffer_full;
3480 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3482 p = unpack_varlen_hex (++p1, &val);
3483 ts->stop_reason = trace_never_run;
3485 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
3488 p = unpack_varlen_hex (++p1, &val);
3489 ts->stop_reason = tracepoint_passcount;
3490 ts->stopping_tracepoint = val;
3492 else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
3494 p = unpack_varlen_hex (++p1, &val);
3495 ts->stop_reason = tstop_command;
3497 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3499 p = unpack_varlen_hex (++p1, &val);
3500 ts->stop_reason = trace_disconnected;
3502 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3504 p2 = strchr (++p1, ':');
3509 ts->error_desc = xmalloc ((p2 - p1) / 2 + 1);
3510 end = hex2bin (p1, ts->error_desc, (p2 - p1) / 2);
3511 ts->error_desc[end] = '\0';
3514 ts->error_desc = xstrdup ("");
3516 p = unpack_varlen_hex (++p2, &val);
3517 ts->stopping_tracepoint = val;
3518 ts->stop_reason = tracepoint_error;
3520 else if (strncmp (p, "tframes", p1 - p) == 0)
3522 p = unpack_varlen_hex (++p1, &val);
3523 ts->traceframe_count = val;
3525 else if (strncmp (p, "tcreated", p1 - p) == 0)
3527 p = unpack_varlen_hex (++p1, &val);
3528 ts->traceframes_created = val;
3530 else if (strncmp (p, "tfree", p1 - p) == 0)
3532 p = unpack_varlen_hex (++p1, &val);
3533 ts->buffer_free = val;
3535 else if (strncmp (p, "tsize", p1 - p) == 0)
3537 p = unpack_varlen_hex (++p1, &val);
3538 ts->buffer_size = val;
3540 else if (strncmp (p, "disconn", p1 - p) == 0)
3542 p = unpack_varlen_hex (++p1, &val);
3543 ts->disconnected_tracing = val;
3545 else if (strncmp (p, "circular", p1 - p) == 0)
3547 p = unpack_varlen_hex (++p1, &val);
3548 ts->circular_buffer = val;
3552 /* Silently skip unknown optional info. */
3553 p_temp = strchr (p1 + 1, ';');
3557 /* Must be at the end. */
3563 /* Given a line of text defining a part of a tracepoint, parse it into
3564 an "uploaded tracepoint". */
3567 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
3571 ULONGEST num, addr, step, pass, orig_size, xlen, start;
3574 char *cond, *srctype, *buf;
3575 struct uploaded_tp *utp = NULL;
3578 /* Both tracepoint and action definitions start with the same number
3579 and address sequence. */
3581 p = unpack_varlen_hex (p, &num);
3582 p++; /* skip a colon */
3583 p = unpack_varlen_hex (p, &addr);
3584 p++; /* skip a colon */
3587 enabled = (*p++ == 'E');
3588 p++; /* skip a colon */
3589 p = unpack_varlen_hex (p, &step);
3590 p++; /* skip a colon */
3591 p = unpack_varlen_hex (p, &pass);
3592 type = bp_tracepoint;
3594 /* Thumb through optional fields. */
3597 p++; /* skip a colon */
3600 type = bp_fast_tracepoint;
3602 p = unpack_varlen_hex (p, &orig_size);
3606 type = bp_static_tracepoint;
3612 p = unpack_varlen_hex (p, &xlen);
3613 p++; /* skip a comma */
3614 cond = (char *) xmalloc (2 * xlen + 1);
3615 strncpy (cond, p, 2 * xlen);
3616 cond[2 * xlen] = '\0';
3620 warning (_("Unrecognized char '%c' in tracepoint "
3621 "definition, skipping rest"), *p);
3623 utp = get_uploaded_tp (num, addr, utpp);
3625 utp->enabled = enabled;
3630 else if (piece == 'A')
3632 utp = get_uploaded_tp (num, addr, utpp);
3633 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
3635 else if (piece == 'S')
3637 utp = get_uploaded_tp (num, addr, utpp);
3638 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
3640 else if (piece == 'Z')
3642 /* Parse a chunk of source form definition. */
3643 utp = get_uploaded_tp (num, addr, utpp);
3645 p = strchr (p, ':');
3646 p++; /* skip a colon */
3647 p = unpack_varlen_hex (p, &start);
3648 p++; /* skip a colon */
3649 p = unpack_varlen_hex (p, &xlen);
3650 p++; /* skip a colon */
3652 buf = alloca (strlen (line));
3654 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3657 if (strncmp (srctype, "at:", strlen ("at:")) == 0)
3658 utp->at_string = xstrdup (buf);
3659 else if (strncmp (srctype, "cond:", strlen ("cond:")) == 0)
3660 utp->cond_string = xstrdup (buf);
3661 else if (strncmp (srctype, "cmd:", strlen ("cmd:")) == 0)
3662 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
3666 /* Don't error out, the target might be sending us optional
3667 info that we don't care about. */
3668 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
3672 /* Convert a textual description of a trace state variable into an
3676 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
3679 ULONGEST num, initval, builtin;
3681 struct uploaded_tsv *utsv = NULL;
3683 buf = alloca (strlen (line));
3686 p = unpack_varlen_hex (p, &num);
3687 p++; /* skip a colon */
3688 p = unpack_varlen_hex (p, &initval);
3689 p++; /* skip a colon */
3690 p = unpack_varlen_hex (p, &builtin);
3691 p++; /* skip a colon */
3692 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3695 utsv = get_uploaded_tsv (num, utsvp);
3696 utsv->initial_value = initval;
3697 utsv->builtin = builtin;
3698 utsv->name = xstrdup (buf);
3701 /* Close the trace file and generally clean up. */
3704 tfile_close (int quitting)
3711 pid = ptid_get_pid (inferior_ptid);
3712 inferior_ptid = null_ptid; /* Avoid confusion from thread stuff. */
3713 exit_inferior_silent (pid);
3718 xfree (trace_filename);
3722 tfile_files_info (struct target_ops *t)
3724 /* (it would be useful to mention the name of the file). */
3725 printf_filtered ("Looking at a trace file.\n");
3728 /* The trace status for a file is that tracing can never be run. */
3731 tfile_get_trace_status (struct trace_status *ts)
3733 /* Other bits of trace status were collected as part of opening the
3734 trace files, so nothing to do here. */
3739 /* Given the position of a traceframe in the file, figure out what
3740 address the frame was collected at. This would normally be the
3741 value of a collected PC register, but if not available, we
3745 tfile_get_traceframe_address (off_t tframe_offset)
3749 struct breakpoint *tp;
3750 off_t saved_offset = cur_offset;
3752 /* FIXME dig pc out of collected registers. */
3754 /* Fall back to using tracepoint address. */
3755 lseek (trace_fd, tframe_offset, SEEK_SET);
3756 tfile_read ((gdb_byte *) &tpnum, 2);
3757 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
3761 tp = get_tracepoint_by_number_on_target (tpnum);
3762 /* FIXME this is a poor heuristic if multiple locations. */
3764 addr = tp->loc->address;
3766 /* Restore our seek position. */
3767 cur_offset = saved_offset;
3768 lseek (trace_fd, cur_offset, SEEK_SET);
3772 /* Make tfile's selected traceframe match GDB's selected
3776 set_tfile_traceframe (void)
3780 if (cur_traceframe_number == get_traceframe_number ())
3783 /* Avoid recursion, tfile_trace_find calls us again. */
3784 cur_traceframe_number = get_traceframe_number ();
3786 newnum = target_trace_find (tfind_number,
3787 get_traceframe_number (), 0, 0, NULL);
3789 /* Should not happen. If it does, all bets are off. */
3790 if (newnum != get_traceframe_number ())
3791 warning (_("could not set tfile's traceframe"));
3794 /* Given a type of search and some parameters, scan the collection of
3795 traceframes in the file looking for a match. When found, return
3796 both the traceframe and tracepoint number, otherwise -1 for
3800 tfile_trace_find (enum trace_find_type type, int num,
3801 ULONGEST addr1, ULONGEST addr2, int *tpp)
3804 int tfnum = 0, found = 0;
3805 unsigned int data_size;
3806 struct breakpoint *tp;
3807 off_t offset, tframe_offset;
3810 /* Lookups other than by absolute frame number depend on the current
3811 trace selected, so make sure it is correct on the tfile end
3813 if (type != tfind_number)
3814 set_tfile_traceframe ();
3816 lseek (trace_fd, trace_frames_offset, SEEK_SET);
3817 offset = trace_frames_offset;
3820 tframe_offset = offset;
3821 tfile_read ((gdb_byte *) &tpnum, 2);
3822 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
3828 tfile_read ((gdb_byte *) &data_size, 4);
3829 data_size = (unsigned int) extract_unsigned_integer
3830 ((gdb_byte *) &data_size, 4,
3831 gdbarch_byte_order (target_gdbarch));
3840 tfaddr = tfile_get_traceframe_address (tframe_offset);
3841 if (tfaddr == addr1)
3845 tp = get_tracepoint (num);
3846 if (tp && tpnum == tp->number_on_target)
3850 tfaddr = tfile_get_traceframe_address (tframe_offset);
3851 if (addr1 <= tfaddr && tfaddr <= addr2)
3855 tfaddr = tfile_get_traceframe_address (tframe_offset);
3856 if (!(addr1 <= tfaddr && tfaddr <= addr2))
3860 internal_error (__FILE__, __LINE__, _("unknown tfind type"));
3866 cur_offset = offset;
3867 cur_data_size = data_size;
3868 cur_traceframe_number = tfnum;
3871 /* Skip past the traceframe's data. */
3872 lseek (trace_fd, data_size, SEEK_CUR);
3873 offset += data_size;
3874 /* Update our own count of traceframes. */
3877 /* Did not find what we were looking for. */
3883 /* Prototype of the callback passed to tframe_walk_blocks. */
3884 typedef int (*walk_blocks_callback_func) (char blocktype, void *data);
3886 /* Callback for traceframe_walk_blocks, used to find a given block
3887 type in a traceframe. */
3890 match_blocktype (char blocktype, void *data)
3892 char *wantedp = data;
3894 if (*wantedp == blocktype)
3900 /* Walk over all traceframe block starting at POS offset from
3901 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
3902 unmodified. If CALLBACK returns true, this returns the position in
3903 the traceframe where the block is found, relative to the start of
3904 the traceframe (cur_offset). Returns -1 if no callback call
3905 returned true, indicating that all blocks have been walked. */
3908 traceframe_walk_blocks (walk_blocks_callback_func callback,
3909 int pos, void *data)
3911 /* Iterate through a traceframe's blocks, looking for a block of the
3914 lseek (trace_fd, cur_offset + pos, SEEK_SET);
3915 while (pos < cur_data_size)
3917 unsigned short mlen;
3920 tfile_read (&block_type, 1);
3924 if ((*callback) (block_type, data))
3930 lseek (trace_fd, cur_offset + pos + trace_regblock_size, SEEK_SET);
3931 pos += trace_regblock_size;
3934 lseek (trace_fd, cur_offset + pos + 8, SEEK_SET);
3935 tfile_read ((gdb_byte *) &mlen, 2);
3936 mlen = (unsigned short)
3937 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
3940 lseek (trace_fd, mlen, SEEK_CUR);
3941 pos += (8 + 2 + mlen);
3944 lseek (trace_fd, cur_offset + pos + 4 + 8, SEEK_SET);
3948 error (_("Unknown block type '%c' (0x%x) in trace frame"),
3949 block_type, block_type);
3957 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
3958 position offset of a block of type TYPE_WANTED in the current trace
3959 frame, starting at POS. Returns -1 if no such block was found. */
3962 traceframe_find_block_type (char type_wanted, int pos)
3964 return traceframe_walk_blocks (match_blocktype, pos, &type_wanted);
3967 /* Look for a block of saved registers in the traceframe, and get the
3968 requested register from it. */
3971 tfile_fetch_registers (struct target_ops *ops,
3972 struct regcache *regcache, int regno)
3974 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3976 int pos, offset, regn, regsize, pc_regno;
3977 unsigned short mlen;
3980 /* An uninitialized reg size says we're not going to be
3981 successful at getting register blocks. */
3982 if (!trace_regblock_size)
3985 set_tfile_traceframe ();
3987 regs = alloca (trace_regblock_size);
3989 if (traceframe_find_block_type ('R', 0) >= 0)
3991 tfile_read (regs, trace_regblock_size);
3993 /* Assume the block is laid out in GDB register number order,
3994 each register with the size that it has in GDB. */
3996 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
3998 regsize = register_size (gdbarch, regn);
3999 /* Make sure we stay within block bounds. */
4000 if (offset + regsize >= trace_regblock_size)
4002 if (regcache_register_status (regcache, regn) == REG_UNKNOWN)
4006 regcache_raw_supply (regcache, regno, regs + offset);
4009 else if (regno == -1)
4011 regcache_raw_supply (regcache, regn, regs + offset);
4019 /* We get here if no register data has been found. Mark registers
4021 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4022 regcache_raw_supply (regcache, regn, NULL);
4024 /* We can often usefully guess that the PC is going to be the same
4025 as the address of the tracepoint. */
4026 pc_regno = gdbarch_pc_regnum (gdbarch);
4027 if (pc_regno >= 0 && (regno == -1 || regno == pc_regno))
4029 struct breakpoint *tp = get_tracepoint (tracepoint_number);
4033 /* But don't try to guess if tracepoint is multi-location... */
4036 warning (_("Tracepoint %d has multiple "
4037 "locations, cannot infer $pc"),
4041 /* ... or does while-stepping. */
4042 if (tp->step_count > 0)
4044 warning (_("Tracepoint %d does while-stepping, "
4045 "cannot infer $pc"),
4050 store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
4051 gdbarch_byte_order (gdbarch),
4053 regcache_raw_supply (regcache, pc_regno, regs);
4059 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
4060 const char *annex, gdb_byte *readbuf,
4061 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
4063 /* We're only doing regular memory for now. */
4064 if (object != TARGET_OBJECT_MEMORY)
4067 if (readbuf == NULL)
4068 error (_("tfile_xfer_partial: trace file is read-only"));
4070 set_tfile_traceframe ();
4072 if (traceframe_number != -1)
4076 /* Iterate through the traceframe's blocks, looking for
4078 while ((pos = traceframe_find_block_type ('M', pos)) >= 0)
4080 ULONGEST maddr, amt;
4081 unsigned short mlen;
4082 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
4084 tfile_read ((gdb_byte *) &maddr, 8);
4085 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
4087 tfile_read ((gdb_byte *) &mlen, 2);
4088 mlen = (unsigned short)
4089 extract_unsigned_integer ((gdb_byte *) &mlen, 2, byte_order);
4091 /* If the block includes the first part of the desired
4092 range, return as much it has; GDB will re-request the
4093 remainder, which might be in a different block of this
4095 if (maddr <= offset && offset < (maddr + mlen))
4097 amt = (maddr + mlen) - offset;
4101 tfile_read (readbuf, amt);
4105 /* Skip over this block. */
4106 pos += (8 + 2 + mlen);
4110 /* It's unduly pedantic to refuse to look at the executable for
4111 read-only pieces; so do the equivalent of readonly regions aka
4113 /* FIXME account for relocation at some point. */
4120 for (s = exec_bfd->sections; s; s = s->next)
4122 if ((s->flags & SEC_LOAD) == 0
4123 || (s->flags & SEC_READONLY) == 0)
4127 size = bfd_get_section_size (s);
4128 if (vma <= offset && offset < (vma + size))
4132 amt = (vma + size) - offset;
4136 amt = bfd_get_section_contents (exec_bfd, s,
4137 readbuf, offset - vma, amt);
4143 /* Indicate failure to find the requested memory block. */
4147 /* Iterate through the blocks of a trace frame, looking for a 'V'
4148 block with a matching tsv number. */
4151 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
4155 set_tfile_traceframe ();
4158 while ((pos = traceframe_find_block_type ('V', pos)) >= 0)
4162 tfile_read ((gdb_byte *) &vnum, 4);
4163 vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
4168 tfile_read ((gdb_byte *) val, 8);
4169 *val = extract_signed_integer ((gdb_byte *) val, 8,
4177 /* Didn't find anything. */
4182 tfile_has_all_memory (struct target_ops *ops)
4188 tfile_has_memory (struct target_ops *ops)
4194 tfile_has_stack (struct target_ops *ops)
4196 return traceframe_number != -1;
4200 tfile_has_registers (struct target_ops *ops)
4202 return traceframe_number != -1;
4205 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
4206 object for the tfile target's current traceframe. */
4209 build_traceframe_info (char blocktype, void *data)
4211 struct traceframe_info *info = data;
4217 struct mem_range *r;
4219 unsigned short mlen;
4221 tfile_read ((gdb_byte *) &maddr, 8);
4222 tfile_read ((gdb_byte *) &mlen, 2);
4224 r = VEC_safe_push (mem_range_s, info->memory, NULL);
4237 warning (_("Unhandled trace block type (%d) '%c ' "
4238 "while building trace frame info."),
4239 blocktype, blocktype);
4246 static struct traceframe_info *
4247 tfile_traceframe_info (void)
4249 struct traceframe_info *info = XCNEW (struct traceframe_info);
4251 traceframe_walk_blocks (build_traceframe_info, 0, info);
4256 init_tfile_ops (void)
4258 tfile_ops.to_shortname = "tfile";
4259 tfile_ops.to_longname = "Local trace dump file";
4261 = "Use a trace file as a target. Specify the filename of the trace file.";
4262 tfile_ops.to_open = tfile_open;
4263 tfile_ops.to_close = tfile_close;
4264 tfile_ops.to_fetch_registers = tfile_fetch_registers;
4265 tfile_ops.to_xfer_partial = tfile_xfer_partial;
4266 tfile_ops.to_files_info = tfile_files_info;
4267 tfile_ops.to_get_trace_status = tfile_get_trace_status;
4268 tfile_ops.to_trace_find = tfile_trace_find;
4269 tfile_ops.to_get_trace_state_variable_value
4270 = tfile_get_trace_state_variable_value;
4271 tfile_ops.to_stratum = process_stratum;
4272 tfile_ops.to_has_all_memory = tfile_has_all_memory;
4273 tfile_ops.to_has_memory = tfile_has_memory;
4274 tfile_ops.to_has_stack = tfile_has_stack;
4275 tfile_ops.to_has_registers = tfile_has_registers;
4276 tfile_ops.to_traceframe_info = tfile_traceframe_info;
4277 tfile_ops.to_magic = OPS_MAGIC;
4280 /* Given a line of text defining a static tracepoint marker, parse it
4281 into a "static tracepoint marker" object. Throws an error is
4282 parsing fails. If PP is non-null, it points to one past the end of
4283 the parsed marker definition. */
4286 parse_static_tracepoint_marker_definition (char *line, char **pp,
4287 struct static_tracepoint_marker *marker)
4294 p = unpack_varlen_hex (p, &addr);
4295 p++; /* skip a colon */
4297 marker->gdbarch = target_gdbarch;
4298 marker->address = (CORE_ADDR) addr;
4300 endp = strchr (p, ':');
4302 error (_("bad marker definition: %s"), line);
4304 marker->str_id = xmalloc (endp - p + 1);
4305 end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
4306 marker->str_id[end] = '\0';
4309 p++; /* skip a colon */
4311 marker->extra = xmalloc (strlen (p) + 1);
4312 end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
4313 marker->extra[end] = '\0';
4319 /* Release a static tracepoint marker's contents. Note that the
4320 object itself isn't released here. There objects are usually on
4324 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
4326 xfree (marker->str_id);
4327 marker->str_id = NULL;
4330 /* Print MARKER to gdb_stdout. */
4333 print_one_static_tracepoint_marker (int count,
4334 struct static_tracepoint_marker *marker)
4336 struct command_line *l;
4339 char wrap_indent[80];
4340 char extra_field_indent[80];
4341 struct ui_stream *stb = ui_out_stream_new (uiout);
4342 struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb);
4343 struct cleanup *bkpt_chain;
4344 VEC(breakpoint_p) *tracepoints;
4346 struct symtab_and_line sal;
4350 sal.pc = marker->address;
4352 tracepoints = static_tracepoints_here (marker->address);
4354 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
4356 /* A counter field to help readability. This is not a stable
4358 ui_out_field_int (uiout, "count", count);
4360 ui_out_field_string (uiout, "marker-id", marker->str_id);
4362 ui_out_field_fmt (uiout, "enabled", "%c",
4363 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
4364 ui_out_spaces (uiout, 2);
4366 strcpy (wrap_indent, " ");
4368 if (gdbarch_addr_bit (marker->gdbarch) <= 32)
4369 strcat (wrap_indent, " ");
4371 strcat (wrap_indent, " ");
4373 strcpy (extra_field_indent, " ");
4375 ui_out_field_core_addr (uiout, "addr", marker->gdbarch, marker->address);
4377 sal = find_pc_line (marker->address, 0);
4378 sym = find_pc_sect_function (marker->address, NULL);
4381 ui_out_text (uiout, "in ");
4382 ui_out_field_string (uiout, "func",
4383 SYMBOL_PRINT_NAME (sym));
4384 ui_out_wrap_hint (uiout, wrap_indent);
4385 ui_out_text (uiout, " at ");
4388 ui_out_field_skip (uiout, "func");
4390 if (sal.symtab != NULL)
4392 ui_out_field_string (uiout, "file", sal.symtab->filename);
4393 ui_out_text (uiout, ":");
4395 if (ui_out_is_mi_like_p (uiout))
4397 char *fullname = symtab_to_fullname (sal.symtab);
4400 ui_out_field_string (uiout, "fullname", fullname);
4403 ui_out_field_skip (uiout, "fullname");
4405 ui_out_field_int (uiout, "line", sal.line);
4409 ui_out_field_skip (uiout, "fullname");
4410 ui_out_field_skip (uiout, "line");
4413 ui_out_text (uiout, "\n");
4414 ui_out_text (uiout, extra_field_indent);
4415 ui_out_text (uiout, _("Data: \""));
4416 ui_out_field_string (uiout, "extra-data", marker->extra);
4417 ui_out_text (uiout, "\"\n");
4419 if (!VEC_empty (breakpoint_p, tracepoints))
4421 struct cleanup *cleanup_chain;
4423 struct breakpoint *b;
4425 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
4428 ui_out_text (uiout, extra_field_indent);
4429 ui_out_text (uiout, _("Probed by static tracepoints: "));
4430 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
4433 ui_out_text (uiout, ", ");
4434 ui_out_text (uiout, "#");
4435 ui_out_field_int (uiout, "tracepoint-id", b->number);
4438 do_cleanups (cleanup_chain);
4440 if (ui_out_is_mi_like_p (uiout))
4441 ui_out_field_int (uiout, "number-of-tracepoints",
4442 VEC_length(breakpoint_p, tracepoints));
4444 ui_out_text (uiout, "\n");
4446 VEC_free (breakpoint_p, tracepoints);
4448 do_cleanups (bkpt_chain);
4449 do_cleanups (old_chain);
4453 info_static_tracepoint_markers_command (char *arg, int from_tty)
4455 VEC(static_tracepoint_marker_p) *markers;
4456 struct cleanup *old_chain;
4457 struct static_tracepoint_marker *marker;
4461 = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
4462 "StaticTracepointMarkersTable");
4464 ui_out_table_header (uiout, 7, ui_left, "counter", "Cnt");
4466 ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
4468 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
4469 if (gdbarch_addr_bit (target_gdbarch) <= 32)
4470 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
4472 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
4473 ui_out_table_header (uiout, 40, ui_noalign, "what", "What");
4475 ui_out_table_body (uiout);
4477 markers = target_static_tracepoint_markers_by_strid (NULL);
4478 make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
4481 VEC_iterate (static_tracepoint_marker_p,
4482 markers, i, marker);
4485 print_one_static_tracepoint_marker (i + 1, marker);
4486 release_static_tracepoint_marker (marker);
4489 do_cleanups (old_chain);
4492 /* The $_sdata convenience variable is a bit special. We don't know
4493 for sure type of the value until we actually have a chance to fetch
4494 the data --- the size of the object depends on what has been
4495 collected. We solve this by making $_sdata be an internalvar that
4496 creates a new value on access. */
4498 /* Return a new value with the correct type for the sdata object of
4499 the current trace frame. Return a void value if there's no object
4502 static struct value *
4503 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var)
4508 /* We need to read the whole object before we know its size. */
4509 size = target_read_alloc (¤t_target,
4510 TARGET_OBJECT_STATIC_TRACE_DATA,
4517 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
4519 v = allocate_value (type);
4520 memcpy (value_contents_raw (v), buf, size);
4525 return allocate_value (builtin_type (gdbarch)->builtin_void);
4528 #if !defined(HAVE_LIBEXPAT)
4530 struct traceframe_info *
4531 parse_traceframe_info (const char *tframe_info)
4533 static int have_warned;
4538 warning (_("Can not parse XML trace frame info; XML support "
4539 "was disabled at compile time"));
4545 #else /* HAVE_LIBEXPAT */
4547 #include "xml-support.h"
4549 /* Handle the start of a <memory> element. */
4552 traceframe_info_start_memory (struct gdb_xml_parser *parser,
4553 const struct gdb_xml_element *element,
4554 void *user_data, VEC(gdb_xml_value_s) *attributes)
4556 struct traceframe_info *info = user_data;
4557 struct mem_range *r = VEC_safe_push (mem_range_s, info->memory, NULL);
4558 ULONGEST *start_p, *length_p;
4560 start_p = xml_find_attribute (attributes, "start")->value;
4561 length_p = xml_find_attribute (attributes, "length")->value;
4563 r->start = *start_p;
4564 r->length = *length_p;
4567 /* Discard the constructed trace frame info (if an error occurs). */
4570 free_result (void *p)
4572 struct traceframe_info *result = p;
4574 free_traceframe_info (result);
4577 /* The allowed elements and attributes for an XML memory map. */
4579 static const struct gdb_xml_attribute memory_attributes[] = {
4580 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4581 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4582 { NULL, GDB_XML_AF_NONE, NULL, NULL }
4585 static const struct gdb_xml_element traceframe_info_children[] = {
4586 { "memory", memory_attributes, NULL,
4587 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
4588 traceframe_info_start_memory, NULL },
4589 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4592 static const struct gdb_xml_element traceframe_info_elements[] = {
4593 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
4595 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4598 /* Parse a traceframe-info XML document. */
4600 struct traceframe_info *
4601 parse_traceframe_info (const char *tframe_info)
4603 struct traceframe_info *result;
4604 struct cleanup *back_to;
4606 result = XCNEW (struct traceframe_info);
4607 back_to = make_cleanup (free_result, result);
4609 if (gdb_xml_parse_quick (_("trace frame info"),
4610 "traceframe-info.dtd", traceframe_info_elements,
4611 tframe_info, result) == 0)
4613 /* Parsed successfully, keep the result. */
4614 discard_cleanups (back_to);
4619 do_cleanups (back_to);
4623 #endif /* HAVE_LIBEXPAT */
4625 /* Returns the traceframe_info object for the current traceframe.
4626 This is where we avoid re-fetching the object from the target if we
4627 already have it cached. */
4629 struct traceframe_info *
4630 get_traceframe_info (void)
4632 if (traceframe_info == NULL)
4633 traceframe_info = target_traceframe_info ();
4635 return traceframe_info;
4638 /* Return in RESULT, the set of collected memory in the current
4639 traceframe, found within the LEN bytes range starting at MEMADDR.
4640 Returns true if the target supports the query, otherwise returns
4644 traceframe_available_memory (VEC(mem_range_s) **result,
4645 CORE_ADDR memaddr, ULONGEST len)
4647 struct traceframe_info *info = get_traceframe_info ();
4651 struct mem_range *r;
4656 for (i = 0; VEC_iterate (mem_range_s, info->memory, i, r); i++)
4657 if (mem_ranges_overlap (r->start, r->length, memaddr, len))
4659 ULONGEST lo1, hi1, lo2, hi2;
4660 struct mem_range *nr;
4663 hi1 = memaddr + len;
4666 hi2 = r->start + r->length;
4668 nr = VEC_safe_push (mem_range_s, *result, NULL);
4670 nr->start = max (lo1, lo2);
4671 nr->length = min (hi1, hi2) - nr->start;
4674 normalize_mem_ranges (*result);
4681 /* module initialization */
4683 _initialize_tracepoint (void)
4685 struct cmd_list_element *c;
4687 /* Explicitly create without lookup, since that tries to create a
4688 value with a void typed value, and when we get here, gdbarch
4689 isn't initialized yet. At this point, we're quite sure there
4690 isn't another convenience variable of the same name. */
4691 create_internalvar_type_lazy ("_sdata", sdata_make_value);
4693 traceframe_number = -1;
4694 tracepoint_number = -1;
4696 if (tracepoint_list.list == NULL)
4698 tracepoint_list.listsize = 128;
4699 tracepoint_list.list = xmalloc
4700 (tracepoint_list.listsize * sizeof (struct memrange));
4702 if (tracepoint_list.aexpr_list == NULL)
4704 tracepoint_list.aexpr_listsize = 128;
4705 tracepoint_list.aexpr_list = xmalloc
4706 (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
4709 if (stepping_list.list == NULL)
4711 stepping_list.listsize = 128;
4712 stepping_list.list = xmalloc
4713 (stepping_list.listsize * sizeof (struct memrange));
4716 if (stepping_list.aexpr_list == NULL)
4718 stepping_list.aexpr_listsize = 128;
4719 stepping_list.aexpr_list = xmalloc
4720 (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
4723 add_info ("scope", scope_info,
4724 _("List the variables local to a scope"));
4726 add_cmd ("tracepoints", class_trace, NULL,
4727 _("Tracing of program execution without stopping the program."),
4730 add_com ("tdump", class_trace, trace_dump_command,
4731 _("Print everything collected at the current tracepoint."));
4733 add_com ("tsave", class_trace, trace_save_command, _("\
4734 Save the trace data to a file.\n\
4735 Use the '-r' option to direct the target to save directly to the file,\n\
4736 using its own filesystem."));
4738 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
4739 Define a trace state variable.\n\
4740 Argument is a $-prefixed name, optionally followed\n\
4741 by '=' and an expression that sets the initial value\n\
4742 at the start of tracing."));
4743 set_cmd_completer (c, expression_completer);
4745 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
4746 Delete one or more trace state variables.\n\
4747 Arguments are the names of the variables to delete.\n\
4748 If no arguments are supplied, delete all variables."), &deletelist);
4749 /* FIXME add a trace variable completer. */
4751 add_info ("tvariables", tvariables_info, _("\
4752 Status of trace state variables and their values.\n\
4755 add_info ("static-tracepoint-markers",
4756 info_static_tracepoint_markers_command, _("\
4757 List target static tracepoints markers.\n\
4760 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
4761 Select a trace frame;\n\
4762 No argument means forward by one frame; '-' means backward by one frame."),
4763 &tfindlist, "tfind ", 1, &cmdlist);
4765 add_cmd ("outside", class_trace, trace_find_outside_command, _("\
4766 Select a trace frame whose PC is outside the given range (exclusive).\n\
4767 Usage: tfind outside addr1, addr2"),
4770 add_cmd ("range", class_trace, trace_find_range_command, _("\
4771 Select a trace frame whose PC is in the given range (inclusive).\n\
4772 Usage: tfind range addr1,addr2"),
4775 add_cmd ("line", class_trace, trace_find_line_command, _("\
4776 Select a trace frame by source line.\n\
4777 Argument can be a line number (with optional source file),\n\
4778 a function name, or '*' followed by an address.\n\
4779 Default argument is 'the next source line that was traced'."),
4782 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
4783 Select a trace frame by tracepoint number.\n\
4784 Default is the tracepoint for the current trace frame."),
4787 add_cmd ("pc", class_trace, trace_find_pc_command, _("\
4788 Select a trace frame by PC.\n\
4789 Default is the current PC, or the PC of the current trace frame."),
4792 add_cmd ("end", class_trace, trace_find_end_command, _("\
4793 Synonym for 'none'.\n\
4794 De-select any trace frame and resume 'live' debugging."),
4797 add_cmd ("none", class_trace, trace_find_none_command,
4798 _("De-select any trace frame and resume 'live' debugging."),
4801 add_cmd ("start", class_trace, trace_find_start_command,
4802 _("Select the first trace frame in the trace buffer."),
4805 add_com ("tstatus", class_trace, trace_status_command,
4806 _("Display the status of the current trace data collection."));
4808 add_com ("tstop", class_trace, trace_stop_command,
4809 _("Stop trace data collection."));
4811 add_com ("tstart", class_trace, trace_start_command,
4812 _("Start trace data collection."));
4814 add_com ("end", class_trace, end_actions_pseudocommand, _("\
4815 Ends a list of commands or actions.\n\
4816 Several GDB commands allow you to enter a list of commands or actions.\n\
4817 Entering \"end\" on a line by itself is the normal way to terminate\n\
4819 Note: the \"end\" command cannot be used at the gdb prompt."));
4821 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
4822 Specify single-stepping behavior at a tracepoint.\n\
4823 Argument is number of instructions to trace in single-step mode\n\
4824 following the tracepoint. This command is normally followed by\n\
4825 one or more \"collect\" commands, to specify what to collect\n\
4826 while single-stepping.\n\n\
4827 Note: this command can only be used in a tracepoint \"actions\" list."));
4829 add_com_alias ("ws", "while-stepping", class_alias, 0);
4830 add_com_alias ("stepping", "while-stepping", class_alias, 0);
4832 add_com ("collect", class_trace, collect_pseudocommand, _("\
4833 Specify one or more data items to be collected at a tracepoint.\n\
4834 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4835 collect all data (variables, registers) referenced by that expression.\n\
4836 Also accepts the following special arguments:\n\
4837 $regs -- all registers.\n\
4838 $args -- all function arguments.\n\
4839 $locals -- all variables local to the block/function scope.\n\
4840 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4841 Note: this command can only be used in a tracepoint \"actions\" list."));
4843 add_com ("teval", class_trace, teval_pseudocommand, _("\
4844 Specify one or more expressions to be evaluated at a tracepoint.\n\
4845 Accepts a comma-separated list of (one or more) expressions.\n\
4846 The result of each evaluation will be discarded.\n\
4847 Note: this command can only be used in a tracepoint \"actions\" list."));
4849 add_com ("actions", class_trace, trace_actions_command, _("\
4850 Specify the actions to be taken at a tracepoint.\n\
4851 Tracepoint actions may include collecting of specified data,\n\
4852 single-stepping, or enabling/disabling other tracepoints,\n\
4853 depending on target's capabilities."));
4855 default_collect = xstrdup ("");
4856 add_setshow_string_cmd ("default-collect", class_trace,
4857 &default_collect, _("\
4858 Set the list of expressions to collect by default"), _("\
4859 Show the list of expressions to collect by default"), NULL,
4861 &setlist, &showlist);
4863 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
4864 &disconnected_tracing, _("\
4865 Set whether tracing continues after GDB disconnects."), _("\
4866 Show whether tracing continues after GDB disconnects."), _("\
4867 Use this to continue a tracing run even if GDB disconnects\n\
4868 or detaches from the target. You can reconnect later and look at\n\
4869 trace data collected in the meantime."),
4870 set_disconnected_tracing,
4875 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
4876 &circular_trace_buffer, _("\
4877 Set target's use of circular trace buffer."), _("\
4878 Show target's use of circular trace buffer."), _("\
4879 Use this to make the trace buffer into a circular buffer,\n\
4880 which will discard traceframes (oldest first) instead of filling\n\
4881 up and stopping the trace run."),
4882 set_circular_trace_buffer,
4889 add_target (&tfile_ops);