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 if (memranges->list[b].end > memranges->list[a].end)
850 memranges->list[a].end = memranges->list[b].end;
851 continue; /* next b, same a */
855 memcpy (&memranges->list[a], &memranges->list[b],
856 sizeof (struct memrange));
858 memranges->next_memrange = a + 1;
862 /* Add a register to a collection list. */
864 add_register (struct collection_list *collection, unsigned int regno)
867 printf_filtered ("collect register %d\n", regno);
868 if (regno >= (8 * sizeof (collection->regs_mask)))
869 error (_("Internal: register number %d too large for tracepoint"),
871 collection->regs_mask[regno / 8] |= 1 << (regno % 8);
874 /* Add a memrange to a collection list. */
876 add_memrange (struct collection_list *memranges,
877 int type, bfd_signed_vma base,
882 printf_filtered ("(%d,", type);
884 printf_filtered (",%ld)\n", len);
887 /* type: memrange_absolute == memory, other n == basereg */
888 memranges->list[memranges->next_memrange].type = type;
889 /* base: addr if memory, offset if reg relative. */
890 memranges->list[memranges->next_memrange].start = base;
891 /* len: we actually save end (base + len) for convenience */
892 memranges->list[memranges->next_memrange].end = base + len;
893 memranges->next_memrange++;
894 if (memranges->next_memrange >= memranges->listsize)
896 memranges->listsize *= 2;
897 memranges->list = xrealloc (memranges->list,
898 memranges->listsize);
901 if (type != memrange_absolute) /* Better collect the base register! */
902 add_register (memranges, type);
905 /* Add a symbol to a collection list. */
907 collect_symbol (struct collection_list *collect,
909 struct gdbarch *gdbarch,
910 long frame_regno, long frame_offset,
915 bfd_signed_vma offset;
916 int treat_as_expr = 0;
918 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
919 switch (SYMBOL_CLASS (sym))
922 printf_filtered ("%s: don't know symbol class %d\n",
923 SYMBOL_PRINT_NAME (sym),
927 printf_filtered ("constant %s (value %ld) will not be collected.\n",
928 SYMBOL_PRINT_NAME (sym), SYMBOL_VALUE (sym));
931 offset = SYMBOL_VALUE_ADDRESS (sym);
936 sprintf_vma (tmp, offset);
937 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
938 SYMBOL_PRINT_NAME (sym), len,
941 /* A struct may be a C++ class with static fields, go to general
942 expression handling. */
943 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
946 add_memrange (collect, memrange_absolute, offset, len);
949 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
951 printf_filtered ("LOC_REG[parm] %s: ",
952 SYMBOL_PRINT_NAME (sym));
953 add_register (collect, reg);
954 /* Check for doubles stored in two registers. */
955 /* FIXME: how about larger types stored in 3 or more regs? */
956 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
957 len > register_size (gdbarch, reg))
958 add_register (collect, reg + 1);
961 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
962 printf_filtered (" (will not collect %s)\n",
963 SYMBOL_PRINT_NAME (sym));
967 offset = frame_offset + SYMBOL_VALUE (sym);
970 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
971 SYMBOL_PRINT_NAME (sym), len);
973 printf_filtered (" from frame ptr reg %d\n", reg);
975 add_memrange (collect, reg, offset, len);
977 case LOC_REGPARM_ADDR:
978 reg = SYMBOL_VALUE (sym);
982 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
983 SYMBOL_PRINT_NAME (sym), len);
985 printf_filtered (" from reg %d\n", reg);
987 add_memrange (collect, reg, offset, len);
991 offset = frame_offset + SYMBOL_VALUE (sym);
994 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
995 SYMBOL_PRINT_NAME (sym), len);
997 printf_filtered (" from frame ptr reg %d\n", reg);
999 add_memrange (collect, reg, offset, len);
1002 case LOC_UNRESOLVED:
1006 case LOC_OPTIMIZED_OUT:
1007 printf_filtered ("%s has been optimized out of existence.\n",
1008 SYMBOL_PRINT_NAME (sym));
1016 /* Expressions are the most general case. */
1019 struct agent_expr *aexpr;
1020 struct cleanup *old_chain1 = NULL;
1022 aexpr = gen_trace_for_var (scope, gdbarch, sym);
1024 /* It can happen that the symbol is recorded as a computed
1025 location, but it's been optimized away and doesn't actually
1026 have a location expression. */
1029 printf_filtered ("%s has been optimized out of existence.\n",
1030 SYMBOL_PRINT_NAME (sym));
1034 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1038 report_agent_reqs_errors (aexpr);
1040 discard_cleanups (old_chain1);
1041 add_aexpr (collect, aexpr);
1043 /* Take care of the registers. */
1044 if (aexpr->reg_mask_len > 0)
1048 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1050 QUIT; /* Allow user to bail out with ^C. */
1051 if (aexpr->reg_mask[ndx1] != 0)
1053 /* Assume chars have 8 bits. */
1054 for (ndx2 = 0; ndx2 < 8; ndx2++)
1055 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1056 /* It's used -- record it. */
1057 add_register (collect, ndx1 * 8 + ndx2);
1064 /* Data to be passed around in the calls to the locals and args
1067 struct add_local_symbols_data
1069 struct collection_list *collect;
1070 struct gdbarch *gdbarch;
1077 /* The callback for the locals and args iterators. */
1080 do_collect_symbol (const char *print_name,
1084 struct add_local_symbols_data *p = cb_data;
1086 collect_symbol (p->collect, sym, p->gdbarch, p->frame_regno,
1087 p->frame_offset, p->pc);
1091 /* Add all locals (or args) symbols to collection list. */
1093 add_local_symbols (struct collection_list *collect,
1094 struct gdbarch *gdbarch, CORE_ADDR pc,
1095 long frame_regno, long frame_offset, int type)
1097 struct block *block;
1098 struct add_local_symbols_data cb_data;
1100 cb_data.collect = collect;
1101 cb_data.gdbarch = gdbarch;
1103 cb_data.frame_regno = frame_regno;
1104 cb_data.frame_offset = frame_offset;
1109 block = block_for_pc (pc);
1112 warning (_("Can't collect locals; "
1113 "no symbol table info available.\n"));
1117 iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1118 if (cb_data.count == 0)
1119 warning (_("No locals found in scope."));
1123 pc = get_pc_function_start (pc);
1124 block = block_for_pc (pc);
1127 warning (_("Can't collect args; no symbol table info available.\n"));
1131 iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1132 if (cb_data.count == 0)
1133 warning (_("No args found in scope."));
1138 add_static_trace_data (struct collection_list *collection)
1141 printf_filtered ("collect static trace data\n");
1142 collection->strace_data = 1;
1145 /* worker function */
1147 clear_collection_list (struct collection_list *list)
1151 list->next_memrange = 0;
1152 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1154 free_agent_expr (list->aexpr_list[ndx]);
1155 list->aexpr_list[ndx] = NULL;
1157 list->next_aexpr_elt = 0;
1158 memset (list->regs_mask, 0, sizeof (list->regs_mask));
1159 list->strace_data = 0;
1162 /* Reduce a collection list to string form (for gdb protocol). */
1164 stringify_collection_list (struct collection_list *list, char *string)
1166 char temp_buf[2048];
1170 char *(*str_list)[];
1174 count = 1 + 1 + list->next_memrange + list->next_aexpr_elt + 1;
1175 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1177 if (list->strace_data)
1180 printf_filtered ("\nCollecting static trace data\n");
1183 (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
1187 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1188 if (list->regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */
1190 if (list->regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
1193 printf_filtered ("\nCollecting registers (mask): 0x");
1198 QUIT; /* Allow user to bail out with ^C. */
1200 printf_filtered ("%02X", list->regs_mask[i]);
1201 sprintf (end, "%02X", list->regs_mask[i]);
1204 (*str_list)[ndx] = xstrdup (temp_buf);
1208 printf_filtered ("\n");
1209 if (list->next_memrange > 0 && info_verbose)
1210 printf_filtered ("Collecting memranges: \n");
1211 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1213 QUIT; /* Allow user to bail out with ^C. */
1214 sprintf_vma (tmp2, list->list[i].start);
1217 printf_filtered ("(%d, %s, %ld)\n",
1220 (long) (list->list[i].end - list->list[i].start));
1222 if (count + 27 > MAX_AGENT_EXPR_LEN)
1224 (*str_list)[ndx] = savestring (temp_buf, count);
1231 bfd_signed_vma length = list->list[i].end - list->list[i].start;
1233 /* The "%X" conversion specifier expects an unsigned argument,
1234 so passing -1 (memrange_absolute) to it directly gives you
1235 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1237 if (list->list[i].type == memrange_absolute)
1238 sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
1240 sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
1243 count += strlen (end);
1244 end = temp_buf + count;
1247 for (i = 0; i < list->next_aexpr_elt; i++)
1249 QUIT; /* Allow user to bail out with ^C. */
1250 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1252 (*str_list)[ndx] = savestring (temp_buf, count);
1257 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1258 end += 10; /* 'X' + 8 hex digits + ',' */
1261 end = mem2hex (list->aexpr_list[i]->buf,
1262 end, list->aexpr_list[i]->len);
1263 count += 2 * list->aexpr_list[i]->len;
1268 (*str_list)[ndx] = savestring (temp_buf, count);
1273 (*str_list)[ndx] = NULL;
1286 encode_actions_1 (struct command_line *action,
1287 struct breakpoint *t,
1288 struct bp_location *tloc,
1290 LONGEST frame_offset,
1291 struct collection_list *collect,
1292 struct collection_list *stepping_list)
1295 struct expression *exp = NULL;
1297 struct value *tempval;
1298 struct cmd_list_element *cmd;
1299 struct agent_expr *aexpr;
1301 for (; action; action = action->next)
1303 QUIT; /* Allow user to bail out with ^C. */
1304 action_exp = action->line;
1305 while (isspace ((int) *action_exp))
1308 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1310 error (_("Bad action list item: %s"), action_exp);
1312 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1315 { /* Repeat over a comma-separated list. */
1316 QUIT; /* Allow user to bail out with ^C. */
1317 while (isspace ((int) *action_exp))
1320 if (0 == strncasecmp ("$reg", action_exp, 4))
1322 for (i = 0; i < gdbarch_num_regs (t->gdbarch); i++)
1323 add_register (collect, i);
1324 action_exp = strchr (action_exp, ','); /* more? */
1326 else if (0 == strncasecmp ("$arg", action_exp, 4))
1328 add_local_symbols (collect,
1334 action_exp = strchr (action_exp, ','); /* more? */
1336 else if (0 == strncasecmp ("$loc", action_exp, 4))
1338 add_local_symbols (collect,
1344 action_exp = strchr (action_exp, ','); /* more? */
1346 else if (0 == strncasecmp ("$_sdata", action_exp, 7))
1348 add_static_trace_data (collect);
1349 action_exp = strchr (action_exp, ','); /* more? */
1353 unsigned long addr, len;
1354 struct cleanup *old_chain = NULL;
1355 struct cleanup *old_chain1 = NULL;
1357 exp = parse_exp_1 (&action_exp,
1358 block_for_pc (tloc->address), 1);
1359 old_chain = make_cleanup (free_current_contents, &exp);
1361 switch (exp->elts[0].opcode)
1365 const char *name = &exp->elts[2].string;
1367 i = user_reg_map_name_to_regnum (t->gdbarch,
1368 name, strlen (name));
1370 internal_error (__FILE__, __LINE__,
1371 _("Register $%s not available"),
1374 printf_filtered ("OP_REGISTER: ");
1375 add_register (collect, i);
1380 /* Safe because we know it's a simple expression. */
1381 tempval = evaluate_expression (exp);
1382 addr = value_address (tempval);
1383 len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
1384 add_memrange (collect, memrange_absolute, addr, len);
1388 collect_symbol (collect,
1389 exp->elts[2].symbol,
1396 default: /* Full-fledged expression. */
1397 aexpr = gen_trace_for_expr (tloc->address, exp);
1399 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1403 report_agent_reqs_errors (aexpr);
1405 discard_cleanups (old_chain1);
1406 add_aexpr (collect, aexpr);
1408 /* Take care of the registers. */
1409 if (aexpr->reg_mask_len > 0)
1414 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1416 QUIT; /* Allow user to bail out with ^C. */
1417 if (aexpr->reg_mask[ndx1] != 0)
1419 /* Assume chars have 8 bits. */
1420 for (ndx2 = 0; ndx2 < 8; ndx2++)
1421 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1422 /* It's used -- record it. */
1423 add_register (collect,
1430 do_cleanups (old_chain);
1433 while (action_exp && *action_exp++ == ',');
1435 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1438 { /* Repeat over a comma-separated list. */
1439 QUIT; /* Allow user to bail out with ^C. */
1440 while (isspace ((int) *action_exp))
1444 struct cleanup *old_chain = NULL;
1445 struct cleanup *old_chain1 = NULL;
1447 exp = parse_exp_1 (&action_exp,
1448 block_for_pc (tloc->address), 1);
1449 old_chain = make_cleanup (free_current_contents, &exp);
1451 aexpr = gen_eval_for_expr (tloc->address, exp);
1452 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1455 report_agent_reqs_errors (aexpr);
1457 discard_cleanups (old_chain1);
1458 /* Even though we're not officially collecting, add
1459 to the collect list anyway. */
1460 add_aexpr (collect, aexpr);
1462 do_cleanups (old_chain);
1465 while (action_exp && *action_exp++ == ',');
1467 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1469 /* We check against nested while-stepping when setting
1470 breakpoint action, so no way to run into nested
1472 gdb_assert (stepping_list);
1474 encode_actions_1 (action->body_list[0], t, tloc, frame_reg,
1475 frame_offset, stepping_list, NULL);
1478 error (_("Invalid tracepoint command '%s'"), action->line);
1482 /* Render all actions into gdb protocol. */
1484 encode_actions (struct breakpoint *t, struct bp_location *tloc,
1485 char ***tdp_actions, char ***stepping_actions)
1487 static char tdp_buff[2048], step_buff[2048];
1488 char *default_collect_line = NULL;
1489 struct command_line *actions;
1490 struct command_line *default_collect_action = NULL;
1492 LONGEST frame_offset;
1493 struct cleanup *back_to;
1495 back_to = make_cleanup (null_cleanup, NULL);
1497 clear_collection_list (&tracepoint_list);
1498 clear_collection_list (&stepping_list);
1500 *tdp_actions = NULL;
1501 *stepping_actions = NULL;
1503 gdbarch_virtual_frame_pointer (t->gdbarch,
1504 t->loc->address, &frame_reg, &frame_offset);
1506 actions = breakpoint_commands (t);
1508 /* If there are default expressions to collect, make up a collect
1509 action and prepend to the action list to encode. Note that since
1510 validation is per-tracepoint (local var "xyz" might be valid for
1511 one tracepoint and not another, etc), we make up the action on
1512 the fly, and don't cache it. */
1513 if (*default_collect)
1517 default_collect_line = xstrprintf ("collect %s", default_collect);
1518 make_cleanup (xfree, default_collect_line);
1520 line = default_collect_line;
1521 validate_actionline (&line, t);
1523 default_collect_action = xmalloc (sizeof (struct command_line));
1524 make_cleanup (xfree, default_collect_action);
1525 default_collect_action->next = actions;
1526 default_collect_action->line = line;
1527 actions = default_collect_action;
1529 encode_actions_1 (actions, t, tloc, frame_reg, frame_offset,
1530 &tracepoint_list, &stepping_list);
1532 memrange_sortmerge (&tracepoint_list);
1533 memrange_sortmerge (&stepping_list);
1535 *tdp_actions = stringify_collection_list (&tracepoint_list,
1537 *stepping_actions = stringify_collection_list (&stepping_list,
1540 do_cleanups (back_to);
1544 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1546 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1548 collect->aexpr_list =
1549 xrealloc (collect->aexpr_list,
1550 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1551 collect->aexpr_listsize *= 2;
1553 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1554 collect->next_aexpr_elt++;
1559 start_tracing (void)
1561 VEC(breakpoint_p) *tp_vec = NULL;
1563 struct breakpoint *t;
1564 struct trace_state_variable *tsv;
1565 int any_enabled = 0, num_to_download = 0;
1567 tp_vec = all_tracepoints ();
1569 /* No point in tracing without any tracepoints... */
1570 if (VEC_length (breakpoint_p, tp_vec) == 0)
1572 VEC_free (breakpoint_p, tp_vec);
1573 error (_("No tracepoints defined, not starting trace"));
1576 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1578 if (t->enable_state == bp_enabled)
1581 if ((t->type == bp_fast_tracepoint
1582 ? may_insert_fast_tracepoints
1583 : may_insert_tracepoints))
1586 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1587 (t->type == bp_fast_tracepoint ? "fast " : ""), t->number);
1590 /* No point in tracing with only disabled tracepoints. */
1593 VEC_free (breakpoint_p, tp_vec);
1594 error (_("No tracepoints enabled, not starting trace"));
1597 if (num_to_download <= 0)
1599 VEC_free (breakpoint_p, tp_vec);
1600 error (_("No tracepoints that may be downloaded, not starting trace"));
1603 target_trace_init ();
1605 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1607 if ((t->type == bp_fast_tracepoint
1608 ? !may_insert_fast_tracepoints
1609 : !may_insert_tracepoints))
1612 t->number_on_target = 0;
1613 target_download_tracepoint (t);
1614 t->number_on_target = t->number;
1616 VEC_free (breakpoint_p, tp_vec);
1618 /* Send down all the trace state variables too. */
1619 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1621 target_download_trace_state_variable (tsv);
1624 /* Tell target to treat text-like sections as transparent. */
1625 target_trace_set_readonly_regions ();
1626 /* Set some mode flags. */
1627 target_set_disconnected_tracing (disconnected_tracing);
1628 target_set_circular_trace_buffer (circular_trace_buffer);
1630 /* Now insert traps and begin collecting data. */
1631 target_trace_start ();
1633 /* Reset our local state. */
1634 set_traceframe_num (-1);
1635 set_tracepoint_num (-1);
1636 set_traceframe_context (NULL);
1637 current_trace_status()->running = 1;
1638 clear_traceframe_info ();
1643 Tell target to clear any previous trace experiment.
1644 Walk the list of tracepoints, and send them (and their actions)
1645 to the target. If no errors,
1646 Tell target to start a new trace experiment. */
1649 trace_start_command (char *args, int from_tty)
1651 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1653 if (current_trace_status ()->running)
1656 && !query (_("A trace is running already. Start a new run? ")))
1657 error (_("New trace run not started."));
1665 trace_stop_command (char *args, int from_tty)
1667 if (!current_trace_status ()->running)
1668 error (_("Trace is not running."));
1676 target_trace_stop ();
1677 /* Should change in response to reply? */
1678 current_trace_status ()->running = 0;
1681 /* tstatus command */
1683 trace_status_command (char *args, int from_tty)
1685 struct trace_status *ts = current_trace_status ();
1688 status = target_get_trace_status (ts);
1693 printf_filtered (_("Using a trace file.\n"));
1696 printf_filtered (_("Trace can not be run on this target.\n"));
1701 if (!ts->running_known)
1703 printf_filtered (_("Run/stop status is unknown.\n"));
1705 else if (ts->running)
1707 printf_filtered (_("Trace is running on the target.\n"));
1711 switch (ts->stop_reason)
1713 case trace_never_run:
1714 printf_filtered (_("No trace has been run on the target.\n"));
1717 printf_filtered (_("Trace stopped by a tstop command.\n"));
1719 case trace_buffer_full:
1720 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1722 case trace_disconnected:
1723 printf_filtered (_("Trace stopped because of disconnection.\n"));
1725 case tracepoint_passcount:
1726 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1727 ts->stopping_tracepoint);
1729 case tracepoint_error:
1730 if (ts->stopping_tracepoint)
1731 printf_filtered (_("Trace stopped by an "
1732 "error (%s, tracepoint %d).\n"),
1733 ts->error_desc, ts->stopping_tracepoint);
1735 printf_filtered (_("Trace stopped by an error (%s).\n"),
1738 case trace_stop_reason_unknown:
1739 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1742 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1748 if (ts->traceframes_created >= 0
1749 && ts->traceframe_count != ts->traceframes_created)
1751 printf_filtered (_("Buffer contains %d trace "
1752 "frames (of %d created total).\n"),
1753 ts->traceframe_count, ts->traceframes_created);
1755 else if (ts->traceframe_count >= 0)
1757 printf_filtered (_("Collected %d trace frames.\n"),
1758 ts->traceframe_count);
1761 if (ts->buffer_free >= 0)
1763 if (ts->buffer_size >= 0)
1765 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1766 ts->buffer_free, ts->buffer_size);
1767 if (ts->buffer_size > 0)
1768 printf_filtered (_(" (%d%% full)"),
1769 ((int) ((((long long) (ts->buffer_size
1770 - ts->buffer_free)) * 100)
1771 / ts->buffer_size)));
1772 printf_filtered (_(".\n"));
1775 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1779 if (ts->disconnected_tracing)
1780 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1782 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1784 if (ts->circular_buffer)
1785 printf_filtered (_("Trace buffer is circular.\n"));
1787 /* Now report on what we're doing with tfind. */
1788 if (traceframe_number >= 0)
1789 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1790 traceframe_number, tracepoint_number);
1792 printf_filtered (_("Not looking at any trace frame.\n"));
1795 /* Report the trace status to uiout, in a way suitable for MI, and not
1796 suitable for CLI. If ON_STOP is true, suppress a few fields that
1797 are not meaningful in the -trace-stop response.
1799 The implementation is essentially parallel to trace_status_command, but
1800 merging them will result in unreadable code. */
1802 trace_status_mi (int on_stop)
1804 struct trace_status *ts = current_trace_status ();
1807 status = target_get_trace_status (ts);
1809 if (status == -1 && !ts->from_file)
1811 ui_out_field_string (uiout, "supported", "0");
1816 ui_out_field_string (uiout, "supported", "file");
1818 ui_out_field_string (uiout, "supported", "1");
1820 gdb_assert (ts->running_known);
1824 ui_out_field_string (uiout, "running", "1");
1826 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1827 Given that the frontend gets the status either on -trace-stop, or from
1828 -trace-status after re-connection, it does not seem like this
1829 information is necessary for anything. It is not necessary for either
1830 figuring the vital state of the target nor for navigation of trace
1831 frames. If the frontend wants to show the current state is some
1832 configure dialog, it can request the value when such dialog is
1833 invoked by the user. */
1837 char *stop_reason = NULL;
1838 int stopping_tracepoint = -1;
1841 ui_out_field_string (uiout, "running", "0");
1843 if (ts->stop_reason != trace_stop_reason_unknown)
1845 switch (ts->stop_reason)
1848 stop_reason = "request";
1850 case trace_buffer_full:
1851 stop_reason = "overflow";
1853 case trace_disconnected:
1854 stop_reason = "disconnection";
1856 case tracepoint_passcount:
1857 stop_reason = "passcount";
1858 stopping_tracepoint = ts->stopping_tracepoint;
1860 case tracepoint_error:
1861 stop_reason = "error";
1862 stopping_tracepoint = ts->stopping_tracepoint;
1868 ui_out_field_string (uiout, "stop-reason", stop_reason);
1869 if (stopping_tracepoint != -1)
1870 ui_out_field_int (uiout, "stopping-tracepoint",
1871 stopping_tracepoint);
1872 if (ts->stop_reason == tracepoint_error)
1873 ui_out_field_string (uiout, "error-description",
1879 if (ts->traceframe_count != -1)
1880 ui_out_field_int (uiout, "frames", ts->traceframe_count);
1881 if (ts->traceframes_created != -1)
1882 ui_out_field_int (uiout, "frames-created", ts->traceframes_created);
1883 if (ts->buffer_size != -1)
1884 ui_out_field_int (uiout, "buffer-size", ts->buffer_size);
1885 if (ts->buffer_free != -1)
1886 ui_out_field_int (uiout, "buffer-free", ts->buffer_free);
1888 ui_out_field_int (uiout, "disconnected", ts->disconnected_tracing);
1889 ui_out_field_int (uiout, "circular", ts->circular_buffer);
1892 /* This function handles the details of what to do about an ongoing
1893 tracing run if the user has asked to detach or otherwise disconnect
1896 disconnect_tracing (int from_tty)
1898 /* It can happen that the target that was tracing went away on its
1899 own, and we didn't notice. Get a status update, and if the
1900 current target doesn't even do tracing, then assume it's not
1902 if (target_get_trace_status (current_trace_status ()) < 0)
1903 current_trace_status ()->running = 0;
1905 /* If running interactively, give the user the option to cancel and
1906 then decide what to do differently with the run. Scripts are
1907 just going to disconnect and let the target deal with it,
1908 according to how it's been instructed previously via
1909 disconnected-tracing. */
1910 if (current_trace_status ()->running && from_tty)
1912 if (current_trace_status ()->disconnected_tracing)
1914 if (!query (_("Trace is running and will "
1915 "continue after detach; detach anyway? ")))
1916 error (_("Not confirmed."));
1920 if (!query (_("Trace is running but will "
1921 "stop on detach; detach anyway? ")))
1922 error (_("Not confirmed."));
1926 /* Also we want to be out of tfind mode, otherwise things can get
1927 confusing upon reconnection. Just use these calls instead of
1928 full tfind_1 behavior because we're in the middle of detaching,
1929 and there's no point to updating current stack frame etc. */
1930 set_current_traceframe (-1);
1931 set_traceframe_context (NULL);
1934 /* Worker function for the various flavors of the tfind command. */
1936 tfind_1 (enum trace_find_type type, int num,
1937 ULONGEST addr1, ULONGEST addr2,
1940 int target_frameno = -1, target_tracept = -1;
1941 struct frame_id old_frame_id = null_frame_id;
1942 struct breakpoint *tp;
1944 /* Only try to get the current stack frame if we have a chance of
1945 succeeding. In particular, if we're trying to get a first trace
1946 frame while all threads are running, it's not going to succeed,
1947 so leave it with a default value and let the frame comparison
1948 below (correctly) decide to print out the source location of the
1950 if (!(type == tfind_number && num == -1)
1951 && (has_stack_frames () || traceframe_number >= 0))
1952 old_frame_id = get_frame_id (get_current_frame ());
1954 target_frameno = target_trace_find (type, num, addr1, addr2,
1957 if (type == tfind_number
1959 && target_frameno == -1)
1961 /* We told the target to get out of tfind mode, and it did. */
1963 else if (target_frameno == -1)
1965 /* A request for a non-existent trace frame has failed.
1966 Our response will be different, depending on FROM_TTY:
1968 If FROM_TTY is true, meaning that this command was
1969 typed interactively by the user, then give an error
1970 and DO NOT change the state of traceframe_number etc.
1972 However if FROM_TTY is false, meaning that we're either
1973 in a script, a loop, or a user-defined command, then
1974 DON'T give an error, but DO change the state of
1975 traceframe_number etc. to invalid.
1977 The rationalle is that if you typed the command, you
1978 might just have committed a typo or something, and you'd
1979 like to NOT lose your current debugging state. However
1980 if you're in a user-defined command or especially in a
1981 loop, then you need a way to detect that the command
1982 failed WITHOUT aborting. This allows you to write
1983 scripts that search thru the trace buffer until the end,
1984 and then continue on to do something else. */
1987 error (_("Target failed to find requested trace frame."));
1991 printf_filtered ("End of trace buffer.\n");
1992 #if 0 /* dubious now? */
1993 /* The following will not recurse, since it's
1995 trace_find_command ("-1", from_tty);
2000 tp = get_tracepoint_by_number_on_target (target_tracept);
2002 reinit_frame_cache ();
2003 registers_changed ();
2004 target_dcache_invalidate ();
2005 set_traceframe_num (target_frameno);
2006 clear_traceframe_info ();
2007 set_tracepoint_num (tp ? tp->number : target_tracept);
2008 if (target_frameno == -1)
2009 set_traceframe_context (NULL);
2011 set_traceframe_context (get_current_frame ());
2013 if (traceframe_number >= 0)
2015 /* Use different branches for MI and CLI to make CLI messages
2017 if (ui_out_is_mi_like_p (uiout))
2019 ui_out_field_string (uiout, "found", "1");
2020 ui_out_field_int (uiout, "tracepoint", tracepoint_number);
2021 ui_out_field_int (uiout, "traceframe", traceframe_number);
2025 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2026 traceframe_number, tracepoint_number);
2031 if (ui_out_is_mi_like_p (uiout))
2032 ui_out_field_string (uiout, "found", "0");
2033 else if (type == tfind_number && num == -1)
2034 printf_unfiltered (_("No longer looking at any trace frame\n"));
2035 else /* This case may never occur, check. */
2036 printf_unfiltered (_("No trace frame found\n"));
2039 /* If we're in nonstop mode and getting out of looking at trace
2040 frames, there won't be any current frame to go back to and
2043 && (has_stack_frames () || traceframe_number >= 0))
2045 enum print_what print_what;
2047 /* NOTE: in imitation of the step command, try to determine
2048 whether we have made a transition from one function to
2049 another. If so, we'll print the "stack frame" (ie. the new
2050 function and it's arguments) -- otherwise we'll just show the
2053 if (frame_id_eq (old_frame_id,
2054 get_frame_id (get_current_frame ())))
2055 print_what = SRC_LINE;
2057 print_what = SRC_AND_LOC;
2059 print_stack_frame (get_selected_frame (NULL), 1, print_what);
2064 /* trace_find_command takes a trace frame number n,
2065 sends "QTFrame:<n>" to the target,
2066 and accepts a reply that may contain several optional pieces
2067 of information: a frame number, a tracepoint number, and an
2068 indication of whether this is a trap frame or a stepping frame.
2070 The minimal response is just "OK" (which indicates that the
2071 target does not give us a frame number or a tracepoint number).
2072 Instead of that, the target may send us a string containing
2074 F<hexnum> (gives the selected frame number)
2075 T<hexnum> (gives the selected tracepoint number)
2080 trace_find_command (char *args, int from_tty)
2081 { /* This should only be called with a numeric argument. */
2084 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2085 error (_("May not look at trace frames while trace is running."));
2087 if (args == 0 || *args == 0)
2088 { /* TFIND with no args means find NEXT trace frame. */
2089 if (traceframe_number == -1)
2090 frameno = 0; /* "next" is first one. */
2092 frameno = traceframe_number + 1;
2094 else if (0 == strcmp (args, "-"))
2096 if (traceframe_number == -1)
2097 error (_("not debugging trace buffer"));
2098 else if (from_tty && traceframe_number == 0)
2099 error (_("already at start of trace buffer"));
2101 frameno = traceframe_number - 1;
2103 /* A hack to work around eval's need for fp to have been collected. */
2104 else if (0 == strcmp (args, "-1"))
2107 frameno = parse_and_eval_long (args);
2110 error (_("invalid input (%d is less than zero)"), frameno);
2112 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2117 trace_find_end_command (char *args, int from_tty)
2119 trace_find_command ("-1", from_tty);
2124 trace_find_none_command (char *args, int from_tty)
2126 trace_find_command ("-1", from_tty);
2131 trace_find_start_command (char *args, int from_tty)
2133 trace_find_command ("0", from_tty);
2136 /* tfind pc command */
2138 trace_find_pc_command (char *args, int from_tty)
2142 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2143 error (_("May not look at trace frames while trace is running."));
2145 if (args == 0 || *args == 0)
2146 pc = regcache_read_pc (get_current_regcache ());
2148 pc = parse_and_eval_address (args);
2150 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2153 /* tfind tracepoint command */
2155 trace_find_tracepoint_command (char *args, int from_tty)
2158 struct breakpoint *tp;
2160 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2161 error (_("May not look at trace frames while trace is running."));
2163 if (args == 0 || *args == 0)
2165 if (tracepoint_number == -1)
2166 error (_("No current tracepoint -- please supply an argument."));
2168 tdp = tracepoint_number; /* Default is current TDP. */
2171 tdp = parse_and_eval_long (args);
2173 /* If we have the tracepoint on hand, use the number that the
2174 target knows about (which may be different if we disconnected
2175 and reconnected). */
2176 tp = get_tracepoint (tdp);
2178 tdp = tp->number_on_target;
2180 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2183 /* TFIND LINE command:
2185 This command will take a sourceline for argument, just like BREAK
2186 or TRACE (ie. anything that "decode_line_1" can handle).
2188 With no argument, this command will find the next trace frame
2189 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2192 trace_find_line_command (char *args, int from_tty)
2194 static CORE_ADDR start_pc, end_pc;
2195 struct symtabs_and_lines sals;
2196 struct symtab_and_line sal;
2197 struct cleanup *old_chain;
2199 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2200 error (_("May not look at trace frames while trace is running."));
2202 if (args == 0 || *args == 0)
2204 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2206 sals.sals = (struct symtab_and_line *)
2207 xmalloc (sizeof (struct symtab_and_line));
2212 sals = decode_line_spec (args, 1);
2216 old_chain = make_cleanup (xfree, sals.sals);
2217 if (sal.symtab == 0)
2218 error (_("No line number information available."));
2220 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2222 if (start_pc == end_pc)
2224 printf_filtered ("Line %d of \"%s\"",
2225 sal.line, sal.symtab->filename);
2227 printf_filtered (" is at address ");
2228 print_address (get_current_arch (), start_pc, gdb_stdout);
2230 printf_filtered (" but contains no code.\n");
2231 sal = find_pc_line (start_pc, 0);
2233 && find_line_pc_range (sal, &start_pc, &end_pc)
2234 && start_pc != end_pc)
2235 printf_filtered ("Attempting to find line %d instead.\n",
2238 error (_("Cannot find a good line."));
2242 /* Is there any case in which we get here, and have an address
2243 which the user would want to see? If we have debugging
2244 symbols and no line numbers? */
2245 error (_("Line number %d is out of range for \"%s\"."),
2246 sal.line, sal.symtab->filename);
2248 /* Find within range of stated line. */
2250 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2252 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2253 do_cleanups (old_chain);
2256 /* tfind range command */
2258 trace_find_range_command (char *args, int from_tty)
2260 static CORE_ADDR start, stop;
2263 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2264 error (_("May not look at trace frames while trace is running."));
2266 if (args == 0 || *args == 0)
2267 { /* XXX FIXME: what should default behavior be? */
2268 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2272 if (0 != (tmp = strchr (args, ',')))
2274 *tmp++ = '\0'; /* Terminate start address. */
2275 while (isspace ((int) *tmp))
2277 start = parse_and_eval_address (args);
2278 stop = parse_and_eval_address (tmp);
2281 { /* No explicit end address? */
2282 start = parse_and_eval_address (args);
2283 stop = start + 1; /* ??? */
2286 tfind_1 (tfind_range, 0, start, stop, from_tty);
2289 /* tfind outside command */
2291 trace_find_outside_command (char *args, int from_tty)
2293 CORE_ADDR start, stop;
2296 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2297 error (_("May not look at trace frames while trace is running."));
2299 if (args == 0 || *args == 0)
2300 { /* XXX FIXME: what should default behavior be? */
2301 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2305 if (0 != (tmp = strchr (args, ',')))
2307 *tmp++ = '\0'; /* Terminate start address. */
2308 while (isspace ((int) *tmp))
2310 start = parse_and_eval_address (args);
2311 stop = parse_and_eval_address (tmp);
2314 { /* No explicit end address? */
2315 start = parse_and_eval_address (args);
2316 stop = start + 1; /* ??? */
2319 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2322 /* info scope command: list the locals for a scope. */
2324 scope_info (char *args, int from_tty)
2326 struct symtabs_and_lines sals;
2328 struct minimal_symbol *msym;
2329 struct block *block;
2330 char **canonical, *symname, *save_args = args;
2331 struct dict_iterator iter;
2333 struct gdbarch *gdbarch;
2336 if (args == 0 || *args == 0)
2337 error (_("requires an argument (function, "
2338 "line or *addr) to define a scope"));
2340 sals = decode_line_1 (&args, 1, NULL, 0, &canonical, NULL);
2341 if (sals.nelts == 0)
2342 return; /* Presumably decode_line_1 has already warned. */
2344 /* Resolve line numbers to PC. */
2345 resolve_sal_pc (&sals.sals[0]);
2346 block = block_for_pc (sals.sals[0].pc);
2350 QUIT; /* Allow user to bail out with ^C. */
2351 ALL_BLOCK_SYMBOLS (block, iter, sym)
2353 QUIT; /* Allow user to bail out with ^C. */
2355 printf_filtered ("Scope for %s:\n", save_args);
2358 symname = SYMBOL_PRINT_NAME (sym);
2359 if (symname == NULL || *symname == '\0')
2360 continue; /* Probably botched, certainly useless. */
2362 gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
2364 printf_filtered ("Symbol %s is ", symname);
2365 switch (SYMBOL_CLASS (sym))
2368 case LOC_UNDEF: /* Messed up symbol? */
2369 printf_filtered ("a bogus symbol, class %d.\n",
2370 SYMBOL_CLASS (sym));
2371 count--; /* Don't count this one. */
2374 printf_filtered ("a constant with value %ld (0x%lx)",
2375 SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
2377 case LOC_CONST_BYTES:
2378 printf_filtered ("constant bytes: ");
2379 if (SYMBOL_TYPE (sym))
2380 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2381 fprintf_filtered (gdb_stdout, " %02x",
2382 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2385 printf_filtered ("in static storage at address ");
2386 printf_filtered ("%s", paddress (gdbarch,
2387 SYMBOL_VALUE_ADDRESS (sym)));
2390 /* GDBARCH is the architecture associated with the objfile
2391 the symbol is defined in; the target architecture may be
2392 different, and may provide additional registers. However,
2393 we do not know the target architecture at this point.
2394 We assume the objfile architecture will contain all the
2395 standard registers that occur in debug info in that
2397 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2400 if (SYMBOL_IS_ARGUMENT (sym))
2401 printf_filtered ("an argument in register $%s",
2402 gdbarch_register_name (gdbarch, regno));
2404 printf_filtered ("a local variable in register $%s",
2405 gdbarch_register_name (gdbarch, regno));
2408 printf_filtered ("an argument at stack/frame offset %ld",
2409 SYMBOL_VALUE (sym));
2412 printf_filtered ("a local variable at frame offset %ld",
2413 SYMBOL_VALUE (sym));
2416 printf_filtered ("a reference argument at offset %ld",
2417 SYMBOL_VALUE (sym));
2419 case LOC_REGPARM_ADDR:
2420 /* Note comment at LOC_REGISTER. */
2421 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2423 printf_filtered ("the address of an argument, in register $%s",
2424 gdbarch_register_name (gdbarch, regno));
2427 printf_filtered ("a typedef.\n");
2430 printf_filtered ("a label at address ");
2431 printf_filtered ("%s", paddress (gdbarch,
2432 SYMBOL_VALUE_ADDRESS (sym)));
2435 printf_filtered ("a function at address ");
2436 printf_filtered ("%s",
2437 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2439 case LOC_UNRESOLVED:
2440 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2443 printf_filtered ("Unresolved Static");
2446 printf_filtered ("static storage at address ");
2447 printf_filtered ("%s",
2448 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msym)));
2451 case LOC_OPTIMIZED_OUT:
2452 printf_filtered ("optimized out.\n");
2455 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2456 BLOCK_START (block),
2460 if (SYMBOL_TYPE (sym))
2461 printf_filtered (", length %d.\n",
2462 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2464 if (BLOCK_FUNCTION (block))
2467 block = BLOCK_SUPERBLOCK (block);
2470 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2474 /* worker function (cleanup) */
2476 replace_comma (void *data)
2483 /* Helper for trace_dump_command. Dump the action list starting at
2484 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2485 actions of the body of a while-stepping action. STEPPING_FRAME is
2486 set if the current traceframe was determined to be a while-stepping
2490 trace_dump_actions (struct command_line *action,
2491 int stepping_actions, int stepping_frame,
2494 char *action_exp, *next_comma;
2496 for (; action != NULL; action = action->next)
2498 struct cmd_list_element *cmd;
2500 QUIT; /* Allow user to bail out with ^C. */
2501 action_exp = action->line;
2502 while (isspace ((int) *action_exp))
2505 /* The collection actions to be done while stepping are
2506 bracketed by the commands "while-stepping" and "end". */
2508 if (*action_exp == '#') /* comment line */
2511 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2513 error (_("Bad action list item: %s"), action_exp);
2515 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2519 for (i = 0; i < action->body_count; ++i)
2520 trace_dump_actions (action->body_list[i],
2521 1, stepping_frame, from_tty);
2523 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2525 /* Display the collected data.
2526 For the trap frame, display only what was collected at
2527 the trap. Likewise for stepping frames, display only
2528 what was collected while stepping. This means that the
2529 two boolean variables, STEPPING_FRAME and
2530 STEPPING_ACTIONS should be equal. */
2531 if (stepping_frame == stepping_actions)
2534 { /* Repeat over a comma-separated list. */
2535 QUIT; /* Allow user to bail out with ^C. */
2536 if (*action_exp == ',')
2538 while (isspace ((int) *action_exp))
2541 next_comma = strchr (action_exp, ',');
2543 if (0 == strncasecmp (action_exp, "$reg", 4))
2544 registers_info (NULL, from_tty);
2545 else if (0 == strncasecmp (action_exp, "$loc", 4))
2546 locals_info (NULL, from_tty);
2547 else if (0 == strncasecmp (action_exp, "$arg", 4))
2548 args_info (NULL, from_tty);
2553 make_cleanup (replace_comma, next_comma);
2556 printf_filtered ("%s = ", action_exp);
2557 output_command (action_exp, from_tty);
2558 printf_filtered ("\n");
2562 action_exp = next_comma;
2564 while (action_exp && *action_exp == ',');
2570 /* The tdump command. */
2573 trace_dump_command (char *args, int from_tty)
2575 struct regcache *regcache;
2576 struct breakpoint *t;
2577 int stepping_frame = 0;
2578 struct bp_location *loc;
2579 char *line, *default_collect_line = NULL;
2580 struct command_line *actions, *default_collect_action = NULL;
2581 struct cleanup *old_chain = NULL;
2583 if (tracepoint_number == -1)
2585 warning (_("No current trace frame."));
2589 t = get_tracepoint (tracepoint_number);
2592 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2595 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2596 tracepoint_number, traceframe_number);
2598 /* The current frame is a trap frame if the frame PC is equal
2599 to the tracepoint PC. If not, then the current frame was
2600 collected during single-stepping. */
2602 regcache = get_current_regcache ();
2604 /* If the traceframe's address matches any of the tracepoint's
2605 locations, assume it is a direct hit rather than a while-stepping
2606 frame. (FIXME this is not reliable, should record each frame's
2609 for (loc = t->loc; loc; loc = loc->next)
2610 if (loc->address == regcache_read_pc (regcache))
2613 actions = breakpoint_commands (t);
2615 /* If there is a default-collect list, make up a collect command,
2616 prepend to the tracepoint's commands, and pass the whole mess to
2617 the trace dump scanner. We need to validate because
2618 default-collect might have been junked since the trace run. */
2619 if (*default_collect)
2621 default_collect_line = xstrprintf ("collect %s", default_collect);
2622 old_chain = make_cleanup (xfree, default_collect_line);
2623 line = default_collect_line;
2624 validate_actionline (&line, t);
2625 default_collect_action = xmalloc (sizeof (struct command_line));
2626 make_cleanup (xfree, default_collect_action);
2627 default_collect_action->next = actions;
2628 default_collect_action->line = line;
2629 actions = default_collect_action;
2632 trace_dump_actions (actions, 0, stepping_frame, from_tty);
2634 if (*default_collect)
2635 do_cleanups (old_chain);
2638 /* Encode a piece of a tracepoint's source-level definition in a form
2639 that is suitable for both protocol and saving in files. */
2640 /* This version does not do multiple encodes for long strings; it should
2641 return an offset to the next piece to encode. FIXME */
2644 encode_source_string (int tpnum, ULONGEST addr,
2645 char *srctype, char *src, char *buf, int buf_size)
2647 if (80 + strlen (srctype) > buf_size)
2648 error (_("Buffer too small for source encoding"));
2649 sprintf (buf, "%x:%s:%s:%x:%x:",
2650 tpnum, phex_nz (addr, sizeof (addr)),
2651 srctype, 0, (int) strlen (src));
2652 if (strlen (buf) + strlen (src) * 2 >= buf_size)
2653 error (_("Source string too long for buffer"));
2654 bin2hex (src, buf + strlen (buf), 0);
2658 extern int trace_regblock_size;
2660 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2661 non-zero, the save is performed on the target, otherwise GDB obtains all
2662 trace data and saves it locally. */
2665 trace_save (const char *filename, int target_does_save)
2667 struct cleanup *cleanup;
2669 struct trace_status *ts = current_trace_status ();
2672 struct uploaded_tp *uploaded_tps = NULL, *utp;
2673 struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
2677 ULONGEST offset = 0;
2678 #define MAX_TRACE_UPLOAD 2000
2679 gdb_byte buf[MAX_TRACE_UPLOAD];
2682 /* If the target is to save the data to a file on its own, then just
2683 send the command and be done with it. */
2684 if (target_does_save)
2686 err = target_save_trace_data (filename);
2688 error (_("Target failed to save trace data to '%s'."),
2693 /* Get the trace status first before opening the file, so if the
2694 target is losing, we can get out without touching files. */
2695 status = target_get_trace_status (ts);
2697 pathname = tilde_expand (filename);
2698 cleanup = make_cleanup (xfree, pathname);
2700 fp = fopen (pathname, "wb");
2702 error (_("Unable to open file '%s' for saving trace data (%s)"),
2703 filename, safe_strerror (errno));
2704 make_cleanup_fclose (fp);
2706 /* Write a file header, with a high-bit-set char to indicate a
2707 binary file, plus a hint as what this file is, and a version
2708 number in case of future needs. */
2709 written = fwrite ("\x7fTRACE0\n", 8, 1, fp);
2711 perror_with_name (pathname);
2713 /* Write descriptive info. */
2715 /* Write out the size of a register block. */
2716 fprintf (fp, "R %x\n", trace_regblock_size);
2718 /* Write out status of the tracing run (aka "tstatus" info). */
2719 fprintf (fp, "status %c;%s",
2720 (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
2721 if (ts->stop_reason == tracepoint_error)
2723 char *buf = (char *) alloca (strlen (ts->error_desc) * 2 + 1);
2725 bin2hex ((gdb_byte *) ts->error_desc, buf, 0);
2726 fprintf (fp, ":%s", buf);
2728 fprintf (fp, ":%x", ts->stopping_tracepoint);
2729 if (ts->traceframe_count >= 0)
2730 fprintf (fp, ";tframes:%x", ts->traceframe_count);
2731 if (ts->traceframes_created >= 0)
2732 fprintf (fp, ";tcreated:%x", ts->traceframes_created);
2733 if (ts->buffer_free >= 0)
2734 fprintf (fp, ";tfree:%x", ts->buffer_free);
2735 if (ts->buffer_size >= 0)
2736 fprintf (fp, ";tsize:%x", ts->buffer_size);
2737 if (ts->disconnected_tracing)
2738 fprintf (fp, ";disconn:%x", ts->disconnected_tracing);
2739 if (ts->circular_buffer)
2740 fprintf (fp, ";circular:%x", ts->circular_buffer);
2743 /* Note that we want to upload tracepoints and save those, rather
2744 than simply writing out the local ones, because the user may have
2745 changed tracepoints in GDB in preparation for a future tracing
2746 run, or maybe just mass-deleted all types of breakpoints as part
2747 of cleaning up. So as not to contaminate the session, leave the
2748 data in its uploaded form, don't make into real tracepoints. */
2750 /* Get trace state variables first, they may be checked when parsing
2751 uploaded commands. */
2753 target_upload_trace_state_variables (&uploaded_tsvs);
2755 for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
2761 buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
2762 bin2hex ((gdb_byte *) (utsv->name), buf, 0);
2765 fprintf (fp, "tsv %x:%s:%x:%s\n",
2766 utsv->number, phex_nz (utsv->initial_value, 8),
2767 utsv->builtin, buf);
2773 free_uploaded_tsvs (&uploaded_tsvs);
2775 target_upload_tracepoints (&uploaded_tps);
2777 for (utp = uploaded_tps; utp; utp = utp->next)
2779 fprintf (fp, "tp T%x:%s:%c:%x:%x",
2780 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
2781 (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
2782 if (utp->type == bp_fast_tracepoint)
2783 fprintf (fp, ":F%x", utp->orig_size);
2785 fprintf (fp, ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
2788 for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
2789 fprintf (fp, "tp A%x:%s:%s\n",
2790 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
2791 for (a = 0; VEC_iterate (char_ptr, utp->step_actions, a, act); ++a)
2792 fprintf (fp, "tp S%x:%s:%s\n",
2793 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
2796 encode_source_string (utp->number, utp->addr,
2797 "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
2798 fprintf (fp, "tp Z%s\n", buf);
2800 if (utp->cond_string)
2802 encode_source_string (utp->number, utp->addr,
2803 "cond", utp->cond_string,
2804 buf, MAX_TRACE_UPLOAD);
2805 fprintf (fp, "tp Z%s\n", buf);
2807 for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
2809 encode_source_string (utp->number, utp->addr, "cmd", act,
2810 buf, MAX_TRACE_UPLOAD);
2811 fprintf (fp, "tp Z%s\n", buf);
2815 free_uploaded_tps (&uploaded_tps);
2817 /* Mark the end of the definition section. */
2820 /* Get and write the trace data proper. We ask for big blocks, in
2821 the hopes of efficiency, but will take less if the target has
2822 packet size limitations or some such. */
2825 gotten = target_get_raw_trace_data (buf, offset, MAX_TRACE_UPLOAD);
2827 error (_("Failure to get requested trace buffer data"));
2828 /* No more data is forthcoming, we're done. */
2831 written = fwrite (buf, gotten, 1, fp);
2833 perror_with_name (pathname);
2837 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
2838 written = fwrite (&gotten, 4, 1, fp);
2840 perror_with_name (pathname);
2842 do_cleanups (cleanup);
2846 trace_save_command (char *args, int from_tty)
2848 int target_does_save = 0;
2850 char *filename = NULL;
2851 struct cleanup *back_to;
2854 error_no_arg (_("file in which to save trace data"));
2856 argv = gdb_buildargv (args);
2857 back_to = make_cleanup_freeargv (argv);
2859 for (; *argv; ++argv)
2861 if (strcmp (*argv, "-r") == 0)
2862 target_does_save = 1;
2863 else if (**argv == '-')
2864 error (_("unknown option `%s'"), *argv);
2870 error_no_arg (_("file in which to save trace data"));
2872 trace_save (filename, target_does_save);
2875 printf_filtered (_("Trace data saved to file '%s'.\n"), args);
2877 do_cleanups (back_to);
2880 /* Tell the target what to do with an ongoing tracing run if GDB
2881 disconnects for some reason. */
2884 send_disconnected_tracing_value (int value)
2886 target_set_disconnected_tracing (value);
2890 set_disconnected_tracing (char *args, int from_tty,
2891 struct cmd_list_element *c)
2893 send_disconnected_tracing_value (disconnected_tracing);
2897 set_circular_trace_buffer (char *args, int from_tty,
2898 struct cmd_list_element *c)
2900 target_set_circular_trace_buffer (circular_trace_buffer);
2903 /* Convert the memory pointed to by mem into hex, placing result in buf.
2904 * Return a pointer to the last char put in buf (null)
2905 * "stolen" from sparc-stub.c
2908 static const char hexchars[] = "0123456789abcdef";
2911 mem2hex (gdb_byte *mem, char *buf, int count)
2919 *buf++ = hexchars[ch >> 4];
2920 *buf++ = hexchars[ch & 0xf];
2929 get_traceframe_number (void)
2931 return traceframe_number;
2934 /* Make the traceframe NUM be the current trace frame. Does nothing
2935 if NUM is already current. */
2938 set_current_traceframe (int num)
2942 if (traceframe_number == num)
2944 /* Nothing to do. */
2948 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
2951 warning (_("could not change traceframe"));
2953 traceframe_number = newnum;
2955 /* Changing the traceframe changes our view of registers and of the
2957 registers_changed ();
2959 clear_traceframe_info ();
2962 /* Make the traceframe NUM be the current trace frame, and do nothing
2966 set_traceframe_number (int num)
2968 traceframe_number = num;
2971 /* A cleanup used when switching away and back from tfind mode. */
2973 struct current_traceframe_cleanup
2975 /* The traceframe we were inspecting. */
2976 int traceframe_number;
2980 do_restore_current_traceframe_cleanup (void *arg)
2982 struct current_traceframe_cleanup *old = arg;
2984 set_current_traceframe (old->traceframe_number);
2988 restore_current_traceframe_cleanup_dtor (void *arg)
2990 struct current_traceframe_cleanup *old = arg;
2996 make_cleanup_restore_current_traceframe (void)
2998 struct current_traceframe_cleanup *old;
3000 old = xmalloc (sizeof (struct current_traceframe_cleanup));
3001 old->traceframe_number = traceframe_number;
3003 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
3004 restore_current_traceframe_cleanup_dtor);
3008 make_cleanup_restore_traceframe_number (void)
3010 return make_cleanup_restore_integer (&traceframe_number);
3013 /* Given a number and address, return an uploaded tracepoint with that
3014 number, creating if necessary. */
3016 struct uploaded_tp *
3017 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
3019 struct uploaded_tp *utp;
3021 for (utp = *utpp; utp; utp = utp->next)
3022 if (utp->number == num && utp->addr == addr)
3024 utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
3025 memset (utp, 0, sizeof (struct uploaded_tp));
3028 utp->actions = NULL;
3029 utp->step_actions = NULL;
3030 utp->cmd_strings = NULL;
3037 free_uploaded_tps (struct uploaded_tp **utpp)
3039 struct uploaded_tp *next_one;
3043 next_one = (*utpp)->next;
3049 /* Given a number and address, return an uploaded tracepoint with that
3050 number, creating if necessary. */
3052 struct uploaded_tsv *
3053 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3055 struct uploaded_tsv *utsv;
3057 for (utsv = *utsvp; utsv; utsv = utsv->next)
3058 if (utsv->number == num)
3060 utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
3061 memset (utsv, 0, sizeof (struct uploaded_tsv));
3063 utsv->next = *utsvp;
3069 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3071 struct uploaded_tsv *next_one;
3075 next_one = (*utsvp)->next;
3081 /* Look for an existing tracepoint that seems similar enough to the
3082 uploaded one. Enablement isn't compared, because the user can
3083 toggle that freely, and may have done so in anticipation of the
3087 find_matching_tracepoint (struct uploaded_tp *utp)
3089 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
3091 struct breakpoint *t;
3092 struct bp_location *loc;
3094 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
3096 if (t->type == utp->type
3097 && t->step_count == utp->step
3098 && t->pass_count == utp->pass
3099 /* FIXME also test conditionals and actions. */
3102 /* Scan the locations for an address match. */
3103 for (loc = t->loc; loc; loc = loc->next)
3105 if (loc->address == utp->addr)
3113 /* Given a list of tracepoints uploaded from a target, attempt to
3114 match them up with existing tracepoints, and create new ones if not
3118 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3120 struct uploaded_tp *utp;
3121 struct breakpoint *t;
3123 /* Look for GDB tracepoints that match up with our uploaded versions. */
3124 for (utp = *uploaded_tps; utp; utp = utp->next)
3126 t = find_matching_tracepoint (utp);
3128 printf_filtered (_("Assuming tracepoint %d is same "
3129 "as target's tracepoint %d at %s.\n"),
3130 t->number, utp->number,
3131 paddress (get_current_arch (), utp->addr));
3134 t = create_tracepoint_from_upload (utp);
3136 printf_filtered (_("Created tracepoint %d for "
3137 "target's tracepoint %d at %s.\n"),
3138 t->number, utp->number,
3139 paddress (get_current_arch (), utp->addr));
3141 printf_filtered (_("Failed to create tracepoint for target's "
3142 "tracepoint %d at %s, skipping it.\n"),
3144 paddress (get_current_arch (), utp->addr));
3146 /* Whether found or created, record the number used by the
3147 target, to help with mapping target tracepoints back to their
3148 counterparts here. */
3150 t->number_on_target = utp->number;
3153 free_uploaded_tps (uploaded_tps);
3156 /* Trace state variables don't have much to identify them beyond their
3157 name, so just use that to detect matches. */
3159 struct trace_state_variable *
3160 find_matching_tsv (struct uploaded_tsv *utsv)
3165 return find_trace_state_variable (utsv->name);
3168 struct trace_state_variable *
3169 create_tsv_from_upload (struct uploaded_tsv *utsv)
3171 const char *namebase;
3174 struct trace_state_variable *tsv;
3178 namebase = utsv->name;
3179 sprintf (buf, "%s", namebase);
3184 sprintf (buf, "%s_%d", namebase, try_num++);
3187 /* Fish for a name that is not in use. */
3188 /* (should check against all internal vars?) */
3189 while (find_trace_state_variable (buf))
3190 sprintf (buf, "%s_%d", namebase, try_num++);
3192 /* We have an available name, create the variable. */
3193 tsv = create_trace_state_variable (xstrdup (buf));
3194 tsv->initial_value = utsv->initial_value;
3195 tsv->builtin = utsv->builtin;
3200 /* Given a list of uploaded trace state variables, try to match them
3201 up with existing variables, or create additional ones. */
3204 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
3207 struct uploaded_tsv *utsv;
3208 struct trace_state_variable *tsv;
3211 /* Most likely some numbers will have to be reassigned as part of
3212 the merge, so clear them all in anticipation. */
3213 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3216 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
3218 tsv = find_matching_tsv (utsv);
3222 printf_filtered (_("Assuming trace state variable $%s "
3223 "is same as target's variable %d.\n"),
3224 tsv->name, utsv->number);
3228 tsv = create_tsv_from_upload (utsv);
3230 printf_filtered (_("Created trace state variable "
3231 "$%s for target's variable %d.\n"),
3232 tsv->name, utsv->number);
3234 /* Give precedence to numberings that come from the target. */
3236 tsv->number = utsv->number;
3239 /* Renumber everything that didn't get a target-assigned number. */
3241 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3242 if (tsv->number > highest)
3243 highest = tsv->number;
3246 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3247 if (tsv->number == 0)
3248 tsv->number = highest++;
3250 free_uploaded_tsvs (uploaded_tsvs);
3253 /* target tfile command */
3255 struct target_ops tfile_ops;
3257 /* Fill in tfile_ops with its defined operations and properties. */
3259 #define TRACE_HEADER_SIZE 8
3261 char *trace_filename;
3263 off_t trace_frames_offset;
3265 int cur_traceframe_number;
3267 int trace_regblock_size;
3269 static void tfile_interp_line (char *line,
3270 struct uploaded_tp **utpp,
3271 struct uploaded_tsv **utsvp);
3273 /* Read SIZE bytes into READBUF from the trace frame, starting at
3274 TRACE_FD's current position. Note that this call `read'
3275 underneath, hence it advances the file's seek position. Throws an
3276 error if the `read' syscall fails, or less than SIZE bytes are
3280 tfile_read (gdb_byte *readbuf, int size)
3284 gotten = read (trace_fd, readbuf, size);
3286 perror_with_name (trace_filename);
3287 else if (gotten < size)
3288 error (_("Premature end of file while reading trace file"));
3292 tfile_open (char *filename, int from_tty)
3295 struct cleanup *old_chain;
3298 char header[TRACE_HEADER_SIZE];
3299 char linebuf[1000]; /* Should be max remote packet size or so. */
3302 struct trace_status *ts;
3303 struct uploaded_tp *uploaded_tps = NULL;
3304 struct uploaded_tsv *uploaded_tsvs = NULL;
3306 target_preopen (from_tty);
3308 error (_("No trace file specified."));
3310 filename = tilde_expand (filename);
3311 if (!IS_ABSOLUTE_PATH(filename))
3313 temp = concat (current_directory, "/", filename, (char *) NULL);
3318 old_chain = make_cleanup (xfree, filename);
3320 flags = O_BINARY | O_LARGEFILE;
3322 scratch_chan = open (filename, flags, 0);
3323 if (scratch_chan < 0)
3324 perror_with_name (filename);
3326 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3328 discard_cleanups (old_chain); /* Don't free filename any more. */
3329 unpush_target (&tfile_ops);
3331 push_target (&tfile_ops);
3333 trace_filename = xstrdup (filename);
3334 trace_fd = scratch_chan;
3337 /* Read the file header and test for validity. */
3338 tfile_read ((gdb_byte *) &header, TRACE_HEADER_SIZE);
3340 bytes += TRACE_HEADER_SIZE;
3341 if (!(header[0] == 0x7f
3342 && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
3343 error (_("File is not a valid trace file."));
3345 trace_regblock_size = 0;
3346 ts = current_trace_status ();
3347 /* We know we're working with a file. */
3349 /* Set defaults in case there is no status line. */
3350 ts->running_known = 0;
3351 ts->stop_reason = trace_stop_reason_unknown;
3352 ts->traceframe_count = -1;
3353 ts->buffer_free = 0;
3354 ts->disconnected_tracing = 0;
3355 ts->circular_buffer = 0;
3357 cur_traceframe_number = -1;
3359 /* Read through a section of newline-terminated lines that
3360 define things like tracepoints. */
3364 tfile_read (&byte, 1);
3369 /* Empty line marks end of the definition section. */
3374 tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
3377 linebuf[i++] = byte;
3379 error (_("Excessively long lines in trace file"));
3382 /* Add the file's tracepoints and variables into the current mix. */
3384 /* Get trace state variables first, they may be checked when parsing
3385 uploaded commands. */
3386 merge_uploaded_trace_state_variables (&uploaded_tsvs);
3388 merge_uploaded_tracepoints (&uploaded_tps);
3390 /* Record the starting offset of the binary trace data. */
3391 trace_frames_offset = bytes;
3393 /* If we don't have a blocksize, we can't interpret the
3395 if (trace_regblock_size == 0)
3396 error (_("No register block size recorded in trace file"));
3397 if (ts->traceframe_count <= 0)
3399 warning (_("No traceframes present in this file."));
3403 #define TFILE_PID (1)
3404 inferior_appeared (current_inferior (), TFILE_PID);
3405 inferior_ptid = pid_to_ptid (TFILE_PID);
3406 add_thread_silent (inferior_ptid);
3408 post_create_inferior (&tfile_ops, from_tty);
3411 /* FIXME this will get defined in MI patch submission. */
3412 tfind_1 (tfind_number, 0, 0, 0, 0);
3416 /* Interpret the given line from the definitions part of the trace
3420 tfile_interp_line (char *line,
3421 struct uploaded_tp **utpp, struct uploaded_tsv **utsvp)
3425 if (strncmp (p, "R ", strlen ("R ")) == 0)
3428 trace_regblock_size = strtol (p, &p, 16);
3430 else if (strncmp (p, "status ", strlen ("status ")) == 0)
3432 p += strlen ("status ");
3433 parse_trace_status (p, current_trace_status ());
3435 else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
3437 p += strlen ("tp ");
3438 parse_tracepoint_definition (p, utpp);
3440 else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
3442 p += strlen ("tsv ");
3443 parse_tsv_definition (p, utsvp);
3446 warning (_("Ignoring trace file definition \"%s\""), line);
3449 /* Parse the part of trace status syntax that is shared between
3450 the remote protocol and the trace file reader. */
3453 parse_trace_status (char *line, struct trace_status *ts)
3455 char *p = line, *p1, *p2, *p_temp;
3458 ts->running_known = 1;
3459 ts->running = (*p++ == '1');
3460 ts->stop_reason = trace_stop_reason_unknown;
3461 xfree (ts->error_desc);
3462 ts->error_desc = NULL;
3463 ts->traceframe_count = -1;
3464 ts->traceframes_created = -1;
3465 ts->buffer_free = -1;
3466 ts->buffer_size = -1;
3467 ts->disconnected_tracing = 0;
3468 ts->circular_buffer = 0;
3472 p1 = strchr (p, ':');
3474 error (_("Malformed trace status, at %s\n\
3475 Status line: '%s'\n"), p, line);
3476 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3478 p = unpack_varlen_hex (++p1, &val);
3479 ts->stop_reason = trace_buffer_full;
3481 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3483 p = unpack_varlen_hex (++p1, &val);
3484 ts->stop_reason = trace_never_run;
3486 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
3489 p = unpack_varlen_hex (++p1, &val);
3490 ts->stop_reason = tracepoint_passcount;
3491 ts->stopping_tracepoint = val;
3493 else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
3495 p = unpack_varlen_hex (++p1, &val);
3496 ts->stop_reason = tstop_command;
3498 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3500 p = unpack_varlen_hex (++p1, &val);
3501 ts->stop_reason = trace_disconnected;
3503 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3505 p2 = strchr (++p1, ':');
3510 ts->error_desc = xmalloc ((p2 - p1) / 2 + 1);
3511 end = hex2bin (p1, ts->error_desc, (p2 - p1) / 2);
3512 ts->error_desc[end] = '\0';
3515 ts->error_desc = xstrdup ("");
3517 p = unpack_varlen_hex (++p2, &val);
3518 ts->stopping_tracepoint = val;
3519 ts->stop_reason = tracepoint_error;
3521 else if (strncmp (p, "tframes", p1 - p) == 0)
3523 p = unpack_varlen_hex (++p1, &val);
3524 ts->traceframe_count = val;
3526 else if (strncmp (p, "tcreated", p1 - p) == 0)
3528 p = unpack_varlen_hex (++p1, &val);
3529 ts->traceframes_created = val;
3531 else if (strncmp (p, "tfree", p1 - p) == 0)
3533 p = unpack_varlen_hex (++p1, &val);
3534 ts->buffer_free = val;
3536 else if (strncmp (p, "tsize", p1 - p) == 0)
3538 p = unpack_varlen_hex (++p1, &val);
3539 ts->buffer_size = val;
3541 else if (strncmp (p, "disconn", p1 - p) == 0)
3543 p = unpack_varlen_hex (++p1, &val);
3544 ts->disconnected_tracing = val;
3546 else if (strncmp (p, "circular", p1 - p) == 0)
3548 p = unpack_varlen_hex (++p1, &val);
3549 ts->circular_buffer = val;
3553 /* Silently skip unknown optional info. */
3554 p_temp = strchr (p1 + 1, ';');
3558 /* Must be at the end. */
3564 /* Given a line of text defining a part of a tracepoint, parse it into
3565 an "uploaded tracepoint". */
3568 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
3572 ULONGEST num, addr, step, pass, orig_size, xlen, start;
3575 char *cond, *srctype, *buf;
3576 struct uploaded_tp *utp = NULL;
3579 /* Both tracepoint and action definitions start with the same number
3580 and address sequence. */
3582 p = unpack_varlen_hex (p, &num);
3583 p++; /* skip a colon */
3584 p = unpack_varlen_hex (p, &addr);
3585 p++; /* skip a colon */
3588 enabled = (*p++ == 'E');
3589 p++; /* skip a colon */
3590 p = unpack_varlen_hex (p, &step);
3591 p++; /* skip a colon */
3592 p = unpack_varlen_hex (p, &pass);
3593 type = bp_tracepoint;
3595 /* Thumb through optional fields. */
3598 p++; /* skip a colon */
3601 type = bp_fast_tracepoint;
3603 p = unpack_varlen_hex (p, &orig_size);
3607 type = bp_static_tracepoint;
3613 p = unpack_varlen_hex (p, &xlen);
3614 p++; /* skip a comma */
3615 cond = (char *) xmalloc (2 * xlen + 1);
3616 strncpy (cond, p, 2 * xlen);
3617 cond[2 * xlen] = '\0';
3621 warning (_("Unrecognized char '%c' in tracepoint "
3622 "definition, skipping rest"), *p);
3624 utp = get_uploaded_tp (num, addr, utpp);
3626 utp->enabled = enabled;
3631 else if (piece == 'A')
3633 utp = get_uploaded_tp (num, addr, utpp);
3634 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
3636 else if (piece == 'S')
3638 utp = get_uploaded_tp (num, addr, utpp);
3639 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
3641 else if (piece == 'Z')
3643 /* Parse a chunk of source form definition. */
3644 utp = get_uploaded_tp (num, addr, utpp);
3646 p = strchr (p, ':');
3647 p++; /* skip a colon */
3648 p = unpack_varlen_hex (p, &start);
3649 p++; /* skip a colon */
3650 p = unpack_varlen_hex (p, &xlen);
3651 p++; /* skip a colon */
3653 buf = alloca (strlen (line));
3655 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3658 if (strncmp (srctype, "at:", strlen ("at:")) == 0)
3659 utp->at_string = xstrdup (buf);
3660 else if (strncmp (srctype, "cond:", strlen ("cond:")) == 0)
3661 utp->cond_string = xstrdup (buf);
3662 else if (strncmp (srctype, "cmd:", strlen ("cmd:")) == 0)
3663 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
3667 /* Don't error out, the target might be sending us optional
3668 info that we don't care about. */
3669 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
3673 /* Convert a textual description of a trace state variable into an
3677 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
3680 ULONGEST num, initval, builtin;
3682 struct uploaded_tsv *utsv = NULL;
3684 buf = alloca (strlen (line));
3687 p = unpack_varlen_hex (p, &num);
3688 p++; /* skip a colon */
3689 p = unpack_varlen_hex (p, &initval);
3690 p++; /* skip a colon */
3691 p = unpack_varlen_hex (p, &builtin);
3692 p++; /* skip a colon */
3693 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3696 utsv = get_uploaded_tsv (num, utsvp);
3697 utsv->initial_value = initval;
3698 utsv->builtin = builtin;
3699 utsv->name = xstrdup (buf);
3702 /* Close the trace file and generally clean up. */
3705 tfile_close (int quitting)
3712 pid = ptid_get_pid (inferior_ptid);
3713 inferior_ptid = null_ptid; /* Avoid confusion from thread stuff. */
3714 exit_inferior_silent (pid);
3719 xfree (trace_filename);
3723 tfile_files_info (struct target_ops *t)
3725 /* (it would be useful to mention the name of the file). */
3726 printf_filtered ("Looking at a trace file.\n");
3729 /* The trace status for a file is that tracing can never be run. */
3732 tfile_get_trace_status (struct trace_status *ts)
3734 /* Other bits of trace status were collected as part of opening the
3735 trace files, so nothing to do here. */
3740 /* Given the position of a traceframe in the file, figure out what
3741 address the frame was collected at. This would normally be the
3742 value of a collected PC register, but if not available, we
3746 tfile_get_traceframe_address (off_t tframe_offset)
3750 struct breakpoint *tp;
3751 off_t saved_offset = cur_offset;
3753 /* FIXME dig pc out of collected registers. */
3755 /* Fall back to using tracepoint address. */
3756 lseek (trace_fd, tframe_offset, SEEK_SET);
3757 tfile_read ((gdb_byte *) &tpnum, 2);
3758 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
3762 tp = get_tracepoint_by_number_on_target (tpnum);
3763 /* FIXME this is a poor heuristic if multiple locations. */
3765 addr = tp->loc->address;
3767 /* Restore our seek position. */
3768 cur_offset = saved_offset;
3769 lseek (trace_fd, cur_offset, SEEK_SET);
3773 /* Make tfile's selected traceframe match GDB's selected
3777 set_tfile_traceframe (void)
3781 if (cur_traceframe_number == get_traceframe_number ())
3784 /* Avoid recursion, tfile_trace_find calls us again. */
3785 cur_traceframe_number = get_traceframe_number ();
3787 newnum = target_trace_find (tfind_number,
3788 get_traceframe_number (), 0, 0, NULL);
3790 /* Should not happen. If it does, all bets are off. */
3791 if (newnum != get_traceframe_number ())
3792 warning (_("could not set tfile's traceframe"));
3795 /* Given a type of search and some parameters, scan the collection of
3796 traceframes in the file looking for a match. When found, return
3797 both the traceframe and tracepoint number, otherwise -1 for
3801 tfile_trace_find (enum trace_find_type type, int num,
3802 ULONGEST addr1, ULONGEST addr2, int *tpp)
3805 int tfnum = 0, found = 0;
3806 unsigned int data_size;
3807 struct breakpoint *tp;
3808 off_t offset, tframe_offset;
3811 /* Lookups other than by absolute frame number depend on the current
3812 trace selected, so make sure it is correct on the tfile end
3814 if (type != tfind_number)
3815 set_tfile_traceframe ();
3817 lseek (trace_fd, trace_frames_offset, SEEK_SET);
3818 offset = trace_frames_offset;
3821 tframe_offset = offset;
3822 tfile_read ((gdb_byte *) &tpnum, 2);
3823 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
3829 tfile_read ((gdb_byte *) &data_size, 4);
3830 data_size = (unsigned int) extract_unsigned_integer
3831 ((gdb_byte *) &data_size, 4,
3832 gdbarch_byte_order (target_gdbarch));
3841 tfaddr = tfile_get_traceframe_address (tframe_offset);
3842 if (tfaddr == addr1)
3846 tp = get_tracepoint (num);
3847 if (tp && tpnum == tp->number_on_target)
3851 tfaddr = tfile_get_traceframe_address (tframe_offset);
3852 if (addr1 <= tfaddr && tfaddr <= addr2)
3856 tfaddr = tfile_get_traceframe_address (tframe_offset);
3857 if (!(addr1 <= tfaddr && tfaddr <= addr2))
3861 internal_error (__FILE__, __LINE__, _("unknown tfind type"));
3867 cur_offset = offset;
3868 cur_data_size = data_size;
3869 cur_traceframe_number = tfnum;
3872 /* Skip past the traceframe's data. */
3873 lseek (trace_fd, data_size, SEEK_CUR);
3874 offset += data_size;
3875 /* Update our own count of traceframes. */
3878 /* Did not find what we were looking for. */
3884 /* Prototype of the callback passed to tframe_walk_blocks. */
3885 typedef int (*walk_blocks_callback_func) (char blocktype, void *data);
3887 /* Callback for traceframe_walk_blocks, used to find a given block
3888 type in a traceframe. */
3891 match_blocktype (char blocktype, void *data)
3893 char *wantedp = data;
3895 if (*wantedp == blocktype)
3901 /* Walk over all traceframe block starting at POS offset from
3902 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
3903 unmodified. If CALLBACK returns true, this returns the position in
3904 the traceframe where the block is found, relative to the start of
3905 the traceframe (cur_offset). Returns -1 if no callback call
3906 returned true, indicating that all blocks have been walked. */
3909 traceframe_walk_blocks (walk_blocks_callback_func callback,
3910 int pos, void *data)
3912 /* Iterate through a traceframe's blocks, looking for a block of the
3915 lseek (trace_fd, cur_offset + pos, SEEK_SET);
3916 while (pos < cur_data_size)
3918 unsigned short mlen;
3921 tfile_read (&block_type, 1);
3925 if ((*callback) (block_type, data))
3931 lseek (trace_fd, cur_offset + pos + trace_regblock_size, SEEK_SET);
3932 pos += trace_regblock_size;
3935 lseek (trace_fd, cur_offset + pos + 8, SEEK_SET);
3936 tfile_read ((gdb_byte *) &mlen, 2);
3937 mlen = (unsigned short)
3938 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
3941 lseek (trace_fd, mlen, SEEK_CUR);
3942 pos += (8 + 2 + mlen);
3945 lseek (trace_fd, cur_offset + pos + 4 + 8, SEEK_SET);
3949 error (_("Unknown block type '%c' (0x%x) in trace frame"),
3950 block_type, block_type);
3958 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
3959 position offset of a block of type TYPE_WANTED in the current trace
3960 frame, starting at POS. Returns -1 if no such block was found. */
3963 traceframe_find_block_type (char type_wanted, int pos)
3965 return traceframe_walk_blocks (match_blocktype, pos, &type_wanted);
3968 /* Look for a block of saved registers in the traceframe, and get the
3969 requested register from it. */
3972 tfile_fetch_registers (struct target_ops *ops,
3973 struct regcache *regcache, int regno)
3975 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3977 int pos, offset, regn, regsize, pc_regno;
3978 unsigned short mlen;
3981 /* An uninitialized reg size says we're not going to be
3982 successful at getting register blocks. */
3983 if (!trace_regblock_size)
3986 set_tfile_traceframe ();
3988 regs = alloca (trace_regblock_size);
3990 if (traceframe_find_block_type ('R', 0) >= 0)
3992 tfile_read (regs, trace_regblock_size);
3994 /* Assume the block is laid out in GDB register number order,
3995 each register with the size that it has in GDB. */
3997 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
3999 regsize = register_size (gdbarch, regn);
4000 /* Make sure we stay within block bounds. */
4001 if (offset + regsize >= trace_regblock_size)
4003 if (regcache_register_status (regcache, regn) == REG_UNKNOWN)
4007 regcache_raw_supply (regcache, regno, regs + offset);
4010 else if (regno == -1)
4012 regcache_raw_supply (regcache, regn, regs + offset);
4020 /* We get here if no register data has been found. Mark registers
4022 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4023 regcache_raw_supply (regcache, regn, NULL);
4025 /* We can often usefully guess that the PC is going to be the same
4026 as the address of the tracepoint. */
4027 pc_regno = gdbarch_pc_regnum (gdbarch);
4028 if (pc_regno >= 0 && (regno == -1 || regno == pc_regno))
4030 struct breakpoint *tp = get_tracepoint (tracepoint_number);
4034 /* But don't try to guess if tracepoint is multi-location... */
4037 warning (_("Tracepoint %d has multiple "
4038 "locations, cannot infer $pc"),
4042 /* ... or does while-stepping. */
4043 if (tp->step_count > 0)
4045 warning (_("Tracepoint %d does while-stepping, "
4046 "cannot infer $pc"),
4051 store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
4052 gdbarch_byte_order (gdbarch),
4054 regcache_raw_supply (regcache, pc_regno, regs);
4060 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
4061 const char *annex, gdb_byte *readbuf,
4062 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
4064 /* We're only doing regular memory for now. */
4065 if (object != TARGET_OBJECT_MEMORY)
4068 if (readbuf == NULL)
4069 error (_("tfile_xfer_partial: trace file is read-only"));
4071 set_tfile_traceframe ();
4073 if (traceframe_number != -1)
4077 /* Iterate through the traceframe's blocks, looking for
4079 while ((pos = traceframe_find_block_type ('M', pos)) >= 0)
4081 ULONGEST maddr, amt;
4082 unsigned short mlen;
4083 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
4085 tfile_read ((gdb_byte *) &maddr, 8);
4086 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
4088 tfile_read ((gdb_byte *) &mlen, 2);
4089 mlen = (unsigned short)
4090 extract_unsigned_integer ((gdb_byte *) &mlen, 2, byte_order);
4092 /* If the block includes the first part of the desired
4093 range, return as much it has; GDB will re-request the
4094 remainder, which might be in a different block of this
4096 if (maddr <= offset && offset < (maddr + mlen))
4098 amt = (maddr + mlen) - offset;
4102 tfile_read (readbuf, amt);
4106 /* Skip over this block. */
4107 pos += (8 + 2 + mlen);
4111 /* It's unduly pedantic to refuse to look at the executable for
4112 read-only pieces; so do the equivalent of readonly regions aka
4114 /* FIXME account for relocation at some point. */
4121 for (s = exec_bfd->sections; s; s = s->next)
4123 if ((s->flags & SEC_LOAD) == 0
4124 || (s->flags & SEC_READONLY) == 0)
4128 size = bfd_get_section_size (s);
4129 if (vma <= offset && offset < (vma + size))
4133 amt = (vma + size) - offset;
4137 amt = bfd_get_section_contents (exec_bfd, s,
4138 readbuf, offset - vma, amt);
4144 /* Indicate failure to find the requested memory block. */
4148 /* Iterate through the blocks of a trace frame, looking for a 'V'
4149 block with a matching tsv number. */
4152 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
4156 set_tfile_traceframe ();
4159 while ((pos = traceframe_find_block_type ('V', pos)) >= 0)
4163 tfile_read ((gdb_byte *) &vnum, 4);
4164 vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
4169 tfile_read ((gdb_byte *) val, 8);
4170 *val = extract_signed_integer ((gdb_byte *) val, 8,
4178 /* Didn't find anything. */
4183 tfile_has_all_memory (struct target_ops *ops)
4189 tfile_has_memory (struct target_ops *ops)
4195 tfile_has_stack (struct target_ops *ops)
4197 return traceframe_number != -1;
4201 tfile_has_registers (struct target_ops *ops)
4203 return traceframe_number != -1;
4206 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
4207 object for the tfile target's current traceframe. */
4210 build_traceframe_info (char blocktype, void *data)
4212 struct traceframe_info *info = data;
4218 struct mem_range *r;
4220 unsigned short mlen;
4222 tfile_read ((gdb_byte *) &maddr, 8);
4223 tfile_read ((gdb_byte *) &mlen, 2);
4225 r = VEC_safe_push (mem_range_s, info->memory, NULL);
4238 warning (_("Unhandled trace block type (%d) '%c ' "
4239 "while building trace frame info."),
4240 blocktype, blocktype);
4247 static struct traceframe_info *
4248 tfile_traceframe_info (void)
4250 struct traceframe_info *info = XCNEW (struct traceframe_info);
4252 traceframe_walk_blocks (build_traceframe_info, 0, info);
4257 init_tfile_ops (void)
4259 tfile_ops.to_shortname = "tfile";
4260 tfile_ops.to_longname = "Local trace dump file";
4262 = "Use a trace file as a target. Specify the filename of the trace file.";
4263 tfile_ops.to_open = tfile_open;
4264 tfile_ops.to_close = tfile_close;
4265 tfile_ops.to_fetch_registers = tfile_fetch_registers;
4266 tfile_ops.to_xfer_partial = tfile_xfer_partial;
4267 tfile_ops.to_files_info = tfile_files_info;
4268 tfile_ops.to_get_trace_status = tfile_get_trace_status;
4269 tfile_ops.to_trace_find = tfile_trace_find;
4270 tfile_ops.to_get_trace_state_variable_value
4271 = tfile_get_trace_state_variable_value;
4272 tfile_ops.to_stratum = process_stratum;
4273 tfile_ops.to_has_all_memory = tfile_has_all_memory;
4274 tfile_ops.to_has_memory = tfile_has_memory;
4275 tfile_ops.to_has_stack = tfile_has_stack;
4276 tfile_ops.to_has_registers = tfile_has_registers;
4277 tfile_ops.to_traceframe_info = tfile_traceframe_info;
4278 tfile_ops.to_magic = OPS_MAGIC;
4281 /* Given a line of text defining a static tracepoint marker, parse it
4282 into a "static tracepoint marker" object. Throws an error is
4283 parsing fails. If PP is non-null, it points to one past the end of
4284 the parsed marker definition. */
4287 parse_static_tracepoint_marker_definition (char *line, char **pp,
4288 struct static_tracepoint_marker *marker)
4295 p = unpack_varlen_hex (p, &addr);
4296 p++; /* skip a colon */
4298 marker->gdbarch = target_gdbarch;
4299 marker->address = (CORE_ADDR) addr;
4301 endp = strchr (p, ':');
4303 error (_("bad marker definition: %s"), line);
4305 marker->str_id = xmalloc (endp - p + 1);
4306 end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
4307 marker->str_id[end] = '\0';
4310 p++; /* skip a colon */
4312 marker->extra = xmalloc (strlen (p) + 1);
4313 end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
4314 marker->extra[end] = '\0';
4320 /* Release a static tracepoint marker's contents. Note that the
4321 object itself isn't released here. There objects are usually on
4325 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
4327 xfree (marker->str_id);
4328 marker->str_id = NULL;
4331 /* Print MARKER to gdb_stdout. */
4334 print_one_static_tracepoint_marker (int count,
4335 struct static_tracepoint_marker *marker)
4337 struct command_line *l;
4340 char wrap_indent[80];
4341 char extra_field_indent[80];
4342 struct ui_stream *stb = ui_out_stream_new (uiout);
4343 struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb);
4344 struct cleanup *bkpt_chain;
4345 VEC(breakpoint_p) *tracepoints;
4347 struct symtab_and_line sal;
4351 sal.pc = marker->address;
4353 tracepoints = static_tracepoints_here (marker->address);
4355 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
4357 /* A counter field to help readability. This is not a stable
4359 ui_out_field_int (uiout, "count", count);
4361 ui_out_field_string (uiout, "marker-id", marker->str_id);
4363 ui_out_field_fmt (uiout, "enabled", "%c",
4364 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
4365 ui_out_spaces (uiout, 2);
4367 strcpy (wrap_indent, " ");
4369 if (gdbarch_addr_bit (marker->gdbarch) <= 32)
4370 strcat (wrap_indent, " ");
4372 strcat (wrap_indent, " ");
4374 strcpy (extra_field_indent, " ");
4376 ui_out_field_core_addr (uiout, "addr", marker->gdbarch, marker->address);
4378 sal = find_pc_line (marker->address, 0);
4379 sym = find_pc_sect_function (marker->address, NULL);
4382 ui_out_text (uiout, "in ");
4383 ui_out_field_string (uiout, "func",
4384 SYMBOL_PRINT_NAME (sym));
4385 ui_out_wrap_hint (uiout, wrap_indent);
4386 ui_out_text (uiout, " at ");
4389 ui_out_field_skip (uiout, "func");
4391 if (sal.symtab != NULL)
4393 ui_out_field_string (uiout, "file", sal.symtab->filename);
4394 ui_out_text (uiout, ":");
4396 if (ui_out_is_mi_like_p (uiout))
4398 char *fullname = symtab_to_fullname (sal.symtab);
4401 ui_out_field_string (uiout, "fullname", fullname);
4404 ui_out_field_skip (uiout, "fullname");
4406 ui_out_field_int (uiout, "line", sal.line);
4410 ui_out_field_skip (uiout, "fullname");
4411 ui_out_field_skip (uiout, "line");
4414 ui_out_text (uiout, "\n");
4415 ui_out_text (uiout, extra_field_indent);
4416 ui_out_text (uiout, _("Data: \""));
4417 ui_out_field_string (uiout, "extra-data", marker->extra);
4418 ui_out_text (uiout, "\"\n");
4420 if (!VEC_empty (breakpoint_p, tracepoints))
4422 struct cleanup *cleanup_chain;
4424 struct breakpoint *b;
4426 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
4429 ui_out_text (uiout, extra_field_indent);
4430 ui_out_text (uiout, _("Probed by static tracepoints: "));
4431 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
4434 ui_out_text (uiout, ", ");
4435 ui_out_text (uiout, "#");
4436 ui_out_field_int (uiout, "tracepoint-id", b->number);
4439 do_cleanups (cleanup_chain);
4441 if (ui_out_is_mi_like_p (uiout))
4442 ui_out_field_int (uiout, "number-of-tracepoints",
4443 VEC_length(breakpoint_p, tracepoints));
4445 ui_out_text (uiout, "\n");
4447 VEC_free (breakpoint_p, tracepoints);
4449 do_cleanups (bkpt_chain);
4450 do_cleanups (old_chain);
4454 info_static_tracepoint_markers_command (char *arg, int from_tty)
4456 VEC(static_tracepoint_marker_p) *markers;
4457 struct cleanup *old_chain;
4458 struct static_tracepoint_marker *marker;
4462 = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
4463 "StaticTracepointMarkersTable");
4465 ui_out_table_header (uiout, 7, ui_left, "counter", "Cnt");
4467 ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
4469 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
4470 if (gdbarch_addr_bit (target_gdbarch) <= 32)
4471 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
4473 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
4474 ui_out_table_header (uiout, 40, ui_noalign, "what", "What");
4476 ui_out_table_body (uiout);
4478 markers = target_static_tracepoint_markers_by_strid (NULL);
4479 make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
4482 VEC_iterate (static_tracepoint_marker_p,
4483 markers, i, marker);
4486 print_one_static_tracepoint_marker (i + 1, marker);
4487 release_static_tracepoint_marker (marker);
4490 do_cleanups (old_chain);
4493 /* The $_sdata convenience variable is a bit special. We don't know
4494 for sure type of the value until we actually have a chance to fetch
4495 the data --- the size of the object depends on what has been
4496 collected. We solve this by making $_sdata be an internalvar that
4497 creates a new value on access. */
4499 /* Return a new value with the correct type for the sdata object of
4500 the current trace frame. Return a void value if there's no object
4503 static struct value *
4504 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var)
4509 /* We need to read the whole object before we know its size. */
4510 size = target_read_alloc (¤t_target,
4511 TARGET_OBJECT_STATIC_TRACE_DATA,
4518 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
4520 v = allocate_value (type);
4521 memcpy (value_contents_raw (v), buf, size);
4526 return allocate_value (builtin_type (gdbarch)->builtin_void);
4529 #if !defined(HAVE_LIBEXPAT)
4531 struct traceframe_info *
4532 parse_traceframe_info (const char *tframe_info)
4534 static int have_warned;
4539 warning (_("Can not parse XML trace frame info; XML support "
4540 "was disabled at compile time"));
4546 #else /* HAVE_LIBEXPAT */
4548 #include "xml-support.h"
4550 /* Handle the start of a <memory> element. */
4553 traceframe_info_start_memory (struct gdb_xml_parser *parser,
4554 const struct gdb_xml_element *element,
4555 void *user_data, VEC(gdb_xml_value_s) *attributes)
4557 struct traceframe_info *info = user_data;
4558 struct mem_range *r = VEC_safe_push (mem_range_s, info->memory, NULL);
4559 ULONGEST *start_p, *length_p;
4561 start_p = xml_find_attribute (attributes, "start")->value;
4562 length_p = xml_find_attribute (attributes, "length")->value;
4564 r->start = *start_p;
4565 r->length = *length_p;
4568 /* Discard the constructed trace frame info (if an error occurs). */
4571 free_result (void *p)
4573 struct traceframe_info *result = p;
4575 free_traceframe_info (result);
4578 /* The allowed elements and attributes for an XML memory map. */
4580 static const struct gdb_xml_attribute memory_attributes[] = {
4581 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4582 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4583 { NULL, GDB_XML_AF_NONE, NULL, NULL }
4586 static const struct gdb_xml_element traceframe_info_children[] = {
4587 { "memory", memory_attributes, NULL,
4588 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
4589 traceframe_info_start_memory, NULL },
4590 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4593 static const struct gdb_xml_element traceframe_info_elements[] = {
4594 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
4596 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4599 /* Parse a traceframe-info XML document. */
4601 struct traceframe_info *
4602 parse_traceframe_info (const char *tframe_info)
4604 struct traceframe_info *result;
4605 struct cleanup *back_to;
4607 result = XCNEW (struct traceframe_info);
4608 back_to = make_cleanup (free_result, result);
4610 if (gdb_xml_parse_quick (_("trace frame info"),
4611 "traceframe-info.dtd", traceframe_info_elements,
4612 tframe_info, result) == 0)
4614 /* Parsed successfully, keep the result. */
4615 discard_cleanups (back_to);
4620 do_cleanups (back_to);
4624 #endif /* HAVE_LIBEXPAT */
4626 /* Returns the traceframe_info object for the current traceframe.
4627 This is where we avoid re-fetching the object from the target if we
4628 already have it cached. */
4630 struct traceframe_info *
4631 get_traceframe_info (void)
4633 if (traceframe_info == NULL)
4634 traceframe_info = target_traceframe_info ();
4636 return traceframe_info;
4639 /* If the target supports the query, return in RESULT the set of
4640 collected memory in the current traceframe, found within the LEN
4641 bytes range starting at MEMADDR. Returns true if the target
4642 supports the query, otherwise returns false, and RESULT is left
4646 traceframe_available_memory (VEC(mem_range_s) **result,
4647 CORE_ADDR memaddr, ULONGEST len)
4649 struct traceframe_info *info = get_traceframe_info ();
4653 struct mem_range *r;
4658 for (i = 0; VEC_iterate (mem_range_s, info->memory, i, r); i++)
4659 if (mem_ranges_overlap (r->start, r->length, memaddr, len))
4661 ULONGEST lo1, hi1, lo2, hi2;
4662 struct mem_range *nr;
4665 hi1 = memaddr + len;
4668 hi2 = r->start + r->length;
4670 nr = VEC_safe_push (mem_range_s, *result, NULL);
4672 nr->start = max (lo1, lo2);
4673 nr->length = min (hi1, hi2) - nr->start;
4676 normalize_mem_ranges (*result);
4683 /* module initialization */
4685 _initialize_tracepoint (void)
4687 struct cmd_list_element *c;
4689 /* Explicitly create without lookup, since that tries to create a
4690 value with a void typed value, and when we get here, gdbarch
4691 isn't initialized yet. At this point, we're quite sure there
4692 isn't another convenience variable of the same name. */
4693 create_internalvar_type_lazy ("_sdata", sdata_make_value);
4695 traceframe_number = -1;
4696 tracepoint_number = -1;
4698 if (tracepoint_list.list == NULL)
4700 tracepoint_list.listsize = 128;
4701 tracepoint_list.list = xmalloc
4702 (tracepoint_list.listsize * sizeof (struct memrange));
4704 if (tracepoint_list.aexpr_list == NULL)
4706 tracepoint_list.aexpr_listsize = 128;
4707 tracepoint_list.aexpr_list = xmalloc
4708 (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
4711 if (stepping_list.list == NULL)
4713 stepping_list.listsize = 128;
4714 stepping_list.list = xmalloc
4715 (stepping_list.listsize * sizeof (struct memrange));
4718 if (stepping_list.aexpr_list == NULL)
4720 stepping_list.aexpr_listsize = 128;
4721 stepping_list.aexpr_list = xmalloc
4722 (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
4725 add_info ("scope", scope_info,
4726 _("List the variables local to a scope"));
4728 add_cmd ("tracepoints", class_trace, NULL,
4729 _("Tracing of program execution without stopping the program."),
4732 add_com ("tdump", class_trace, trace_dump_command,
4733 _("Print everything collected at the current tracepoint."));
4735 add_com ("tsave", class_trace, trace_save_command, _("\
4736 Save the trace data to a file.\n\
4737 Use the '-r' option to direct the target to save directly to the file,\n\
4738 using its own filesystem."));
4740 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
4741 Define a trace state variable.\n\
4742 Argument is a $-prefixed name, optionally followed\n\
4743 by '=' and an expression that sets the initial value\n\
4744 at the start of tracing."));
4745 set_cmd_completer (c, expression_completer);
4747 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
4748 Delete one or more trace state variables.\n\
4749 Arguments are the names of the variables to delete.\n\
4750 If no arguments are supplied, delete all variables."), &deletelist);
4751 /* FIXME add a trace variable completer. */
4753 add_info ("tvariables", tvariables_info, _("\
4754 Status of trace state variables and their values.\n\
4757 add_info ("static-tracepoint-markers",
4758 info_static_tracepoint_markers_command, _("\
4759 List target static tracepoints markers.\n\
4762 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
4763 Select a trace frame;\n\
4764 No argument means forward by one frame; '-' means backward by one frame."),
4765 &tfindlist, "tfind ", 1, &cmdlist);
4767 add_cmd ("outside", class_trace, trace_find_outside_command, _("\
4768 Select a trace frame whose PC is outside the given range (exclusive).\n\
4769 Usage: tfind outside addr1, addr2"),
4772 add_cmd ("range", class_trace, trace_find_range_command, _("\
4773 Select a trace frame whose PC is in the given range (inclusive).\n\
4774 Usage: tfind range addr1,addr2"),
4777 add_cmd ("line", class_trace, trace_find_line_command, _("\
4778 Select a trace frame by source line.\n\
4779 Argument can be a line number (with optional source file),\n\
4780 a function name, or '*' followed by an address.\n\
4781 Default argument is 'the next source line that was traced'."),
4784 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
4785 Select a trace frame by tracepoint number.\n\
4786 Default is the tracepoint for the current trace frame."),
4789 add_cmd ("pc", class_trace, trace_find_pc_command, _("\
4790 Select a trace frame by PC.\n\
4791 Default is the current PC, or the PC of the current trace frame."),
4794 add_cmd ("end", class_trace, trace_find_end_command, _("\
4795 Synonym for 'none'.\n\
4796 De-select any trace frame and resume 'live' debugging."),
4799 add_cmd ("none", class_trace, trace_find_none_command,
4800 _("De-select any trace frame and resume 'live' debugging."),
4803 add_cmd ("start", class_trace, trace_find_start_command,
4804 _("Select the first trace frame in the trace buffer."),
4807 add_com ("tstatus", class_trace, trace_status_command,
4808 _("Display the status of the current trace data collection."));
4810 add_com ("tstop", class_trace, trace_stop_command,
4811 _("Stop trace data collection."));
4813 add_com ("tstart", class_trace, trace_start_command,
4814 _("Start trace data collection."));
4816 add_com ("end", class_trace, end_actions_pseudocommand, _("\
4817 Ends a list of commands or actions.\n\
4818 Several GDB commands allow you to enter a list of commands or actions.\n\
4819 Entering \"end\" on a line by itself is the normal way to terminate\n\
4821 Note: the \"end\" command cannot be used at the gdb prompt."));
4823 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
4824 Specify single-stepping behavior at a tracepoint.\n\
4825 Argument is number of instructions to trace in single-step mode\n\
4826 following the tracepoint. This command is normally followed by\n\
4827 one or more \"collect\" commands, to specify what to collect\n\
4828 while single-stepping.\n\n\
4829 Note: this command can only be used in a tracepoint \"actions\" list."));
4831 add_com_alias ("ws", "while-stepping", class_alias, 0);
4832 add_com_alias ("stepping", "while-stepping", class_alias, 0);
4834 add_com ("collect", class_trace, collect_pseudocommand, _("\
4835 Specify one or more data items to be collected at a tracepoint.\n\
4836 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4837 collect all data (variables, registers) referenced by that expression.\n\
4838 Also accepts the following special arguments:\n\
4839 $regs -- all registers.\n\
4840 $args -- all function arguments.\n\
4841 $locals -- all variables local to the block/function scope.\n\
4842 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4843 Note: this command can only be used in a tracepoint \"actions\" list."));
4845 add_com ("teval", class_trace, teval_pseudocommand, _("\
4846 Specify one or more expressions to be evaluated at a tracepoint.\n\
4847 Accepts a comma-separated list of (one or more) expressions.\n\
4848 The result of each evaluation will be discarded.\n\
4849 Note: this command can only be used in a tracepoint \"actions\" list."));
4851 add_com ("actions", class_trace, trace_actions_command, _("\
4852 Specify the actions to be taken at a tracepoint.\n\
4853 Tracepoint actions may include collecting of specified data,\n\
4854 single-stepping, or enabling/disabling other tracepoints,\n\
4855 depending on target's capabilities."));
4857 default_collect = xstrdup ("");
4858 add_setshow_string_cmd ("default-collect", class_trace,
4859 &default_collect, _("\
4860 Set the list of expressions to collect by default"), _("\
4861 Show the list of expressions to collect by default"), NULL,
4863 &setlist, &showlist);
4865 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
4866 &disconnected_tracing, _("\
4867 Set whether tracing continues after GDB disconnects."), _("\
4868 Show whether tracing continues after GDB disconnects."), _("\
4869 Use this to continue a tracing run even if GDB disconnects\n\
4870 or detaches from the target. You can reconnect later and look at\n\
4871 trace data collected in the meantime."),
4872 set_disconnected_tracing,
4877 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
4878 &circular_trace_buffer, _("\
4879 Set target's use of circular trace buffer."), _("\
4880 Show target's use of circular trace buffer."), _("\
4881 Use this to make the trace buffer into a circular buffer,\n\
4882 which will discard traceframes (oldest first) instead of filling\n\
4883 up and stopping the trace run."),
4884 set_circular_trace_buffer,
4891 add_target (&tfile_ops);