1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
4 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "arch-utils.h"
26 #include "expression.h"
31 #include "gdb_string.h"
33 #include "breakpoint.h"
34 #include "tracepoint.h"
37 #include "completer.h"
39 #include "dictionary.h"
41 #include "user-regs.h"
45 #include "filenames.h"
46 #include "gdbthread.h"
54 #include "exceptions.h"
55 #include "cli/cli-utils.h"
57 /* readline include files */
58 #include "readline/readline.h"
59 #include "readline/history.h"
61 /* readline defines this. */
72 extern int hex2bin (const char *hex, gdb_byte *bin, int count);
73 extern int bin2hex (const gdb_byte *bin, char *hex, int count);
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
87 /* A hook used to notify the UI of tracepoint operations. */
89 void (*deprecated_trace_find_hook) (char *arg, int from_tty);
90 void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
92 extern void (*deprecated_readline_begin_hook) (char *, ...);
93 extern char *(*deprecated_readline_hook) (char *);
94 extern void (*deprecated_readline_end_hook) (void);
96 /* GDB commands implemented in other modules:
99 extern void output_command (char *, int);
104 This module defines the following debugger commands:
105 trace : set a tracepoint on a function, line, or address.
106 info trace : list all debugger-defined tracepoints.
107 delete trace : delete one or more tracepoints.
108 enable trace : enable one or more tracepoints.
109 disable trace : disable one or more tracepoints.
110 actions : specify actions to be taken at a tracepoint.
111 passcount : specify a pass count for a tracepoint.
112 tstart : start a trace experiment.
113 tstop : stop a trace experiment.
114 tstatus : query the status of a trace experiment.
115 tfind : find a trace frame in the trace buffer.
116 tdump : print everything collected at the current tracepoint.
117 save-tracepoints : write tracepoint setup into a file.
119 This module defines the following user-visible debugger variables:
120 $trace_frame : sequence number of trace frame currently being debugged.
121 $trace_line : source line of trace frame currently being debugged.
122 $trace_file : source file of trace frame currently being debugged.
123 $tracepoint : tracepoint number of trace frame currently being debugged.
127 /* ======= Important global variables: ======= */
129 /* The list of all trace state variables. We don't retain pointers to
130 any of these for any reason - API is by name or number only - so it
131 works to have a vector of objects. */
133 typedef struct trace_state_variable tsv_s;
136 /* An object describing the contents of a traceframe. */
138 struct traceframe_info
140 /* Collected memory. */
141 VEC(mem_range_s) *memory;
144 static VEC(tsv_s) *tvariables;
146 /* The next integer to assign to a variable. */
148 static int next_tsv_number = 1;
150 /* Number of last traceframe collected. */
151 static int traceframe_number;
153 /* Tracepoint for last traceframe collected. */
154 static int tracepoint_number;
156 /* Symbol for function for last traceframe collected. */
157 static struct symbol *traceframe_fun;
159 /* Symtab and line for last traceframe collected. */
160 static struct symtab_and_line traceframe_sal;
162 /* The traceframe info of the current traceframe. NULL if we haven't
163 yet attempted to fetch it, or if the target does not support
164 fetching this object, or if we're not inspecting a traceframe
166 static struct traceframe_info *traceframe_info;
168 /* Tracing command lists. */
169 static struct cmd_list_element *tfindlist;
171 /* List of expressions to collect by default at each tracepoint hit. */
172 char *default_collect = "";
174 static int disconnected_tracing;
176 /* This variable controls whether we ask the target for a linear or
177 circular trace buffer. */
179 static int circular_trace_buffer;
181 /* ======= Important command functions: ======= */
182 static void trace_actions_command (char *, int);
183 static void trace_start_command (char *, int);
184 static void trace_stop_command (char *, int);
185 static void trace_status_command (char *, int);
186 static void trace_find_command (char *, int);
187 static void trace_find_pc_command (char *, int);
188 static void trace_find_tracepoint_command (char *, int);
189 static void trace_find_line_command (char *, int);
190 static void trace_find_range_command (char *, int);
191 static void trace_find_outside_command (char *, int);
192 static void trace_dump_command (char *, int);
194 /* support routines */
196 struct collection_list;
197 static void add_aexpr (struct collection_list *, struct agent_expr *);
198 static char *mem2hex (gdb_byte *, char *, int);
199 static void add_register (struct collection_list *collection,
202 extern void send_disconnected_tracing_value (int value);
204 static void free_uploaded_tps (struct uploaded_tp **utpp);
205 static void free_uploaded_tsvs (struct uploaded_tsv **utsvp);
208 extern void _initialize_tracepoint (void);
210 static struct trace_status trace_status;
212 char *stop_reason_names[] = {
222 struct trace_status *
223 current_trace_status (void)
225 return &trace_status;
231 free_traceframe_info (struct traceframe_info *info)
235 VEC_free (mem_range_s, info->memory);
241 /* Free and clear the traceframe info cache of the current
245 clear_traceframe_info (void)
247 free_traceframe_info (traceframe_info);
248 traceframe_info = NULL;
251 /* Set traceframe number to NUM. */
253 set_traceframe_num (int num)
255 traceframe_number = num;
256 set_internalvar_integer (lookup_internalvar ("trace_frame"), num);
259 /* Set tracepoint number to NUM. */
261 set_tracepoint_num (int num)
263 tracepoint_number = num;
264 set_internalvar_integer (lookup_internalvar ("tracepoint"), num);
267 /* Set externally visible debug variables for querying/printing
268 the traceframe context (line, function, file). */
271 set_traceframe_context (struct frame_info *trace_frame)
275 /* Save as globals for internal use. */
276 if (trace_frame != NULL
277 && get_frame_pc_if_available (trace_frame, &trace_pc))
279 traceframe_sal = find_pc_line (trace_pc, 0);
280 traceframe_fun = find_pc_function (trace_pc);
282 /* Save linenumber as "$trace_line", a debugger variable visible to
284 set_internalvar_integer (lookup_internalvar ("trace_line"),
285 traceframe_sal.line);
289 init_sal (&traceframe_sal);
290 traceframe_fun = NULL;
291 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
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;
461 struct ui_out *uiout = current_uiout;
463 if (VEC_length (tsv_s, tvariables) == 0 && !ui_out_is_mi_like_p (uiout))
465 printf_filtered (_("No trace state variables.\n"));
469 /* Try to acquire values from the target. */
470 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix, ++count)
471 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
474 back_to = make_cleanup_ui_out_table_begin_end (uiout, 3,
475 count, "trace-variables");
476 ui_out_table_header (uiout, 15, ui_left, "name", "Name");
477 ui_out_table_header (uiout, 11, ui_left, "initial", "Initial");
478 ui_out_table_header (uiout, 11, ui_left, "current", "Current");
480 ui_out_table_body (uiout);
482 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
484 struct cleanup *back_to2;
488 back_to2 = make_cleanup_ui_out_tuple_begin_end (uiout, "variable");
490 name = concat ("$", tsv->name, (char *) NULL);
491 make_cleanup (xfree, name);
492 ui_out_field_string (uiout, "name", name);
493 ui_out_field_string (uiout, "initial", plongest (tsv->initial_value));
495 if (tsv->value_known)
496 c = plongest (tsv->value);
497 else if (ui_out_is_mi_like_p (uiout))
498 /* For MI, we prefer not to use magic string constants, but rather
499 omit the field completely. The difference between unknown and
500 undefined does not seem important enough to represent. */
502 else if (current_trace_status ()->running || traceframe_number >= 0)
503 /* The value is/was defined, but we don't have it. */
506 /* It is not meaningful to ask about the value. */
509 ui_out_field_string (uiout, "current", c);
510 ui_out_text (uiout, "\n");
512 do_cleanups (back_to2);
515 do_cleanups (back_to);
518 /* List all the trace state variables. */
521 tvariables_info (char *args, int from_tty)
523 tvariables_info_1 ();
526 /* Stash definitions of tsvs into the given file. */
529 save_trace_state_variables (struct ui_file *fp)
531 struct trace_state_variable *tsv;
534 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
536 fprintf_unfiltered (fp, "tvariable $%s", tsv->name);
537 if (tsv->initial_value)
538 fprintf_unfiltered (fp, " = %s", plongest (tsv->initial_value));
539 fprintf_unfiltered (fp, "\n");
543 /* ACTIONS functions: */
545 /* The three functions:
546 collect_pseudocommand,
547 while_stepping_pseudocommand, and
548 end_actions_pseudocommand
549 are placeholders for "commands" that are actually ONLY to be used
550 within a tracepoint action list. If the actual function is ever called,
551 it means that somebody issued the "command" at the top level,
552 which is always an error. */
555 end_actions_pseudocommand (char *args, int from_tty)
557 error (_("This command cannot be used at the top level."));
561 while_stepping_pseudocommand (char *args, int from_tty)
563 error (_("This command can only be used in a tracepoint actions list."));
567 collect_pseudocommand (char *args, int from_tty)
569 error (_("This command can only be used in a tracepoint actions list."));
573 teval_pseudocommand (char *args, int from_tty)
575 error (_("This command can only be used in a tracepoint actions list."));
578 /* Parse any collection options, such as /s for strings. */
581 decode_agent_options (char *exp)
583 struct value_print_options opts;
588 /* Call this to borrow the print elements default for collection
590 get_user_print_options (&opts);
595 if (target_supports_string_tracing ())
597 /* Allow an optional decimal number giving an explicit maximum
598 string length, defaulting it to the "print elements" value;
599 so "collect/s80 mystr" gets at most 80 bytes of string. */
600 trace_string_kludge = opts.print_max;
602 if (*exp >= '0' && *exp <= '9')
603 trace_string_kludge = atoi (exp);
604 while (*exp >= '0' && *exp <= '9')
608 error (_("Target does not support \"/s\" option for string tracing."));
611 error (_("Undefined collection format \"%c\"."), *exp);
613 exp = skip_spaces (exp);
618 /* Enter a list of actions for a tracepoint. */
620 trace_actions_command (char *args, int from_tty)
622 struct tracepoint *t;
623 struct command_line *l;
625 t = get_tracepoint_by_number (&args, NULL, 1);
629 xstrprintf ("Enter actions for tracepoint %d, one per line.",
631 struct cleanup *cleanups = make_cleanup (xfree, tmpbuf);
633 l = read_command_lines (tmpbuf, from_tty, 1,
634 check_tracepoint_command, t);
635 do_cleanups (cleanups);
636 breakpoint_set_commands (&t->base, l);
638 /* else just return */
641 /* Report the results of checking the agent expression, as errors or
645 report_agent_reqs_errors (struct agent_expr *aexpr)
647 /* All of the "flaws" are serious bytecode generation issues that
648 should never occur. */
649 if (aexpr->flaw != agent_flaw_none)
650 internal_error (__FILE__, __LINE__, _("expression is malformed"));
652 /* If analysis shows a stack underflow, GDB must have done something
653 badly wrong in its bytecode generation. */
654 if (aexpr->min_height < 0)
655 internal_error (__FILE__, __LINE__,
656 _("expression has min height < 0"));
658 /* Issue this error if the stack is predicted to get too deep. The
659 limit is rather arbitrary; a better scheme might be for the
660 target to report how much stack it will have available. The
661 depth roughly corresponds to parenthesization, so a limit of 20
662 amounts to 20 levels of expression nesting, which is actually
663 a pretty big hairy expression. */
664 if (aexpr->max_height > 20)
665 error (_("Expression is too complicated."));
668 /* worker function */
670 validate_actionline (char **line, struct breakpoint *b)
672 struct cmd_list_element *c;
673 struct expression *exp = NULL;
674 struct cleanup *old_chain = NULL;
676 struct bp_location *loc;
677 struct agent_expr *aexpr;
678 struct tracepoint *t = (struct tracepoint *) b;
680 /* If EOF is typed, *line is NULL. */
684 for (p = *line; isspace ((int) *p);)
687 /* Symbol lookup etc. */
688 if (*p == '\0') /* empty line: just prompt for another line. */
691 if (*p == '#') /* comment line */
694 c = lookup_cmd (&p, cmdlist, "", -1, 1);
696 error (_("`%s' is not a tracepoint action, or is ambiguous."), p);
698 if (cmd_cfunc_eq (c, collect_pseudocommand))
700 trace_string_kludge = 0;
702 p = decode_agent_options (p);
705 { /* Repeat over a comma-separated list. */
706 QUIT; /* Allow user to bail out with ^C. */
707 while (isspace ((int) *p))
710 if (*p == '$') /* Look for special pseudo-symbols. */
712 if (0 == strncasecmp ("reg", p + 1, 3)
713 || 0 == strncasecmp ("arg", p + 1, 3)
714 || 0 == strncasecmp ("loc", p + 1, 3)
715 || 0 == strncasecmp ("_ret", p + 1, 4)
716 || 0 == strncasecmp ("_sdata", p + 1, 6))
721 /* else fall thru, treat p as an expression and parse it! */
724 for (loc = t->base.loc; loc; loc = loc->next)
727 exp = parse_exp_1 (&p, block_for_pc (loc->address), 1);
728 old_chain = make_cleanup (free_current_contents, &exp);
730 if (exp->elts[0].opcode == OP_VAR_VALUE)
732 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
734 error (_("constant `%s' (value %ld) "
735 "will not be collected."),
736 SYMBOL_PRINT_NAME (exp->elts[2].symbol),
737 SYMBOL_VALUE (exp->elts[2].symbol));
739 else if (SYMBOL_CLASS (exp->elts[2].symbol)
740 == LOC_OPTIMIZED_OUT)
742 error (_("`%s' is optimized away "
743 "and cannot be collected."),
744 SYMBOL_PRINT_NAME (exp->elts[2].symbol));
748 /* We have something to collect, make sure that the expr to
749 bytecode translator can handle it and that it's not too
751 aexpr = gen_trace_for_expr (loc->address, exp);
752 make_cleanup_free_agent_expr (aexpr);
754 if (aexpr->len > MAX_AGENT_EXPR_LEN)
755 error (_("Expression is too complicated."));
759 report_agent_reqs_errors (aexpr);
761 do_cleanups (old_chain);
764 while (p && *p++ == ',');
767 else if (cmd_cfunc_eq (c, teval_pseudocommand))
770 { /* Repeat over a comma-separated list. */
771 QUIT; /* Allow user to bail out with ^C. */
772 while (isspace ((int) *p))
776 for (loc = t->base.loc; loc; loc = loc->next)
779 /* Only expressions are allowed for this action. */
780 exp = parse_exp_1 (&p, block_for_pc (loc->address), 1);
781 old_chain = make_cleanup (free_current_contents, &exp);
783 /* We have something to evaluate, make sure that the expr to
784 bytecode translator can handle it and that it's not too
786 aexpr = gen_eval_for_expr (loc->address, exp);
787 make_cleanup_free_agent_expr (aexpr);
789 if (aexpr->len > MAX_AGENT_EXPR_LEN)
790 error (_("Expression is too complicated."));
793 report_agent_reqs_errors (aexpr);
795 do_cleanups (old_chain);
798 while (p && *p++ == ',');
801 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
803 char *steparg; /* In case warning is necessary. */
805 while (isspace ((int) *p))
809 if (*p == '\0' || (t->step_count = strtol (p, &p, 0)) == 0)
810 error (_("while-stepping step count `%s' is malformed."), *line);
813 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
817 error (_("`%s' is not a supported tracepoint action."), *line);
821 memrange_absolute = -1
826 int type; /* memrange_absolute for absolute memory range,
827 else basereg number. */
828 bfd_signed_vma start;
832 struct collection_list
834 unsigned char regs_mask[32]; /* room for up to 256 regs */
837 struct memrange *list;
838 long aexpr_listsize; /* size of array pointed to by expr_list elt */
840 struct agent_expr **aexpr_list;
842 /* True is the user requested a collection of "$_sdata", "static
846 tracepoint_list, stepping_list;
848 /* MEMRANGE functions: */
850 static int memrange_cmp (const void *, const void *);
852 /* Compare memranges for qsort. */
854 memrange_cmp (const void *va, const void *vb)
856 const struct memrange *a = va, *b = vb;
858 if (a->type < b->type)
860 if (a->type > b->type)
862 if (a->type == memrange_absolute)
864 if ((bfd_vma) a->start < (bfd_vma) b->start)
866 if ((bfd_vma) a->start > (bfd_vma) b->start)
871 if (a->start < b->start)
873 if (a->start > b->start)
879 /* Sort the memrange list using qsort, and merge adjacent memranges. */
881 memrange_sortmerge (struct collection_list *memranges)
885 qsort (memranges->list, memranges->next_memrange,
886 sizeof (struct memrange), memrange_cmp);
887 if (memranges->next_memrange > 0)
889 for (a = 0, b = 1; b < memranges->next_memrange; b++)
891 /* If memrange b overlaps or is adjacent to memrange a,
893 if (memranges->list[a].type == memranges->list[b].type
894 && memranges->list[b].start <= memranges->list[a].end)
896 if (memranges->list[b].end > memranges->list[a].end)
897 memranges->list[a].end = memranges->list[b].end;
898 continue; /* next b, same a */
902 memcpy (&memranges->list[a], &memranges->list[b],
903 sizeof (struct memrange));
905 memranges->next_memrange = a + 1;
909 /* Add a register to a collection list. */
911 add_register (struct collection_list *collection, unsigned int regno)
914 printf_filtered ("collect register %d\n", regno);
915 if (regno >= (8 * sizeof (collection->regs_mask)))
916 error (_("Internal: register number %d too large for tracepoint"),
918 collection->regs_mask[regno / 8] |= 1 << (regno % 8);
921 /* Add a memrange to a collection list. */
923 add_memrange (struct collection_list *memranges,
924 int type, bfd_signed_vma base,
929 printf_filtered ("(%d,", type);
931 printf_filtered (",%ld)\n", len);
934 /* type: memrange_absolute == memory, other n == basereg */
935 memranges->list[memranges->next_memrange].type = type;
936 /* base: addr if memory, offset if reg relative. */
937 memranges->list[memranges->next_memrange].start = base;
938 /* len: we actually save end (base + len) for convenience */
939 memranges->list[memranges->next_memrange].end = base + len;
940 memranges->next_memrange++;
941 if (memranges->next_memrange >= memranges->listsize)
943 memranges->listsize *= 2;
944 memranges->list = xrealloc (memranges->list,
945 memranges->listsize);
948 if (type != memrange_absolute) /* Better collect the base register! */
949 add_register (memranges, type);
952 /* Add a symbol to a collection list. */
954 collect_symbol (struct collection_list *collect,
956 struct gdbarch *gdbarch,
957 long frame_regno, long frame_offset,
962 bfd_signed_vma offset;
963 int treat_as_expr = 0;
965 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
966 switch (SYMBOL_CLASS (sym))
969 printf_filtered ("%s: don't know symbol class %d\n",
970 SYMBOL_PRINT_NAME (sym),
974 printf_filtered ("constant %s (value %ld) will not be collected.\n",
975 SYMBOL_PRINT_NAME (sym), SYMBOL_VALUE (sym));
978 offset = SYMBOL_VALUE_ADDRESS (sym);
983 sprintf_vma (tmp, offset);
984 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
985 SYMBOL_PRINT_NAME (sym), len,
988 /* A struct may be a C++ class with static fields, go to general
989 expression handling. */
990 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
993 add_memrange (collect, memrange_absolute, offset, len);
996 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
998 printf_filtered ("LOC_REG[parm] %s: ",
999 SYMBOL_PRINT_NAME (sym));
1000 add_register (collect, reg);
1001 /* Check for doubles stored in two registers. */
1002 /* FIXME: how about larger types stored in 3 or more regs? */
1003 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
1004 len > register_size (gdbarch, reg))
1005 add_register (collect, reg + 1);
1008 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1009 printf_filtered (" (will not collect %s)\n",
1010 SYMBOL_PRINT_NAME (sym));
1014 offset = frame_offset + SYMBOL_VALUE (sym);
1017 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1018 SYMBOL_PRINT_NAME (sym), len);
1019 printf_vma (offset);
1020 printf_filtered (" from frame ptr reg %d\n", reg);
1022 add_memrange (collect, reg, offset, len);
1024 case LOC_REGPARM_ADDR:
1025 reg = SYMBOL_VALUE (sym);
1029 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1030 SYMBOL_PRINT_NAME (sym), len);
1031 printf_vma (offset);
1032 printf_filtered (" from reg %d\n", reg);
1034 add_memrange (collect, reg, offset, len);
1038 offset = frame_offset + SYMBOL_VALUE (sym);
1041 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1042 SYMBOL_PRINT_NAME (sym), len);
1043 printf_vma (offset);
1044 printf_filtered (" from frame ptr reg %d\n", reg);
1046 add_memrange (collect, reg, offset, len);
1049 case LOC_UNRESOLVED:
1053 case LOC_OPTIMIZED_OUT:
1054 printf_filtered ("%s has been optimized out of existence.\n",
1055 SYMBOL_PRINT_NAME (sym));
1063 /* Expressions are the most general case. */
1066 struct agent_expr *aexpr;
1067 struct cleanup *old_chain1 = NULL;
1069 aexpr = gen_trace_for_var (scope, gdbarch, sym);
1071 /* It can happen that the symbol is recorded as a computed
1072 location, but it's been optimized away and doesn't actually
1073 have a location expression. */
1076 printf_filtered ("%s has been optimized out of existence.\n",
1077 SYMBOL_PRINT_NAME (sym));
1081 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1085 report_agent_reqs_errors (aexpr);
1087 discard_cleanups (old_chain1);
1088 add_aexpr (collect, aexpr);
1090 /* Take care of the registers. */
1091 if (aexpr->reg_mask_len > 0)
1095 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1097 QUIT; /* Allow user to bail out with ^C. */
1098 if (aexpr->reg_mask[ndx1] != 0)
1100 /* Assume chars have 8 bits. */
1101 for (ndx2 = 0; ndx2 < 8; ndx2++)
1102 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1103 /* It's used -- record it. */
1104 add_register (collect, ndx1 * 8 + ndx2);
1111 /* Data to be passed around in the calls to the locals and args
1114 struct add_local_symbols_data
1116 struct collection_list *collect;
1117 struct gdbarch *gdbarch;
1124 /* The callback for the locals and args iterators. */
1127 do_collect_symbol (const char *print_name,
1131 struct add_local_symbols_data *p = cb_data;
1133 collect_symbol (p->collect, sym, p->gdbarch, p->frame_regno,
1134 p->frame_offset, p->pc);
1138 /* Add all locals (or args) symbols to collection list. */
1140 add_local_symbols (struct collection_list *collect,
1141 struct gdbarch *gdbarch, CORE_ADDR pc,
1142 long frame_regno, long frame_offset, int type)
1144 struct block *block;
1145 struct add_local_symbols_data cb_data;
1147 cb_data.collect = collect;
1148 cb_data.gdbarch = gdbarch;
1150 cb_data.frame_regno = frame_regno;
1151 cb_data.frame_offset = frame_offset;
1156 block = block_for_pc (pc);
1159 warning (_("Can't collect locals; "
1160 "no symbol table info available.\n"));
1164 iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1165 if (cb_data.count == 0)
1166 warning (_("No locals found in scope."));
1170 pc = get_pc_function_start (pc);
1171 block = block_for_pc (pc);
1174 warning (_("Can't collect args; no symbol table info available."));
1178 iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1179 if (cb_data.count == 0)
1180 warning (_("No args found in scope."));
1185 add_static_trace_data (struct collection_list *collection)
1188 printf_filtered ("collect static trace data\n");
1189 collection->strace_data = 1;
1192 /* worker function */
1194 clear_collection_list (struct collection_list *list)
1198 list->next_memrange = 0;
1199 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1201 free_agent_expr (list->aexpr_list[ndx]);
1202 list->aexpr_list[ndx] = NULL;
1204 list->next_aexpr_elt = 0;
1205 memset (list->regs_mask, 0, sizeof (list->regs_mask));
1206 list->strace_data = 0;
1209 /* Reduce a collection list to string form (for gdb protocol). */
1211 stringify_collection_list (struct collection_list *list, char *string)
1213 char temp_buf[2048];
1217 char *(*str_list)[];
1221 count = 1 + 1 + list->next_memrange + list->next_aexpr_elt + 1;
1222 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1224 if (list->strace_data)
1227 printf_filtered ("\nCollecting static trace data\n");
1230 (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
1234 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1235 if (list->regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */
1237 if (list->regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
1240 printf_filtered ("\nCollecting registers (mask): 0x");
1245 QUIT; /* Allow user to bail out with ^C. */
1247 printf_filtered ("%02X", list->regs_mask[i]);
1248 sprintf (end, "%02X", list->regs_mask[i]);
1251 (*str_list)[ndx] = xstrdup (temp_buf);
1255 printf_filtered ("\n");
1256 if (list->next_memrange > 0 && info_verbose)
1257 printf_filtered ("Collecting memranges: \n");
1258 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1260 QUIT; /* Allow user to bail out with ^C. */
1261 sprintf_vma (tmp2, list->list[i].start);
1264 printf_filtered ("(%d, %s, %ld)\n",
1267 (long) (list->list[i].end - list->list[i].start));
1269 if (count + 27 > MAX_AGENT_EXPR_LEN)
1271 (*str_list)[ndx] = savestring (temp_buf, count);
1278 bfd_signed_vma length = list->list[i].end - list->list[i].start;
1280 /* The "%X" conversion specifier expects an unsigned argument,
1281 so passing -1 (memrange_absolute) to it directly gives you
1282 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1284 if (list->list[i].type == memrange_absolute)
1285 sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
1287 sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
1290 count += strlen (end);
1291 end = temp_buf + count;
1294 for (i = 0; i < list->next_aexpr_elt; i++)
1296 QUIT; /* Allow user to bail out with ^C. */
1297 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1299 (*str_list)[ndx] = savestring (temp_buf, count);
1304 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1305 end += 10; /* 'X' + 8 hex digits + ',' */
1308 end = mem2hex (list->aexpr_list[i]->buf,
1309 end, list->aexpr_list[i]->len);
1310 count += 2 * list->aexpr_list[i]->len;
1315 (*str_list)[ndx] = savestring (temp_buf, count);
1320 (*str_list)[ndx] = NULL;
1333 encode_actions_1 (struct command_line *action,
1334 struct breakpoint *t,
1335 struct bp_location *tloc,
1337 LONGEST frame_offset,
1338 struct collection_list *collect,
1339 struct collection_list *stepping_list)
1342 struct expression *exp = NULL;
1344 struct value *tempval;
1345 struct cmd_list_element *cmd;
1346 struct agent_expr *aexpr;
1348 for (; action; action = action->next)
1350 QUIT; /* Allow user to bail out with ^C. */
1351 action_exp = action->line;
1352 while (isspace ((int) *action_exp))
1355 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1357 error (_("Bad action list item: %s"), action_exp);
1359 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1361 trace_string_kludge = 0;
1362 if (*action_exp == '/')
1363 action_exp = decode_agent_options (action_exp);
1366 { /* Repeat over a comma-separated list. */
1367 QUIT; /* Allow user to bail out with ^C. */
1368 while (isspace ((int) *action_exp))
1371 if (0 == strncasecmp ("$reg", action_exp, 4))
1373 for (i = 0; i < gdbarch_num_regs (t->gdbarch); i++)
1374 add_register (collect, i);
1375 action_exp = strchr (action_exp, ','); /* more? */
1377 else if (0 == strncasecmp ("$arg", action_exp, 4))
1379 add_local_symbols (collect,
1385 action_exp = strchr (action_exp, ','); /* more? */
1387 else if (0 == strncasecmp ("$loc", action_exp, 4))
1389 add_local_symbols (collect,
1395 action_exp = strchr (action_exp, ','); /* more? */
1397 else if (0 == strncasecmp ("$_ret", action_exp, 5))
1399 struct cleanup *old_chain1 = NULL;
1401 aexpr = gen_trace_for_return_address (tloc->address,
1404 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1407 report_agent_reqs_errors (aexpr);
1409 discard_cleanups (old_chain1);
1410 add_aexpr (collect, aexpr);
1412 /* take care of the registers */
1413 if (aexpr->reg_mask_len > 0)
1417 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1419 QUIT; /* allow user to bail out with ^C */
1420 if (aexpr->reg_mask[ndx1] != 0)
1422 /* assume chars have 8 bits */
1423 for (ndx2 = 0; ndx2 < 8; ndx2++)
1424 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1425 /* it's used -- record it */
1426 add_register (collect,
1432 action_exp = strchr (action_exp, ','); /* more? */
1434 else if (0 == strncasecmp ("$_sdata", action_exp, 7))
1436 add_static_trace_data (collect);
1437 action_exp = strchr (action_exp, ','); /* more? */
1441 unsigned long addr, len;
1442 struct cleanup *old_chain = NULL;
1443 struct cleanup *old_chain1 = NULL;
1445 exp = parse_exp_1 (&action_exp,
1446 block_for_pc (tloc->address), 1);
1447 old_chain = make_cleanup (free_current_contents, &exp);
1449 switch (exp->elts[0].opcode)
1453 const char *name = &exp->elts[2].string;
1455 i = user_reg_map_name_to_regnum (t->gdbarch,
1456 name, strlen (name));
1458 internal_error (__FILE__, __LINE__,
1459 _("Register $%s not available"),
1462 printf_filtered ("OP_REGISTER: ");
1463 add_register (collect, i);
1468 /* Safe because we know it's a simple expression. */
1469 tempval = evaluate_expression (exp);
1470 addr = value_address (tempval);
1471 len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
1472 add_memrange (collect, memrange_absolute, addr, len);
1476 collect_symbol (collect,
1477 exp->elts[2].symbol,
1484 default: /* Full-fledged expression. */
1485 aexpr = gen_trace_for_expr (tloc->address, exp);
1487 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1491 report_agent_reqs_errors (aexpr);
1493 discard_cleanups (old_chain1);
1494 add_aexpr (collect, aexpr);
1496 /* Take care of the registers. */
1497 if (aexpr->reg_mask_len > 0)
1502 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1504 QUIT; /* Allow user to bail out with ^C. */
1505 if (aexpr->reg_mask[ndx1] != 0)
1507 /* Assume chars have 8 bits. */
1508 for (ndx2 = 0; ndx2 < 8; ndx2++)
1509 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1510 /* It's used -- record it. */
1511 add_register (collect,
1518 do_cleanups (old_chain);
1521 while (action_exp && *action_exp++ == ',');
1523 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1526 { /* Repeat over a comma-separated list. */
1527 QUIT; /* Allow user to bail out with ^C. */
1528 while (isspace ((int) *action_exp))
1532 struct cleanup *old_chain = NULL;
1533 struct cleanup *old_chain1 = NULL;
1535 exp = parse_exp_1 (&action_exp,
1536 block_for_pc (tloc->address), 1);
1537 old_chain = make_cleanup (free_current_contents, &exp);
1539 aexpr = gen_eval_for_expr (tloc->address, exp);
1540 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1543 report_agent_reqs_errors (aexpr);
1545 discard_cleanups (old_chain1);
1546 /* Even though we're not officially collecting, add
1547 to the collect list anyway. */
1548 add_aexpr (collect, aexpr);
1550 do_cleanups (old_chain);
1553 while (action_exp && *action_exp++ == ',');
1555 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1557 /* We check against nested while-stepping when setting
1558 breakpoint action, so no way to run into nested
1560 gdb_assert (stepping_list);
1562 encode_actions_1 (action->body_list[0], t, tloc, frame_reg,
1563 frame_offset, stepping_list, NULL);
1566 error (_("Invalid tracepoint command '%s'"), action->line);
1570 /* Render all actions into gdb protocol. */
1572 encode_actions (struct breakpoint *t, struct bp_location *tloc,
1573 char ***tdp_actions, char ***stepping_actions)
1575 static char tdp_buff[2048], step_buff[2048];
1576 char *default_collect_line = NULL;
1577 struct command_line *actions;
1578 struct command_line *default_collect_action = NULL;
1580 LONGEST frame_offset;
1581 struct cleanup *back_to;
1583 back_to = make_cleanup (null_cleanup, NULL);
1585 clear_collection_list (&tracepoint_list);
1586 clear_collection_list (&stepping_list);
1588 *tdp_actions = NULL;
1589 *stepping_actions = NULL;
1591 gdbarch_virtual_frame_pointer (t->gdbarch,
1592 t->loc->address, &frame_reg, &frame_offset);
1594 actions = breakpoint_commands (t);
1596 /* If there are default expressions to collect, make up a collect
1597 action and prepend to the action list to encode. Note that since
1598 validation is per-tracepoint (local var "xyz" might be valid for
1599 one tracepoint and not another, etc), we make up the action on
1600 the fly, and don't cache it. */
1601 if (*default_collect)
1605 default_collect_line = xstrprintf ("collect %s", default_collect);
1606 make_cleanup (xfree, default_collect_line);
1608 line = default_collect_line;
1609 validate_actionline (&line, t);
1611 default_collect_action = xmalloc (sizeof (struct command_line));
1612 make_cleanup (xfree, default_collect_action);
1613 default_collect_action->next = actions;
1614 default_collect_action->line = line;
1615 actions = default_collect_action;
1617 encode_actions_1 (actions, t, tloc, frame_reg, frame_offset,
1618 &tracepoint_list, &stepping_list);
1620 memrange_sortmerge (&tracepoint_list);
1621 memrange_sortmerge (&stepping_list);
1623 *tdp_actions = stringify_collection_list (&tracepoint_list,
1625 *stepping_actions = stringify_collection_list (&stepping_list,
1628 do_cleanups (back_to);
1632 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1634 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1636 collect->aexpr_list =
1637 xrealloc (collect->aexpr_list,
1638 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1639 collect->aexpr_listsize *= 2;
1641 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1642 collect->next_aexpr_elt++;
1647 start_tracing (void)
1649 VEC(breakpoint_p) *tp_vec = NULL;
1651 struct breakpoint *b;
1652 struct trace_state_variable *tsv;
1653 int any_enabled = 0, num_to_download = 0;
1655 tp_vec = all_tracepoints ();
1657 /* No point in tracing without any tracepoints... */
1658 if (VEC_length (breakpoint_p, tp_vec) == 0)
1660 VEC_free (breakpoint_p, tp_vec);
1661 error (_("No tracepoints defined, not starting trace"));
1664 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1666 struct tracepoint *t = (struct tracepoint *) b;
1668 if (b->enable_state == bp_enabled)
1671 if ((b->type == bp_fast_tracepoint
1672 ? may_insert_fast_tracepoints
1673 : may_insert_tracepoints))
1676 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1677 (b->type == bp_fast_tracepoint ? "fast " : ""), b->number);
1682 if (target_supports_enable_disable_tracepoint ())
1683 warning (_("No tracepoints enabled"));
1686 /* No point in tracing with only disabled tracepoints that
1687 cannot be re-enabled. */
1688 VEC_free (breakpoint_p, tp_vec);
1689 error (_("No tracepoints enabled, not starting trace"));
1693 if (num_to_download <= 0)
1695 VEC_free (breakpoint_p, tp_vec);
1696 error (_("No tracepoints that may be downloaded, not starting trace"));
1699 target_trace_init ();
1701 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1703 struct tracepoint *t = (struct tracepoint *) b;
1704 struct bp_location *loc;
1706 if ((b->type == bp_fast_tracepoint
1707 ? !may_insert_fast_tracepoints
1708 : !may_insert_tracepoints))
1711 t->number_on_target = 0;
1713 for (loc = b->loc; loc; loc = loc->next)
1714 target_download_tracepoint (loc);
1716 t->number_on_target = b->number;
1718 VEC_free (breakpoint_p, tp_vec);
1720 /* Send down all the trace state variables too. */
1721 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1723 target_download_trace_state_variable (tsv);
1726 /* Tell target to treat text-like sections as transparent. */
1727 target_trace_set_readonly_regions ();
1728 /* Set some mode flags. */
1729 target_set_disconnected_tracing (disconnected_tracing);
1730 target_set_circular_trace_buffer (circular_trace_buffer);
1732 /* Now insert traps and begin collecting data. */
1733 target_trace_start ();
1735 /* Reset our local state. */
1736 set_traceframe_num (-1);
1737 set_tracepoint_num (-1);
1738 set_traceframe_context (NULL);
1739 current_trace_status()->running = 1;
1740 clear_traceframe_info ();
1745 Tell target to clear any previous trace experiment.
1746 Walk the list of tracepoints, and send them (and their actions)
1747 to the target. If no errors,
1748 Tell target to start a new trace experiment. */
1751 trace_start_command (char *args, int from_tty)
1753 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1755 if (current_trace_status ()->running)
1758 && !query (_("A trace is running already. Start a new run? ")))
1759 error (_("New trace run not started."));
1767 trace_stop_command (char *args, int from_tty)
1769 if (!current_trace_status ()->running)
1770 error (_("Trace is not running."));
1778 target_trace_stop ();
1779 /* Should change in response to reply? */
1780 current_trace_status ()->running = 0;
1783 /* tstatus command */
1785 trace_status_command (char *args, int from_tty)
1787 struct trace_status *ts = current_trace_status ();
1790 status = target_get_trace_status (ts);
1795 printf_filtered (_("Using a trace file.\n"));
1798 printf_filtered (_("Trace can not be run on this target.\n"));
1803 if (!ts->running_known)
1805 printf_filtered (_("Run/stop status is unknown.\n"));
1807 else if (ts->running)
1809 printf_filtered (_("Trace is running on the target.\n"));
1813 switch (ts->stop_reason)
1815 case trace_never_run:
1816 printf_filtered (_("No trace has been run on the target.\n"));
1819 printf_filtered (_("Trace stopped by a tstop command.\n"));
1821 case trace_buffer_full:
1822 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1824 case trace_disconnected:
1825 printf_filtered (_("Trace stopped because of disconnection.\n"));
1827 case tracepoint_passcount:
1828 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1829 ts->stopping_tracepoint);
1831 case tracepoint_error:
1832 if (ts->stopping_tracepoint)
1833 printf_filtered (_("Trace stopped by an "
1834 "error (%s, tracepoint %d).\n"),
1835 ts->error_desc, ts->stopping_tracepoint);
1837 printf_filtered (_("Trace stopped by an error (%s).\n"),
1840 case trace_stop_reason_unknown:
1841 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1844 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1850 if (ts->traceframes_created >= 0
1851 && ts->traceframe_count != ts->traceframes_created)
1853 printf_filtered (_("Buffer contains %d trace "
1854 "frames (of %d created total).\n"),
1855 ts->traceframe_count, ts->traceframes_created);
1857 else if (ts->traceframe_count >= 0)
1859 printf_filtered (_("Collected %d trace frames.\n"),
1860 ts->traceframe_count);
1863 if (ts->buffer_free >= 0)
1865 if (ts->buffer_size >= 0)
1867 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1868 ts->buffer_free, ts->buffer_size);
1869 if (ts->buffer_size > 0)
1870 printf_filtered (_(" (%d%% full)"),
1871 ((int) ((((long long) (ts->buffer_size
1872 - ts->buffer_free)) * 100)
1873 / ts->buffer_size)));
1874 printf_filtered (_(".\n"));
1877 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1881 if (ts->disconnected_tracing)
1882 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1884 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1886 if (ts->circular_buffer)
1887 printf_filtered (_("Trace buffer is circular.\n"));
1889 /* Now report on what we're doing with tfind. */
1890 if (traceframe_number >= 0)
1891 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1892 traceframe_number, tracepoint_number);
1894 printf_filtered (_("Not looking at any trace frame.\n"));
1897 /* Report the trace status to uiout, in a way suitable for MI, and not
1898 suitable for CLI. If ON_STOP is true, suppress a few fields that
1899 are not meaningful in the -trace-stop response.
1901 The implementation is essentially parallel to trace_status_command, but
1902 merging them will result in unreadable code. */
1904 trace_status_mi (int on_stop)
1906 struct ui_out *uiout = current_uiout;
1907 struct trace_status *ts = current_trace_status ();
1910 status = target_get_trace_status (ts);
1912 if (status == -1 && !ts->from_file)
1914 ui_out_field_string (uiout, "supported", "0");
1919 ui_out_field_string (uiout, "supported", "file");
1921 ui_out_field_string (uiout, "supported", "1");
1923 gdb_assert (ts->running_known);
1927 ui_out_field_string (uiout, "running", "1");
1929 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1930 Given that the frontend gets the status either on -trace-stop, or from
1931 -trace-status after re-connection, it does not seem like this
1932 information is necessary for anything. It is not necessary for either
1933 figuring the vital state of the target nor for navigation of trace
1934 frames. If the frontend wants to show the current state is some
1935 configure dialog, it can request the value when such dialog is
1936 invoked by the user. */
1940 char *stop_reason = NULL;
1941 int stopping_tracepoint = -1;
1944 ui_out_field_string (uiout, "running", "0");
1946 if (ts->stop_reason != trace_stop_reason_unknown)
1948 switch (ts->stop_reason)
1951 stop_reason = "request";
1953 case trace_buffer_full:
1954 stop_reason = "overflow";
1956 case trace_disconnected:
1957 stop_reason = "disconnection";
1959 case tracepoint_passcount:
1960 stop_reason = "passcount";
1961 stopping_tracepoint = ts->stopping_tracepoint;
1963 case tracepoint_error:
1964 stop_reason = "error";
1965 stopping_tracepoint = ts->stopping_tracepoint;
1971 ui_out_field_string (uiout, "stop-reason", stop_reason);
1972 if (stopping_tracepoint != -1)
1973 ui_out_field_int (uiout, "stopping-tracepoint",
1974 stopping_tracepoint);
1975 if (ts->stop_reason == tracepoint_error)
1976 ui_out_field_string (uiout, "error-description",
1982 if (ts->traceframe_count != -1)
1983 ui_out_field_int (uiout, "frames", ts->traceframe_count);
1984 if (ts->traceframes_created != -1)
1985 ui_out_field_int (uiout, "frames-created", ts->traceframes_created);
1986 if (ts->buffer_size != -1)
1987 ui_out_field_int (uiout, "buffer-size", ts->buffer_size);
1988 if (ts->buffer_free != -1)
1989 ui_out_field_int (uiout, "buffer-free", ts->buffer_free);
1991 ui_out_field_int (uiout, "disconnected", ts->disconnected_tracing);
1992 ui_out_field_int (uiout, "circular", ts->circular_buffer);
1995 /* This function handles the details of what to do about an ongoing
1996 tracing run if the user has asked to detach or otherwise disconnect
1999 disconnect_tracing (int from_tty)
2001 /* It can happen that the target that was tracing went away on its
2002 own, and we didn't notice. Get a status update, and if the
2003 current target doesn't even do tracing, then assume it's not
2005 if (target_get_trace_status (current_trace_status ()) < 0)
2006 current_trace_status ()->running = 0;
2008 /* If running interactively, give the user the option to cancel and
2009 then decide what to do differently with the run. Scripts are
2010 just going to disconnect and let the target deal with it,
2011 according to how it's been instructed previously via
2012 disconnected-tracing. */
2013 if (current_trace_status ()->running && from_tty)
2015 if (current_trace_status ()->disconnected_tracing)
2017 if (!query (_("Trace is running and will "
2018 "continue after detach; detach anyway? ")))
2019 error (_("Not confirmed."));
2023 if (!query (_("Trace is running but will "
2024 "stop on detach; detach anyway? ")))
2025 error (_("Not confirmed."));
2029 /* Also we want to be out of tfind mode, otherwise things can get
2030 confusing upon reconnection. Just use these calls instead of
2031 full tfind_1 behavior because we're in the middle of detaching,
2032 and there's no point to updating current stack frame etc. */
2033 set_current_traceframe (-1);
2034 set_traceframe_context (NULL);
2037 /* Worker function for the various flavors of the tfind command. */
2039 tfind_1 (enum trace_find_type type, int num,
2040 ULONGEST addr1, ULONGEST addr2,
2043 int target_frameno = -1, target_tracept = -1;
2044 struct frame_id old_frame_id = null_frame_id;
2045 struct tracepoint *tp;
2046 struct ui_out *uiout = current_uiout;
2048 /* Only try to get the current stack frame if we have a chance of
2049 succeeding. In particular, if we're trying to get a first trace
2050 frame while all threads are running, it's not going to succeed,
2051 so leave it with a default value and let the frame comparison
2052 below (correctly) decide to print out the source location of the
2054 if (!(type == tfind_number && num == -1)
2055 && (has_stack_frames () || traceframe_number >= 0))
2056 old_frame_id = get_frame_id (get_current_frame ());
2058 target_frameno = target_trace_find (type, num, addr1, addr2,
2061 if (type == tfind_number
2063 && target_frameno == -1)
2065 /* We told the target to get out of tfind mode, and it did. */
2067 else if (target_frameno == -1)
2069 /* A request for a non-existent trace frame has failed.
2070 Our response will be different, depending on FROM_TTY:
2072 If FROM_TTY is true, meaning that this command was
2073 typed interactively by the user, then give an error
2074 and DO NOT change the state of traceframe_number etc.
2076 However if FROM_TTY is false, meaning that we're either
2077 in a script, a loop, or a user-defined command, then
2078 DON'T give an error, but DO change the state of
2079 traceframe_number etc. to invalid.
2081 The rationalle is that if you typed the command, you
2082 might just have committed a typo or something, and you'd
2083 like to NOT lose your current debugging state. However
2084 if you're in a user-defined command or especially in a
2085 loop, then you need a way to detect that the command
2086 failed WITHOUT aborting. This allows you to write
2087 scripts that search thru the trace buffer until the end,
2088 and then continue on to do something else. */
2091 error (_("Target failed to find requested trace frame."));
2095 printf_filtered ("End of trace buffer.\n");
2096 #if 0 /* dubious now? */
2097 /* The following will not recurse, since it's
2099 trace_find_command ("-1", from_tty);
2104 tp = get_tracepoint_by_number_on_target (target_tracept);
2106 reinit_frame_cache ();
2107 registers_changed ();
2108 target_dcache_invalidate ();
2109 set_traceframe_num (target_frameno);
2110 clear_traceframe_info ();
2111 set_tracepoint_num (tp ? tp->base.number : target_tracept);
2112 if (target_frameno == -1)
2113 set_traceframe_context (NULL);
2115 set_traceframe_context (get_current_frame ());
2117 if (traceframe_number >= 0)
2119 /* Use different branches for MI and CLI to make CLI messages
2121 if (ui_out_is_mi_like_p (uiout))
2123 ui_out_field_string (uiout, "found", "1");
2124 ui_out_field_int (uiout, "tracepoint", tracepoint_number);
2125 ui_out_field_int (uiout, "traceframe", traceframe_number);
2129 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2130 traceframe_number, tracepoint_number);
2135 if (ui_out_is_mi_like_p (uiout))
2136 ui_out_field_string (uiout, "found", "0");
2137 else if (type == tfind_number && num == -1)
2138 printf_unfiltered (_("No longer looking at any trace frame\n"));
2139 else /* This case may never occur, check. */
2140 printf_unfiltered (_("No trace frame found\n"));
2143 /* If we're in nonstop mode and getting out of looking at trace
2144 frames, there won't be any current frame to go back to and
2147 && (has_stack_frames () || traceframe_number >= 0))
2149 enum print_what print_what;
2151 /* NOTE: in imitation of the step command, try to determine
2152 whether we have made a transition from one function to
2153 another. If so, we'll print the "stack frame" (ie. the new
2154 function and it's arguments) -- otherwise we'll just show the
2157 if (frame_id_eq (old_frame_id,
2158 get_frame_id (get_current_frame ())))
2159 print_what = SRC_LINE;
2161 print_what = SRC_AND_LOC;
2163 print_stack_frame (get_selected_frame (NULL), 1, print_what);
2168 /* trace_find_command takes a trace frame number n,
2169 sends "QTFrame:<n>" to the target,
2170 and accepts a reply that may contain several optional pieces
2171 of information: a frame number, a tracepoint number, and an
2172 indication of whether this is a trap frame or a stepping frame.
2174 The minimal response is just "OK" (which indicates that the
2175 target does not give us a frame number or a tracepoint number).
2176 Instead of that, the target may send us a string containing
2178 F<hexnum> (gives the selected frame number)
2179 T<hexnum> (gives the selected tracepoint number)
2184 trace_find_command (char *args, int from_tty)
2185 { /* This should only be called with a numeric argument. */
2188 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2189 error (_("May not look at trace frames while trace is running."));
2191 if (args == 0 || *args == 0)
2192 { /* TFIND with no args means find NEXT trace frame. */
2193 if (traceframe_number == -1)
2194 frameno = 0; /* "next" is first one. */
2196 frameno = traceframe_number + 1;
2198 else if (0 == strcmp (args, "-"))
2200 if (traceframe_number == -1)
2201 error (_("not debugging trace buffer"));
2202 else if (from_tty && traceframe_number == 0)
2203 error (_("already at start of trace buffer"));
2205 frameno = traceframe_number - 1;
2207 /* A hack to work around eval's need for fp to have been collected. */
2208 else if (0 == strcmp (args, "-1"))
2211 frameno = parse_and_eval_long (args);
2214 error (_("invalid input (%d is less than zero)"), frameno);
2216 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2221 trace_find_end_command (char *args, int from_tty)
2223 trace_find_command ("-1", from_tty);
2228 trace_find_none_command (char *args, int from_tty)
2230 trace_find_command ("-1", from_tty);
2235 trace_find_start_command (char *args, int from_tty)
2237 trace_find_command ("0", from_tty);
2240 /* tfind pc command */
2242 trace_find_pc_command (char *args, int from_tty)
2246 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2247 error (_("May not look at trace frames while trace is running."));
2249 if (args == 0 || *args == 0)
2250 pc = regcache_read_pc (get_current_regcache ());
2252 pc = parse_and_eval_address (args);
2254 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2257 /* tfind tracepoint command */
2259 trace_find_tracepoint_command (char *args, int from_tty)
2262 struct tracepoint *tp;
2264 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2265 error (_("May not look at trace frames while trace is running."));
2267 if (args == 0 || *args == 0)
2269 if (tracepoint_number == -1)
2270 error (_("No current tracepoint -- please supply an argument."));
2272 tdp = tracepoint_number; /* Default is current TDP. */
2275 tdp = parse_and_eval_long (args);
2277 /* If we have the tracepoint on hand, use the number that the
2278 target knows about (which may be different if we disconnected
2279 and reconnected). */
2280 tp = get_tracepoint (tdp);
2282 tdp = tp->number_on_target;
2284 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2287 /* TFIND LINE command:
2289 This command will take a sourceline for argument, just like BREAK
2290 or TRACE (ie. anything that "decode_line_1" can handle).
2292 With no argument, this command will find the next trace frame
2293 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2296 trace_find_line_command (char *args, int from_tty)
2298 static CORE_ADDR start_pc, end_pc;
2299 struct symtabs_and_lines sals;
2300 struct symtab_and_line sal;
2301 struct cleanup *old_chain;
2303 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2304 error (_("May not look at trace frames while trace is running."));
2306 if (args == 0 || *args == 0)
2308 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2310 sals.sals = (struct symtab_and_line *)
2311 xmalloc (sizeof (struct symtab_and_line));
2316 sals = decode_line_spec (args, 1);
2320 old_chain = make_cleanup (xfree, sals.sals);
2321 if (sal.symtab == 0)
2322 error (_("No line number information available."));
2324 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2326 if (start_pc == end_pc)
2328 printf_filtered ("Line %d of \"%s\"",
2329 sal.line, sal.symtab->filename);
2331 printf_filtered (" is at address ");
2332 print_address (get_current_arch (), start_pc, gdb_stdout);
2334 printf_filtered (" but contains no code.\n");
2335 sal = find_pc_line (start_pc, 0);
2337 && find_line_pc_range (sal, &start_pc, &end_pc)
2338 && start_pc != end_pc)
2339 printf_filtered ("Attempting to find line %d instead.\n",
2342 error (_("Cannot find a good line."));
2346 /* Is there any case in which we get here, and have an address
2347 which the user would want to see? If we have debugging
2348 symbols and no line numbers? */
2349 error (_("Line number %d is out of range for \"%s\"."),
2350 sal.line, sal.symtab->filename);
2352 /* Find within range of stated line. */
2354 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2356 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2357 do_cleanups (old_chain);
2360 /* tfind range command */
2362 trace_find_range_command (char *args, int from_tty)
2364 static CORE_ADDR start, stop;
2367 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2368 error (_("May not look at trace frames while trace is running."));
2370 if (args == 0 || *args == 0)
2371 { /* XXX FIXME: what should default behavior be? */
2372 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2376 if (0 != (tmp = strchr (args, ',')))
2378 *tmp++ = '\0'; /* Terminate start address. */
2379 while (isspace ((int) *tmp))
2381 start = parse_and_eval_address (args);
2382 stop = parse_and_eval_address (tmp);
2385 { /* No explicit end address? */
2386 start = parse_and_eval_address (args);
2387 stop = start + 1; /* ??? */
2390 tfind_1 (tfind_range, 0, start, stop, from_tty);
2393 /* tfind outside command */
2395 trace_find_outside_command (char *args, int from_tty)
2397 CORE_ADDR start, stop;
2400 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2401 error (_("May not look at trace frames while trace is running."));
2403 if (args == 0 || *args == 0)
2404 { /* XXX FIXME: what should default behavior be? */
2405 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2409 if (0 != (tmp = strchr (args, ',')))
2411 *tmp++ = '\0'; /* Terminate start address. */
2412 while (isspace ((int) *tmp))
2414 start = parse_and_eval_address (args);
2415 stop = parse_and_eval_address (tmp);
2418 { /* No explicit end address? */
2419 start = parse_and_eval_address (args);
2420 stop = start + 1; /* ??? */
2423 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2426 /* info scope command: list the locals for a scope. */
2428 scope_info (char *args, int from_tty)
2430 struct symtabs_and_lines sals;
2432 struct minimal_symbol *msym;
2433 struct block *block;
2434 char *symname, *save_args = args;
2435 struct dict_iterator iter;
2437 struct gdbarch *gdbarch;
2440 if (args == 0 || *args == 0)
2441 error (_("requires an argument (function, "
2442 "line or *addr) to define a scope"));
2444 sals = decode_line_1 (&args, 1, NULL, 0, NULL);
2445 if (sals.nelts == 0)
2446 return; /* Presumably decode_line_1 has already warned. */
2448 /* Resolve line numbers to PC. */
2449 resolve_sal_pc (&sals.sals[0]);
2450 block = block_for_pc (sals.sals[0].pc);
2454 QUIT; /* Allow user to bail out with ^C. */
2455 ALL_BLOCK_SYMBOLS (block, iter, sym)
2457 QUIT; /* Allow user to bail out with ^C. */
2459 printf_filtered ("Scope for %s:\n", save_args);
2462 symname = SYMBOL_PRINT_NAME (sym);
2463 if (symname == NULL || *symname == '\0')
2464 continue; /* Probably botched, certainly useless. */
2466 gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
2468 printf_filtered ("Symbol %s is ", symname);
2469 switch (SYMBOL_CLASS (sym))
2472 case LOC_UNDEF: /* Messed up symbol? */
2473 printf_filtered ("a bogus symbol, class %d.\n",
2474 SYMBOL_CLASS (sym));
2475 count--; /* Don't count this one. */
2478 printf_filtered ("a constant with value %ld (0x%lx)",
2479 SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
2481 case LOC_CONST_BYTES:
2482 printf_filtered ("constant bytes: ");
2483 if (SYMBOL_TYPE (sym))
2484 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2485 fprintf_filtered (gdb_stdout, " %02x",
2486 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2489 printf_filtered ("in static storage at address ");
2490 printf_filtered ("%s", paddress (gdbarch,
2491 SYMBOL_VALUE_ADDRESS (sym)));
2494 /* GDBARCH is the architecture associated with the objfile
2495 the symbol is defined in; the target architecture may be
2496 different, and may provide additional registers. However,
2497 we do not know the target architecture at this point.
2498 We assume the objfile architecture will contain all the
2499 standard registers that occur in debug info in that
2501 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2504 if (SYMBOL_IS_ARGUMENT (sym))
2505 printf_filtered ("an argument in register $%s",
2506 gdbarch_register_name (gdbarch, regno));
2508 printf_filtered ("a local variable in register $%s",
2509 gdbarch_register_name (gdbarch, regno));
2512 printf_filtered ("an argument at stack/frame offset %ld",
2513 SYMBOL_VALUE (sym));
2516 printf_filtered ("a local variable at frame offset %ld",
2517 SYMBOL_VALUE (sym));
2520 printf_filtered ("a reference argument at offset %ld",
2521 SYMBOL_VALUE (sym));
2523 case LOC_REGPARM_ADDR:
2524 /* Note comment at LOC_REGISTER. */
2525 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2527 printf_filtered ("the address of an argument, in register $%s",
2528 gdbarch_register_name (gdbarch, regno));
2531 printf_filtered ("a typedef.\n");
2534 printf_filtered ("a label at address ");
2535 printf_filtered ("%s", paddress (gdbarch,
2536 SYMBOL_VALUE_ADDRESS (sym)));
2539 printf_filtered ("a function at address ");
2540 printf_filtered ("%s",
2541 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2543 case LOC_UNRESOLVED:
2544 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2547 printf_filtered ("Unresolved Static");
2550 printf_filtered ("static storage at address ");
2551 printf_filtered ("%s",
2552 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msym)));
2555 case LOC_OPTIMIZED_OUT:
2556 printf_filtered ("optimized out.\n");
2559 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2560 BLOCK_START (block),
2564 if (SYMBOL_TYPE (sym))
2565 printf_filtered (", length %d.\n",
2566 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2568 if (BLOCK_FUNCTION (block))
2571 block = BLOCK_SUPERBLOCK (block);
2574 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2578 /* worker function (cleanup) */
2580 replace_comma (void *data)
2587 /* Helper for trace_dump_command. Dump the action list starting at
2588 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2589 actions of the body of a while-stepping action. STEPPING_FRAME is
2590 set if the current traceframe was determined to be a while-stepping
2594 trace_dump_actions (struct command_line *action,
2595 int stepping_actions, int stepping_frame,
2598 char *action_exp, *next_comma;
2600 for (; action != NULL; action = action->next)
2602 struct cmd_list_element *cmd;
2604 QUIT; /* Allow user to bail out with ^C. */
2605 action_exp = action->line;
2606 while (isspace ((int) *action_exp))
2609 /* The collection actions to be done while stepping are
2610 bracketed by the commands "while-stepping" and "end". */
2612 if (*action_exp == '#') /* comment line */
2615 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2617 error (_("Bad action list item: %s"), action_exp);
2619 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2623 for (i = 0; i < action->body_count; ++i)
2624 trace_dump_actions (action->body_list[i],
2625 1, stepping_frame, from_tty);
2627 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2629 /* Display the collected data.
2630 For the trap frame, display only what was collected at
2631 the trap. Likewise for stepping frames, display only
2632 what was collected while stepping. This means that the
2633 two boolean variables, STEPPING_FRAME and
2634 STEPPING_ACTIONS should be equal. */
2635 if (stepping_frame == stepping_actions)
2637 if (*action_exp == '/')
2638 action_exp = decode_agent_options (action_exp);
2641 { /* Repeat over a comma-separated list. */
2642 QUIT; /* Allow user to bail out with ^C. */
2643 if (*action_exp == ',')
2645 while (isspace ((int) *action_exp))
2648 next_comma = strchr (action_exp, ',');
2650 if (0 == strncasecmp (action_exp, "$reg", 4))
2651 registers_info (NULL, from_tty);
2652 else if (0 == strncasecmp (action_exp, "$_ret", 5))
2654 else if (0 == strncasecmp (action_exp, "$loc", 4))
2655 locals_info (NULL, from_tty);
2656 else if (0 == strncasecmp (action_exp, "$arg", 4))
2657 args_info (NULL, from_tty);
2662 make_cleanup (replace_comma, next_comma);
2665 printf_filtered ("%s = ", action_exp);
2666 output_command (action_exp, from_tty);
2667 printf_filtered ("\n");
2671 action_exp = next_comma;
2673 while (action_exp && *action_exp == ',');
2679 /* The tdump command. */
2682 trace_dump_command (char *args, int from_tty)
2684 struct regcache *regcache;
2685 struct tracepoint *t;
2686 int stepping_frame = 0;
2687 struct bp_location *loc;
2688 char *line, *default_collect_line = NULL;
2689 struct command_line *actions, *default_collect_action = NULL;
2690 struct cleanup *old_chain = NULL;
2692 if (tracepoint_number == -1)
2694 warning (_("No current trace frame."));
2698 t = get_tracepoint (tracepoint_number);
2701 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2704 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2705 tracepoint_number, traceframe_number);
2707 /* The current frame is a trap frame if the frame PC is equal
2708 to the tracepoint PC. If not, then the current frame was
2709 collected during single-stepping. */
2711 regcache = get_current_regcache ();
2713 /* If the traceframe's address matches any of the tracepoint's
2714 locations, assume it is a direct hit rather than a while-stepping
2715 frame. (FIXME this is not reliable, should record each frame's
2718 for (loc = t->base.loc; loc; loc = loc->next)
2719 if (loc->address == regcache_read_pc (regcache))
2722 actions = breakpoint_commands (&t->base);
2724 /* If there is a default-collect list, make up a collect command,
2725 prepend to the tracepoint's commands, and pass the whole mess to
2726 the trace dump scanner. We need to validate because
2727 default-collect might have been junked since the trace run. */
2728 if (*default_collect)
2730 default_collect_line = xstrprintf ("collect %s", default_collect);
2731 old_chain = make_cleanup (xfree, default_collect_line);
2732 line = default_collect_line;
2733 validate_actionline (&line, &t->base);
2734 default_collect_action = xmalloc (sizeof (struct command_line));
2735 make_cleanup (xfree, default_collect_action);
2736 default_collect_action->next = actions;
2737 default_collect_action->line = line;
2738 actions = default_collect_action;
2741 trace_dump_actions (actions, 0, stepping_frame, from_tty);
2743 if (*default_collect)
2744 do_cleanups (old_chain);
2747 /* Encode a piece of a tracepoint's source-level definition in a form
2748 that is suitable for both protocol and saving in files. */
2749 /* This version does not do multiple encodes for long strings; it should
2750 return an offset to the next piece to encode. FIXME */
2753 encode_source_string (int tpnum, ULONGEST addr,
2754 char *srctype, char *src, char *buf, int buf_size)
2756 if (80 + strlen (srctype) > buf_size)
2757 error (_("Buffer too small for source encoding"));
2758 sprintf (buf, "%x:%s:%s:%x:%x:",
2759 tpnum, phex_nz (addr, sizeof (addr)),
2760 srctype, 0, (int) strlen (src));
2761 if (strlen (buf) + strlen (src) * 2 >= buf_size)
2762 error (_("Source string too long for buffer"));
2763 bin2hex (src, buf + strlen (buf), 0);
2767 extern int trace_regblock_size;
2769 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2770 non-zero, the save is performed on the target, otherwise GDB obtains all
2771 trace data and saves it locally. */
2774 trace_save (const char *filename, int target_does_save)
2776 struct cleanup *cleanup;
2778 struct trace_status *ts = current_trace_status ();
2781 struct uploaded_tp *uploaded_tps = NULL, *utp;
2782 struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
2786 ULONGEST offset = 0;
2787 #define MAX_TRACE_UPLOAD 2000
2788 gdb_byte buf[MAX_TRACE_UPLOAD];
2791 /* If the target is to save the data to a file on its own, then just
2792 send the command and be done with it. */
2793 if (target_does_save)
2795 err = target_save_trace_data (filename);
2797 error (_("Target failed to save trace data to '%s'."),
2802 /* Get the trace status first before opening the file, so if the
2803 target is losing, we can get out without touching files. */
2804 status = target_get_trace_status (ts);
2806 pathname = tilde_expand (filename);
2807 cleanup = make_cleanup (xfree, pathname);
2809 fp = fopen (pathname, "wb");
2811 error (_("Unable to open file '%s' for saving trace data (%s)"),
2812 filename, safe_strerror (errno));
2813 make_cleanup_fclose (fp);
2815 /* Write a file header, with a high-bit-set char to indicate a
2816 binary file, plus a hint as what this file is, and a version
2817 number in case of future needs. */
2818 written = fwrite ("\x7fTRACE0\n", 8, 1, fp);
2820 perror_with_name (pathname);
2822 /* Write descriptive info. */
2824 /* Write out the size of a register block. */
2825 fprintf (fp, "R %x\n", trace_regblock_size);
2827 /* Write out status of the tracing run (aka "tstatus" info). */
2828 fprintf (fp, "status %c;%s",
2829 (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
2830 if (ts->stop_reason == tracepoint_error)
2832 char *buf = (char *) alloca (strlen (ts->error_desc) * 2 + 1);
2834 bin2hex ((gdb_byte *) ts->error_desc, buf, 0);
2835 fprintf (fp, ":%s", buf);
2837 fprintf (fp, ":%x", ts->stopping_tracepoint);
2838 if (ts->traceframe_count >= 0)
2839 fprintf (fp, ";tframes:%x", ts->traceframe_count);
2840 if (ts->traceframes_created >= 0)
2841 fprintf (fp, ";tcreated:%x", ts->traceframes_created);
2842 if (ts->buffer_free >= 0)
2843 fprintf (fp, ";tfree:%x", ts->buffer_free);
2844 if (ts->buffer_size >= 0)
2845 fprintf (fp, ";tsize:%x", ts->buffer_size);
2846 if (ts->disconnected_tracing)
2847 fprintf (fp, ";disconn:%x", ts->disconnected_tracing);
2848 if (ts->circular_buffer)
2849 fprintf (fp, ";circular:%x", ts->circular_buffer);
2852 /* Note that we want to upload tracepoints and save those, rather
2853 than simply writing out the local ones, because the user may have
2854 changed tracepoints in GDB in preparation for a future tracing
2855 run, or maybe just mass-deleted all types of breakpoints as part
2856 of cleaning up. So as not to contaminate the session, leave the
2857 data in its uploaded form, don't make into real tracepoints. */
2859 /* Get trace state variables first, they may be checked when parsing
2860 uploaded commands. */
2862 target_upload_trace_state_variables (&uploaded_tsvs);
2864 for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
2870 buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
2871 bin2hex ((gdb_byte *) (utsv->name), buf, 0);
2874 fprintf (fp, "tsv %x:%s:%x:%s\n",
2875 utsv->number, phex_nz (utsv->initial_value, 8),
2876 utsv->builtin, buf);
2882 free_uploaded_tsvs (&uploaded_tsvs);
2884 target_upload_tracepoints (&uploaded_tps);
2886 for (utp = uploaded_tps; utp; utp = utp->next)
2888 fprintf (fp, "tp T%x:%s:%c:%x:%x",
2889 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
2890 (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
2891 if (utp->type == bp_fast_tracepoint)
2892 fprintf (fp, ":F%x", utp->orig_size);
2894 fprintf (fp, ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
2897 for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
2898 fprintf (fp, "tp A%x:%s:%s\n",
2899 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
2900 for (a = 0; VEC_iterate (char_ptr, utp->step_actions, a, act); ++a)
2901 fprintf (fp, "tp S%x:%s:%s\n",
2902 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
2905 encode_source_string (utp->number, utp->addr,
2906 "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
2907 fprintf (fp, "tp Z%s\n", buf);
2909 if (utp->cond_string)
2911 encode_source_string (utp->number, utp->addr,
2912 "cond", utp->cond_string,
2913 buf, MAX_TRACE_UPLOAD);
2914 fprintf (fp, "tp Z%s\n", buf);
2916 for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
2918 encode_source_string (utp->number, utp->addr, "cmd", act,
2919 buf, MAX_TRACE_UPLOAD);
2920 fprintf (fp, "tp Z%s\n", buf);
2924 free_uploaded_tps (&uploaded_tps);
2926 /* Mark the end of the definition section. */
2929 /* Get and write the trace data proper. We ask for big blocks, in
2930 the hopes of efficiency, but will take less if the target has
2931 packet size limitations or some such. */
2934 gotten = target_get_raw_trace_data (buf, offset, MAX_TRACE_UPLOAD);
2936 error (_("Failure to get requested trace buffer data"));
2937 /* No more data is forthcoming, we're done. */
2940 written = fwrite (buf, gotten, 1, fp);
2942 perror_with_name (pathname);
2946 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
2947 written = fwrite (&gotten, 4, 1, fp);
2949 perror_with_name (pathname);
2951 do_cleanups (cleanup);
2955 trace_save_command (char *args, int from_tty)
2957 int target_does_save = 0;
2959 char *filename = NULL;
2960 struct cleanup *back_to;
2963 error_no_arg (_("file in which to save trace data"));
2965 argv = gdb_buildargv (args);
2966 back_to = make_cleanup_freeargv (argv);
2968 for (; *argv; ++argv)
2970 if (strcmp (*argv, "-r") == 0)
2971 target_does_save = 1;
2972 else if (**argv == '-')
2973 error (_("unknown option `%s'"), *argv);
2979 error_no_arg (_("file in which to save trace data"));
2981 trace_save (filename, target_does_save);
2984 printf_filtered (_("Trace data saved to file '%s'.\n"), filename);
2986 do_cleanups (back_to);
2989 /* Tell the target what to do with an ongoing tracing run if GDB
2990 disconnects for some reason. */
2993 send_disconnected_tracing_value (int value)
2995 target_set_disconnected_tracing (value);
2999 set_disconnected_tracing (char *args, int from_tty,
3000 struct cmd_list_element *c)
3002 send_disconnected_tracing_value (disconnected_tracing);
3006 set_circular_trace_buffer (char *args, int from_tty,
3007 struct cmd_list_element *c)
3009 target_set_circular_trace_buffer (circular_trace_buffer);
3012 /* Convert the memory pointed to by mem into hex, placing result in buf.
3013 * Return a pointer to the last char put in buf (null)
3014 * "stolen" from sparc-stub.c
3017 static const char hexchars[] = "0123456789abcdef";
3020 mem2hex (gdb_byte *mem, char *buf, int count)
3028 *buf++ = hexchars[ch >> 4];
3029 *buf++ = hexchars[ch & 0xf];
3038 get_traceframe_number (void)
3040 return traceframe_number;
3043 /* Make the traceframe NUM be the current trace frame. Does nothing
3044 if NUM is already current. */
3047 set_current_traceframe (int num)
3051 if (traceframe_number == num)
3053 /* Nothing to do. */
3057 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
3060 warning (_("could not change traceframe"));
3062 traceframe_number = newnum;
3064 /* Changing the traceframe changes our view of registers and of the
3066 registers_changed ();
3068 clear_traceframe_info ();
3071 /* Make the traceframe NUM be the current trace frame, and do nothing
3075 set_traceframe_number (int num)
3077 traceframe_number = num;
3080 /* A cleanup used when switching away and back from tfind mode. */
3082 struct current_traceframe_cleanup
3084 /* The traceframe we were inspecting. */
3085 int traceframe_number;
3089 do_restore_current_traceframe_cleanup (void *arg)
3091 struct current_traceframe_cleanup *old = arg;
3093 set_current_traceframe (old->traceframe_number);
3097 restore_current_traceframe_cleanup_dtor (void *arg)
3099 struct current_traceframe_cleanup *old = arg;
3105 make_cleanup_restore_current_traceframe (void)
3107 struct current_traceframe_cleanup *old;
3109 old = xmalloc (sizeof (struct current_traceframe_cleanup));
3110 old->traceframe_number = traceframe_number;
3112 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
3113 restore_current_traceframe_cleanup_dtor);
3117 make_cleanup_restore_traceframe_number (void)
3119 return make_cleanup_restore_integer (&traceframe_number);
3122 /* Given a number and address, return an uploaded tracepoint with that
3123 number, creating if necessary. */
3125 struct uploaded_tp *
3126 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
3128 struct uploaded_tp *utp;
3130 for (utp = *utpp; utp; utp = utp->next)
3131 if (utp->number == num && utp->addr == addr)
3133 utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
3134 memset (utp, 0, sizeof (struct uploaded_tp));
3137 utp->actions = NULL;
3138 utp->step_actions = NULL;
3139 utp->cmd_strings = NULL;
3146 free_uploaded_tps (struct uploaded_tp **utpp)
3148 struct uploaded_tp *next_one;
3152 next_one = (*utpp)->next;
3158 /* Given a number and address, return an uploaded tracepoint with that
3159 number, creating if necessary. */
3161 struct uploaded_tsv *
3162 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3164 struct uploaded_tsv *utsv;
3166 for (utsv = *utsvp; utsv; utsv = utsv->next)
3167 if (utsv->number == num)
3169 utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
3170 memset (utsv, 0, sizeof (struct uploaded_tsv));
3172 utsv->next = *utsvp;
3178 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3180 struct uploaded_tsv *next_one;
3184 next_one = (*utsvp)->next;
3190 /* FIXME this function is heuristic and will miss the cases where the
3191 conditional is semantically identical but differs in whitespace,
3192 such as "x == 0" vs "x==0". */
3195 cond_string_is_same (char *str1, char *str2)
3197 if (str1 == NULL || str2 == NULL)
3198 return (str1 == str2);
3200 return (strcmp (str1, str2) == 0);
3203 /* Look for an existing tracepoint that seems similar enough to the
3204 uploaded one. Enablement isn't compared, because the user can
3205 toggle that freely, and may have done so in anticipation of the
3209 find_matching_tracepoint (struct uploaded_tp *utp)
3211 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
3213 struct breakpoint *b;
3214 struct bp_location *loc;
3216 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
3218 struct tracepoint *t = (struct tracepoint *) b;
3220 if (b->type == utp->type
3221 && t->step_count == utp->step
3222 && t->pass_count == utp->pass
3223 && cond_string_is_same (t->base.cond_string, utp->cond_string)
3224 /* FIXME also test actions. */
3227 /* Scan the locations for an address match. */
3228 for (loc = b->loc; loc; loc = loc->next)
3230 if (loc->address == utp->addr)
3238 /* Given a list of tracepoints uploaded from a target, attempt to
3239 match them up with existing tracepoints, and create new ones if not
3243 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3245 struct uploaded_tp *utp;
3246 struct tracepoint *t;
3248 /* Look for GDB tracepoints that match up with our uploaded versions. */
3249 for (utp = *uploaded_tps; utp; utp = utp->next)
3251 t = find_matching_tracepoint (utp);
3253 printf_filtered (_("Assuming tracepoint %d is same "
3254 "as target's tracepoint %d at %s.\n"),
3255 t->base.number, utp->number,
3256 paddress (get_current_arch (), utp->addr));
3259 t = create_tracepoint_from_upload (utp);
3261 printf_filtered (_("Created tracepoint %d for "
3262 "target's tracepoint %d at %s.\n"),
3263 t->base.number, utp->number,
3264 paddress (get_current_arch (), utp->addr));
3266 printf_filtered (_("Failed to create tracepoint for target's "
3267 "tracepoint %d at %s, skipping it.\n"),
3269 paddress (get_current_arch (), utp->addr));
3271 /* Whether found or created, record the number used by the
3272 target, to help with mapping target tracepoints back to their
3273 counterparts here. */
3275 t->number_on_target = utp->number;
3278 free_uploaded_tps (uploaded_tps);
3281 /* Trace state variables don't have much to identify them beyond their
3282 name, so just use that to detect matches. */
3284 struct trace_state_variable *
3285 find_matching_tsv (struct uploaded_tsv *utsv)
3290 return find_trace_state_variable (utsv->name);
3293 struct trace_state_variable *
3294 create_tsv_from_upload (struct uploaded_tsv *utsv)
3296 const char *namebase;
3299 struct trace_state_variable *tsv;
3303 namebase = utsv->name;
3304 sprintf (buf, "%s", namebase);
3309 sprintf (buf, "%s_%d", namebase, try_num++);
3312 /* Fish for a name that is not in use. */
3313 /* (should check against all internal vars?) */
3314 while (find_trace_state_variable (buf))
3315 sprintf (buf, "%s_%d", namebase, try_num++);
3317 /* We have an available name, create the variable. */
3318 tsv = create_trace_state_variable (buf);
3319 tsv->initial_value = utsv->initial_value;
3320 tsv->builtin = utsv->builtin;
3325 /* Given a list of uploaded trace state variables, try to match them
3326 up with existing variables, or create additional ones. */
3329 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
3332 struct uploaded_tsv *utsv;
3333 struct trace_state_variable *tsv;
3336 /* Most likely some numbers will have to be reassigned as part of
3337 the merge, so clear them all in anticipation. */
3338 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3341 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
3343 tsv = find_matching_tsv (utsv);
3347 printf_filtered (_("Assuming trace state variable $%s "
3348 "is same as target's variable %d.\n"),
3349 tsv->name, utsv->number);
3353 tsv = create_tsv_from_upload (utsv);
3355 printf_filtered (_("Created trace state variable "
3356 "$%s for target's variable %d.\n"),
3357 tsv->name, utsv->number);
3359 /* Give precedence to numberings that come from the target. */
3361 tsv->number = utsv->number;
3364 /* Renumber everything that didn't get a target-assigned number. */
3366 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3367 if (tsv->number > highest)
3368 highest = tsv->number;
3371 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3372 if (tsv->number == 0)
3373 tsv->number = highest++;
3375 free_uploaded_tsvs (uploaded_tsvs);
3378 /* target tfile command */
3380 struct target_ops tfile_ops;
3382 /* Fill in tfile_ops with its defined operations and properties. */
3384 #define TRACE_HEADER_SIZE 8
3386 char *trace_filename;
3388 off_t trace_frames_offset;
3390 int cur_traceframe_number;
3392 int trace_regblock_size;
3394 static void tfile_interp_line (char *line,
3395 struct uploaded_tp **utpp,
3396 struct uploaded_tsv **utsvp);
3398 /* Read SIZE bytes into READBUF from the trace frame, starting at
3399 TRACE_FD's current position. Note that this call `read'
3400 underneath, hence it advances the file's seek position. Throws an
3401 error if the `read' syscall fails, or less than SIZE bytes are
3405 tfile_read (gdb_byte *readbuf, int size)
3409 gotten = read (trace_fd, readbuf, size);
3411 perror_with_name (trace_filename);
3412 else if (gotten < size)
3413 error (_("Premature end of file while reading trace file"));
3417 tfile_open (char *filename, int from_tty)
3419 volatile struct gdb_exception ex;
3421 struct cleanup *old_chain;
3424 char header[TRACE_HEADER_SIZE];
3425 char linebuf[1000]; /* Should be max remote packet size or so. */
3428 struct trace_status *ts;
3429 struct uploaded_tp *uploaded_tps = NULL;
3430 struct uploaded_tsv *uploaded_tsvs = NULL;
3432 target_preopen (from_tty);
3434 error (_("No trace file specified."));
3436 filename = tilde_expand (filename);
3437 if (!IS_ABSOLUTE_PATH(filename))
3439 temp = concat (current_directory, "/", filename, (char *) NULL);
3444 old_chain = make_cleanup (xfree, filename);
3446 flags = O_BINARY | O_LARGEFILE;
3448 scratch_chan = open (filename, flags, 0);
3449 if (scratch_chan < 0)
3450 perror_with_name (filename);
3452 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3454 discard_cleanups (old_chain); /* Don't free filename any more. */
3455 unpush_target (&tfile_ops);
3457 trace_filename = xstrdup (filename);
3458 trace_fd = scratch_chan;
3461 /* Read the file header and test for validity. */
3462 tfile_read ((gdb_byte *) &header, TRACE_HEADER_SIZE);
3464 bytes += TRACE_HEADER_SIZE;
3465 if (!(header[0] == 0x7f
3466 && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
3467 error (_("File is not a valid trace file."));
3469 push_target (&tfile_ops);
3471 trace_regblock_size = 0;
3472 ts = current_trace_status ();
3473 /* We know we're working with a file. */
3475 /* Set defaults in case there is no status line. */
3476 ts->running_known = 0;
3477 ts->stop_reason = trace_stop_reason_unknown;
3478 ts->traceframe_count = -1;
3479 ts->buffer_free = 0;
3480 ts->disconnected_tracing = 0;
3481 ts->circular_buffer = 0;
3483 cur_traceframe_number = -1;
3485 TRY_CATCH (ex, RETURN_MASK_ALL)
3487 /* Read through a section of newline-terminated lines that
3488 define things like tracepoints. */
3492 tfile_read (&byte, 1);
3497 /* Empty line marks end of the definition section. */
3502 tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
3505 linebuf[i++] = byte;
3507 error (_("Excessively long lines in trace file"));
3510 /* Record the starting offset of the binary trace data. */
3511 trace_frames_offset = bytes;
3513 /* If we don't have a blocksize, we can't interpret the
3515 if (trace_regblock_size == 0)
3516 error (_("No register block size recorded in trace file"));
3520 /* Pop the partially set up target. */
3522 throw_exception (ex);
3525 inferior_appeared (current_inferior (), TFILE_PID);
3526 inferior_ptid = pid_to_ptid (TFILE_PID);
3527 add_thread_silent (inferior_ptid);
3529 if (ts->traceframe_count <= 0)
3530 warning (_("No traceframes present in this file."));
3532 /* Add the file's tracepoints and variables into the current mix. */
3534 /* Get trace state variables first, they may be checked when parsing
3535 uploaded commands. */
3536 merge_uploaded_trace_state_variables (&uploaded_tsvs);
3538 merge_uploaded_tracepoints (&uploaded_tps);
3540 post_create_inferior (&tfile_ops, from_tty);
3543 /* Interpret the given line from the definitions part of the trace
3547 tfile_interp_line (char *line,
3548 struct uploaded_tp **utpp, struct uploaded_tsv **utsvp)
3552 if (strncmp (p, "R ", strlen ("R ")) == 0)
3555 trace_regblock_size = strtol (p, &p, 16);
3557 else if (strncmp (p, "status ", strlen ("status ")) == 0)
3559 p += strlen ("status ");
3560 parse_trace_status (p, current_trace_status ());
3562 else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
3564 p += strlen ("tp ");
3565 parse_tracepoint_definition (p, utpp);
3567 else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
3569 p += strlen ("tsv ");
3570 parse_tsv_definition (p, utsvp);
3573 warning (_("Ignoring trace file definition \"%s\""), line);
3576 /* Parse the part of trace status syntax that is shared between
3577 the remote protocol and the trace file reader. */
3580 parse_trace_status (char *line, struct trace_status *ts)
3582 char *p = line, *p1, *p2, *p_temp;
3585 ts->running_known = 1;
3586 ts->running = (*p++ == '1');
3587 ts->stop_reason = trace_stop_reason_unknown;
3588 xfree (ts->error_desc);
3589 ts->error_desc = NULL;
3590 ts->traceframe_count = -1;
3591 ts->traceframes_created = -1;
3592 ts->buffer_free = -1;
3593 ts->buffer_size = -1;
3594 ts->disconnected_tracing = 0;
3595 ts->circular_buffer = 0;
3599 p1 = strchr (p, ':');
3601 error (_("Malformed trace status, at %s\n\
3602 Status line: '%s'\n"), p, line);
3603 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3605 p = unpack_varlen_hex (++p1, &val);
3606 ts->stop_reason = trace_buffer_full;
3608 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3610 p = unpack_varlen_hex (++p1, &val);
3611 ts->stop_reason = trace_never_run;
3613 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
3616 p = unpack_varlen_hex (++p1, &val);
3617 ts->stop_reason = tracepoint_passcount;
3618 ts->stopping_tracepoint = val;
3620 else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
3622 p = unpack_varlen_hex (++p1, &val);
3623 ts->stop_reason = tstop_command;
3625 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3627 p = unpack_varlen_hex (++p1, &val);
3628 ts->stop_reason = trace_disconnected;
3630 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3632 p2 = strchr (++p1, ':');
3637 ts->error_desc = xmalloc ((p2 - p1) / 2 + 1);
3638 end = hex2bin (p1, ts->error_desc, (p2 - p1) / 2);
3639 ts->error_desc[end] = '\0';
3642 ts->error_desc = xstrdup ("");
3644 p = unpack_varlen_hex (++p2, &val);
3645 ts->stopping_tracepoint = val;
3646 ts->stop_reason = tracepoint_error;
3648 else if (strncmp (p, "tframes", p1 - p) == 0)
3650 p = unpack_varlen_hex (++p1, &val);
3651 ts->traceframe_count = val;
3653 else if (strncmp (p, "tcreated", p1 - p) == 0)
3655 p = unpack_varlen_hex (++p1, &val);
3656 ts->traceframes_created = val;
3658 else if (strncmp (p, "tfree", p1 - p) == 0)
3660 p = unpack_varlen_hex (++p1, &val);
3661 ts->buffer_free = val;
3663 else if (strncmp (p, "tsize", p1 - p) == 0)
3665 p = unpack_varlen_hex (++p1, &val);
3666 ts->buffer_size = val;
3668 else if (strncmp (p, "disconn", p1 - p) == 0)
3670 p = unpack_varlen_hex (++p1, &val);
3671 ts->disconnected_tracing = val;
3673 else if (strncmp (p, "circular", p1 - p) == 0)
3675 p = unpack_varlen_hex (++p1, &val);
3676 ts->circular_buffer = val;
3680 /* Silently skip unknown optional info. */
3681 p_temp = strchr (p1 + 1, ';');
3685 /* Must be at the end. */
3691 /* Given a line of text defining a part of a tracepoint, parse it into
3692 an "uploaded tracepoint". */
3695 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
3699 ULONGEST num, addr, step, pass, orig_size, xlen, start;
3702 char *cond, *srctype, *buf;
3703 struct uploaded_tp *utp = NULL;
3706 /* Both tracepoint and action definitions start with the same number
3707 and address sequence. */
3709 p = unpack_varlen_hex (p, &num);
3710 p++; /* skip a colon */
3711 p = unpack_varlen_hex (p, &addr);
3712 p++; /* skip a colon */
3715 enabled = (*p++ == 'E');
3716 p++; /* skip a colon */
3717 p = unpack_varlen_hex (p, &step);
3718 p++; /* skip a colon */
3719 p = unpack_varlen_hex (p, &pass);
3720 type = bp_tracepoint;
3722 /* Thumb through optional fields. */
3725 p++; /* skip a colon */
3728 type = bp_fast_tracepoint;
3730 p = unpack_varlen_hex (p, &orig_size);
3734 type = bp_static_tracepoint;
3740 p = unpack_varlen_hex (p, &xlen);
3741 p++; /* skip a comma */
3742 cond = (char *) xmalloc (2 * xlen + 1);
3743 strncpy (cond, p, 2 * xlen);
3744 cond[2 * xlen] = '\0';
3748 warning (_("Unrecognized char '%c' in tracepoint "
3749 "definition, skipping rest"), *p);
3751 utp = get_uploaded_tp (num, addr, utpp);
3753 utp->enabled = enabled;
3758 else if (piece == 'A')
3760 utp = get_uploaded_tp (num, addr, utpp);
3761 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
3763 else if (piece == 'S')
3765 utp = get_uploaded_tp (num, addr, utpp);
3766 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
3768 else if (piece == 'Z')
3770 /* Parse a chunk of source form definition. */
3771 utp = get_uploaded_tp (num, addr, utpp);
3773 p = strchr (p, ':');
3774 p++; /* skip a colon */
3775 p = unpack_varlen_hex (p, &start);
3776 p++; /* skip a colon */
3777 p = unpack_varlen_hex (p, &xlen);
3778 p++; /* skip a colon */
3780 buf = alloca (strlen (line));
3782 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3785 if (strncmp (srctype, "at:", strlen ("at:")) == 0)
3786 utp->at_string = xstrdup (buf);
3787 else if (strncmp (srctype, "cond:", strlen ("cond:")) == 0)
3788 utp->cond_string = xstrdup (buf);
3789 else if (strncmp (srctype, "cmd:", strlen ("cmd:")) == 0)
3790 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
3794 /* Don't error out, the target might be sending us optional
3795 info that we don't care about. */
3796 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
3800 /* Convert a textual description of a trace state variable into an
3804 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
3807 ULONGEST num, initval, builtin;
3809 struct uploaded_tsv *utsv = NULL;
3811 buf = alloca (strlen (line));
3814 p = unpack_varlen_hex (p, &num);
3815 p++; /* skip a colon */
3816 p = unpack_varlen_hex (p, &initval);
3817 p++; /* skip a colon */
3818 p = unpack_varlen_hex (p, &builtin);
3819 p++; /* skip a colon */
3820 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3823 utsv = get_uploaded_tsv (num, utsvp);
3824 utsv->initial_value = initval;
3825 utsv->builtin = builtin;
3826 utsv->name = xstrdup (buf);
3829 /* Close the trace file and generally clean up. */
3832 tfile_close (int quitting)
3839 pid = ptid_get_pid (inferior_ptid);
3840 inferior_ptid = null_ptid; /* Avoid confusion from thread stuff. */
3841 exit_inferior_silent (pid);
3845 xfree (trace_filename);
3846 trace_filename = NULL;
3850 tfile_files_info (struct target_ops *t)
3852 /* (it would be useful to mention the name of the file). */
3853 printf_filtered ("Looking at a trace file.\n");
3856 /* The trace status for a file is that tracing can never be run. */
3859 tfile_get_trace_status (struct trace_status *ts)
3861 /* Other bits of trace status were collected as part of opening the
3862 trace files, so nothing to do here. */
3867 /* Given the position of a traceframe in the file, figure out what
3868 address the frame was collected at. This would normally be the
3869 value of a collected PC register, but if not available, we
3873 tfile_get_traceframe_address (off_t tframe_offset)
3877 struct tracepoint *tp;
3878 off_t saved_offset = cur_offset;
3880 /* FIXME dig pc out of collected registers. */
3882 /* Fall back to using tracepoint address. */
3883 lseek (trace_fd, tframe_offset, SEEK_SET);
3884 tfile_read ((gdb_byte *) &tpnum, 2);
3885 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
3889 tp = get_tracepoint_by_number_on_target (tpnum);
3890 /* FIXME this is a poor heuristic if multiple locations. */
3891 if (tp && tp->base.loc)
3892 addr = tp->base.loc->address;
3894 /* Restore our seek position. */
3895 cur_offset = saved_offset;
3896 lseek (trace_fd, cur_offset, SEEK_SET);
3900 /* Make tfile's selected traceframe match GDB's selected
3904 set_tfile_traceframe (void)
3908 if (cur_traceframe_number == get_traceframe_number ())
3911 /* Avoid recursion, tfile_trace_find calls us again. */
3912 cur_traceframe_number = get_traceframe_number ();
3914 newnum = target_trace_find (tfind_number,
3915 get_traceframe_number (), 0, 0, NULL);
3917 /* Should not happen. If it does, all bets are off. */
3918 if (newnum != get_traceframe_number ())
3919 warning (_("could not set tfile's traceframe"));
3922 /* Given a type of search and some parameters, scan the collection of
3923 traceframes in the file looking for a match. When found, return
3924 both the traceframe and tracepoint number, otherwise -1 for
3928 tfile_trace_find (enum trace_find_type type, int num,
3929 ULONGEST addr1, ULONGEST addr2, int *tpp)
3932 int tfnum = 0, found = 0;
3933 unsigned int data_size;
3934 struct tracepoint *tp;
3935 off_t offset, tframe_offset;
3938 /* Lookups other than by absolute frame number depend on the current
3939 trace selected, so make sure it is correct on the tfile end
3941 if (type != tfind_number)
3942 set_tfile_traceframe ();
3950 lseek (trace_fd, trace_frames_offset, SEEK_SET);
3951 offset = trace_frames_offset;
3954 tframe_offset = offset;
3955 tfile_read ((gdb_byte *) &tpnum, 2);
3956 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
3962 tfile_read ((gdb_byte *) &data_size, 4);
3963 data_size = (unsigned int) extract_unsigned_integer
3964 ((gdb_byte *) &data_size, 4,
3965 gdbarch_byte_order (target_gdbarch));
3974 tfaddr = tfile_get_traceframe_address (tframe_offset);
3975 if (tfaddr == addr1)
3979 tp = get_tracepoint (num);
3980 if (tp && tpnum == tp->number_on_target)
3984 tfaddr = tfile_get_traceframe_address (tframe_offset);
3985 if (addr1 <= tfaddr && tfaddr <= addr2)
3989 tfaddr = tfile_get_traceframe_address (tframe_offset);
3990 if (!(addr1 <= tfaddr && tfaddr <= addr2))
3994 internal_error (__FILE__, __LINE__, _("unknown tfind type"));
4000 cur_offset = offset;
4001 cur_data_size = data_size;
4002 cur_traceframe_number = tfnum;
4005 /* Skip past the traceframe's data. */
4006 lseek (trace_fd, data_size, SEEK_CUR);
4007 offset += data_size;
4008 /* Update our own count of traceframes. */
4011 /* Did not find what we were looking for. */
4017 /* Prototype of the callback passed to tframe_walk_blocks. */
4018 typedef int (*walk_blocks_callback_func) (char blocktype, void *data);
4020 /* Callback for traceframe_walk_blocks, used to find a given block
4021 type in a traceframe. */
4024 match_blocktype (char blocktype, void *data)
4026 char *wantedp = data;
4028 if (*wantedp == blocktype)
4034 /* Walk over all traceframe block starting at POS offset from
4035 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4036 unmodified. If CALLBACK returns true, this returns the position in
4037 the traceframe where the block is found, relative to the start of
4038 the traceframe (cur_offset). Returns -1 if no callback call
4039 returned true, indicating that all blocks have been walked. */
4042 traceframe_walk_blocks (walk_blocks_callback_func callback,
4043 int pos, void *data)
4045 /* Iterate through a traceframe's blocks, looking for a block of the
4048 lseek (trace_fd, cur_offset + pos, SEEK_SET);
4049 while (pos < cur_data_size)
4051 unsigned short mlen;
4054 tfile_read (&block_type, 1);
4058 if ((*callback) (block_type, data))
4064 lseek (trace_fd, cur_offset + pos + trace_regblock_size, SEEK_SET);
4065 pos += trace_regblock_size;
4068 lseek (trace_fd, cur_offset + pos + 8, SEEK_SET);
4069 tfile_read ((gdb_byte *) &mlen, 2);
4070 mlen = (unsigned short)
4071 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
4074 lseek (trace_fd, mlen, SEEK_CUR);
4075 pos += (8 + 2 + mlen);
4078 lseek (trace_fd, cur_offset + pos + 4 + 8, SEEK_SET);
4082 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4083 block_type, block_type);
4091 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4092 position offset of a block of type TYPE_WANTED in the current trace
4093 frame, starting at POS. Returns -1 if no such block was found. */
4096 traceframe_find_block_type (char type_wanted, int pos)
4098 return traceframe_walk_blocks (match_blocktype, pos, &type_wanted);
4101 /* Look for a block of saved registers in the traceframe, and get the
4102 requested register from it. */
4105 tfile_fetch_registers (struct target_ops *ops,
4106 struct regcache *regcache, int regno)
4108 struct gdbarch *gdbarch = get_regcache_arch (regcache);
4110 int pos, offset, regn, regsize, pc_regno;
4111 unsigned short mlen;
4114 /* An uninitialized reg size says we're not going to be
4115 successful at getting register blocks. */
4116 if (!trace_regblock_size)
4119 set_tfile_traceframe ();
4121 regs = alloca (trace_regblock_size);
4123 if (traceframe_find_block_type ('R', 0) >= 0)
4125 tfile_read (regs, trace_regblock_size);
4127 /* Assume the block is laid out in GDB register number order,
4128 each register with the size that it has in GDB. */
4130 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4132 regsize = register_size (gdbarch, regn);
4133 /* Make sure we stay within block bounds. */
4134 if (offset + regsize >= trace_regblock_size)
4136 if (regcache_register_status (regcache, regn) == REG_UNKNOWN)
4140 regcache_raw_supply (regcache, regno, regs + offset);
4143 else if (regno == -1)
4145 regcache_raw_supply (regcache, regn, regs + offset);
4153 /* We get here if no register data has been found. Mark registers
4155 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4156 regcache_raw_supply (regcache, regn, NULL);
4158 /* We can often usefully guess that the PC is going to be the same
4159 as the address of the tracepoint. */
4160 pc_regno = gdbarch_pc_regnum (gdbarch);
4161 if (pc_regno >= 0 && (regno == -1 || regno == pc_regno))
4163 struct tracepoint *tp = get_tracepoint (tracepoint_number);
4165 if (tp && tp->base.loc)
4167 /* But don't try to guess if tracepoint is multi-location... */
4168 if (tp->base.loc->next)
4170 warning (_("Tracepoint %d has multiple "
4171 "locations, cannot infer $pc"),
4175 /* ... or does while-stepping. */
4176 if (tp->step_count > 0)
4178 warning (_("Tracepoint %d does while-stepping, "
4179 "cannot infer $pc"),
4184 store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
4185 gdbarch_byte_order (gdbarch),
4186 tp->base.loc->address);
4187 regcache_raw_supply (regcache, pc_regno, regs);
4193 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
4194 const char *annex, gdb_byte *readbuf,
4195 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
4197 /* We're only doing regular memory for now. */
4198 if (object != TARGET_OBJECT_MEMORY)
4201 if (readbuf == NULL)
4202 error (_("tfile_xfer_partial: trace file is read-only"));
4204 set_tfile_traceframe ();
4206 if (traceframe_number != -1)
4210 /* Iterate through the traceframe's blocks, looking for
4212 while ((pos = traceframe_find_block_type ('M', pos)) >= 0)
4214 ULONGEST maddr, amt;
4215 unsigned short mlen;
4216 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
4218 tfile_read ((gdb_byte *) &maddr, 8);
4219 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
4221 tfile_read ((gdb_byte *) &mlen, 2);
4222 mlen = (unsigned short)
4223 extract_unsigned_integer ((gdb_byte *) &mlen, 2, byte_order);
4225 /* If the block includes the first part of the desired
4226 range, return as much it has; GDB will re-request the
4227 remainder, which might be in a different block of this
4229 if (maddr <= offset && offset < (maddr + mlen))
4231 amt = (maddr + mlen) - offset;
4235 tfile_read (readbuf, amt);
4239 /* Skip over this block. */
4240 pos += (8 + 2 + mlen);
4244 /* It's unduly pedantic to refuse to look at the executable for
4245 read-only pieces; so do the equivalent of readonly regions aka
4247 /* FIXME account for relocation at some point. */
4254 for (s = exec_bfd->sections; s; s = s->next)
4256 if ((s->flags & SEC_LOAD) == 0
4257 || (s->flags & SEC_READONLY) == 0)
4261 size = bfd_get_section_size (s);
4262 if (vma <= offset && offset < (vma + size))
4266 amt = (vma + size) - offset;
4270 amt = bfd_get_section_contents (exec_bfd, s,
4271 readbuf, offset - vma, amt);
4277 /* Indicate failure to find the requested memory block. */
4281 /* Iterate through the blocks of a trace frame, looking for a 'V'
4282 block with a matching tsv number. */
4285 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
4289 set_tfile_traceframe ();
4292 while ((pos = traceframe_find_block_type ('V', pos)) >= 0)
4296 tfile_read ((gdb_byte *) &vnum, 4);
4297 vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
4302 tfile_read ((gdb_byte *) val, 8);
4303 *val = extract_signed_integer ((gdb_byte *) val, 8,
4311 /* Didn't find anything. */
4316 tfile_has_all_memory (struct target_ops *ops)
4322 tfile_has_memory (struct target_ops *ops)
4328 tfile_has_stack (struct target_ops *ops)
4330 return traceframe_number != -1;
4334 tfile_has_registers (struct target_ops *ops)
4336 return traceframe_number != -1;
4340 tfile_thread_alive (struct target_ops *ops, ptid_t ptid)
4345 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
4346 object for the tfile target's current traceframe. */
4349 build_traceframe_info (char blocktype, void *data)
4351 struct traceframe_info *info = data;
4357 struct mem_range *r;
4359 unsigned short mlen;
4361 tfile_read ((gdb_byte *) &maddr, 8);
4362 tfile_read ((gdb_byte *) &mlen, 2);
4364 r = VEC_safe_push (mem_range_s, info->memory, NULL);
4377 warning (_("Unhandled trace block type (%d) '%c ' "
4378 "while building trace frame info."),
4379 blocktype, blocktype);
4386 static struct traceframe_info *
4387 tfile_traceframe_info (void)
4389 struct traceframe_info *info = XCNEW (struct traceframe_info);
4391 traceframe_walk_blocks (build_traceframe_info, 0, info);
4396 init_tfile_ops (void)
4398 tfile_ops.to_shortname = "tfile";
4399 tfile_ops.to_longname = "Local trace dump file";
4401 = "Use a trace file as a target. Specify the filename of the trace file.";
4402 tfile_ops.to_open = tfile_open;
4403 tfile_ops.to_close = tfile_close;
4404 tfile_ops.to_fetch_registers = tfile_fetch_registers;
4405 tfile_ops.to_xfer_partial = tfile_xfer_partial;
4406 tfile_ops.to_files_info = tfile_files_info;
4407 tfile_ops.to_get_trace_status = tfile_get_trace_status;
4408 tfile_ops.to_trace_find = tfile_trace_find;
4409 tfile_ops.to_get_trace_state_variable_value
4410 = tfile_get_trace_state_variable_value;
4411 tfile_ops.to_stratum = process_stratum;
4412 tfile_ops.to_has_all_memory = tfile_has_all_memory;
4413 tfile_ops.to_has_memory = tfile_has_memory;
4414 tfile_ops.to_has_stack = tfile_has_stack;
4415 tfile_ops.to_has_registers = tfile_has_registers;
4416 tfile_ops.to_traceframe_info = tfile_traceframe_info;
4417 tfile_ops.to_thread_alive = tfile_thread_alive;
4418 tfile_ops.to_magic = OPS_MAGIC;
4421 /* Given a line of text defining a static tracepoint marker, parse it
4422 into a "static tracepoint marker" object. Throws an error is
4423 parsing fails. If PP is non-null, it points to one past the end of
4424 the parsed marker definition. */
4427 parse_static_tracepoint_marker_definition (char *line, char **pp,
4428 struct static_tracepoint_marker *marker)
4435 p = unpack_varlen_hex (p, &addr);
4436 p++; /* skip a colon */
4438 marker->gdbarch = target_gdbarch;
4439 marker->address = (CORE_ADDR) addr;
4441 endp = strchr (p, ':');
4443 error (_("bad marker definition: %s"), line);
4445 marker->str_id = xmalloc (endp - p + 1);
4446 end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
4447 marker->str_id[end] = '\0';
4450 p++; /* skip a colon */
4452 marker->extra = xmalloc (strlen (p) + 1);
4453 end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
4454 marker->extra[end] = '\0';
4460 /* Release a static tracepoint marker's contents. Note that the
4461 object itself isn't released here. There objects are usually on
4465 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
4467 xfree (marker->str_id);
4468 marker->str_id = NULL;
4471 /* Print MARKER to gdb_stdout. */
4474 print_one_static_tracepoint_marker (int count,
4475 struct static_tracepoint_marker *marker)
4477 struct command_line *l;
4480 char wrap_indent[80];
4481 char extra_field_indent[80];
4482 struct ui_out *uiout = current_uiout;
4483 struct ui_stream *stb = ui_out_stream_new (uiout);
4484 struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb);
4485 struct cleanup *bkpt_chain;
4486 VEC(breakpoint_p) *tracepoints;
4488 struct symtab_and_line sal;
4492 sal.pc = marker->address;
4494 tracepoints = static_tracepoints_here (marker->address);
4496 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
4498 /* A counter field to help readability. This is not a stable
4500 ui_out_field_int (uiout, "count", count);
4502 ui_out_field_string (uiout, "marker-id", marker->str_id);
4504 ui_out_field_fmt (uiout, "enabled", "%c",
4505 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
4506 ui_out_spaces (uiout, 2);
4508 strcpy (wrap_indent, " ");
4510 if (gdbarch_addr_bit (marker->gdbarch) <= 32)
4511 strcat (wrap_indent, " ");
4513 strcat (wrap_indent, " ");
4515 strcpy (extra_field_indent, " ");
4517 ui_out_field_core_addr (uiout, "addr", marker->gdbarch, marker->address);
4519 sal = find_pc_line (marker->address, 0);
4520 sym = find_pc_sect_function (marker->address, NULL);
4523 ui_out_text (uiout, "in ");
4524 ui_out_field_string (uiout, "func",
4525 SYMBOL_PRINT_NAME (sym));
4526 ui_out_wrap_hint (uiout, wrap_indent);
4527 ui_out_text (uiout, " at ");
4530 ui_out_field_skip (uiout, "func");
4532 if (sal.symtab != NULL)
4534 ui_out_field_string (uiout, "file", sal.symtab->filename);
4535 ui_out_text (uiout, ":");
4537 if (ui_out_is_mi_like_p (uiout))
4539 char *fullname = symtab_to_fullname (sal.symtab);
4542 ui_out_field_string (uiout, "fullname", fullname);
4545 ui_out_field_skip (uiout, "fullname");
4547 ui_out_field_int (uiout, "line", sal.line);
4551 ui_out_field_skip (uiout, "fullname");
4552 ui_out_field_skip (uiout, "line");
4555 ui_out_text (uiout, "\n");
4556 ui_out_text (uiout, extra_field_indent);
4557 ui_out_text (uiout, _("Data: \""));
4558 ui_out_field_string (uiout, "extra-data", marker->extra);
4559 ui_out_text (uiout, "\"\n");
4561 if (!VEC_empty (breakpoint_p, tracepoints))
4563 struct cleanup *cleanup_chain;
4565 struct breakpoint *b;
4567 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
4570 ui_out_text (uiout, extra_field_indent);
4571 ui_out_text (uiout, _("Probed by static tracepoints: "));
4572 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
4575 ui_out_text (uiout, ", ");
4576 ui_out_text (uiout, "#");
4577 ui_out_field_int (uiout, "tracepoint-id", b->number);
4580 do_cleanups (cleanup_chain);
4582 if (ui_out_is_mi_like_p (uiout))
4583 ui_out_field_int (uiout, "number-of-tracepoints",
4584 VEC_length(breakpoint_p, tracepoints));
4586 ui_out_text (uiout, "\n");
4588 VEC_free (breakpoint_p, tracepoints);
4590 do_cleanups (bkpt_chain);
4591 do_cleanups (old_chain);
4595 info_static_tracepoint_markers_command (char *arg, int from_tty)
4597 VEC(static_tracepoint_marker_p) *markers;
4598 struct cleanup *old_chain;
4599 struct static_tracepoint_marker *marker;
4600 struct ui_out *uiout = current_uiout;
4604 = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
4605 "StaticTracepointMarkersTable");
4607 ui_out_table_header (uiout, 7, ui_left, "counter", "Cnt");
4609 ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
4611 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
4612 if (gdbarch_addr_bit (target_gdbarch) <= 32)
4613 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
4615 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
4616 ui_out_table_header (uiout, 40, ui_noalign, "what", "What");
4618 ui_out_table_body (uiout);
4620 markers = target_static_tracepoint_markers_by_strid (NULL);
4621 make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
4624 VEC_iterate (static_tracepoint_marker_p,
4625 markers, i, marker);
4628 print_one_static_tracepoint_marker (i + 1, marker);
4629 release_static_tracepoint_marker (marker);
4632 do_cleanups (old_chain);
4635 /* The $_sdata convenience variable is a bit special. We don't know
4636 for sure type of the value until we actually have a chance to fetch
4637 the data --- the size of the object depends on what has been
4638 collected. We solve this by making $_sdata be an internalvar that
4639 creates a new value on access. */
4641 /* Return a new value with the correct type for the sdata object of
4642 the current trace frame. Return a void value if there's no object
4645 static struct value *
4646 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var)
4651 /* We need to read the whole object before we know its size. */
4652 size = target_read_alloc (¤t_target,
4653 TARGET_OBJECT_STATIC_TRACE_DATA,
4660 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
4662 v = allocate_value (type);
4663 memcpy (value_contents_raw (v), buf, size);
4668 return allocate_value (builtin_type (gdbarch)->builtin_void);
4671 #if !defined(HAVE_LIBEXPAT)
4673 struct traceframe_info *
4674 parse_traceframe_info (const char *tframe_info)
4676 static int have_warned;
4681 warning (_("Can not parse XML trace frame info; XML support "
4682 "was disabled at compile time"));
4688 #else /* HAVE_LIBEXPAT */
4690 #include "xml-support.h"
4692 /* Handle the start of a <memory> element. */
4695 traceframe_info_start_memory (struct gdb_xml_parser *parser,
4696 const struct gdb_xml_element *element,
4697 void *user_data, VEC(gdb_xml_value_s) *attributes)
4699 struct traceframe_info *info = user_data;
4700 struct mem_range *r = VEC_safe_push (mem_range_s, info->memory, NULL);
4701 ULONGEST *start_p, *length_p;
4703 start_p = xml_find_attribute (attributes, "start")->value;
4704 length_p = xml_find_attribute (attributes, "length")->value;
4706 r->start = *start_p;
4707 r->length = *length_p;
4710 /* Discard the constructed trace frame info (if an error occurs). */
4713 free_result (void *p)
4715 struct traceframe_info *result = p;
4717 free_traceframe_info (result);
4720 /* The allowed elements and attributes for an XML memory map. */
4722 static const struct gdb_xml_attribute memory_attributes[] = {
4723 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4724 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4725 { NULL, GDB_XML_AF_NONE, NULL, NULL }
4728 static const struct gdb_xml_element traceframe_info_children[] = {
4729 { "memory", memory_attributes, NULL,
4730 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
4731 traceframe_info_start_memory, NULL },
4732 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4735 static const struct gdb_xml_element traceframe_info_elements[] = {
4736 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
4738 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4741 /* Parse a traceframe-info XML document. */
4743 struct traceframe_info *
4744 parse_traceframe_info (const char *tframe_info)
4746 struct traceframe_info *result;
4747 struct cleanup *back_to;
4749 result = XCNEW (struct traceframe_info);
4750 back_to = make_cleanup (free_result, result);
4752 if (gdb_xml_parse_quick (_("trace frame info"),
4753 "traceframe-info.dtd", traceframe_info_elements,
4754 tframe_info, result) == 0)
4756 /* Parsed successfully, keep the result. */
4757 discard_cleanups (back_to);
4762 do_cleanups (back_to);
4766 #endif /* HAVE_LIBEXPAT */
4768 /* Returns the traceframe_info object for the current traceframe.
4769 This is where we avoid re-fetching the object from the target if we
4770 already have it cached. */
4772 struct traceframe_info *
4773 get_traceframe_info (void)
4775 if (traceframe_info == NULL)
4776 traceframe_info = target_traceframe_info ();
4778 return traceframe_info;
4781 /* If the target supports the query, return in RESULT the set of
4782 collected memory in the current traceframe, found within the LEN
4783 bytes range starting at MEMADDR. Returns true if the target
4784 supports the query, otherwise returns false, and RESULT is left
4788 traceframe_available_memory (VEC(mem_range_s) **result,
4789 CORE_ADDR memaddr, ULONGEST len)
4791 struct traceframe_info *info = get_traceframe_info ();
4795 struct mem_range *r;
4800 for (i = 0; VEC_iterate (mem_range_s, info->memory, i, r); i++)
4801 if (mem_ranges_overlap (r->start, r->length, memaddr, len))
4803 ULONGEST lo1, hi1, lo2, hi2;
4804 struct mem_range *nr;
4807 hi1 = memaddr + len;
4810 hi2 = r->start + r->length;
4812 nr = VEC_safe_push (mem_range_s, *result, NULL);
4814 nr->start = max (lo1, lo2);
4815 nr->length = min (hi1, hi2) - nr->start;
4818 normalize_mem_ranges (*result);
4825 /* module initialization */
4827 _initialize_tracepoint (void)
4829 struct cmd_list_element *c;
4831 /* Explicitly create without lookup, since that tries to create a
4832 value with a void typed value, and when we get here, gdbarch
4833 isn't initialized yet. At this point, we're quite sure there
4834 isn't another convenience variable of the same name. */
4835 create_internalvar_type_lazy ("_sdata", sdata_make_value);
4837 traceframe_number = -1;
4838 tracepoint_number = -1;
4840 if (tracepoint_list.list == NULL)
4842 tracepoint_list.listsize = 128;
4843 tracepoint_list.list = xmalloc
4844 (tracepoint_list.listsize * sizeof (struct memrange));
4846 if (tracepoint_list.aexpr_list == NULL)
4848 tracepoint_list.aexpr_listsize = 128;
4849 tracepoint_list.aexpr_list = xmalloc
4850 (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
4853 if (stepping_list.list == NULL)
4855 stepping_list.listsize = 128;
4856 stepping_list.list = xmalloc
4857 (stepping_list.listsize * sizeof (struct memrange));
4860 if (stepping_list.aexpr_list == NULL)
4862 stepping_list.aexpr_listsize = 128;
4863 stepping_list.aexpr_list = xmalloc
4864 (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
4867 add_info ("scope", scope_info,
4868 _("List the variables local to a scope"));
4870 add_cmd ("tracepoints", class_trace, NULL,
4871 _("Tracing of program execution without stopping the program."),
4874 add_com ("tdump", class_trace, trace_dump_command,
4875 _("Print everything collected at the current tracepoint."));
4877 add_com ("tsave", class_trace, trace_save_command, _("\
4878 Save the trace data to a file.\n\
4879 Use the '-r' option to direct the target to save directly to the file,\n\
4880 using its own filesystem."));
4882 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
4883 Define a trace state variable.\n\
4884 Argument is a $-prefixed name, optionally followed\n\
4885 by '=' and an expression that sets the initial value\n\
4886 at the start of tracing."));
4887 set_cmd_completer (c, expression_completer);
4889 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
4890 Delete one or more trace state variables.\n\
4891 Arguments are the names of the variables to delete.\n\
4892 If no arguments are supplied, delete all variables."), &deletelist);
4893 /* FIXME add a trace variable completer. */
4895 add_info ("tvariables", tvariables_info, _("\
4896 Status of trace state variables and their values.\n\
4899 add_info ("static-tracepoint-markers",
4900 info_static_tracepoint_markers_command, _("\
4901 List target static tracepoints markers.\n\
4904 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
4905 Select a trace frame;\n\
4906 No argument means forward by one frame; '-' means backward by one frame."),
4907 &tfindlist, "tfind ", 1, &cmdlist);
4909 add_cmd ("outside", class_trace, trace_find_outside_command, _("\
4910 Select a trace frame whose PC is outside the given range (exclusive).\n\
4911 Usage: tfind outside addr1, addr2"),
4914 add_cmd ("range", class_trace, trace_find_range_command, _("\
4915 Select a trace frame whose PC is in the given range (inclusive).\n\
4916 Usage: tfind range addr1,addr2"),
4919 add_cmd ("line", class_trace, trace_find_line_command, _("\
4920 Select a trace frame by source line.\n\
4921 Argument can be a line number (with optional source file),\n\
4922 a function name, or '*' followed by an address.\n\
4923 Default argument is 'the next source line that was traced'."),
4926 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
4927 Select a trace frame by tracepoint number.\n\
4928 Default is the tracepoint for the current trace frame."),
4931 add_cmd ("pc", class_trace, trace_find_pc_command, _("\
4932 Select a trace frame by PC.\n\
4933 Default is the current PC, or the PC of the current trace frame."),
4936 add_cmd ("end", class_trace, trace_find_end_command, _("\
4937 Synonym for 'none'.\n\
4938 De-select any trace frame and resume 'live' debugging."),
4941 add_cmd ("none", class_trace, trace_find_none_command,
4942 _("De-select any trace frame and resume 'live' debugging."),
4945 add_cmd ("start", class_trace, trace_find_start_command,
4946 _("Select the first trace frame in the trace buffer."),
4949 add_com ("tstatus", class_trace, trace_status_command,
4950 _("Display the status of the current trace data collection."));
4952 add_com ("tstop", class_trace, trace_stop_command,
4953 _("Stop trace data collection."));
4955 add_com ("tstart", class_trace, trace_start_command,
4956 _("Start trace data collection."));
4958 add_com ("end", class_trace, end_actions_pseudocommand, _("\
4959 Ends a list of commands or actions.\n\
4960 Several GDB commands allow you to enter a list of commands or actions.\n\
4961 Entering \"end\" on a line by itself is the normal way to terminate\n\
4963 Note: the \"end\" command cannot be used at the gdb prompt."));
4965 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
4966 Specify single-stepping behavior at a tracepoint.\n\
4967 Argument is number of instructions to trace in single-step mode\n\
4968 following the tracepoint. This command is normally followed by\n\
4969 one or more \"collect\" commands, to specify what to collect\n\
4970 while single-stepping.\n\n\
4971 Note: this command can only be used in a tracepoint \"actions\" list."));
4973 add_com_alias ("ws", "while-stepping", class_alias, 0);
4974 add_com_alias ("stepping", "while-stepping", class_alias, 0);
4976 add_com ("collect", class_trace, collect_pseudocommand, _("\
4977 Specify one or more data items to be collected at a tracepoint.\n\
4978 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4979 collect all data (variables, registers) referenced by that expression.\n\
4980 Also accepts the following special arguments:\n\
4981 $regs -- all registers.\n\
4982 $args -- all function arguments.\n\
4983 $locals -- all variables local to the block/function scope.\n\
4984 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4985 Note: this command can only be used in a tracepoint \"actions\" list."));
4987 add_com ("teval", class_trace, teval_pseudocommand, _("\
4988 Specify one or more expressions to be evaluated at a tracepoint.\n\
4989 Accepts a comma-separated list of (one or more) expressions.\n\
4990 The result of each evaluation will be discarded.\n\
4991 Note: this command can only be used in a tracepoint \"actions\" list."));
4993 add_com ("actions", class_trace, trace_actions_command, _("\
4994 Specify the actions to be taken at a tracepoint.\n\
4995 Tracepoint actions may include collecting of specified data,\n\
4996 single-stepping, or enabling/disabling other tracepoints,\n\
4997 depending on target's capabilities."));
4999 default_collect = xstrdup ("");
5000 add_setshow_string_cmd ("default-collect", class_trace,
5001 &default_collect, _("\
5002 Set the list of expressions to collect by default"), _("\
5003 Show the list of expressions to collect by default"), NULL,
5005 &setlist, &showlist);
5007 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
5008 &disconnected_tracing, _("\
5009 Set whether tracing continues after GDB disconnects."), _("\
5010 Show whether tracing continues after GDB disconnects."), _("\
5011 Use this to continue a tracing run even if GDB disconnects\n\
5012 or detaches from the target. You can reconnect later and look at\n\
5013 trace data collected in the meantime."),
5014 set_disconnected_tracing,
5019 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
5020 &circular_trace_buffer, _("\
5021 Set target's use of circular trace buffer."), _("\
5022 Show target's use of circular trace buffer."), _("\
5023 Use this to make the trace buffer into a circular buffer,\n\
5024 which will discard traceframes (oldest first) instead of filling\n\
5025 up and stopping the trace run."),
5026 set_circular_trace_buffer,
5033 add_target (&tfile_ops);