1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
4 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "arch-utils.h"
26 #include "expression.h"
31 #include "gdb_string.h"
33 #include "breakpoint.h"
34 #include "tracepoint.h"
37 #include "completer.h"
39 #include "dictionary.h"
41 #include "user-regs.h"
45 #include "filenames.h"
46 #include "gdbthread.h"
54 #include "exceptions.h"
56 /* readline include files */
57 #include "readline/readline.h"
58 #include "readline/history.h"
60 /* readline defines this. */
71 extern int hex2bin (const char *hex, gdb_byte *bin, int count);
72 extern int bin2hex (const gdb_byte *bin, char *hex, int count);
74 /* Maximum length of an agent aexpression.
75 This accounts for the fact that packets are limited to 400 bytes
76 (which includes everything -- including the checksum), and assumes
77 the worst case of maximum length for each of the pieces of a
80 NOTE: expressions get mem2hex'ed otherwise this would be twice as
81 large. (400 - 31)/2 == 184 */
82 #define MAX_AGENT_EXPR_LEN 184
86 /* A hook used to notify the UI of tracepoint operations. */
88 void (*deprecated_trace_find_hook) (char *arg, int from_tty);
89 void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
91 extern void (*deprecated_readline_begin_hook) (char *, ...);
92 extern char *(*deprecated_readline_hook) (char *);
93 extern void (*deprecated_readline_end_hook) (void);
95 /* GDB commands implemented in other modules:
98 extern void output_command (char *, int);
103 This module defines the following debugger commands:
104 trace : set a tracepoint on a function, line, or address.
105 info trace : list all debugger-defined tracepoints.
106 delete trace : delete one or more tracepoints.
107 enable trace : enable one or more tracepoints.
108 disable trace : disable one or more tracepoints.
109 actions : specify actions to be taken at a tracepoint.
110 passcount : specify a pass count for a tracepoint.
111 tstart : start a trace experiment.
112 tstop : stop a trace experiment.
113 tstatus : query the status of a trace experiment.
114 tfind : find a trace frame in the trace buffer.
115 tdump : print everything collected at the current tracepoint.
116 save-tracepoints : write tracepoint setup into a file.
118 This module defines the following user-visible debugger variables:
119 $trace_frame : sequence number of trace frame currently being debugged.
120 $trace_line : source line of trace frame currently being debugged.
121 $trace_file : source file of trace frame currently being debugged.
122 $tracepoint : tracepoint number of trace frame currently being debugged.
126 /* ======= Important global variables: ======= */
128 /* The list of all trace state variables. We don't retain pointers to
129 any of these for any reason - API is by name or number only - so it
130 works to have a vector of objects. */
132 typedef struct trace_state_variable tsv_s;
135 /* An object describing the contents of a traceframe. */
137 struct traceframe_info
139 /* Collected memory. */
140 VEC(mem_range_s) *memory;
143 static VEC(tsv_s) *tvariables;
145 /* The next integer to assign to a variable. */
147 static int next_tsv_number = 1;
149 /* Number of last traceframe collected. */
150 static int traceframe_number;
152 /* Tracepoint for last traceframe collected. */
153 static int tracepoint_number;
155 /* Symbol for function for last traceframe collected. */
156 static struct symbol *traceframe_fun;
158 /* Symtab and line for last traceframe collected. */
159 static struct symtab_and_line traceframe_sal;
161 /* The traceframe info of the current traceframe. NULL if we haven't
162 yet attempted to fetch it, or if the target does not support
163 fetching this object, or if we're not inspecting a traceframe
165 static struct traceframe_info *traceframe_info;
167 /* Tracing command lists. */
168 static struct cmd_list_element *tfindlist;
170 /* List of expressions to collect by default at each tracepoint hit. */
171 char *default_collect = "";
173 static int disconnected_tracing;
175 /* This variable controls whether we ask the target for a linear or
176 circular trace buffer. */
178 static int circular_trace_buffer;
180 /* ======= Important command functions: ======= */
181 static void trace_actions_command (char *, int);
182 static void trace_start_command (char *, int);
183 static void trace_stop_command (char *, int);
184 static void trace_status_command (char *, int);
185 static void trace_find_command (char *, int);
186 static void trace_find_pc_command (char *, int);
187 static void trace_find_tracepoint_command (char *, int);
188 static void trace_find_line_command (char *, int);
189 static void trace_find_range_command (char *, int);
190 static void trace_find_outside_command (char *, int);
191 static void trace_dump_command (char *, int);
193 /* support routines */
195 struct collection_list;
196 static void add_aexpr (struct collection_list *, struct agent_expr *);
197 static char *mem2hex (gdb_byte *, char *, int);
198 static void add_register (struct collection_list *collection,
201 extern void send_disconnected_tracing_value (int value);
203 static void free_uploaded_tps (struct uploaded_tp **utpp);
204 static void free_uploaded_tsvs (struct uploaded_tsv **utsvp);
207 extern void _initialize_tracepoint (void);
209 static struct trace_status trace_status;
211 char *stop_reason_names[] = {
221 struct trace_status *
222 current_trace_status (void)
224 return &trace_status;
230 free_traceframe_info (struct traceframe_info *info)
234 VEC_free (mem_range_s, info->memory);
240 /* Free and clear the traceframe info cache of the current
244 clear_traceframe_info (void)
246 free_traceframe_info (traceframe_info);
247 traceframe_info = NULL;
250 /* Set traceframe number to NUM. */
252 set_traceframe_num (int num)
254 traceframe_number = num;
255 set_internalvar_integer (lookup_internalvar ("trace_frame"), num);
258 /* Set tracepoint number to NUM. */
260 set_tracepoint_num (int num)
262 tracepoint_number = num;
263 set_internalvar_integer (lookup_internalvar ("tracepoint"), num);
266 /* Set externally visible debug variables for querying/printing
267 the traceframe context (line, function, file). */
270 set_traceframe_context (struct frame_info *trace_frame)
274 /* Save as globals for internal use. */
275 if (trace_frame != NULL
276 && get_frame_pc_if_available (trace_frame, &trace_pc))
278 traceframe_sal = find_pc_line (trace_pc, 0);
279 traceframe_fun = find_pc_function (trace_pc);
281 /* Save linenumber as "$trace_line", a debugger variable visible to
283 set_internalvar_integer (lookup_internalvar ("trace_line"),
284 traceframe_sal.line);
288 init_sal (&traceframe_sal);
289 traceframe_fun = NULL;
290 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
293 /* Save func name as "$trace_func", a debugger variable visible to
295 if (traceframe_fun == NULL
296 || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
297 clear_internalvar (lookup_internalvar ("trace_func"));
299 set_internalvar_string (lookup_internalvar ("trace_func"),
300 SYMBOL_LINKAGE_NAME (traceframe_fun));
302 /* Save file name as "$trace_file", a debugger variable visible to
304 if (traceframe_sal.symtab == NULL
305 || traceframe_sal.symtab->filename == NULL)
306 clear_internalvar (lookup_internalvar ("trace_file"));
308 set_internalvar_string (lookup_internalvar ("trace_file"),
309 traceframe_sal.symtab->filename);
312 /* Create a new trace state variable with the given name. */
314 struct trace_state_variable *
315 create_trace_state_variable (const char *name)
317 struct trace_state_variable tsv;
319 memset (&tsv, 0, sizeof (tsv));
320 tsv.name = xstrdup (name);
321 tsv.number = next_tsv_number++;
322 return VEC_safe_push (tsv_s, tvariables, &tsv);
325 /* Look for a trace state variable of the given name. */
327 struct trace_state_variable *
328 find_trace_state_variable (const char *name)
330 struct trace_state_variable *tsv;
333 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
334 if (strcmp (name, tsv->name) == 0)
341 delete_trace_state_variable (const char *name)
343 struct trace_state_variable *tsv;
346 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
347 if (strcmp (name, tsv->name) == 0)
349 xfree ((void *)tsv->name);
350 VEC_unordered_remove (tsv_s, tvariables, ix);
354 warning (_("No trace variable named \"$%s\", not deleting"), name);
357 /* The 'tvariable' command collects a name and optional expression to
358 evaluate into an initial value. */
361 trace_variable_command (char *args, int from_tty)
363 struct expression *expr;
364 struct cleanup *old_chain;
365 struct internalvar *intvar = NULL;
367 struct trace_state_variable *tsv;
370 error_no_arg (_("trace state variable name"));
372 /* All the possible valid arguments are expressions. */
373 expr = parse_expression (args);
374 old_chain = make_cleanup (free_current_contents, &expr);
376 if (expr->nelts == 0)
377 error (_("No expression?"));
379 /* Only allow two syntaxes; "$name" and "$name=value". */
380 if (expr->elts[0].opcode == OP_INTERNALVAR)
382 intvar = expr->elts[1].internalvar;
384 else if (expr->elts[0].opcode == BINOP_ASSIGN
385 && expr->elts[1].opcode == OP_INTERNALVAR)
387 intvar = expr->elts[2].internalvar;
388 initval = value_as_long (evaluate_subexpression_type (expr, 4));
391 error (_("Syntax must be $NAME [ = EXPR ]"));
394 error (_("No name given"));
396 if (strlen (internalvar_name (intvar)) <= 0)
397 error (_("Must supply a non-empty variable name"));
399 /* If the variable already exists, just change its initial value. */
400 tsv = find_trace_state_variable (internalvar_name (intvar));
403 tsv->initial_value = initval;
404 printf_filtered (_("Trace state variable $%s "
405 "now has initial value %s.\n"),
406 tsv->name, plongest (tsv->initial_value));
407 do_cleanups (old_chain);
411 /* Create a new variable. */
412 tsv = create_trace_state_variable (internalvar_name (intvar));
413 tsv->initial_value = initval;
415 printf_filtered (_("Trace state variable $%s "
416 "created, with initial value %s.\n"),
417 tsv->name, plongest (tsv->initial_value));
419 do_cleanups (old_chain);
423 delete_trace_variable_command (char *args, int from_tty)
427 struct cleanup *back_to;
431 if (query (_("Delete all trace state variables? ")))
432 VEC_free (tsv_s, tvariables);
437 argv = gdb_buildargv (args);
438 back_to = make_cleanup_freeargv (argv);
440 for (ix = 0; argv[ix] != NULL; ix++)
442 if (*argv[ix] == '$')
443 delete_trace_state_variable (argv[ix] + 1);
445 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv[ix]);
448 do_cleanups (back_to);
454 tvariables_info_1 (void)
456 struct trace_state_variable *tsv;
459 struct cleanup *back_to;
460 struct ui_out *uiout = current_uiout;
462 if (VEC_length (tsv_s, tvariables) == 0 && !ui_out_is_mi_like_p (uiout))
464 printf_filtered (_("No trace state variables.\n"));
468 /* Try to acquire values from the target. */
469 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix, ++count)
470 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
473 back_to = make_cleanup_ui_out_table_begin_end (uiout, 3,
474 count, "trace-variables");
475 ui_out_table_header (uiout, 15, ui_left, "name", "Name");
476 ui_out_table_header (uiout, 11, ui_left, "initial", "Initial");
477 ui_out_table_header (uiout, 11, ui_left, "current", "Current");
479 ui_out_table_body (uiout);
481 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
483 struct cleanup *back_to2;
487 back_to2 = make_cleanup_ui_out_tuple_begin_end (uiout, "variable");
489 name = concat ("$", tsv->name, (char *) NULL);
490 make_cleanup (xfree, name);
491 ui_out_field_string (uiout, "name", name);
492 ui_out_field_string (uiout, "initial", plongest (tsv->initial_value));
494 if (tsv->value_known)
495 c = plongest (tsv->value);
496 else if (ui_out_is_mi_like_p (uiout))
497 /* For MI, we prefer not to use magic string constants, but rather
498 omit the field completely. The difference between unknown and
499 undefined does not seem important enough to represent. */
501 else if (current_trace_status ()->running || traceframe_number >= 0)
502 /* The value is/was defined, but we don't have it. */
505 /* It is not meaningful to ask about the value. */
508 ui_out_field_string (uiout, "current", c);
509 ui_out_text (uiout, "\n");
511 do_cleanups (back_to2);
514 do_cleanups (back_to);
517 /* List all the trace state variables. */
520 tvariables_info (char *args, int from_tty)
522 tvariables_info_1 ();
525 /* Stash definitions of tsvs into the given file. */
528 save_trace_state_variables (struct ui_file *fp)
530 struct trace_state_variable *tsv;
533 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
535 fprintf_unfiltered (fp, "tvariable $%s", tsv->name);
536 if (tsv->initial_value)
537 fprintf_unfiltered (fp, " = %s", plongest (tsv->initial_value));
538 fprintf_unfiltered (fp, "\n");
542 /* ACTIONS functions: */
544 /* The three functions:
545 collect_pseudocommand,
546 while_stepping_pseudocommand, and
547 end_actions_pseudocommand
548 are placeholders for "commands" that are actually ONLY to be used
549 within a tracepoint action list. If the actual function is ever called,
550 it means that somebody issued the "command" at the top level,
551 which is always an error. */
554 end_actions_pseudocommand (char *args, int from_tty)
556 error (_("This command cannot be used at the top level."));
560 while_stepping_pseudocommand (char *args, int from_tty)
562 error (_("This command can only be used in a tracepoint actions list."));
566 collect_pseudocommand (char *args, int from_tty)
568 error (_("This command can only be used in a tracepoint actions list."));
572 teval_pseudocommand (char *args, int from_tty)
574 error (_("This command can only be used in a tracepoint actions list."));
577 /* Enter a list of actions for a tracepoint. */
579 trace_actions_command (char *args, int from_tty)
581 struct tracepoint *t;
582 struct command_line *l;
584 t = get_tracepoint_by_number (&args, NULL, 1);
588 xstrprintf ("Enter actions for tracepoint %d, one per line.",
590 struct cleanup *cleanups = make_cleanup (xfree, tmpbuf);
592 l = read_command_lines (tmpbuf, from_tty, 1,
593 check_tracepoint_command, t);
594 do_cleanups (cleanups);
595 breakpoint_set_commands (&t->base, l);
597 /* else just return */
600 /* Report the results of checking the agent expression, as errors or
604 report_agent_reqs_errors (struct agent_expr *aexpr)
606 /* All of the "flaws" are serious bytecode generation issues that
607 should never occur. */
608 if (aexpr->flaw != agent_flaw_none)
609 internal_error (__FILE__, __LINE__, _("expression is malformed"));
611 /* If analysis shows a stack underflow, GDB must have done something
612 badly wrong in its bytecode generation. */
613 if (aexpr->min_height < 0)
614 internal_error (__FILE__, __LINE__,
615 _("expression has min height < 0"));
617 /* Issue this error if the stack is predicted to get too deep. The
618 limit is rather arbitrary; a better scheme might be for the
619 target to report how much stack it will have available. The
620 depth roughly corresponds to parenthesization, so a limit of 20
621 amounts to 20 levels of expression nesting, which is actually
622 a pretty big hairy expression. */
623 if (aexpr->max_height > 20)
624 error (_("Expression is too complicated."));
627 /* worker function */
629 validate_actionline (char **line, struct breakpoint *b)
631 struct cmd_list_element *c;
632 struct expression *exp = NULL;
633 struct cleanup *old_chain = NULL;
635 struct bp_location *loc;
636 struct agent_expr *aexpr;
637 struct tracepoint *t = (struct tracepoint *) b;
639 /* If EOF is typed, *line is NULL. */
643 for (p = *line; isspace ((int) *p);)
646 /* Symbol lookup etc. */
647 if (*p == '\0') /* empty line: just prompt for another line. */
650 if (*p == '#') /* comment line */
653 c = lookup_cmd (&p, cmdlist, "", -1, 1);
655 error (_("`%s' is not a tracepoint action, or is ambiguous."), p);
657 if (cmd_cfunc_eq (c, collect_pseudocommand))
660 { /* Repeat over a comma-separated list. */
661 QUIT; /* Allow user to bail out with ^C. */
662 while (isspace ((int) *p))
665 if (*p == '$') /* Look for special pseudo-symbols. */
667 if (0 == strncasecmp ("reg", p + 1, 3)
668 || 0 == strncasecmp ("arg", p + 1, 3)
669 || 0 == strncasecmp ("loc", p + 1, 3)
670 || 0 == strncasecmp ("_sdata", p + 1, 6))
675 /* else fall thru, treat p as an expression and parse it! */
678 for (loc = t->base.loc; loc; loc = loc->next)
681 exp = parse_exp_1 (&p, block_for_pc (loc->address), 1);
682 old_chain = make_cleanup (free_current_contents, &exp);
684 if (exp->elts[0].opcode == OP_VAR_VALUE)
686 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
688 error (_("constant `%s' (value %ld) "
689 "will not be collected."),
690 SYMBOL_PRINT_NAME (exp->elts[2].symbol),
691 SYMBOL_VALUE (exp->elts[2].symbol));
693 else if (SYMBOL_CLASS (exp->elts[2].symbol)
694 == LOC_OPTIMIZED_OUT)
696 error (_("`%s' is optimized away "
697 "and cannot be collected."),
698 SYMBOL_PRINT_NAME (exp->elts[2].symbol));
702 /* We have something to collect, make sure that the expr to
703 bytecode translator can handle it and that it's not too
705 aexpr = gen_trace_for_expr (loc->address, exp);
706 make_cleanup_free_agent_expr (aexpr);
708 if (aexpr->len > MAX_AGENT_EXPR_LEN)
709 error (_("Expression is too complicated."));
713 report_agent_reqs_errors (aexpr);
715 do_cleanups (old_chain);
718 while (p && *p++ == ',');
721 else if (cmd_cfunc_eq (c, teval_pseudocommand))
724 { /* Repeat over a comma-separated list. */
725 QUIT; /* Allow user to bail out with ^C. */
726 while (isspace ((int) *p))
730 for (loc = t->base.loc; loc; loc = loc->next)
733 /* Only expressions are allowed for this action. */
734 exp = parse_exp_1 (&p, block_for_pc (loc->address), 1);
735 old_chain = make_cleanup (free_current_contents, &exp);
737 /* We have something to evaluate, make sure that the expr to
738 bytecode translator can handle it and that it's not too
740 aexpr = gen_eval_for_expr (loc->address, exp);
741 make_cleanup_free_agent_expr (aexpr);
743 if (aexpr->len > MAX_AGENT_EXPR_LEN)
744 error (_("Expression is too complicated."));
747 report_agent_reqs_errors (aexpr);
749 do_cleanups (old_chain);
752 while (p && *p++ == ',');
755 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
757 char *steparg; /* In case warning is necessary. */
759 while (isspace ((int) *p))
763 if (*p == '\0' || (t->step_count = strtol (p, &p, 0)) == 0)
764 error (_("while-stepping step count `%s' is malformed."), *line);
767 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
771 error (_("`%s' is not a supported tracepoint action."), *line);
775 memrange_absolute = -1
780 int type; /* memrange_absolute for absolute memory range,
781 else basereg number. */
782 bfd_signed_vma start;
786 struct collection_list
788 unsigned char regs_mask[32]; /* room for up to 256 regs */
791 struct memrange *list;
792 long aexpr_listsize; /* size of array pointed to by expr_list elt */
794 struct agent_expr **aexpr_list;
796 /* True is the user requested a collection of "$_sdata", "static
800 tracepoint_list, stepping_list;
802 /* MEMRANGE functions: */
804 static int memrange_cmp (const void *, const void *);
806 /* Compare memranges for qsort. */
808 memrange_cmp (const void *va, const void *vb)
810 const struct memrange *a = va, *b = vb;
812 if (a->type < b->type)
814 if (a->type > b->type)
816 if (a->type == memrange_absolute)
818 if ((bfd_vma) a->start < (bfd_vma) b->start)
820 if ((bfd_vma) a->start > (bfd_vma) b->start)
825 if (a->start < b->start)
827 if (a->start > b->start)
833 /* Sort the memrange list using qsort, and merge adjacent memranges. */
835 memrange_sortmerge (struct collection_list *memranges)
839 qsort (memranges->list, memranges->next_memrange,
840 sizeof (struct memrange), memrange_cmp);
841 if (memranges->next_memrange > 0)
843 for (a = 0, b = 1; b < memranges->next_memrange; b++)
845 /* If memrange b overlaps or is adjacent to memrange a,
847 if (memranges->list[a].type == memranges->list[b].type
848 && memranges->list[b].start <= memranges->list[a].end)
850 if (memranges->list[b].end > memranges->list[a].end)
851 memranges->list[a].end = memranges->list[b].end;
852 continue; /* next b, same a */
856 memcpy (&memranges->list[a], &memranges->list[b],
857 sizeof (struct memrange));
859 memranges->next_memrange = a + 1;
863 /* Add a register to a collection list. */
865 add_register (struct collection_list *collection, unsigned int regno)
868 printf_filtered ("collect register %d\n", regno);
869 if (regno >= (8 * sizeof (collection->regs_mask)))
870 error (_("Internal: register number %d too large for tracepoint"),
872 collection->regs_mask[regno / 8] |= 1 << (regno % 8);
875 /* Add a memrange to a collection list. */
877 add_memrange (struct collection_list *memranges,
878 int type, bfd_signed_vma base,
883 printf_filtered ("(%d,", type);
885 printf_filtered (",%ld)\n", len);
888 /* type: memrange_absolute == memory, other n == basereg */
889 memranges->list[memranges->next_memrange].type = type;
890 /* base: addr if memory, offset if reg relative. */
891 memranges->list[memranges->next_memrange].start = base;
892 /* len: we actually save end (base + len) for convenience */
893 memranges->list[memranges->next_memrange].end = base + len;
894 memranges->next_memrange++;
895 if (memranges->next_memrange >= memranges->listsize)
897 memranges->listsize *= 2;
898 memranges->list = xrealloc (memranges->list,
899 memranges->listsize);
902 if (type != memrange_absolute) /* Better collect the base register! */
903 add_register (memranges, type);
906 /* Add a symbol to a collection list. */
908 collect_symbol (struct collection_list *collect,
910 struct gdbarch *gdbarch,
911 long frame_regno, long frame_offset,
916 bfd_signed_vma offset;
917 int treat_as_expr = 0;
919 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
920 switch (SYMBOL_CLASS (sym))
923 printf_filtered ("%s: don't know symbol class %d\n",
924 SYMBOL_PRINT_NAME (sym),
928 printf_filtered ("constant %s (value %ld) will not be collected.\n",
929 SYMBOL_PRINT_NAME (sym), SYMBOL_VALUE (sym));
932 offset = SYMBOL_VALUE_ADDRESS (sym);
937 sprintf_vma (tmp, offset);
938 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
939 SYMBOL_PRINT_NAME (sym), len,
942 /* A struct may be a C++ class with static fields, go to general
943 expression handling. */
944 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
947 add_memrange (collect, memrange_absolute, offset, len);
950 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
952 printf_filtered ("LOC_REG[parm] %s: ",
953 SYMBOL_PRINT_NAME (sym));
954 add_register (collect, reg);
955 /* Check for doubles stored in two registers. */
956 /* FIXME: how about larger types stored in 3 or more regs? */
957 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
958 len > register_size (gdbarch, reg))
959 add_register (collect, reg + 1);
962 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
963 printf_filtered (" (will not collect %s)\n",
964 SYMBOL_PRINT_NAME (sym));
968 offset = frame_offset + SYMBOL_VALUE (sym);
971 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
972 SYMBOL_PRINT_NAME (sym), len);
974 printf_filtered (" from frame ptr reg %d\n", reg);
976 add_memrange (collect, reg, offset, len);
978 case LOC_REGPARM_ADDR:
979 reg = SYMBOL_VALUE (sym);
983 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
984 SYMBOL_PRINT_NAME (sym), len);
986 printf_filtered (" from reg %d\n", reg);
988 add_memrange (collect, reg, offset, len);
992 offset = frame_offset + SYMBOL_VALUE (sym);
995 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
996 SYMBOL_PRINT_NAME (sym), len);
998 printf_filtered (" from frame ptr reg %d\n", reg);
1000 add_memrange (collect, reg, offset, len);
1003 case LOC_UNRESOLVED:
1007 case LOC_OPTIMIZED_OUT:
1008 printf_filtered ("%s has been optimized out of existence.\n",
1009 SYMBOL_PRINT_NAME (sym));
1017 /* Expressions are the most general case. */
1020 struct agent_expr *aexpr;
1021 struct cleanup *old_chain1 = NULL;
1023 aexpr = gen_trace_for_var (scope, gdbarch, sym);
1025 /* It can happen that the symbol is recorded as a computed
1026 location, but it's been optimized away and doesn't actually
1027 have a location expression. */
1030 printf_filtered ("%s has been optimized out of existence.\n",
1031 SYMBOL_PRINT_NAME (sym));
1035 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1039 report_agent_reqs_errors (aexpr);
1041 discard_cleanups (old_chain1);
1042 add_aexpr (collect, aexpr);
1044 /* Take care of the registers. */
1045 if (aexpr->reg_mask_len > 0)
1049 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1051 QUIT; /* Allow user to bail out with ^C. */
1052 if (aexpr->reg_mask[ndx1] != 0)
1054 /* Assume chars have 8 bits. */
1055 for (ndx2 = 0; ndx2 < 8; ndx2++)
1056 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1057 /* It's used -- record it. */
1058 add_register (collect, ndx1 * 8 + ndx2);
1065 /* Data to be passed around in the calls to the locals and args
1068 struct add_local_symbols_data
1070 struct collection_list *collect;
1071 struct gdbarch *gdbarch;
1078 /* The callback for the locals and args iterators. */
1081 do_collect_symbol (const char *print_name,
1085 struct add_local_symbols_data *p = cb_data;
1087 collect_symbol (p->collect, sym, p->gdbarch, p->frame_regno,
1088 p->frame_offset, p->pc);
1092 /* Add all locals (or args) symbols to collection list. */
1094 add_local_symbols (struct collection_list *collect,
1095 struct gdbarch *gdbarch, CORE_ADDR pc,
1096 long frame_regno, long frame_offset, int type)
1098 struct block *block;
1099 struct add_local_symbols_data cb_data;
1101 cb_data.collect = collect;
1102 cb_data.gdbarch = gdbarch;
1104 cb_data.frame_regno = frame_regno;
1105 cb_data.frame_offset = frame_offset;
1110 block = block_for_pc (pc);
1113 warning (_("Can't collect locals; "
1114 "no symbol table info available.\n"));
1118 iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1119 if (cb_data.count == 0)
1120 warning (_("No locals found in scope."));
1124 pc = get_pc_function_start (pc);
1125 block = block_for_pc (pc);
1128 warning (_("Can't collect args; no symbol table info available."));
1132 iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1133 if (cb_data.count == 0)
1134 warning (_("No args found in scope."));
1139 add_static_trace_data (struct collection_list *collection)
1142 printf_filtered ("collect static trace data\n");
1143 collection->strace_data = 1;
1146 /* worker function */
1148 clear_collection_list (struct collection_list *list)
1152 list->next_memrange = 0;
1153 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1155 free_agent_expr (list->aexpr_list[ndx]);
1156 list->aexpr_list[ndx] = NULL;
1158 list->next_aexpr_elt = 0;
1159 memset (list->regs_mask, 0, sizeof (list->regs_mask));
1160 list->strace_data = 0;
1163 /* Reduce a collection list to string form (for gdb protocol). */
1165 stringify_collection_list (struct collection_list *list, char *string)
1167 char temp_buf[2048];
1171 char *(*str_list)[];
1175 count = 1 + 1 + list->next_memrange + list->next_aexpr_elt + 1;
1176 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1178 if (list->strace_data)
1181 printf_filtered ("\nCollecting static trace data\n");
1184 (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
1188 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1189 if (list->regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */
1191 if (list->regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
1194 printf_filtered ("\nCollecting registers (mask): 0x");
1199 QUIT; /* Allow user to bail out with ^C. */
1201 printf_filtered ("%02X", list->regs_mask[i]);
1202 sprintf (end, "%02X", list->regs_mask[i]);
1205 (*str_list)[ndx] = xstrdup (temp_buf);
1209 printf_filtered ("\n");
1210 if (list->next_memrange > 0 && info_verbose)
1211 printf_filtered ("Collecting memranges: \n");
1212 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1214 QUIT; /* Allow user to bail out with ^C. */
1215 sprintf_vma (tmp2, list->list[i].start);
1218 printf_filtered ("(%d, %s, %ld)\n",
1221 (long) (list->list[i].end - list->list[i].start));
1223 if (count + 27 > MAX_AGENT_EXPR_LEN)
1225 (*str_list)[ndx] = savestring (temp_buf, count);
1232 bfd_signed_vma length = list->list[i].end - list->list[i].start;
1234 /* The "%X" conversion specifier expects an unsigned argument,
1235 so passing -1 (memrange_absolute) to it directly gives you
1236 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1238 if (list->list[i].type == memrange_absolute)
1239 sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
1241 sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
1244 count += strlen (end);
1245 end = temp_buf + count;
1248 for (i = 0; i < list->next_aexpr_elt; i++)
1250 QUIT; /* Allow user to bail out with ^C. */
1251 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1253 (*str_list)[ndx] = savestring (temp_buf, count);
1258 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1259 end += 10; /* 'X' + 8 hex digits + ',' */
1262 end = mem2hex (list->aexpr_list[i]->buf,
1263 end, list->aexpr_list[i]->len);
1264 count += 2 * list->aexpr_list[i]->len;
1269 (*str_list)[ndx] = savestring (temp_buf, count);
1274 (*str_list)[ndx] = NULL;
1287 encode_actions_1 (struct command_line *action,
1288 struct breakpoint *t,
1289 struct bp_location *tloc,
1291 LONGEST frame_offset,
1292 struct collection_list *collect,
1293 struct collection_list *stepping_list)
1296 struct expression *exp = NULL;
1298 struct value *tempval;
1299 struct cmd_list_element *cmd;
1300 struct agent_expr *aexpr;
1302 for (; action; action = action->next)
1304 QUIT; /* Allow user to bail out with ^C. */
1305 action_exp = action->line;
1306 while (isspace ((int) *action_exp))
1309 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1311 error (_("Bad action list item: %s"), action_exp);
1313 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1316 { /* Repeat over a comma-separated list. */
1317 QUIT; /* Allow user to bail out with ^C. */
1318 while (isspace ((int) *action_exp))
1321 if (0 == strncasecmp ("$reg", action_exp, 4))
1323 for (i = 0; i < gdbarch_num_regs (t->gdbarch); i++)
1324 add_register (collect, i);
1325 action_exp = strchr (action_exp, ','); /* more? */
1327 else if (0 == strncasecmp ("$arg", action_exp, 4))
1329 add_local_symbols (collect,
1335 action_exp = strchr (action_exp, ','); /* more? */
1337 else if (0 == strncasecmp ("$loc", action_exp, 4))
1339 add_local_symbols (collect,
1345 action_exp = strchr (action_exp, ','); /* more? */
1347 else if (0 == strncasecmp ("$_sdata", action_exp, 7))
1349 add_static_trace_data (collect);
1350 action_exp = strchr (action_exp, ','); /* more? */
1354 unsigned long addr, len;
1355 struct cleanup *old_chain = NULL;
1356 struct cleanup *old_chain1 = NULL;
1358 exp = parse_exp_1 (&action_exp,
1359 block_for_pc (tloc->address), 1);
1360 old_chain = make_cleanup (free_current_contents, &exp);
1362 switch (exp->elts[0].opcode)
1366 const char *name = &exp->elts[2].string;
1368 i = user_reg_map_name_to_regnum (t->gdbarch,
1369 name, strlen (name));
1371 internal_error (__FILE__, __LINE__,
1372 _("Register $%s not available"),
1375 printf_filtered ("OP_REGISTER: ");
1376 add_register (collect, i);
1381 /* Safe because we know it's a simple expression. */
1382 tempval = evaluate_expression (exp);
1383 addr = value_address (tempval);
1384 len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
1385 add_memrange (collect, memrange_absolute, addr, len);
1389 collect_symbol (collect,
1390 exp->elts[2].symbol,
1397 default: /* Full-fledged expression. */
1398 aexpr = gen_trace_for_expr (tloc->address, exp);
1400 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1404 report_agent_reqs_errors (aexpr);
1406 discard_cleanups (old_chain1);
1407 add_aexpr (collect, aexpr);
1409 /* Take care of the registers. */
1410 if (aexpr->reg_mask_len > 0)
1415 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1417 QUIT; /* Allow user to bail out with ^C. */
1418 if (aexpr->reg_mask[ndx1] != 0)
1420 /* Assume chars have 8 bits. */
1421 for (ndx2 = 0; ndx2 < 8; ndx2++)
1422 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1423 /* It's used -- record it. */
1424 add_register (collect,
1431 do_cleanups (old_chain);
1434 while (action_exp && *action_exp++ == ',');
1436 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1439 { /* Repeat over a comma-separated list. */
1440 QUIT; /* Allow user to bail out with ^C. */
1441 while (isspace ((int) *action_exp))
1445 struct cleanup *old_chain = NULL;
1446 struct cleanup *old_chain1 = NULL;
1448 exp = parse_exp_1 (&action_exp,
1449 block_for_pc (tloc->address), 1);
1450 old_chain = make_cleanup (free_current_contents, &exp);
1452 aexpr = gen_eval_for_expr (tloc->address, exp);
1453 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1456 report_agent_reqs_errors (aexpr);
1458 discard_cleanups (old_chain1);
1459 /* Even though we're not officially collecting, add
1460 to the collect list anyway. */
1461 add_aexpr (collect, aexpr);
1463 do_cleanups (old_chain);
1466 while (action_exp && *action_exp++ == ',');
1468 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1470 /* We check against nested while-stepping when setting
1471 breakpoint action, so no way to run into nested
1473 gdb_assert (stepping_list);
1475 encode_actions_1 (action->body_list[0], t, tloc, frame_reg,
1476 frame_offset, stepping_list, NULL);
1479 error (_("Invalid tracepoint command '%s'"), action->line);
1483 /* Render all actions into gdb protocol. */
1485 encode_actions (struct breakpoint *t, struct bp_location *tloc,
1486 char ***tdp_actions, char ***stepping_actions)
1488 static char tdp_buff[2048], step_buff[2048];
1489 char *default_collect_line = NULL;
1490 struct command_line *actions;
1491 struct command_line *default_collect_action = NULL;
1493 LONGEST frame_offset;
1494 struct cleanup *back_to;
1496 back_to = make_cleanup (null_cleanup, NULL);
1498 clear_collection_list (&tracepoint_list);
1499 clear_collection_list (&stepping_list);
1501 *tdp_actions = NULL;
1502 *stepping_actions = NULL;
1504 gdbarch_virtual_frame_pointer (t->gdbarch,
1505 t->loc->address, &frame_reg, &frame_offset);
1507 actions = breakpoint_commands (t);
1509 /* If there are default expressions to collect, make up a collect
1510 action and prepend to the action list to encode. Note that since
1511 validation is per-tracepoint (local var "xyz" might be valid for
1512 one tracepoint and not another, etc), we make up the action on
1513 the fly, and don't cache it. */
1514 if (*default_collect)
1518 default_collect_line = xstrprintf ("collect %s", default_collect);
1519 make_cleanup (xfree, default_collect_line);
1521 line = default_collect_line;
1522 validate_actionline (&line, t);
1524 default_collect_action = xmalloc (sizeof (struct command_line));
1525 make_cleanup (xfree, default_collect_action);
1526 default_collect_action->next = actions;
1527 default_collect_action->line = line;
1528 actions = default_collect_action;
1530 encode_actions_1 (actions, t, tloc, frame_reg, frame_offset,
1531 &tracepoint_list, &stepping_list);
1533 memrange_sortmerge (&tracepoint_list);
1534 memrange_sortmerge (&stepping_list);
1536 *tdp_actions = stringify_collection_list (&tracepoint_list,
1538 *stepping_actions = stringify_collection_list (&stepping_list,
1541 do_cleanups (back_to);
1545 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1547 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1549 collect->aexpr_list =
1550 xrealloc (collect->aexpr_list,
1551 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1552 collect->aexpr_listsize *= 2;
1554 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1555 collect->next_aexpr_elt++;
1560 start_tracing (void)
1562 VEC(breakpoint_p) *tp_vec = NULL;
1564 struct breakpoint *b;
1565 struct trace_state_variable *tsv;
1566 int any_enabled = 0, num_to_download = 0;
1568 tp_vec = all_tracepoints ();
1570 /* No point in tracing without any tracepoints... */
1571 if (VEC_length (breakpoint_p, tp_vec) == 0)
1573 VEC_free (breakpoint_p, tp_vec);
1574 error (_("No tracepoints defined, not starting trace"));
1577 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1579 struct tracepoint *t = (struct tracepoint *) b;
1581 if (b->enable_state == bp_enabled)
1584 if ((b->type == bp_fast_tracepoint
1585 ? may_insert_fast_tracepoints
1586 : may_insert_tracepoints))
1589 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1590 (b->type == bp_fast_tracepoint ? "fast " : ""), b->number);
1595 if (target_supports_enable_disable_tracepoint ())
1596 warning (_("No tracepoints enabled"));
1599 /* No point in tracing with only disabled tracepoints that
1600 cannot be re-enabled. */
1601 VEC_free (breakpoint_p, tp_vec);
1602 error (_("No tracepoints enabled, not starting trace"));
1606 if (num_to_download <= 0)
1608 VEC_free (breakpoint_p, tp_vec);
1609 error (_("No tracepoints that may be downloaded, not starting trace"));
1612 target_trace_init ();
1614 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1616 struct tracepoint *t = (struct tracepoint *) b;
1618 if ((b->type == bp_fast_tracepoint
1619 ? !may_insert_fast_tracepoints
1620 : !may_insert_tracepoints))
1623 t->number_on_target = 0;
1624 target_download_tracepoint (b);
1625 t->number_on_target = b->number;
1627 VEC_free (breakpoint_p, tp_vec);
1629 /* Send down all the trace state variables too. */
1630 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1632 target_download_trace_state_variable (tsv);
1635 /* Tell target to treat text-like sections as transparent. */
1636 target_trace_set_readonly_regions ();
1637 /* Set some mode flags. */
1638 target_set_disconnected_tracing (disconnected_tracing);
1639 target_set_circular_trace_buffer (circular_trace_buffer);
1641 /* Now insert traps and begin collecting data. */
1642 target_trace_start ();
1644 /* Reset our local state. */
1645 set_traceframe_num (-1);
1646 set_tracepoint_num (-1);
1647 set_traceframe_context (NULL);
1648 current_trace_status()->running = 1;
1649 clear_traceframe_info ();
1654 Tell target to clear any previous trace experiment.
1655 Walk the list of tracepoints, and send them (and their actions)
1656 to the target. If no errors,
1657 Tell target to start a new trace experiment. */
1660 trace_start_command (char *args, int from_tty)
1662 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1664 if (current_trace_status ()->running)
1667 && !query (_("A trace is running already. Start a new run? ")))
1668 error (_("New trace run not started."));
1676 trace_stop_command (char *args, int from_tty)
1678 if (!current_trace_status ()->running)
1679 error (_("Trace is not running."));
1687 target_trace_stop ();
1688 /* Should change in response to reply? */
1689 current_trace_status ()->running = 0;
1692 /* tstatus command */
1694 trace_status_command (char *args, int from_tty)
1696 struct trace_status *ts = current_trace_status ();
1699 status = target_get_trace_status (ts);
1704 printf_filtered (_("Using a trace file.\n"));
1707 printf_filtered (_("Trace can not be run on this target.\n"));
1712 if (!ts->running_known)
1714 printf_filtered (_("Run/stop status is unknown.\n"));
1716 else if (ts->running)
1718 printf_filtered (_("Trace is running on the target.\n"));
1722 switch (ts->stop_reason)
1724 case trace_never_run:
1725 printf_filtered (_("No trace has been run on the target.\n"));
1728 printf_filtered (_("Trace stopped by a tstop command.\n"));
1730 case trace_buffer_full:
1731 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1733 case trace_disconnected:
1734 printf_filtered (_("Trace stopped because of disconnection.\n"));
1736 case tracepoint_passcount:
1737 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1738 ts->stopping_tracepoint);
1740 case tracepoint_error:
1741 if (ts->stopping_tracepoint)
1742 printf_filtered (_("Trace stopped by an "
1743 "error (%s, tracepoint %d).\n"),
1744 ts->error_desc, ts->stopping_tracepoint);
1746 printf_filtered (_("Trace stopped by an error (%s).\n"),
1749 case trace_stop_reason_unknown:
1750 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1753 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1759 if (ts->traceframes_created >= 0
1760 && ts->traceframe_count != ts->traceframes_created)
1762 printf_filtered (_("Buffer contains %d trace "
1763 "frames (of %d created total).\n"),
1764 ts->traceframe_count, ts->traceframes_created);
1766 else if (ts->traceframe_count >= 0)
1768 printf_filtered (_("Collected %d trace frames.\n"),
1769 ts->traceframe_count);
1772 if (ts->buffer_free >= 0)
1774 if (ts->buffer_size >= 0)
1776 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1777 ts->buffer_free, ts->buffer_size);
1778 if (ts->buffer_size > 0)
1779 printf_filtered (_(" (%d%% full)"),
1780 ((int) ((((long long) (ts->buffer_size
1781 - ts->buffer_free)) * 100)
1782 / ts->buffer_size)));
1783 printf_filtered (_(".\n"));
1786 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1790 if (ts->disconnected_tracing)
1791 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1793 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1795 if (ts->circular_buffer)
1796 printf_filtered (_("Trace buffer is circular.\n"));
1798 /* Now report on what we're doing with tfind. */
1799 if (traceframe_number >= 0)
1800 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1801 traceframe_number, tracepoint_number);
1803 printf_filtered (_("Not looking at any trace frame.\n"));
1806 /* Report the trace status to uiout, in a way suitable for MI, and not
1807 suitable for CLI. If ON_STOP is true, suppress a few fields that
1808 are not meaningful in the -trace-stop response.
1810 The implementation is essentially parallel to trace_status_command, but
1811 merging them will result in unreadable code. */
1813 trace_status_mi (int on_stop)
1815 struct ui_out *uiout = current_uiout;
1816 struct trace_status *ts = current_trace_status ();
1819 status = target_get_trace_status (ts);
1821 if (status == -1 && !ts->from_file)
1823 ui_out_field_string (uiout, "supported", "0");
1828 ui_out_field_string (uiout, "supported", "file");
1830 ui_out_field_string (uiout, "supported", "1");
1832 gdb_assert (ts->running_known);
1836 ui_out_field_string (uiout, "running", "1");
1838 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1839 Given that the frontend gets the status either on -trace-stop, or from
1840 -trace-status after re-connection, it does not seem like this
1841 information is necessary for anything. It is not necessary for either
1842 figuring the vital state of the target nor for navigation of trace
1843 frames. If the frontend wants to show the current state is some
1844 configure dialog, it can request the value when such dialog is
1845 invoked by the user. */
1849 char *stop_reason = NULL;
1850 int stopping_tracepoint = -1;
1853 ui_out_field_string (uiout, "running", "0");
1855 if (ts->stop_reason != trace_stop_reason_unknown)
1857 switch (ts->stop_reason)
1860 stop_reason = "request";
1862 case trace_buffer_full:
1863 stop_reason = "overflow";
1865 case trace_disconnected:
1866 stop_reason = "disconnection";
1868 case tracepoint_passcount:
1869 stop_reason = "passcount";
1870 stopping_tracepoint = ts->stopping_tracepoint;
1872 case tracepoint_error:
1873 stop_reason = "error";
1874 stopping_tracepoint = ts->stopping_tracepoint;
1880 ui_out_field_string (uiout, "stop-reason", stop_reason);
1881 if (stopping_tracepoint != -1)
1882 ui_out_field_int (uiout, "stopping-tracepoint",
1883 stopping_tracepoint);
1884 if (ts->stop_reason == tracepoint_error)
1885 ui_out_field_string (uiout, "error-description",
1891 if (ts->traceframe_count != -1)
1892 ui_out_field_int (uiout, "frames", ts->traceframe_count);
1893 if (ts->traceframes_created != -1)
1894 ui_out_field_int (uiout, "frames-created", ts->traceframes_created);
1895 if (ts->buffer_size != -1)
1896 ui_out_field_int (uiout, "buffer-size", ts->buffer_size);
1897 if (ts->buffer_free != -1)
1898 ui_out_field_int (uiout, "buffer-free", ts->buffer_free);
1900 ui_out_field_int (uiout, "disconnected", ts->disconnected_tracing);
1901 ui_out_field_int (uiout, "circular", ts->circular_buffer);
1904 /* This function handles the details of what to do about an ongoing
1905 tracing run if the user has asked to detach or otherwise disconnect
1908 disconnect_tracing (int from_tty)
1910 /* It can happen that the target that was tracing went away on its
1911 own, and we didn't notice. Get a status update, and if the
1912 current target doesn't even do tracing, then assume it's not
1914 if (target_get_trace_status (current_trace_status ()) < 0)
1915 current_trace_status ()->running = 0;
1917 /* If running interactively, give the user the option to cancel and
1918 then decide what to do differently with the run. Scripts are
1919 just going to disconnect and let the target deal with it,
1920 according to how it's been instructed previously via
1921 disconnected-tracing. */
1922 if (current_trace_status ()->running && from_tty)
1924 if (current_trace_status ()->disconnected_tracing)
1926 if (!query (_("Trace is running and will "
1927 "continue after detach; detach anyway? ")))
1928 error (_("Not confirmed."));
1932 if (!query (_("Trace is running but will "
1933 "stop on detach; detach anyway? ")))
1934 error (_("Not confirmed."));
1938 /* Also we want to be out of tfind mode, otherwise things can get
1939 confusing upon reconnection. Just use these calls instead of
1940 full tfind_1 behavior because we're in the middle of detaching,
1941 and there's no point to updating current stack frame etc. */
1942 set_current_traceframe (-1);
1943 set_traceframe_context (NULL);
1946 /* Worker function for the various flavors of the tfind command. */
1948 tfind_1 (enum trace_find_type type, int num,
1949 ULONGEST addr1, ULONGEST addr2,
1952 int target_frameno = -1, target_tracept = -1;
1953 struct frame_id old_frame_id = null_frame_id;
1954 struct tracepoint *tp;
1955 struct ui_out *uiout = current_uiout;
1957 /* Only try to get the current stack frame if we have a chance of
1958 succeeding. In particular, if we're trying to get a first trace
1959 frame while all threads are running, it's not going to succeed,
1960 so leave it with a default value and let the frame comparison
1961 below (correctly) decide to print out the source location of the
1963 if (!(type == tfind_number && num == -1)
1964 && (has_stack_frames () || traceframe_number >= 0))
1965 old_frame_id = get_frame_id (get_current_frame ());
1967 target_frameno = target_trace_find (type, num, addr1, addr2,
1970 if (type == tfind_number
1972 && target_frameno == -1)
1974 /* We told the target to get out of tfind mode, and it did. */
1976 else if (target_frameno == -1)
1978 /* A request for a non-existent trace frame has failed.
1979 Our response will be different, depending on FROM_TTY:
1981 If FROM_TTY is true, meaning that this command was
1982 typed interactively by the user, then give an error
1983 and DO NOT change the state of traceframe_number etc.
1985 However if FROM_TTY is false, meaning that we're either
1986 in a script, a loop, or a user-defined command, then
1987 DON'T give an error, but DO change the state of
1988 traceframe_number etc. to invalid.
1990 The rationalle is that if you typed the command, you
1991 might just have committed a typo or something, and you'd
1992 like to NOT lose your current debugging state. However
1993 if you're in a user-defined command or especially in a
1994 loop, then you need a way to detect that the command
1995 failed WITHOUT aborting. This allows you to write
1996 scripts that search thru the trace buffer until the end,
1997 and then continue on to do something else. */
2000 error (_("Target failed to find requested trace frame."));
2004 printf_filtered ("End of trace buffer.\n");
2005 #if 0 /* dubious now? */
2006 /* The following will not recurse, since it's
2008 trace_find_command ("-1", from_tty);
2013 tp = get_tracepoint_by_number_on_target (target_tracept);
2015 reinit_frame_cache ();
2016 registers_changed ();
2017 target_dcache_invalidate ();
2018 set_traceframe_num (target_frameno);
2019 clear_traceframe_info ();
2020 set_tracepoint_num (tp ? tp->base.number : target_tracept);
2021 if (target_frameno == -1)
2022 set_traceframe_context (NULL);
2024 set_traceframe_context (get_current_frame ());
2026 if (traceframe_number >= 0)
2028 /* Use different branches for MI and CLI to make CLI messages
2030 if (ui_out_is_mi_like_p (uiout))
2032 ui_out_field_string (uiout, "found", "1");
2033 ui_out_field_int (uiout, "tracepoint", tracepoint_number);
2034 ui_out_field_int (uiout, "traceframe", traceframe_number);
2038 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2039 traceframe_number, tracepoint_number);
2044 if (ui_out_is_mi_like_p (uiout))
2045 ui_out_field_string (uiout, "found", "0");
2046 else if (type == tfind_number && num == -1)
2047 printf_unfiltered (_("No longer looking at any trace frame\n"));
2048 else /* This case may never occur, check. */
2049 printf_unfiltered (_("No trace frame found\n"));
2052 /* If we're in nonstop mode and getting out of looking at trace
2053 frames, there won't be any current frame to go back to and
2056 && (has_stack_frames () || traceframe_number >= 0))
2058 enum print_what print_what;
2060 /* NOTE: in imitation of the step command, try to determine
2061 whether we have made a transition from one function to
2062 another. If so, we'll print the "stack frame" (ie. the new
2063 function and it's arguments) -- otherwise we'll just show the
2066 if (frame_id_eq (old_frame_id,
2067 get_frame_id (get_current_frame ())))
2068 print_what = SRC_LINE;
2070 print_what = SRC_AND_LOC;
2072 print_stack_frame (get_selected_frame (NULL), 1, print_what);
2077 /* trace_find_command takes a trace frame number n,
2078 sends "QTFrame:<n>" to the target,
2079 and accepts a reply that may contain several optional pieces
2080 of information: a frame number, a tracepoint number, and an
2081 indication of whether this is a trap frame or a stepping frame.
2083 The minimal response is just "OK" (which indicates that the
2084 target does not give us a frame number or a tracepoint number).
2085 Instead of that, the target may send us a string containing
2087 F<hexnum> (gives the selected frame number)
2088 T<hexnum> (gives the selected tracepoint number)
2093 trace_find_command (char *args, int from_tty)
2094 { /* This should only be called with a numeric argument. */
2097 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2098 error (_("May not look at trace frames while trace is running."));
2100 if (args == 0 || *args == 0)
2101 { /* TFIND with no args means find NEXT trace frame. */
2102 if (traceframe_number == -1)
2103 frameno = 0; /* "next" is first one. */
2105 frameno = traceframe_number + 1;
2107 else if (0 == strcmp (args, "-"))
2109 if (traceframe_number == -1)
2110 error (_("not debugging trace buffer"));
2111 else if (from_tty && traceframe_number == 0)
2112 error (_("already at start of trace buffer"));
2114 frameno = traceframe_number - 1;
2116 /* A hack to work around eval's need for fp to have been collected. */
2117 else if (0 == strcmp (args, "-1"))
2120 frameno = parse_and_eval_long (args);
2123 error (_("invalid input (%d is less than zero)"), frameno);
2125 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2130 trace_find_end_command (char *args, int from_tty)
2132 trace_find_command ("-1", from_tty);
2137 trace_find_none_command (char *args, int from_tty)
2139 trace_find_command ("-1", from_tty);
2144 trace_find_start_command (char *args, int from_tty)
2146 trace_find_command ("0", from_tty);
2149 /* tfind pc command */
2151 trace_find_pc_command (char *args, int from_tty)
2155 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2156 error (_("May not look at trace frames while trace is running."));
2158 if (args == 0 || *args == 0)
2159 pc = regcache_read_pc (get_current_regcache ());
2161 pc = parse_and_eval_address (args);
2163 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2166 /* tfind tracepoint command */
2168 trace_find_tracepoint_command (char *args, int from_tty)
2171 struct tracepoint *tp;
2173 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2174 error (_("May not look at trace frames while trace is running."));
2176 if (args == 0 || *args == 0)
2178 if (tracepoint_number == -1)
2179 error (_("No current tracepoint -- please supply an argument."));
2181 tdp = tracepoint_number; /* Default is current TDP. */
2184 tdp = parse_and_eval_long (args);
2186 /* If we have the tracepoint on hand, use the number that the
2187 target knows about (which may be different if we disconnected
2188 and reconnected). */
2189 tp = get_tracepoint (tdp);
2191 tdp = tp->number_on_target;
2193 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2196 /* TFIND LINE command:
2198 This command will take a sourceline for argument, just like BREAK
2199 or TRACE (ie. anything that "decode_line_1" can handle).
2201 With no argument, this command will find the next trace frame
2202 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2205 trace_find_line_command (char *args, int from_tty)
2207 static CORE_ADDR start_pc, end_pc;
2208 struct symtabs_and_lines sals;
2209 struct symtab_and_line sal;
2210 struct cleanup *old_chain;
2212 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2213 error (_("May not look at trace frames while trace is running."));
2215 if (args == 0 || *args == 0)
2217 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2219 sals.sals = (struct symtab_and_line *)
2220 xmalloc (sizeof (struct symtab_and_line));
2225 sals = decode_line_spec (args, 1);
2229 old_chain = make_cleanup (xfree, sals.sals);
2230 if (sal.symtab == 0)
2231 error (_("No line number information available."));
2233 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2235 if (start_pc == end_pc)
2237 printf_filtered ("Line %d of \"%s\"",
2238 sal.line, sal.symtab->filename);
2240 printf_filtered (" is at address ");
2241 print_address (get_current_arch (), start_pc, gdb_stdout);
2243 printf_filtered (" but contains no code.\n");
2244 sal = find_pc_line (start_pc, 0);
2246 && find_line_pc_range (sal, &start_pc, &end_pc)
2247 && start_pc != end_pc)
2248 printf_filtered ("Attempting to find line %d instead.\n",
2251 error (_("Cannot find a good line."));
2255 /* Is there any case in which we get here, and have an address
2256 which the user would want to see? If we have debugging
2257 symbols and no line numbers? */
2258 error (_("Line number %d is out of range for \"%s\"."),
2259 sal.line, sal.symtab->filename);
2261 /* Find within range of stated line. */
2263 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2265 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2266 do_cleanups (old_chain);
2269 /* tfind range command */
2271 trace_find_range_command (char *args, int from_tty)
2273 static CORE_ADDR start, stop;
2276 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2277 error (_("May not look at trace frames while trace is running."));
2279 if (args == 0 || *args == 0)
2280 { /* XXX FIXME: what should default behavior be? */
2281 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2285 if (0 != (tmp = strchr (args, ',')))
2287 *tmp++ = '\0'; /* Terminate start address. */
2288 while (isspace ((int) *tmp))
2290 start = parse_and_eval_address (args);
2291 stop = parse_and_eval_address (tmp);
2294 { /* No explicit end address? */
2295 start = parse_and_eval_address (args);
2296 stop = start + 1; /* ??? */
2299 tfind_1 (tfind_range, 0, start, stop, from_tty);
2302 /* tfind outside command */
2304 trace_find_outside_command (char *args, int from_tty)
2306 CORE_ADDR start, stop;
2309 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2310 error (_("May not look at trace frames while trace is running."));
2312 if (args == 0 || *args == 0)
2313 { /* XXX FIXME: what should default behavior be? */
2314 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2318 if (0 != (tmp = strchr (args, ',')))
2320 *tmp++ = '\0'; /* Terminate start address. */
2321 while (isspace ((int) *tmp))
2323 start = parse_and_eval_address (args);
2324 stop = parse_and_eval_address (tmp);
2327 { /* No explicit end address? */
2328 start = parse_and_eval_address (args);
2329 stop = start + 1; /* ??? */
2332 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2335 /* info scope command: list the locals for a scope. */
2337 scope_info (char *args, int from_tty)
2339 struct symtabs_and_lines sals;
2341 struct minimal_symbol *msym;
2342 struct block *block;
2343 char *symname, *save_args = args;
2344 struct dict_iterator iter;
2346 struct gdbarch *gdbarch;
2349 if (args == 0 || *args == 0)
2350 error (_("requires an argument (function, "
2351 "line or *addr) to define a scope"));
2353 sals = decode_line_1 (&args, 1, NULL, 0, NULL);
2354 if (sals.nelts == 0)
2355 return; /* Presumably decode_line_1 has already warned. */
2357 /* Resolve line numbers to PC. */
2358 resolve_sal_pc (&sals.sals[0]);
2359 block = block_for_pc (sals.sals[0].pc);
2363 QUIT; /* Allow user to bail out with ^C. */
2364 ALL_BLOCK_SYMBOLS (block, iter, sym)
2366 QUIT; /* Allow user to bail out with ^C. */
2368 printf_filtered ("Scope for %s:\n", save_args);
2371 symname = SYMBOL_PRINT_NAME (sym);
2372 if (symname == NULL || *symname == '\0')
2373 continue; /* Probably botched, certainly useless. */
2375 gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
2377 printf_filtered ("Symbol %s is ", symname);
2378 switch (SYMBOL_CLASS (sym))
2381 case LOC_UNDEF: /* Messed up symbol? */
2382 printf_filtered ("a bogus symbol, class %d.\n",
2383 SYMBOL_CLASS (sym));
2384 count--; /* Don't count this one. */
2387 printf_filtered ("a constant with value %ld (0x%lx)",
2388 SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
2390 case LOC_CONST_BYTES:
2391 printf_filtered ("constant bytes: ");
2392 if (SYMBOL_TYPE (sym))
2393 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2394 fprintf_filtered (gdb_stdout, " %02x",
2395 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2398 printf_filtered ("in static storage at address ");
2399 printf_filtered ("%s", paddress (gdbarch,
2400 SYMBOL_VALUE_ADDRESS (sym)));
2403 /* GDBARCH is the architecture associated with the objfile
2404 the symbol is defined in; the target architecture may be
2405 different, and may provide additional registers. However,
2406 we do not know the target architecture at this point.
2407 We assume the objfile architecture will contain all the
2408 standard registers that occur in debug info in that
2410 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2413 if (SYMBOL_IS_ARGUMENT (sym))
2414 printf_filtered ("an argument in register $%s",
2415 gdbarch_register_name (gdbarch, regno));
2417 printf_filtered ("a local variable in register $%s",
2418 gdbarch_register_name (gdbarch, regno));
2421 printf_filtered ("an argument at stack/frame offset %ld",
2422 SYMBOL_VALUE (sym));
2425 printf_filtered ("a local variable at frame offset %ld",
2426 SYMBOL_VALUE (sym));
2429 printf_filtered ("a reference argument at offset %ld",
2430 SYMBOL_VALUE (sym));
2432 case LOC_REGPARM_ADDR:
2433 /* Note comment at LOC_REGISTER. */
2434 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2436 printf_filtered ("the address of an argument, in register $%s",
2437 gdbarch_register_name (gdbarch, regno));
2440 printf_filtered ("a typedef.\n");
2443 printf_filtered ("a label at address ");
2444 printf_filtered ("%s", paddress (gdbarch,
2445 SYMBOL_VALUE_ADDRESS (sym)));
2448 printf_filtered ("a function at address ");
2449 printf_filtered ("%s",
2450 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2452 case LOC_UNRESOLVED:
2453 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2456 printf_filtered ("Unresolved Static");
2459 printf_filtered ("static storage at address ");
2460 printf_filtered ("%s",
2461 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msym)));
2464 case LOC_OPTIMIZED_OUT:
2465 printf_filtered ("optimized out.\n");
2468 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2469 BLOCK_START (block),
2473 if (SYMBOL_TYPE (sym))
2474 printf_filtered (", length %d.\n",
2475 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2477 if (BLOCK_FUNCTION (block))
2480 block = BLOCK_SUPERBLOCK (block);
2483 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2487 /* worker function (cleanup) */
2489 replace_comma (void *data)
2496 /* Helper for trace_dump_command. Dump the action list starting at
2497 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2498 actions of the body of a while-stepping action. STEPPING_FRAME is
2499 set if the current traceframe was determined to be a while-stepping
2503 trace_dump_actions (struct command_line *action,
2504 int stepping_actions, int stepping_frame,
2507 char *action_exp, *next_comma;
2509 for (; action != NULL; action = action->next)
2511 struct cmd_list_element *cmd;
2513 QUIT; /* Allow user to bail out with ^C. */
2514 action_exp = action->line;
2515 while (isspace ((int) *action_exp))
2518 /* The collection actions to be done while stepping are
2519 bracketed by the commands "while-stepping" and "end". */
2521 if (*action_exp == '#') /* comment line */
2524 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2526 error (_("Bad action list item: %s"), action_exp);
2528 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2532 for (i = 0; i < action->body_count; ++i)
2533 trace_dump_actions (action->body_list[i],
2534 1, stepping_frame, from_tty);
2536 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2538 /* Display the collected data.
2539 For the trap frame, display only what was collected at
2540 the trap. Likewise for stepping frames, display only
2541 what was collected while stepping. This means that the
2542 two boolean variables, STEPPING_FRAME and
2543 STEPPING_ACTIONS should be equal. */
2544 if (stepping_frame == stepping_actions)
2547 { /* Repeat over a comma-separated list. */
2548 QUIT; /* Allow user to bail out with ^C. */
2549 if (*action_exp == ',')
2551 while (isspace ((int) *action_exp))
2554 next_comma = strchr (action_exp, ',');
2556 if (0 == strncasecmp (action_exp, "$reg", 4))
2557 registers_info (NULL, from_tty);
2558 else if (0 == strncasecmp (action_exp, "$loc", 4))
2559 locals_info (NULL, from_tty);
2560 else if (0 == strncasecmp (action_exp, "$arg", 4))
2561 args_info (NULL, from_tty);
2566 make_cleanup (replace_comma, next_comma);
2569 printf_filtered ("%s = ", action_exp);
2570 output_command (action_exp, from_tty);
2571 printf_filtered ("\n");
2575 action_exp = next_comma;
2577 while (action_exp && *action_exp == ',');
2583 /* The tdump command. */
2586 trace_dump_command (char *args, int from_tty)
2588 struct regcache *regcache;
2589 struct tracepoint *t;
2590 int stepping_frame = 0;
2591 struct bp_location *loc;
2592 char *line, *default_collect_line = NULL;
2593 struct command_line *actions, *default_collect_action = NULL;
2594 struct cleanup *old_chain = NULL;
2596 if (tracepoint_number == -1)
2598 warning (_("No current trace frame."));
2602 t = get_tracepoint (tracepoint_number);
2605 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2608 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2609 tracepoint_number, traceframe_number);
2611 /* The current frame is a trap frame if the frame PC is equal
2612 to the tracepoint PC. If not, then the current frame was
2613 collected during single-stepping. */
2615 regcache = get_current_regcache ();
2617 /* If the traceframe's address matches any of the tracepoint's
2618 locations, assume it is a direct hit rather than a while-stepping
2619 frame. (FIXME this is not reliable, should record each frame's
2622 for (loc = t->base.loc; loc; loc = loc->next)
2623 if (loc->address == regcache_read_pc (regcache))
2626 actions = breakpoint_commands (&t->base);
2628 /* If there is a default-collect list, make up a collect command,
2629 prepend to the tracepoint's commands, and pass the whole mess to
2630 the trace dump scanner. We need to validate because
2631 default-collect might have been junked since the trace run. */
2632 if (*default_collect)
2634 default_collect_line = xstrprintf ("collect %s", default_collect);
2635 old_chain = make_cleanup (xfree, default_collect_line);
2636 line = default_collect_line;
2637 validate_actionline (&line, &t->base);
2638 default_collect_action = xmalloc (sizeof (struct command_line));
2639 make_cleanup (xfree, default_collect_action);
2640 default_collect_action->next = actions;
2641 default_collect_action->line = line;
2642 actions = default_collect_action;
2645 trace_dump_actions (actions, 0, stepping_frame, from_tty);
2647 if (*default_collect)
2648 do_cleanups (old_chain);
2651 /* Encode a piece of a tracepoint's source-level definition in a form
2652 that is suitable for both protocol and saving in files. */
2653 /* This version does not do multiple encodes for long strings; it should
2654 return an offset to the next piece to encode. FIXME */
2657 encode_source_string (int tpnum, ULONGEST addr,
2658 char *srctype, char *src, char *buf, int buf_size)
2660 if (80 + strlen (srctype) > buf_size)
2661 error (_("Buffer too small for source encoding"));
2662 sprintf (buf, "%x:%s:%s:%x:%x:",
2663 tpnum, phex_nz (addr, sizeof (addr)),
2664 srctype, 0, (int) strlen (src));
2665 if (strlen (buf) + strlen (src) * 2 >= buf_size)
2666 error (_("Source string too long for buffer"));
2667 bin2hex (src, buf + strlen (buf), 0);
2671 extern int trace_regblock_size;
2673 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2674 non-zero, the save is performed on the target, otherwise GDB obtains all
2675 trace data and saves it locally. */
2678 trace_save (const char *filename, int target_does_save)
2680 struct cleanup *cleanup;
2682 struct trace_status *ts = current_trace_status ();
2685 struct uploaded_tp *uploaded_tps = NULL, *utp;
2686 struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
2690 ULONGEST offset = 0;
2691 #define MAX_TRACE_UPLOAD 2000
2692 gdb_byte buf[MAX_TRACE_UPLOAD];
2695 /* If the target is to save the data to a file on its own, then just
2696 send the command and be done with it. */
2697 if (target_does_save)
2699 err = target_save_trace_data (filename);
2701 error (_("Target failed to save trace data to '%s'."),
2706 /* Get the trace status first before opening the file, so if the
2707 target is losing, we can get out without touching files. */
2708 status = target_get_trace_status (ts);
2710 pathname = tilde_expand (filename);
2711 cleanup = make_cleanup (xfree, pathname);
2713 fp = fopen (pathname, "wb");
2715 error (_("Unable to open file '%s' for saving trace data (%s)"),
2716 filename, safe_strerror (errno));
2717 make_cleanup_fclose (fp);
2719 /* Write a file header, with a high-bit-set char to indicate a
2720 binary file, plus a hint as what this file is, and a version
2721 number in case of future needs. */
2722 written = fwrite ("\x7fTRACE0\n", 8, 1, fp);
2724 perror_with_name (pathname);
2726 /* Write descriptive info. */
2728 /* Write out the size of a register block. */
2729 fprintf (fp, "R %x\n", trace_regblock_size);
2731 /* Write out status of the tracing run (aka "tstatus" info). */
2732 fprintf (fp, "status %c;%s",
2733 (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
2734 if (ts->stop_reason == tracepoint_error)
2736 char *buf = (char *) alloca (strlen (ts->error_desc) * 2 + 1);
2738 bin2hex ((gdb_byte *) ts->error_desc, buf, 0);
2739 fprintf (fp, ":%s", buf);
2741 fprintf (fp, ":%x", ts->stopping_tracepoint);
2742 if (ts->traceframe_count >= 0)
2743 fprintf (fp, ";tframes:%x", ts->traceframe_count);
2744 if (ts->traceframes_created >= 0)
2745 fprintf (fp, ";tcreated:%x", ts->traceframes_created);
2746 if (ts->buffer_free >= 0)
2747 fprintf (fp, ";tfree:%x", ts->buffer_free);
2748 if (ts->buffer_size >= 0)
2749 fprintf (fp, ";tsize:%x", ts->buffer_size);
2750 if (ts->disconnected_tracing)
2751 fprintf (fp, ";disconn:%x", ts->disconnected_tracing);
2752 if (ts->circular_buffer)
2753 fprintf (fp, ";circular:%x", ts->circular_buffer);
2756 /* Note that we want to upload tracepoints and save those, rather
2757 than simply writing out the local ones, because the user may have
2758 changed tracepoints in GDB in preparation for a future tracing
2759 run, or maybe just mass-deleted all types of breakpoints as part
2760 of cleaning up. So as not to contaminate the session, leave the
2761 data in its uploaded form, don't make into real tracepoints. */
2763 /* Get trace state variables first, they may be checked when parsing
2764 uploaded commands. */
2766 target_upload_trace_state_variables (&uploaded_tsvs);
2768 for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
2774 buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
2775 bin2hex ((gdb_byte *) (utsv->name), buf, 0);
2778 fprintf (fp, "tsv %x:%s:%x:%s\n",
2779 utsv->number, phex_nz (utsv->initial_value, 8),
2780 utsv->builtin, buf);
2786 free_uploaded_tsvs (&uploaded_tsvs);
2788 target_upload_tracepoints (&uploaded_tps);
2790 for (utp = uploaded_tps; utp; utp = utp->next)
2792 fprintf (fp, "tp T%x:%s:%c:%x:%x",
2793 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
2794 (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
2795 if (utp->type == bp_fast_tracepoint)
2796 fprintf (fp, ":F%x", utp->orig_size);
2798 fprintf (fp, ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
2801 for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
2802 fprintf (fp, "tp A%x:%s:%s\n",
2803 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
2804 for (a = 0; VEC_iterate (char_ptr, utp->step_actions, a, act); ++a)
2805 fprintf (fp, "tp S%x:%s:%s\n",
2806 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
2809 encode_source_string (utp->number, utp->addr,
2810 "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
2811 fprintf (fp, "tp Z%s\n", buf);
2813 if (utp->cond_string)
2815 encode_source_string (utp->number, utp->addr,
2816 "cond", utp->cond_string,
2817 buf, MAX_TRACE_UPLOAD);
2818 fprintf (fp, "tp Z%s\n", buf);
2820 for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
2822 encode_source_string (utp->number, utp->addr, "cmd", act,
2823 buf, MAX_TRACE_UPLOAD);
2824 fprintf (fp, "tp Z%s\n", buf);
2828 free_uploaded_tps (&uploaded_tps);
2830 /* Mark the end of the definition section. */
2833 /* Get and write the trace data proper. We ask for big blocks, in
2834 the hopes of efficiency, but will take less if the target has
2835 packet size limitations or some such. */
2838 gotten = target_get_raw_trace_data (buf, offset, MAX_TRACE_UPLOAD);
2840 error (_("Failure to get requested trace buffer data"));
2841 /* No more data is forthcoming, we're done. */
2844 written = fwrite (buf, gotten, 1, fp);
2846 perror_with_name (pathname);
2850 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
2851 written = fwrite (&gotten, 4, 1, fp);
2853 perror_with_name (pathname);
2855 do_cleanups (cleanup);
2859 trace_save_command (char *args, int from_tty)
2861 int target_does_save = 0;
2863 char *filename = NULL;
2864 struct cleanup *back_to;
2867 error_no_arg (_("file in which to save trace data"));
2869 argv = gdb_buildargv (args);
2870 back_to = make_cleanup_freeargv (argv);
2872 for (; *argv; ++argv)
2874 if (strcmp (*argv, "-r") == 0)
2875 target_does_save = 1;
2876 else if (**argv == '-')
2877 error (_("unknown option `%s'"), *argv);
2883 error_no_arg (_("file in which to save trace data"));
2885 trace_save (filename, target_does_save);
2888 printf_filtered (_("Trace data saved to file '%s'.\n"), args);
2890 do_cleanups (back_to);
2893 /* Tell the target what to do with an ongoing tracing run if GDB
2894 disconnects for some reason. */
2897 send_disconnected_tracing_value (int value)
2899 target_set_disconnected_tracing (value);
2903 set_disconnected_tracing (char *args, int from_tty,
2904 struct cmd_list_element *c)
2906 send_disconnected_tracing_value (disconnected_tracing);
2910 set_circular_trace_buffer (char *args, int from_tty,
2911 struct cmd_list_element *c)
2913 target_set_circular_trace_buffer (circular_trace_buffer);
2916 /* Convert the memory pointed to by mem into hex, placing result in buf.
2917 * Return a pointer to the last char put in buf (null)
2918 * "stolen" from sparc-stub.c
2921 static const char hexchars[] = "0123456789abcdef";
2924 mem2hex (gdb_byte *mem, char *buf, int count)
2932 *buf++ = hexchars[ch >> 4];
2933 *buf++ = hexchars[ch & 0xf];
2942 get_traceframe_number (void)
2944 return traceframe_number;
2947 /* Make the traceframe NUM be the current trace frame. Does nothing
2948 if NUM is already current. */
2951 set_current_traceframe (int num)
2955 if (traceframe_number == num)
2957 /* Nothing to do. */
2961 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
2964 warning (_("could not change traceframe"));
2966 traceframe_number = newnum;
2968 /* Changing the traceframe changes our view of registers and of the
2970 registers_changed ();
2972 clear_traceframe_info ();
2975 /* Make the traceframe NUM be the current trace frame, and do nothing
2979 set_traceframe_number (int num)
2981 traceframe_number = num;
2984 /* A cleanup used when switching away and back from tfind mode. */
2986 struct current_traceframe_cleanup
2988 /* The traceframe we were inspecting. */
2989 int traceframe_number;
2993 do_restore_current_traceframe_cleanup (void *arg)
2995 struct current_traceframe_cleanup *old = arg;
2997 set_current_traceframe (old->traceframe_number);
3001 restore_current_traceframe_cleanup_dtor (void *arg)
3003 struct current_traceframe_cleanup *old = arg;
3009 make_cleanup_restore_current_traceframe (void)
3011 struct current_traceframe_cleanup *old;
3013 old = xmalloc (sizeof (struct current_traceframe_cleanup));
3014 old->traceframe_number = traceframe_number;
3016 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
3017 restore_current_traceframe_cleanup_dtor);
3021 make_cleanup_restore_traceframe_number (void)
3023 return make_cleanup_restore_integer (&traceframe_number);
3026 /* Given a number and address, return an uploaded tracepoint with that
3027 number, creating if necessary. */
3029 struct uploaded_tp *
3030 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
3032 struct uploaded_tp *utp;
3034 for (utp = *utpp; utp; utp = utp->next)
3035 if (utp->number == num && utp->addr == addr)
3037 utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
3038 memset (utp, 0, sizeof (struct uploaded_tp));
3041 utp->actions = NULL;
3042 utp->step_actions = NULL;
3043 utp->cmd_strings = NULL;
3050 free_uploaded_tps (struct uploaded_tp **utpp)
3052 struct uploaded_tp *next_one;
3056 next_one = (*utpp)->next;
3062 /* Given a number and address, return an uploaded tracepoint with that
3063 number, creating if necessary. */
3065 struct uploaded_tsv *
3066 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3068 struct uploaded_tsv *utsv;
3070 for (utsv = *utsvp; utsv; utsv = utsv->next)
3071 if (utsv->number == num)
3073 utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
3074 memset (utsv, 0, sizeof (struct uploaded_tsv));
3076 utsv->next = *utsvp;
3082 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3084 struct uploaded_tsv *next_one;
3088 next_one = (*utsvp)->next;
3094 /* Look for an existing tracepoint that seems similar enough to the
3095 uploaded one. Enablement isn't compared, because the user can
3096 toggle that freely, and may have done so in anticipation of the
3100 find_matching_tracepoint (struct uploaded_tp *utp)
3102 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
3104 struct breakpoint *b;
3105 struct bp_location *loc;
3107 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
3109 struct tracepoint *t = (struct tracepoint *) b;
3111 if (b->type == utp->type
3112 && t->step_count == utp->step
3113 && t->pass_count == utp->pass
3114 /* FIXME also test conditionals and actions. */
3117 /* Scan the locations for an address match. */
3118 for (loc = b->loc; loc; loc = loc->next)
3120 if (loc->address == utp->addr)
3128 /* Given a list of tracepoints uploaded from a target, attempt to
3129 match them up with existing tracepoints, and create new ones if not
3133 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3135 struct uploaded_tp *utp;
3136 struct tracepoint *t;
3138 /* Look for GDB tracepoints that match up with our uploaded versions. */
3139 for (utp = *uploaded_tps; utp; utp = utp->next)
3141 t = find_matching_tracepoint (utp);
3143 printf_filtered (_("Assuming tracepoint %d is same "
3144 "as target's tracepoint %d at %s.\n"),
3145 t->base.number, utp->number,
3146 paddress (get_current_arch (), utp->addr));
3149 t = create_tracepoint_from_upload (utp);
3151 printf_filtered (_("Created tracepoint %d for "
3152 "target's tracepoint %d at %s.\n"),
3153 t->base.number, utp->number,
3154 paddress (get_current_arch (), utp->addr));
3156 printf_filtered (_("Failed to create tracepoint for target's "
3157 "tracepoint %d at %s, skipping it.\n"),
3159 paddress (get_current_arch (), utp->addr));
3161 /* Whether found or created, record the number used by the
3162 target, to help with mapping target tracepoints back to their
3163 counterparts here. */
3165 t->number_on_target = utp->number;
3168 free_uploaded_tps (uploaded_tps);
3171 /* Trace state variables don't have much to identify them beyond their
3172 name, so just use that to detect matches. */
3174 struct trace_state_variable *
3175 find_matching_tsv (struct uploaded_tsv *utsv)
3180 return find_trace_state_variable (utsv->name);
3183 struct trace_state_variable *
3184 create_tsv_from_upload (struct uploaded_tsv *utsv)
3186 const char *namebase;
3189 struct trace_state_variable *tsv;
3193 namebase = utsv->name;
3194 sprintf (buf, "%s", namebase);
3199 sprintf (buf, "%s_%d", namebase, try_num++);
3202 /* Fish for a name that is not in use. */
3203 /* (should check against all internal vars?) */
3204 while (find_trace_state_variable (buf))
3205 sprintf (buf, "%s_%d", namebase, try_num++);
3207 /* We have an available name, create the variable. */
3208 tsv = create_trace_state_variable (buf);
3209 tsv->initial_value = utsv->initial_value;
3210 tsv->builtin = utsv->builtin;
3215 /* Given a list of uploaded trace state variables, try to match them
3216 up with existing variables, or create additional ones. */
3219 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
3222 struct uploaded_tsv *utsv;
3223 struct trace_state_variable *tsv;
3226 /* Most likely some numbers will have to be reassigned as part of
3227 the merge, so clear them all in anticipation. */
3228 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3231 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
3233 tsv = find_matching_tsv (utsv);
3237 printf_filtered (_("Assuming trace state variable $%s "
3238 "is same as target's variable %d.\n"),
3239 tsv->name, utsv->number);
3243 tsv = create_tsv_from_upload (utsv);
3245 printf_filtered (_("Created trace state variable "
3246 "$%s for target's variable %d.\n"),
3247 tsv->name, utsv->number);
3249 /* Give precedence to numberings that come from the target. */
3251 tsv->number = utsv->number;
3254 /* Renumber everything that didn't get a target-assigned number. */
3256 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3257 if (tsv->number > highest)
3258 highest = tsv->number;
3261 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3262 if (tsv->number == 0)
3263 tsv->number = highest++;
3265 free_uploaded_tsvs (uploaded_tsvs);
3268 /* target tfile command */
3270 struct target_ops tfile_ops;
3272 /* Fill in tfile_ops with its defined operations and properties. */
3274 #define TRACE_HEADER_SIZE 8
3276 char *trace_filename;
3278 off_t trace_frames_offset;
3280 int cur_traceframe_number;
3282 int trace_regblock_size;
3284 static void tfile_interp_line (char *line,
3285 struct uploaded_tp **utpp,
3286 struct uploaded_tsv **utsvp);
3288 /* Read SIZE bytes into READBUF from the trace frame, starting at
3289 TRACE_FD's current position. Note that this call `read'
3290 underneath, hence it advances the file's seek position. Throws an
3291 error if the `read' syscall fails, or less than SIZE bytes are
3295 tfile_read (gdb_byte *readbuf, int size)
3299 gotten = read (trace_fd, readbuf, size);
3301 perror_with_name (trace_filename);
3302 else if (gotten < size)
3303 error (_("Premature end of file while reading trace file"));
3307 tfile_open (char *filename, int from_tty)
3309 volatile struct gdb_exception ex;
3311 struct cleanup *old_chain;
3314 char header[TRACE_HEADER_SIZE];
3315 char linebuf[1000]; /* Should be max remote packet size or so. */
3318 struct trace_status *ts;
3319 struct uploaded_tp *uploaded_tps = NULL;
3320 struct uploaded_tsv *uploaded_tsvs = NULL;
3322 target_preopen (from_tty);
3324 error (_("No trace file specified."));
3326 filename = tilde_expand (filename);
3327 if (!IS_ABSOLUTE_PATH(filename))
3329 temp = concat (current_directory, "/", filename, (char *) NULL);
3334 old_chain = make_cleanup (xfree, filename);
3336 flags = O_BINARY | O_LARGEFILE;
3338 scratch_chan = open (filename, flags, 0);
3339 if (scratch_chan < 0)
3340 perror_with_name (filename);
3342 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3344 discard_cleanups (old_chain); /* Don't free filename any more. */
3345 unpush_target (&tfile_ops);
3347 trace_filename = xstrdup (filename);
3348 trace_fd = scratch_chan;
3351 /* Read the file header and test for validity. */
3352 tfile_read ((gdb_byte *) &header, TRACE_HEADER_SIZE);
3354 bytes += TRACE_HEADER_SIZE;
3355 if (!(header[0] == 0x7f
3356 && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
3357 error (_("File is not a valid trace file."));
3359 push_target (&tfile_ops);
3361 trace_regblock_size = 0;
3362 ts = current_trace_status ();
3363 /* We know we're working with a file. */
3365 /* Set defaults in case there is no status line. */
3366 ts->running_known = 0;
3367 ts->stop_reason = trace_stop_reason_unknown;
3368 ts->traceframe_count = -1;
3369 ts->buffer_free = 0;
3370 ts->disconnected_tracing = 0;
3371 ts->circular_buffer = 0;
3373 cur_traceframe_number = -1;
3375 TRY_CATCH (ex, RETURN_MASK_ALL)
3377 /* Read through a section of newline-terminated lines that
3378 define things like tracepoints. */
3382 tfile_read (&byte, 1);
3387 /* Empty line marks end of the definition section. */
3392 tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
3395 linebuf[i++] = byte;
3397 error (_("Excessively long lines in trace file"));
3400 /* Record the starting offset of the binary trace data. */
3401 trace_frames_offset = bytes;
3403 /* If we don't have a blocksize, we can't interpret the
3405 if (trace_regblock_size == 0)
3406 error (_("No register block size recorded in trace file"));
3410 /* Pop the partially set up target. */
3412 throw_exception (ex);
3415 inferior_appeared (current_inferior (), TFILE_PID);
3416 inferior_ptid = pid_to_ptid (TFILE_PID);
3417 add_thread_silent (inferior_ptid);
3419 if (ts->traceframe_count <= 0)
3420 warning (_("No traceframes present in this file."));
3422 /* Add the file's tracepoints and variables into the current mix. */
3424 /* Get trace state variables first, they may be checked when parsing
3425 uploaded commands. */
3426 merge_uploaded_trace_state_variables (&uploaded_tsvs);
3428 merge_uploaded_tracepoints (&uploaded_tps);
3430 post_create_inferior (&tfile_ops, from_tty);
3433 /* Interpret the given line from the definitions part of the trace
3437 tfile_interp_line (char *line,
3438 struct uploaded_tp **utpp, struct uploaded_tsv **utsvp)
3442 if (strncmp (p, "R ", strlen ("R ")) == 0)
3445 trace_regblock_size = strtol (p, &p, 16);
3447 else if (strncmp (p, "status ", strlen ("status ")) == 0)
3449 p += strlen ("status ");
3450 parse_trace_status (p, current_trace_status ());
3452 else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
3454 p += strlen ("tp ");
3455 parse_tracepoint_definition (p, utpp);
3457 else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
3459 p += strlen ("tsv ");
3460 parse_tsv_definition (p, utsvp);
3463 warning (_("Ignoring trace file definition \"%s\""), line);
3466 /* Parse the part of trace status syntax that is shared between
3467 the remote protocol and the trace file reader. */
3470 parse_trace_status (char *line, struct trace_status *ts)
3472 char *p = line, *p1, *p2, *p_temp;
3475 ts->running_known = 1;
3476 ts->running = (*p++ == '1');
3477 ts->stop_reason = trace_stop_reason_unknown;
3478 xfree (ts->error_desc);
3479 ts->error_desc = NULL;
3480 ts->traceframe_count = -1;
3481 ts->traceframes_created = -1;
3482 ts->buffer_free = -1;
3483 ts->buffer_size = -1;
3484 ts->disconnected_tracing = 0;
3485 ts->circular_buffer = 0;
3489 p1 = strchr (p, ':');
3491 error (_("Malformed trace status, at %s\n\
3492 Status line: '%s'\n"), p, line);
3493 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3495 p = unpack_varlen_hex (++p1, &val);
3496 ts->stop_reason = trace_buffer_full;
3498 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3500 p = unpack_varlen_hex (++p1, &val);
3501 ts->stop_reason = trace_never_run;
3503 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
3506 p = unpack_varlen_hex (++p1, &val);
3507 ts->stop_reason = tracepoint_passcount;
3508 ts->stopping_tracepoint = val;
3510 else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
3512 p = unpack_varlen_hex (++p1, &val);
3513 ts->stop_reason = tstop_command;
3515 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3517 p = unpack_varlen_hex (++p1, &val);
3518 ts->stop_reason = trace_disconnected;
3520 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3522 p2 = strchr (++p1, ':');
3527 ts->error_desc = xmalloc ((p2 - p1) / 2 + 1);
3528 end = hex2bin (p1, ts->error_desc, (p2 - p1) / 2);
3529 ts->error_desc[end] = '\0';
3532 ts->error_desc = xstrdup ("");
3534 p = unpack_varlen_hex (++p2, &val);
3535 ts->stopping_tracepoint = val;
3536 ts->stop_reason = tracepoint_error;
3538 else if (strncmp (p, "tframes", p1 - p) == 0)
3540 p = unpack_varlen_hex (++p1, &val);
3541 ts->traceframe_count = val;
3543 else if (strncmp (p, "tcreated", p1 - p) == 0)
3545 p = unpack_varlen_hex (++p1, &val);
3546 ts->traceframes_created = val;
3548 else if (strncmp (p, "tfree", p1 - p) == 0)
3550 p = unpack_varlen_hex (++p1, &val);
3551 ts->buffer_free = val;
3553 else if (strncmp (p, "tsize", p1 - p) == 0)
3555 p = unpack_varlen_hex (++p1, &val);
3556 ts->buffer_size = val;
3558 else if (strncmp (p, "disconn", p1 - p) == 0)
3560 p = unpack_varlen_hex (++p1, &val);
3561 ts->disconnected_tracing = val;
3563 else if (strncmp (p, "circular", p1 - p) == 0)
3565 p = unpack_varlen_hex (++p1, &val);
3566 ts->circular_buffer = val;
3570 /* Silently skip unknown optional info. */
3571 p_temp = strchr (p1 + 1, ';');
3575 /* Must be at the end. */
3581 /* Given a line of text defining a part of a tracepoint, parse it into
3582 an "uploaded tracepoint". */
3585 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
3589 ULONGEST num, addr, step, pass, orig_size, xlen, start;
3592 char *cond, *srctype, *buf;
3593 struct uploaded_tp *utp = NULL;
3596 /* Both tracepoint and action definitions start with the same number
3597 and address sequence. */
3599 p = unpack_varlen_hex (p, &num);
3600 p++; /* skip a colon */
3601 p = unpack_varlen_hex (p, &addr);
3602 p++; /* skip a colon */
3605 enabled = (*p++ == 'E');
3606 p++; /* skip a colon */
3607 p = unpack_varlen_hex (p, &step);
3608 p++; /* skip a colon */
3609 p = unpack_varlen_hex (p, &pass);
3610 type = bp_tracepoint;
3612 /* Thumb through optional fields. */
3615 p++; /* skip a colon */
3618 type = bp_fast_tracepoint;
3620 p = unpack_varlen_hex (p, &orig_size);
3624 type = bp_static_tracepoint;
3630 p = unpack_varlen_hex (p, &xlen);
3631 p++; /* skip a comma */
3632 cond = (char *) xmalloc (2 * xlen + 1);
3633 strncpy (cond, p, 2 * xlen);
3634 cond[2 * xlen] = '\0';
3638 warning (_("Unrecognized char '%c' in tracepoint "
3639 "definition, skipping rest"), *p);
3641 utp = get_uploaded_tp (num, addr, utpp);
3643 utp->enabled = enabled;
3648 else if (piece == 'A')
3650 utp = get_uploaded_tp (num, addr, utpp);
3651 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
3653 else if (piece == 'S')
3655 utp = get_uploaded_tp (num, addr, utpp);
3656 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
3658 else if (piece == 'Z')
3660 /* Parse a chunk of source form definition. */
3661 utp = get_uploaded_tp (num, addr, utpp);
3663 p = strchr (p, ':');
3664 p++; /* skip a colon */
3665 p = unpack_varlen_hex (p, &start);
3666 p++; /* skip a colon */
3667 p = unpack_varlen_hex (p, &xlen);
3668 p++; /* skip a colon */
3670 buf = alloca (strlen (line));
3672 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3675 if (strncmp (srctype, "at:", strlen ("at:")) == 0)
3676 utp->at_string = xstrdup (buf);
3677 else if (strncmp (srctype, "cond:", strlen ("cond:")) == 0)
3678 utp->cond_string = xstrdup (buf);
3679 else if (strncmp (srctype, "cmd:", strlen ("cmd:")) == 0)
3680 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
3684 /* Don't error out, the target might be sending us optional
3685 info that we don't care about. */
3686 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
3690 /* Convert a textual description of a trace state variable into an
3694 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
3697 ULONGEST num, initval, builtin;
3699 struct uploaded_tsv *utsv = NULL;
3701 buf = alloca (strlen (line));
3704 p = unpack_varlen_hex (p, &num);
3705 p++; /* skip a colon */
3706 p = unpack_varlen_hex (p, &initval);
3707 p++; /* skip a colon */
3708 p = unpack_varlen_hex (p, &builtin);
3709 p++; /* skip a colon */
3710 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3713 utsv = get_uploaded_tsv (num, utsvp);
3714 utsv->initial_value = initval;
3715 utsv->builtin = builtin;
3716 utsv->name = xstrdup (buf);
3719 /* Close the trace file and generally clean up. */
3722 tfile_close (int quitting)
3729 pid = ptid_get_pid (inferior_ptid);
3730 inferior_ptid = null_ptid; /* Avoid confusion from thread stuff. */
3731 exit_inferior_silent (pid);
3735 xfree (trace_filename);
3736 trace_filename = NULL;
3740 tfile_files_info (struct target_ops *t)
3742 /* (it would be useful to mention the name of the file). */
3743 printf_filtered ("Looking at a trace file.\n");
3746 /* The trace status for a file is that tracing can never be run. */
3749 tfile_get_trace_status (struct trace_status *ts)
3751 /* Other bits of trace status were collected as part of opening the
3752 trace files, so nothing to do here. */
3757 /* Given the position of a traceframe in the file, figure out what
3758 address the frame was collected at. This would normally be the
3759 value of a collected PC register, but if not available, we
3763 tfile_get_traceframe_address (off_t tframe_offset)
3767 struct tracepoint *tp;
3768 off_t saved_offset = cur_offset;
3770 /* FIXME dig pc out of collected registers. */
3772 /* Fall back to using tracepoint address. */
3773 lseek (trace_fd, tframe_offset, SEEK_SET);
3774 tfile_read ((gdb_byte *) &tpnum, 2);
3775 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
3779 tp = get_tracepoint_by_number_on_target (tpnum);
3780 /* FIXME this is a poor heuristic if multiple locations. */
3781 if (tp && tp->base.loc)
3782 addr = tp->base.loc->address;
3784 /* Restore our seek position. */
3785 cur_offset = saved_offset;
3786 lseek (trace_fd, cur_offset, SEEK_SET);
3790 /* Make tfile's selected traceframe match GDB's selected
3794 set_tfile_traceframe (void)
3798 if (cur_traceframe_number == get_traceframe_number ())
3801 /* Avoid recursion, tfile_trace_find calls us again. */
3802 cur_traceframe_number = get_traceframe_number ();
3804 newnum = target_trace_find (tfind_number,
3805 get_traceframe_number (), 0, 0, NULL);
3807 /* Should not happen. If it does, all bets are off. */
3808 if (newnum != get_traceframe_number ())
3809 warning (_("could not set tfile's traceframe"));
3812 /* Given a type of search and some parameters, scan the collection of
3813 traceframes in the file looking for a match. When found, return
3814 both the traceframe and tracepoint number, otherwise -1 for
3818 tfile_trace_find (enum trace_find_type type, int num,
3819 ULONGEST addr1, ULONGEST addr2, int *tpp)
3822 int tfnum = 0, found = 0;
3823 unsigned int data_size;
3824 struct tracepoint *tp;
3825 off_t offset, tframe_offset;
3828 /* Lookups other than by absolute frame number depend on the current
3829 trace selected, so make sure it is correct on the tfile end
3831 if (type != tfind_number)
3832 set_tfile_traceframe ();
3840 lseek (trace_fd, trace_frames_offset, SEEK_SET);
3841 offset = trace_frames_offset;
3844 tframe_offset = offset;
3845 tfile_read ((gdb_byte *) &tpnum, 2);
3846 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
3852 tfile_read ((gdb_byte *) &data_size, 4);
3853 data_size = (unsigned int) extract_unsigned_integer
3854 ((gdb_byte *) &data_size, 4,
3855 gdbarch_byte_order (target_gdbarch));
3864 tfaddr = tfile_get_traceframe_address (tframe_offset);
3865 if (tfaddr == addr1)
3869 tp = get_tracepoint (num);
3870 if (tp && tpnum == tp->number_on_target)
3874 tfaddr = tfile_get_traceframe_address (tframe_offset);
3875 if (addr1 <= tfaddr && tfaddr <= addr2)
3879 tfaddr = tfile_get_traceframe_address (tframe_offset);
3880 if (!(addr1 <= tfaddr && tfaddr <= addr2))
3884 internal_error (__FILE__, __LINE__, _("unknown tfind type"));
3890 cur_offset = offset;
3891 cur_data_size = data_size;
3892 cur_traceframe_number = tfnum;
3895 /* Skip past the traceframe's data. */
3896 lseek (trace_fd, data_size, SEEK_CUR);
3897 offset += data_size;
3898 /* Update our own count of traceframes. */
3901 /* Did not find what we were looking for. */
3907 /* Prototype of the callback passed to tframe_walk_blocks. */
3908 typedef int (*walk_blocks_callback_func) (char blocktype, void *data);
3910 /* Callback for traceframe_walk_blocks, used to find a given block
3911 type in a traceframe. */
3914 match_blocktype (char blocktype, void *data)
3916 char *wantedp = data;
3918 if (*wantedp == blocktype)
3924 /* Walk over all traceframe block starting at POS offset from
3925 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
3926 unmodified. If CALLBACK returns true, this returns the position in
3927 the traceframe where the block is found, relative to the start of
3928 the traceframe (cur_offset). Returns -1 if no callback call
3929 returned true, indicating that all blocks have been walked. */
3932 traceframe_walk_blocks (walk_blocks_callback_func callback,
3933 int pos, void *data)
3935 /* Iterate through a traceframe's blocks, looking for a block of the
3938 lseek (trace_fd, cur_offset + pos, SEEK_SET);
3939 while (pos < cur_data_size)
3941 unsigned short mlen;
3944 tfile_read (&block_type, 1);
3948 if ((*callback) (block_type, data))
3954 lseek (trace_fd, cur_offset + pos + trace_regblock_size, SEEK_SET);
3955 pos += trace_regblock_size;
3958 lseek (trace_fd, cur_offset + pos + 8, SEEK_SET);
3959 tfile_read ((gdb_byte *) &mlen, 2);
3960 mlen = (unsigned short)
3961 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
3964 lseek (trace_fd, mlen, SEEK_CUR);
3965 pos += (8 + 2 + mlen);
3968 lseek (trace_fd, cur_offset + pos + 4 + 8, SEEK_SET);
3972 error (_("Unknown block type '%c' (0x%x) in trace frame"),
3973 block_type, block_type);
3981 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
3982 position offset of a block of type TYPE_WANTED in the current trace
3983 frame, starting at POS. Returns -1 if no such block was found. */
3986 traceframe_find_block_type (char type_wanted, int pos)
3988 return traceframe_walk_blocks (match_blocktype, pos, &type_wanted);
3991 /* Look for a block of saved registers in the traceframe, and get the
3992 requested register from it. */
3995 tfile_fetch_registers (struct target_ops *ops,
3996 struct regcache *regcache, int regno)
3998 struct gdbarch *gdbarch = get_regcache_arch (regcache);
4000 int pos, offset, regn, regsize, pc_regno;
4001 unsigned short mlen;
4004 /* An uninitialized reg size says we're not going to be
4005 successful at getting register blocks. */
4006 if (!trace_regblock_size)
4009 set_tfile_traceframe ();
4011 regs = alloca (trace_regblock_size);
4013 if (traceframe_find_block_type ('R', 0) >= 0)
4015 tfile_read (regs, trace_regblock_size);
4017 /* Assume the block is laid out in GDB register number order,
4018 each register with the size that it has in GDB. */
4020 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4022 regsize = register_size (gdbarch, regn);
4023 /* Make sure we stay within block bounds. */
4024 if (offset + regsize >= trace_regblock_size)
4026 if (regcache_register_status (regcache, regn) == REG_UNKNOWN)
4030 regcache_raw_supply (regcache, regno, regs + offset);
4033 else if (regno == -1)
4035 regcache_raw_supply (regcache, regn, regs + offset);
4043 /* We get here if no register data has been found. Mark registers
4045 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4046 regcache_raw_supply (regcache, regn, NULL);
4048 /* We can often usefully guess that the PC is going to be the same
4049 as the address of the tracepoint. */
4050 pc_regno = gdbarch_pc_regnum (gdbarch);
4051 if (pc_regno >= 0 && (regno == -1 || regno == pc_regno))
4053 struct tracepoint *tp = get_tracepoint (tracepoint_number);
4055 if (tp && tp->base.loc)
4057 /* But don't try to guess if tracepoint is multi-location... */
4058 if (tp->base.loc->next)
4060 warning (_("Tracepoint %d has multiple "
4061 "locations, cannot infer $pc"),
4065 /* ... or does while-stepping. */
4066 if (tp->step_count > 0)
4068 warning (_("Tracepoint %d does while-stepping, "
4069 "cannot infer $pc"),
4074 store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
4075 gdbarch_byte_order (gdbarch),
4076 tp->base.loc->address);
4077 regcache_raw_supply (regcache, pc_regno, regs);
4083 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
4084 const char *annex, gdb_byte *readbuf,
4085 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
4087 /* We're only doing regular memory for now. */
4088 if (object != TARGET_OBJECT_MEMORY)
4091 if (readbuf == NULL)
4092 error (_("tfile_xfer_partial: trace file is read-only"));
4094 set_tfile_traceframe ();
4096 if (traceframe_number != -1)
4100 /* Iterate through the traceframe's blocks, looking for
4102 while ((pos = traceframe_find_block_type ('M', pos)) >= 0)
4104 ULONGEST maddr, amt;
4105 unsigned short mlen;
4106 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch);
4108 tfile_read ((gdb_byte *) &maddr, 8);
4109 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
4111 tfile_read ((gdb_byte *) &mlen, 2);
4112 mlen = (unsigned short)
4113 extract_unsigned_integer ((gdb_byte *) &mlen, 2, byte_order);
4115 /* If the block includes the first part of the desired
4116 range, return as much it has; GDB will re-request the
4117 remainder, which might be in a different block of this
4119 if (maddr <= offset && offset < (maddr + mlen))
4121 amt = (maddr + mlen) - offset;
4125 tfile_read (readbuf, amt);
4129 /* Skip over this block. */
4130 pos += (8 + 2 + mlen);
4134 /* It's unduly pedantic to refuse to look at the executable for
4135 read-only pieces; so do the equivalent of readonly regions aka
4137 /* FIXME account for relocation at some point. */
4144 for (s = exec_bfd->sections; s; s = s->next)
4146 if ((s->flags & SEC_LOAD) == 0
4147 || (s->flags & SEC_READONLY) == 0)
4151 size = bfd_get_section_size (s);
4152 if (vma <= offset && offset < (vma + size))
4156 amt = (vma + size) - offset;
4160 amt = bfd_get_section_contents (exec_bfd, s,
4161 readbuf, offset - vma, amt);
4167 /* Indicate failure to find the requested memory block. */
4171 /* Iterate through the blocks of a trace frame, looking for a 'V'
4172 block with a matching tsv number. */
4175 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
4179 set_tfile_traceframe ();
4182 while ((pos = traceframe_find_block_type ('V', pos)) >= 0)
4186 tfile_read ((gdb_byte *) &vnum, 4);
4187 vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
4192 tfile_read ((gdb_byte *) val, 8);
4193 *val = extract_signed_integer ((gdb_byte *) val, 8,
4201 /* Didn't find anything. */
4206 tfile_has_all_memory (struct target_ops *ops)
4212 tfile_has_memory (struct target_ops *ops)
4218 tfile_has_stack (struct target_ops *ops)
4220 return traceframe_number != -1;
4224 tfile_has_registers (struct target_ops *ops)
4226 return traceframe_number != -1;
4230 tfile_thread_alive (struct target_ops *ops, ptid_t ptid)
4235 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
4236 object for the tfile target's current traceframe. */
4239 build_traceframe_info (char blocktype, void *data)
4241 struct traceframe_info *info = data;
4247 struct mem_range *r;
4249 unsigned short mlen;
4251 tfile_read ((gdb_byte *) &maddr, 8);
4252 tfile_read ((gdb_byte *) &mlen, 2);
4254 r = VEC_safe_push (mem_range_s, info->memory, NULL);
4267 warning (_("Unhandled trace block type (%d) '%c ' "
4268 "while building trace frame info."),
4269 blocktype, blocktype);
4276 static struct traceframe_info *
4277 tfile_traceframe_info (void)
4279 struct traceframe_info *info = XCNEW (struct traceframe_info);
4281 traceframe_walk_blocks (build_traceframe_info, 0, info);
4286 init_tfile_ops (void)
4288 tfile_ops.to_shortname = "tfile";
4289 tfile_ops.to_longname = "Local trace dump file";
4291 = "Use a trace file as a target. Specify the filename of the trace file.";
4292 tfile_ops.to_open = tfile_open;
4293 tfile_ops.to_close = tfile_close;
4294 tfile_ops.to_fetch_registers = tfile_fetch_registers;
4295 tfile_ops.to_xfer_partial = tfile_xfer_partial;
4296 tfile_ops.to_files_info = tfile_files_info;
4297 tfile_ops.to_get_trace_status = tfile_get_trace_status;
4298 tfile_ops.to_trace_find = tfile_trace_find;
4299 tfile_ops.to_get_trace_state_variable_value
4300 = tfile_get_trace_state_variable_value;
4301 tfile_ops.to_stratum = process_stratum;
4302 tfile_ops.to_has_all_memory = tfile_has_all_memory;
4303 tfile_ops.to_has_memory = tfile_has_memory;
4304 tfile_ops.to_has_stack = tfile_has_stack;
4305 tfile_ops.to_has_registers = tfile_has_registers;
4306 tfile_ops.to_traceframe_info = tfile_traceframe_info;
4307 tfile_ops.to_thread_alive = tfile_thread_alive;
4308 tfile_ops.to_magic = OPS_MAGIC;
4311 /* Given a line of text defining a static tracepoint marker, parse it
4312 into a "static tracepoint marker" object. Throws an error is
4313 parsing fails. If PP is non-null, it points to one past the end of
4314 the parsed marker definition. */
4317 parse_static_tracepoint_marker_definition (char *line, char **pp,
4318 struct static_tracepoint_marker *marker)
4325 p = unpack_varlen_hex (p, &addr);
4326 p++; /* skip a colon */
4328 marker->gdbarch = target_gdbarch;
4329 marker->address = (CORE_ADDR) addr;
4331 endp = strchr (p, ':');
4333 error (_("bad marker definition: %s"), line);
4335 marker->str_id = xmalloc (endp - p + 1);
4336 end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
4337 marker->str_id[end] = '\0';
4340 p++; /* skip a colon */
4342 marker->extra = xmalloc (strlen (p) + 1);
4343 end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
4344 marker->extra[end] = '\0';
4350 /* Release a static tracepoint marker's contents. Note that the
4351 object itself isn't released here. There objects are usually on
4355 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
4357 xfree (marker->str_id);
4358 marker->str_id = NULL;
4361 /* Print MARKER to gdb_stdout. */
4364 print_one_static_tracepoint_marker (int count,
4365 struct static_tracepoint_marker *marker)
4367 struct command_line *l;
4370 char wrap_indent[80];
4371 char extra_field_indent[80];
4372 struct ui_out *uiout = current_uiout;
4373 struct ui_stream *stb = ui_out_stream_new (uiout);
4374 struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb);
4375 struct cleanup *bkpt_chain;
4376 VEC(breakpoint_p) *tracepoints;
4378 struct symtab_and_line sal;
4382 sal.pc = marker->address;
4384 tracepoints = static_tracepoints_here (marker->address);
4386 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
4388 /* A counter field to help readability. This is not a stable
4390 ui_out_field_int (uiout, "count", count);
4392 ui_out_field_string (uiout, "marker-id", marker->str_id);
4394 ui_out_field_fmt (uiout, "enabled", "%c",
4395 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
4396 ui_out_spaces (uiout, 2);
4398 strcpy (wrap_indent, " ");
4400 if (gdbarch_addr_bit (marker->gdbarch) <= 32)
4401 strcat (wrap_indent, " ");
4403 strcat (wrap_indent, " ");
4405 strcpy (extra_field_indent, " ");
4407 ui_out_field_core_addr (uiout, "addr", marker->gdbarch, marker->address);
4409 sal = find_pc_line (marker->address, 0);
4410 sym = find_pc_sect_function (marker->address, NULL);
4413 ui_out_text (uiout, "in ");
4414 ui_out_field_string (uiout, "func",
4415 SYMBOL_PRINT_NAME (sym));
4416 ui_out_wrap_hint (uiout, wrap_indent);
4417 ui_out_text (uiout, " at ");
4420 ui_out_field_skip (uiout, "func");
4422 if (sal.symtab != NULL)
4424 ui_out_field_string (uiout, "file", sal.symtab->filename);
4425 ui_out_text (uiout, ":");
4427 if (ui_out_is_mi_like_p (uiout))
4429 char *fullname = symtab_to_fullname (sal.symtab);
4432 ui_out_field_string (uiout, "fullname", fullname);
4435 ui_out_field_skip (uiout, "fullname");
4437 ui_out_field_int (uiout, "line", sal.line);
4441 ui_out_field_skip (uiout, "fullname");
4442 ui_out_field_skip (uiout, "line");
4445 ui_out_text (uiout, "\n");
4446 ui_out_text (uiout, extra_field_indent);
4447 ui_out_text (uiout, _("Data: \""));
4448 ui_out_field_string (uiout, "extra-data", marker->extra);
4449 ui_out_text (uiout, "\"\n");
4451 if (!VEC_empty (breakpoint_p, tracepoints))
4453 struct cleanup *cleanup_chain;
4455 struct breakpoint *b;
4457 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
4460 ui_out_text (uiout, extra_field_indent);
4461 ui_out_text (uiout, _("Probed by static tracepoints: "));
4462 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
4465 ui_out_text (uiout, ", ");
4466 ui_out_text (uiout, "#");
4467 ui_out_field_int (uiout, "tracepoint-id", b->number);
4470 do_cleanups (cleanup_chain);
4472 if (ui_out_is_mi_like_p (uiout))
4473 ui_out_field_int (uiout, "number-of-tracepoints",
4474 VEC_length(breakpoint_p, tracepoints));
4476 ui_out_text (uiout, "\n");
4478 VEC_free (breakpoint_p, tracepoints);
4480 do_cleanups (bkpt_chain);
4481 do_cleanups (old_chain);
4485 info_static_tracepoint_markers_command (char *arg, int from_tty)
4487 VEC(static_tracepoint_marker_p) *markers;
4488 struct cleanup *old_chain;
4489 struct static_tracepoint_marker *marker;
4490 struct ui_out *uiout = current_uiout;
4494 = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
4495 "StaticTracepointMarkersTable");
4497 ui_out_table_header (uiout, 7, ui_left, "counter", "Cnt");
4499 ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
4501 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
4502 if (gdbarch_addr_bit (target_gdbarch) <= 32)
4503 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
4505 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
4506 ui_out_table_header (uiout, 40, ui_noalign, "what", "What");
4508 ui_out_table_body (uiout);
4510 markers = target_static_tracepoint_markers_by_strid (NULL);
4511 make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
4514 VEC_iterate (static_tracepoint_marker_p,
4515 markers, i, marker);
4518 print_one_static_tracepoint_marker (i + 1, marker);
4519 release_static_tracepoint_marker (marker);
4522 do_cleanups (old_chain);
4525 /* The $_sdata convenience variable is a bit special. We don't know
4526 for sure type of the value until we actually have a chance to fetch
4527 the data --- the size of the object depends on what has been
4528 collected. We solve this by making $_sdata be an internalvar that
4529 creates a new value on access. */
4531 /* Return a new value with the correct type for the sdata object of
4532 the current trace frame. Return a void value if there's no object
4535 static struct value *
4536 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var)
4541 /* We need to read the whole object before we know its size. */
4542 size = target_read_alloc (¤t_target,
4543 TARGET_OBJECT_STATIC_TRACE_DATA,
4550 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
4552 v = allocate_value (type);
4553 memcpy (value_contents_raw (v), buf, size);
4558 return allocate_value (builtin_type (gdbarch)->builtin_void);
4561 #if !defined(HAVE_LIBEXPAT)
4563 struct traceframe_info *
4564 parse_traceframe_info (const char *tframe_info)
4566 static int have_warned;
4571 warning (_("Can not parse XML trace frame info; XML support "
4572 "was disabled at compile time"));
4578 #else /* HAVE_LIBEXPAT */
4580 #include "xml-support.h"
4582 /* Handle the start of a <memory> element. */
4585 traceframe_info_start_memory (struct gdb_xml_parser *parser,
4586 const struct gdb_xml_element *element,
4587 void *user_data, VEC(gdb_xml_value_s) *attributes)
4589 struct traceframe_info *info = user_data;
4590 struct mem_range *r = VEC_safe_push (mem_range_s, info->memory, NULL);
4591 ULONGEST *start_p, *length_p;
4593 start_p = xml_find_attribute (attributes, "start")->value;
4594 length_p = xml_find_attribute (attributes, "length")->value;
4596 r->start = *start_p;
4597 r->length = *length_p;
4600 /* Discard the constructed trace frame info (if an error occurs). */
4603 free_result (void *p)
4605 struct traceframe_info *result = p;
4607 free_traceframe_info (result);
4610 /* The allowed elements and attributes for an XML memory map. */
4612 static const struct gdb_xml_attribute memory_attributes[] = {
4613 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4614 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
4615 { NULL, GDB_XML_AF_NONE, NULL, NULL }
4618 static const struct gdb_xml_element traceframe_info_children[] = {
4619 { "memory", memory_attributes, NULL,
4620 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
4621 traceframe_info_start_memory, NULL },
4622 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4625 static const struct gdb_xml_element traceframe_info_elements[] = {
4626 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
4628 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
4631 /* Parse a traceframe-info XML document. */
4633 struct traceframe_info *
4634 parse_traceframe_info (const char *tframe_info)
4636 struct traceframe_info *result;
4637 struct cleanup *back_to;
4639 result = XCNEW (struct traceframe_info);
4640 back_to = make_cleanup (free_result, result);
4642 if (gdb_xml_parse_quick (_("trace frame info"),
4643 "traceframe-info.dtd", traceframe_info_elements,
4644 tframe_info, result) == 0)
4646 /* Parsed successfully, keep the result. */
4647 discard_cleanups (back_to);
4652 do_cleanups (back_to);
4656 #endif /* HAVE_LIBEXPAT */
4658 /* Returns the traceframe_info object for the current traceframe.
4659 This is where we avoid re-fetching the object from the target if we
4660 already have it cached. */
4662 struct traceframe_info *
4663 get_traceframe_info (void)
4665 if (traceframe_info == NULL)
4666 traceframe_info = target_traceframe_info ();
4668 return traceframe_info;
4671 /* If the target supports the query, return in RESULT the set of
4672 collected memory in the current traceframe, found within the LEN
4673 bytes range starting at MEMADDR. Returns true if the target
4674 supports the query, otherwise returns false, and RESULT is left
4678 traceframe_available_memory (VEC(mem_range_s) **result,
4679 CORE_ADDR memaddr, ULONGEST len)
4681 struct traceframe_info *info = get_traceframe_info ();
4685 struct mem_range *r;
4690 for (i = 0; VEC_iterate (mem_range_s, info->memory, i, r); i++)
4691 if (mem_ranges_overlap (r->start, r->length, memaddr, len))
4693 ULONGEST lo1, hi1, lo2, hi2;
4694 struct mem_range *nr;
4697 hi1 = memaddr + len;
4700 hi2 = r->start + r->length;
4702 nr = VEC_safe_push (mem_range_s, *result, NULL);
4704 nr->start = max (lo1, lo2);
4705 nr->length = min (hi1, hi2) - nr->start;
4708 normalize_mem_ranges (*result);
4715 /* module initialization */
4717 _initialize_tracepoint (void)
4719 struct cmd_list_element *c;
4721 /* Explicitly create without lookup, since that tries to create a
4722 value with a void typed value, and when we get here, gdbarch
4723 isn't initialized yet. At this point, we're quite sure there
4724 isn't another convenience variable of the same name. */
4725 create_internalvar_type_lazy ("_sdata", sdata_make_value);
4727 traceframe_number = -1;
4728 tracepoint_number = -1;
4730 if (tracepoint_list.list == NULL)
4732 tracepoint_list.listsize = 128;
4733 tracepoint_list.list = xmalloc
4734 (tracepoint_list.listsize * sizeof (struct memrange));
4736 if (tracepoint_list.aexpr_list == NULL)
4738 tracepoint_list.aexpr_listsize = 128;
4739 tracepoint_list.aexpr_list = xmalloc
4740 (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
4743 if (stepping_list.list == NULL)
4745 stepping_list.listsize = 128;
4746 stepping_list.list = xmalloc
4747 (stepping_list.listsize * sizeof (struct memrange));
4750 if (stepping_list.aexpr_list == NULL)
4752 stepping_list.aexpr_listsize = 128;
4753 stepping_list.aexpr_list = xmalloc
4754 (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
4757 add_info ("scope", scope_info,
4758 _("List the variables local to a scope"));
4760 add_cmd ("tracepoints", class_trace, NULL,
4761 _("Tracing of program execution without stopping the program."),
4764 add_com ("tdump", class_trace, trace_dump_command,
4765 _("Print everything collected at the current tracepoint."));
4767 add_com ("tsave", class_trace, trace_save_command, _("\
4768 Save the trace data to a file.\n\
4769 Use the '-r' option to direct the target to save directly to the file,\n\
4770 using its own filesystem."));
4772 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
4773 Define a trace state variable.\n\
4774 Argument is a $-prefixed name, optionally followed\n\
4775 by '=' and an expression that sets the initial value\n\
4776 at the start of tracing."));
4777 set_cmd_completer (c, expression_completer);
4779 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
4780 Delete one or more trace state variables.\n\
4781 Arguments are the names of the variables to delete.\n\
4782 If no arguments are supplied, delete all variables."), &deletelist);
4783 /* FIXME add a trace variable completer. */
4785 add_info ("tvariables", tvariables_info, _("\
4786 Status of trace state variables and their values.\n\
4789 add_info ("static-tracepoint-markers",
4790 info_static_tracepoint_markers_command, _("\
4791 List target static tracepoints markers.\n\
4794 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
4795 Select a trace frame;\n\
4796 No argument means forward by one frame; '-' means backward by one frame."),
4797 &tfindlist, "tfind ", 1, &cmdlist);
4799 add_cmd ("outside", class_trace, trace_find_outside_command, _("\
4800 Select a trace frame whose PC is outside the given range (exclusive).\n\
4801 Usage: tfind outside addr1, addr2"),
4804 add_cmd ("range", class_trace, trace_find_range_command, _("\
4805 Select a trace frame whose PC is in the given range (inclusive).\n\
4806 Usage: tfind range addr1,addr2"),
4809 add_cmd ("line", class_trace, trace_find_line_command, _("\
4810 Select a trace frame by source line.\n\
4811 Argument can be a line number (with optional source file),\n\
4812 a function name, or '*' followed by an address.\n\
4813 Default argument is 'the next source line that was traced'."),
4816 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
4817 Select a trace frame by tracepoint number.\n\
4818 Default is the tracepoint for the current trace frame."),
4821 add_cmd ("pc", class_trace, trace_find_pc_command, _("\
4822 Select a trace frame by PC.\n\
4823 Default is the current PC, or the PC of the current trace frame."),
4826 add_cmd ("end", class_trace, trace_find_end_command, _("\
4827 Synonym for 'none'.\n\
4828 De-select any trace frame and resume 'live' debugging."),
4831 add_cmd ("none", class_trace, trace_find_none_command,
4832 _("De-select any trace frame and resume 'live' debugging."),
4835 add_cmd ("start", class_trace, trace_find_start_command,
4836 _("Select the first trace frame in the trace buffer."),
4839 add_com ("tstatus", class_trace, trace_status_command,
4840 _("Display the status of the current trace data collection."));
4842 add_com ("tstop", class_trace, trace_stop_command,
4843 _("Stop trace data collection."));
4845 add_com ("tstart", class_trace, trace_start_command,
4846 _("Start trace data collection."));
4848 add_com ("end", class_trace, end_actions_pseudocommand, _("\
4849 Ends a list of commands or actions.\n\
4850 Several GDB commands allow you to enter a list of commands or actions.\n\
4851 Entering \"end\" on a line by itself is the normal way to terminate\n\
4853 Note: the \"end\" command cannot be used at the gdb prompt."));
4855 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
4856 Specify single-stepping behavior at a tracepoint.\n\
4857 Argument is number of instructions to trace in single-step mode\n\
4858 following the tracepoint. This command is normally followed by\n\
4859 one or more \"collect\" commands, to specify what to collect\n\
4860 while single-stepping.\n\n\
4861 Note: this command can only be used in a tracepoint \"actions\" list."));
4863 add_com_alias ("ws", "while-stepping", class_alias, 0);
4864 add_com_alias ("stepping", "while-stepping", class_alias, 0);
4866 add_com ("collect", class_trace, collect_pseudocommand, _("\
4867 Specify one or more data items to be collected at a tracepoint.\n\
4868 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4869 collect all data (variables, registers) referenced by that expression.\n\
4870 Also accepts the following special arguments:\n\
4871 $regs -- all registers.\n\
4872 $args -- all function arguments.\n\
4873 $locals -- all variables local to the block/function scope.\n\
4874 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4875 Note: this command can only be used in a tracepoint \"actions\" list."));
4877 add_com ("teval", class_trace, teval_pseudocommand, _("\
4878 Specify one or more expressions to be evaluated at a tracepoint.\n\
4879 Accepts a comma-separated list of (one or more) expressions.\n\
4880 The result of each evaluation will be discarded.\n\
4881 Note: this command can only be used in a tracepoint \"actions\" list."));
4883 add_com ("actions", class_trace, trace_actions_command, _("\
4884 Specify the actions to be taken at a tracepoint.\n\
4885 Tracepoint actions may include collecting of specified data,\n\
4886 single-stepping, or enabling/disabling other tracepoints,\n\
4887 depending on target's capabilities."));
4889 default_collect = xstrdup ("");
4890 add_setshow_string_cmd ("default-collect", class_trace,
4891 &default_collect, _("\
4892 Set the list of expressions to collect by default"), _("\
4893 Show the list of expressions to collect by default"), NULL,
4895 &setlist, &showlist);
4897 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
4898 &disconnected_tracing, _("\
4899 Set whether tracing continues after GDB disconnects."), _("\
4900 Show whether tracing continues after GDB disconnects."), _("\
4901 Use this to continue a tracing run even if GDB disconnects\n\
4902 or detaches from the target. You can reconnect later and look at\n\
4903 trace data collected in the meantime."),
4904 set_disconnected_tracing,
4909 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
4910 &circular_trace_buffer, _("\
4911 Set target's use of circular trace buffer."), _("\
4912 Show target's use of circular trace buffer."), _("\
4913 Use this to make the trace buffer into a circular buffer,\n\
4914 which will discard traceframes (oldest first) instead of filling\n\
4915 up and stopping the trace run."),
4916 set_circular_trace_buffer,
4923 add_target (&tfile_ops);