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 /* readline include files */
55 #include "readline/readline.h"
56 #include "readline/history.h"
58 /* readline defines this. */
69 extern int hex2bin (const char *hex, gdb_byte *bin, int count);
70 extern int bin2hex (const gdb_byte *bin, char *hex, int count);
72 extern void stop_tracing ();
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
84 /* A hook used to notify the UI of tracepoint operations. */
86 void (*deprecated_trace_find_hook) (char *arg, int from_tty);
87 void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
89 extern void (*deprecated_readline_begin_hook) (char *, ...);
90 extern char *(*deprecated_readline_hook) (char *);
91 extern void (*deprecated_readline_end_hook) (void);
93 /* GDB commands implemented in other modules:
96 extern void output_command (char *, int);
101 This module defines the following debugger commands:
102 trace : set a tracepoint on a function, line, or address.
103 info trace : list all debugger-defined tracepoints.
104 delete trace : delete one or more tracepoints.
105 enable trace : enable one or more tracepoints.
106 disable trace : disable one or more tracepoints.
107 actions : specify actions to be taken at a tracepoint.
108 passcount : specify a pass count for a tracepoint.
109 tstart : start a trace experiment.
110 tstop : stop a trace experiment.
111 tstatus : query the status of a trace experiment.
112 tfind : find a trace frame in the trace buffer.
113 tdump : print everything collected at the current tracepoint.
114 save-tracepoints : write tracepoint setup into a file.
116 This module defines the following user-visible debugger variables:
117 $trace_frame : sequence number of trace frame currently being debugged.
118 $trace_line : source line of trace frame currently being debugged.
119 $trace_file : source file of trace frame currently being debugged.
120 $tracepoint : tracepoint number of trace frame currently being debugged.
124 /* ======= Important global variables: ======= */
126 /* The list of all trace state variables. We don't retain pointers to
127 any of these for any reason - API is by name or number only - so it
128 works to have a vector of objects. */
130 typedef struct trace_state_variable tsv_s;
133 static VEC(tsv_s) *tvariables;
135 /* The next integer to assign to a variable. */
137 static int next_tsv_number = 1;
139 /* Number of last traceframe collected. */
140 static int traceframe_number;
142 /* Tracepoint for last traceframe collected. */
143 static int tracepoint_number;
145 /* Symbol for function for last traceframe collected */
146 static struct symbol *traceframe_fun;
148 /* Symtab and line for last traceframe collected */
149 static struct symtab_and_line traceframe_sal;
151 /* Tracing command lists */
152 static struct cmd_list_element *tfindlist;
154 /* List of expressions to collect by default at each tracepoint hit. */
155 char *default_collect = "";
157 static int disconnected_tracing;
159 /* This variable controls whether we ask the target for a linear or
160 circular trace buffer. */
162 static int circular_trace_buffer;
164 /* ======= Important command functions: ======= */
165 static void trace_actions_command (char *, int);
166 static void trace_start_command (char *, int);
167 static void trace_stop_command (char *, int);
168 static void trace_status_command (char *, int);
169 static void trace_find_command (char *, int);
170 static void trace_find_pc_command (char *, int);
171 static void trace_find_tracepoint_command (char *, int);
172 static void trace_find_line_command (char *, int);
173 static void trace_find_range_command (char *, int);
174 static void trace_find_outside_command (char *, int);
175 static void trace_dump_command (char *, int);
177 /* support routines */
179 struct collection_list;
180 static void add_aexpr (struct collection_list *, struct agent_expr *);
181 static char *mem2hex (gdb_byte *, char *, int);
182 static void add_register (struct collection_list *collection,
185 extern void send_disconnected_tracing_value (int value);
187 static void free_uploaded_tps (struct uploaded_tp **utpp);
188 static void free_uploaded_tsvs (struct uploaded_tsv **utsvp);
191 extern void _initialize_tracepoint (void);
193 static struct trace_status trace_status;
195 char *stop_reason_names[] = {
205 struct trace_status *
206 current_trace_status ()
208 return &trace_status;
211 /* Set traceframe number to NUM. */
213 set_traceframe_num (int num)
215 traceframe_number = num;
216 set_internalvar_integer (lookup_internalvar ("trace_frame"), num);
219 /* Set tracepoint number to NUM. */
221 set_tracepoint_num (int num)
223 tracepoint_number = num;
224 set_internalvar_integer (lookup_internalvar ("tracepoint"), num);
227 /* Set externally visible debug variables for querying/printing
228 the traceframe context (line, function, file) */
231 set_traceframe_context (struct frame_info *trace_frame)
235 if (trace_frame == NULL) /* Cease debugging any trace buffers. */
238 traceframe_sal.pc = traceframe_sal.line = 0;
239 traceframe_sal.symtab = NULL;
240 clear_internalvar (lookup_internalvar ("trace_func"));
241 clear_internalvar (lookup_internalvar ("trace_file"));
242 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
246 /* Save as globals for internal use. */
247 trace_pc = get_frame_pc (trace_frame);
248 traceframe_sal = find_pc_line (trace_pc, 0);
249 traceframe_fun = find_pc_function (trace_pc);
251 /* Save linenumber as "$trace_line", a debugger variable visible to
253 set_internalvar_integer (lookup_internalvar ("trace_line"),
254 traceframe_sal.line);
256 /* Save func name as "$trace_func", a debugger variable visible to
258 if (traceframe_fun == NULL
259 || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
260 clear_internalvar (lookup_internalvar ("trace_func"));
262 set_internalvar_string (lookup_internalvar ("trace_func"),
263 SYMBOL_LINKAGE_NAME (traceframe_fun));
265 /* Save file name as "$trace_file", a debugger variable visible to
267 if (traceframe_sal.symtab == NULL
268 || traceframe_sal.symtab->filename == NULL)
269 clear_internalvar (lookup_internalvar ("trace_file"));
271 set_internalvar_string (lookup_internalvar ("trace_file"),
272 traceframe_sal.symtab->filename);
275 /* Create a new trace state variable with the given name. */
277 struct trace_state_variable *
278 create_trace_state_variable (const char *name)
280 struct trace_state_variable tsv;
282 memset (&tsv, 0, sizeof (tsv));
283 tsv.name = xstrdup (name);
284 tsv.number = next_tsv_number++;
285 return VEC_safe_push (tsv_s, tvariables, &tsv);
288 /* Look for a trace state variable of the given name. */
290 struct trace_state_variable *
291 find_trace_state_variable (const char *name)
293 struct trace_state_variable *tsv;
296 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
297 if (strcmp (name, tsv->name) == 0)
304 delete_trace_state_variable (const char *name)
306 struct trace_state_variable *tsv;
309 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
310 if (strcmp (name, tsv->name) == 0)
312 xfree ((void *)tsv->name);
313 VEC_unordered_remove (tsv_s, tvariables, ix);
317 warning (_("No trace variable named \"$%s\", not deleting"), name);
320 /* The 'tvariable' command collects a name and optional expression to
321 evaluate into an initial value. */
324 trace_variable_command (char *args, int from_tty)
326 struct expression *expr;
327 struct cleanup *old_chain;
328 struct internalvar *intvar = NULL;
330 struct trace_state_variable *tsv;
333 error_no_arg (_("trace state variable name"));
335 /* All the possible valid arguments are expressions. */
336 expr = parse_expression (args);
337 old_chain = make_cleanup (free_current_contents, &expr);
339 if (expr->nelts == 0)
340 error (_("No expression?"));
342 /* Only allow two syntaxes; "$name" and "$name=value". */
343 if (expr->elts[0].opcode == OP_INTERNALVAR)
345 intvar = expr->elts[1].internalvar;
347 else if (expr->elts[0].opcode == BINOP_ASSIGN
348 && expr->elts[1].opcode == OP_INTERNALVAR)
350 intvar = expr->elts[2].internalvar;
351 initval = value_as_long (evaluate_subexpression_type (expr, 4));
354 error (_("Syntax must be $NAME [ = EXPR ]"));
357 error (_("No name given"));
359 if (strlen (internalvar_name (intvar)) <= 0)
360 error (_("Must supply a non-empty variable name"));
362 /* If the variable already exists, just change its initial value. */
363 tsv = find_trace_state_variable (internalvar_name (intvar));
366 tsv->initial_value = initval;
367 printf_filtered (_("Trace state variable $%s "
368 "now has initial value %s.\n"),
369 tsv->name, plongest (tsv->initial_value));
370 do_cleanups (old_chain);
374 /* Create a new variable. */
375 tsv = create_trace_state_variable (internalvar_name (intvar));
376 tsv->initial_value = initval;
378 printf_filtered (_("Trace state variable $%s "
379 "created, with initial value %s.\n"),
380 tsv->name, plongest (tsv->initial_value));
382 do_cleanups (old_chain);
386 delete_trace_variable_command (char *args, int from_tty)
390 struct cleanup *back_to;
394 if (query (_("Delete all trace state variables? ")))
395 VEC_free (tsv_s, tvariables);
400 argv = gdb_buildargv (args);
401 back_to = make_cleanup_freeargv (argv);
403 for (ix = 0; argv[ix] != NULL; ix++)
405 if (*argv[ix] == '$')
406 delete_trace_state_variable (argv[ix] + 1);
408 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv[ix]);
411 do_cleanups (back_to);
417 tvariables_info_1 (void)
419 struct trace_state_variable *tsv;
422 struct cleanup *back_to;
424 if (VEC_length (tsv_s, tvariables) == 0 && !ui_out_is_mi_like_p (uiout))
426 printf_filtered (_("No trace state variables.\n"));
430 /* Try to acquire values from the target. */
431 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix, ++count)
432 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
435 back_to = make_cleanup_ui_out_table_begin_end (uiout, 3,
436 count, "trace-variables");
437 ui_out_table_header (uiout, 15, ui_left, "name", "Name");
438 ui_out_table_header (uiout, 11, ui_left, "initial", "Initial");
439 ui_out_table_header (uiout, 11, ui_left, "current", "Current");
441 ui_out_table_body (uiout);
443 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
445 struct cleanup *back_to2;
449 back_to2 = make_cleanup_ui_out_tuple_begin_end (uiout, "variable");
451 name = concat ("$", tsv->name, (char *) NULL);
452 make_cleanup (xfree, name);
453 ui_out_field_string (uiout, "name", name);
454 ui_out_field_string (uiout, "initial", plongest (tsv->initial_value));
456 if (tsv->value_known)
457 c = plongest (tsv->value);
458 else if (ui_out_is_mi_like_p (uiout))
459 /* For MI, we prefer not to use magic string constants, but rather
460 omit the field completely. The difference between unknown and
461 undefined does not seem important enough to represent. */
463 else if (current_trace_status ()->running || traceframe_number >= 0)
464 /* The value is/was defined, but we don't have it. */
467 /* It is not meaningful to ask about the value. */
470 ui_out_field_string (uiout, "current", c);
471 ui_out_text (uiout, "\n");
473 do_cleanups (back_to2);
476 do_cleanups (back_to);
479 /* List all the trace state variables. */
482 tvariables_info (char *args, int from_tty)
484 tvariables_info_1 ();
487 /* Stash definitions of tsvs into the given file. */
490 save_trace_state_variables (struct ui_file *fp)
492 struct trace_state_variable *tsv;
495 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
497 fprintf_unfiltered (fp, "tvariable $%s", tsv->name);
498 if (tsv->initial_value)
499 fprintf_unfiltered (fp, " = %s", plongest (tsv->initial_value));
500 fprintf_unfiltered (fp, "\n");
504 /* ACTIONS functions: */
506 /* The three functions:
507 collect_pseudocommand,
508 while_stepping_pseudocommand, and
509 end_actions_pseudocommand
510 are placeholders for "commands" that are actually ONLY to be used
511 within a tracepoint action list. If the actual function is ever called,
512 it means that somebody issued the "command" at the top level,
513 which is always an error. */
516 end_actions_pseudocommand (char *args, int from_tty)
518 error (_("This command cannot be used at the top level."));
522 while_stepping_pseudocommand (char *args, int from_tty)
524 error (_("This command can only be used in a tracepoint actions list."));
528 collect_pseudocommand (char *args, int from_tty)
530 error (_("This command can only be used in a tracepoint actions list."));
534 teval_pseudocommand (char *args, int from_tty)
536 error (_("This command can only be used in a tracepoint actions list."));
539 /* Enter a list of actions for a tracepoint. */
541 trace_actions_command (char *args, int from_tty)
543 struct breakpoint *t;
544 struct command_line *l;
546 t = get_tracepoint_by_number (&args, 0, 1);
550 xstrprintf ("Enter actions for tracepoint %d, one per line.",
552 struct cleanup *cleanups = make_cleanup (xfree, tmpbuf);
554 l = read_command_lines (tmpbuf, from_tty, 1,
555 check_tracepoint_command, t);
556 do_cleanups (cleanups);
557 breakpoint_set_commands (t, l);
559 /* else just return */
562 /* Report the results of checking the agent expression, as errors or
566 report_agent_reqs_errors (struct agent_expr *aexpr)
568 /* All of the "flaws" are serious bytecode generation issues that
569 should never occur. */
570 if (aexpr->flaw != agent_flaw_none)
571 internal_error (__FILE__, __LINE__, _("expression is malformed"));
573 /* If analysis shows a stack underflow, GDB must have done something
574 badly wrong in its bytecode generation. */
575 if (aexpr->min_height < 0)
576 internal_error (__FILE__, __LINE__,
577 _("expression has min height < 0"));
579 /* Issue this error if the stack is predicted to get too deep. The
580 limit is rather arbitrary; a better scheme might be for the
581 target to report how much stack it will have available. The
582 depth roughly corresponds to parenthesization, so a limit of 20
583 amounts to 20 levels of expression nesting, which is actually
584 a pretty big hairy expression. */
585 if (aexpr->max_height > 20)
586 error (_("Expression is too complicated."));
589 /* worker function */
591 validate_actionline (char **line, struct breakpoint *t)
593 struct cmd_list_element *c;
594 struct expression *exp = NULL;
595 struct cleanup *old_chain = NULL;
597 struct bp_location *loc;
598 struct agent_expr *aexpr;
600 /* if EOF is typed, *line is NULL */
604 for (p = *line; isspace ((int) *p);)
607 /* Symbol lookup etc. */
608 if (*p == '\0') /* empty line: just prompt for another line. */
611 if (*p == '#') /* comment line */
614 c = lookup_cmd (&p, cmdlist, "", -1, 1);
616 error (_("`%s' is not a tracepoint action, or is ambiguous."), p);
618 if (cmd_cfunc_eq (c, collect_pseudocommand))
621 { /* repeat over a comma-separated list */
622 QUIT; /* allow user to bail out with ^C */
623 while (isspace ((int) *p))
626 if (*p == '$') /* look for special pseudo-symbols */
628 if (0 == strncasecmp ("reg", p + 1, 3)
629 || 0 == strncasecmp ("arg", p + 1, 3)
630 || 0 == strncasecmp ("loc", p + 1, 3)
631 || 0 == strncasecmp ("_sdata", p + 1, 6))
636 /* else fall thru, treat p as an expression and parse it! */
639 for (loc = t->loc; loc; loc = loc->next)
642 exp = parse_exp_1 (&p, block_for_pc (loc->address), 1);
643 old_chain = make_cleanup (free_current_contents, &exp);
645 if (exp->elts[0].opcode == OP_VAR_VALUE)
647 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
649 error (_("constant `%s' (value %ld) "
650 "will not be collected."),
651 SYMBOL_PRINT_NAME (exp->elts[2].symbol),
652 SYMBOL_VALUE (exp->elts[2].symbol));
654 else if (SYMBOL_CLASS (exp->elts[2].symbol)
655 == LOC_OPTIMIZED_OUT)
657 error (_("`%s' is optimized away "
658 "and cannot be collected."),
659 SYMBOL_PRINT_NAME (exp->elts[2].symbol));
663 /* We have something to collect, make sure that the expr to
664 bytecode translator can handle it and that it's not too
666 aexpr = gen_trace_for_expr (loc->address, exp);
667 make_cleanup_free_agent_expr (aexpr);
669 if (aexpr->len > MAX_AGENT_EXPR_LEN)
670 error (_("Expression is too complicated."));
674 report_agent_reqs_errors (aexpr);
676 do_cleanups (old_chain);
679 while (p && *p++ == ',');
682 else if (cmd_cfunc_eq (c, teval_pseudocommand))
685 { /* repeat over a comma-separated list */
686 QUIT; /* allow user to bail out with ^C */
687 while (isspace ((int) *p))
691 for (loc = t->loc; loc; loc = loc->next)
694 /* Only expressions are allowed for this action. */
695 exp = parse_exp_1 (&p, block_for_pc (loc->address), 1);
696 old_chain = make_cleanup (free_current_contents, &exp);
698 /* We have something to evaluate, make sure that the expr to
699 bytecode translator can handle it and that it's not too
701 aexpr = gen_eval_for_expr (loc->address, exp);
702 make_cleanup_free_agent_expr (aexpr);
704 if (aexpr->len > MAX_AGENT_EXPR_LEN)
705 error (_("Expression is too complicated."));
708 report_agent_reqs_errors (aexpr);
710 do_cleanups (old_chain);
713 while (p && *p++ == ',');
716 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
718 char *steparg; /* in case warning is necessary */
720 while (isspace ((int) *p))
724 if (*p == '\0' || (t->step_count = strtol (p, &p, 0)) == 0)
725 error (_("while-stepping step count `%s' is malformed."), *line);
728 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
732 error (_("`%s' is not a supported tracepoint action."), *line);
736 memrange_absolute = -1
741 int type; /* memrange_absolute for absolute memory range,
742 else basereg number */
743 bfd_signed_vma start;
747 struct collection_list
749 unsigned char regs_mask[32]; /* room for up to 256 regs */
752 struct memrange *list;
753 long aexpr_listsize; /* size of array pointed to by expr_list elt */
755 struct agent_expr **aexpr_list;
757 /* True is the user requested a collection of "$_sdata", "static
761 tracepoint_list, stepping_list;
763 /* MEMRANGE functions: */
765 static int memrange_cmp (const void *, const void *);
767 /* compare memranges for qsort */
769 memrange_cmp (const void *va, const void *vb)
771 const struct memrange *a = va, *b = vb;
773 if (a->type < b->type)
775 if (a->type > b->type)
777 if (a->type == memrange_absolute)
779 if ((bfd_vma) a->start < (bfd_vma) b->start)
781 if ((bfd_vma) a->start > (bfd_vma) b->start)
786 if (a->start < b->start)
788 if (a->start > b->start)
794 /* Sort the memrange list using qsort, and merge adjacent memranges. */
796 memrange_sortmerge (struct collection_list *memranges)
800 qsort (memranges->list, memranges->next_memrange,
801 sizeof (struct memrange), memrange_cmp);
802 if (memranges->next_memrange > 0)
804 for (a = 0, b = 1; b < memranges->next_memrange; b++)
806 if (memranges->list[a].type == memranges->list[b].type &&
807 memranges->list[b].start - memranges->list[a].end <=
810 /* memrange b starts before memrange a ends; merge them. */
811 if (memranges->list[b].end > memranges->list[a].end)
812 memranges->list[a].end = memranges->list[b].end;
813 continue; /* next b, same a */
817 memcpy (&memranges->list[a], &memranges->list[b],
818 sizeof (struct memrange));
820 memranges->next_memrange = a + 1;
824 /* Add a register to a collection list. */
826 add_register (struct collection_list *collection, unsigned int regno)
829 printf_filtered ("collect register %d\n", regno);
830 if (regno >= (8 * sizeof (collection->regs_mask)))
831 error (_("Internal: register number %d too large for tracepoint"),
833 collection->regs_mask[regno / 8] |= 1 << (regno % 8);
836 /* Add a memrange to a collection list */
838 add_memrange (struct collection_list *memranges,
839 int type, bfd_signed_vma base,
844 printf_filtered ("(%d,", type);
846 printf_filtered (",%ld)\n", len);
849 /* type: memrange_absolute == memory, other n == basereg */
850 memranges->list[memranges->next_memrange].type = type;
851 /* base: addr if memory, offset if reg relative. */
852 memranges->list[memranges->next_memrange].start = base;
853 /* len: we actually save end (base + len) for convenience */
854 memranges->list[memranges->next_memrange].end = base + len;
855 memranges->next_memrange++;
856 if (memranges->next_memrange >= memranges->listsize)
858 memranges->listsize *= 2;
859 memranges->list = xrealloc (memranges->list,
860 memranges->listsize);
863 if (type != memrange_absolute) /* Better collect the base register! */
864 add_register (memranges, type);
867 /* Add a symbol to a collection list. */
869 collect_symbol (struct collection_list *collect,
871 struct gdbarch *gdbarch,
872 long frame_regno, long frame_offset,
877 bfd_signed_vma offset;
878 int treat_as_expr = 0;
880 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
881 switch (SYMBOL_CLASS (sym))
884 printf_filtered ("%s: don't know symbol class %d\n",
885 SYMBOL_PRINT_NAME (sym),
889 printf_filtered ("constant %s (value %ld) will not be collected.\n",
890 SYMBOL_PRINT_NAME (sym), SYMBOL_VALUE (sym));
893 offset = SYMBOL_VALUE_ADDRESS (sym);
898 sprintf_vma (tmp, offset);
899 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
900 SYMBOL_PRINT_NAME (sym), len,
903 /* A struct may be a C++ class with static fields, go to general
904 expression handling. */
905 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
908 add_memrange (collect, memrange_absolute, offset, len);
911 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
913 printf_filtered ("LOC_REG[parm] %s: ",
914 SYMBOL_PRINT_NAME (sym));
915 add_register (collect, reg);
916 /* Check for doubles stored in two registers. */
917 /* FIXME: how about larger types stored in 3 or more regs? */
918 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
919 len > register_size (gdbarch, reg))
920 add_register (collect, reg + 1);
923 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
924 printf_filtered (" (will not collect %s)\n",
925 SYMBOL_PRINT_NAME (sym));
929 offset = frame_offset + SYMBOL_VALUE (sym);
932 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
933 SYMBOL_PRINT_NAME (sym), len);
935 printf_filtered (" from frame ptr reg %d\n", reg);
937 add_memrange (collect, reg, offset, len);
939 case LOC_REGPARM_ADDR:
940 reg = SYMBOL_VALUE (sym);
944 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
945 SYMBOL_PRINT_NAME (sym), len);
947 printf_filtered (" from reg %d\n", reg);
949 add_memrange (collect, reg, offset, len);
953 offset = frame_offset + SYMBOL_VALUE (sym);
956 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
957 SYMBOL_PRINT_NAME (sym), len);
959 printf_filtered (" from frame ptr reg %d\n", reg);
961 add_memrange (collect, reg, offset, len);
968 case LOC_OPTIMIZED_OUT:
969 printf_filtered ("%s has been optimized out of existence.\n",
970 SYMBOL_PRINT_NAME (sym));
978 /* Expressions are the most general case. */
981 struct agent_expr *aexpr;
982 struct cleanup *old_chain1 = NULL;
984 aexpr = gen_trace_for_var (scope, gdbarch, sym);
986 /* It can happen that the symbol is recorded as a computed
987 location, but it's been optimized away and doesn't actually
988 have a location expression. */
991 printf_filtered ("%s has been optimized out of existence.\n",
992 SYMBOL_PRINT_NAME (sym));
996 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1000 report_agent_reqs_errors (aexpr);
1002 discard_cleanups (old_chain1);
1003 add_aexpr (collect, aexpr);
1005 /* take care of the registers */
1006 if (aexpr->reg_mask_len > 0)
1010 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1012 QUIT; /* allow user to bail out with ^C */
1013 if (aexpr->reg_mask[ndx1] != 0)
1015 /* assume chars have 8 bits */
1016 for (ndx2 = 0; ndx2 < 8; ndx2++)
1017 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1018 /* it's used -- record it */
1019 add_register (collect, ndx1 * 8 + ndx2);
1026 /* Data to be passed around in the calls to the locals and args
1029 struct add_local_symbols_data
1031 struct collection_list *collect;
1032 struct gdbarch *gdbarch;
1039 /* The callback for the locals and args iterators */
1042 do_collect_symbol (const char *print_name,
1046 struct add_local_symbols_data *p = cb_data;
1048 collect_symbol (p->collect, sym, p->gdbarch, p->frame_regno,
1049 p->frame_offset, p->pc);
1053 /* Add all locals (or args) symbols to collection list */
1055 add_local_symbols (struct collection_list *collect,
1056 struct gdbarch *gdbarch, CORE_ADDR pc,
1057 long frame_regno, long frame_offset, int type)
1059 struct block *block;
1060 struct add_local_symbols_data cb_data;
1062 cb_data.collect = collect;
1063 cb_data.gdbarch = gdbarch;
1065 cb_data.frame_regno = frame_regno;
1066 cb_data.frame_offset = frame_offset;
1071 block = block_for_pc (pc);
1074 warning (_("Can't collect locals; "
1075 "no symbol table info available.\n"));
1079 iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1080 if (cb_data.count == 0)
1081 warning (_("No locals found in scope."));
1085 pc = get_pc_function_start (pc);
1086 block = block_for_pc (pc);
1089 warning (_("Can't collect args; no symbol table info available.\n"));
1093 iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1094 if (cb_data.count == 0)
1095 warning (_("No args found in scope."));
1100 add_static_trace_data (struct collection_list *collection)
1103 printf_filtered ("collect static trace data\n");
1104 collection->strace_data = 1;
1107 /* worker function */
1109 clear_collection_list (struct collection_list *list)
1113 list->next_memrange = 0;
1114 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1116 free_agent_expr (list->aexpr_list[ndx]);
1117 list->aexpr_list[ndx] = NULL;
1119 list->next_aexpr_elt = 0;
1120 memset (list->regs_mask, 0, sizeof (list->regs_mask));
1121 list->strace_data = 0;
1124 /* reduce a collection list to string form (for gdb protocol) */
1126 stringify_collection_list (struct collection_list *list, char *string)
1128 char temp_buf[2048];
1132 char *(*str_list)[];
1136 count = 1 + 1 + list->next_memrange + list->next_aexpr_elt + 1;
1137 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1139 if (list->strace_data)
1142 printf_filtered ("\nCollecting static trace data\n");
1145 (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
1149 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1150 if (list->regs_mask[i] != 0) /* skip leading zeroes in regs_mask */
1152 if (list->regs_mask[i] != 0) /* prepare to send regs_mask to the stub */
1155 printf_filtered ("\nCollecting registers (mask): 0x");
1160 QUIT; /* allow user to bail out with ^C */
1162 printf_filtered ("%02X", list->regs_mask[i]);
1163 sprintf (end, "%02X", list->regs_mask[i]);
1166 (*str_list)[ndx] = xstrdup (temp_buf);
1170 printf_filtered ("\n");
1171 if (list->next_memrange > 0 && info_verbose)
1172 printf_filtered ("Collecting memranges: \n");
1173 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1175 QUIT; /* allow user to bail out with ^C */
1176 sprintf_vma (tmp2, list->list[i].start);
1179 printf_filtered ("(%d, %s, %ld)\n",
1182 (long) (list->list[i].end - list->list[i].start));
1184 if (count + 27 > MAX_AGENT_EXPR_LEN)
1186 (*str_list)[ndx] = savestring (temp_buf, count);
1193 bfd_signed_vma length = list->list[i].end - list->list[i].start;
1195 /* The "%X" conversion specifier expects an unsigned argument,
1196 so passing -1 (memrange_absolute) to it directly gives you
1197 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1199 if (list->list[i].type == memrange_absolute)
1200 sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
1202 sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
1205 count += strlen (end);
1206 end = temp_buf + count;
1209 for (i = 0; i < list->next_aexpr_elt; i++)
1211 QUIT; /* allow user to bail out with ^C */
1212 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1214 (*str_list)[ndx] = savestring (temp_buf, count);
1219 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1220 end += 10; /* 'X' + 8 hex digits + ',' */
1223 end = mem2hex (list->aexpr_list[i]->buf,
1224 end, list->aexpr_list[i]->len);
1225 count += 2 * list->aexpr_list[i]->len;
1230 (*str_list)[ndx] = savestring (temp_buf, count);
1235 (*str_list)[ndx] = NULL;
1248 encode_actions_1 (struct command_line *action,
1249 struct breakpoint *t,
1250 struct bp_location *tloc,
1252 LONGEST frame_offset,
1253 struct collection_list *collect,
1254 struct collection_list *stepping_list)
1257 struct expression *exp = NULL;
1259 struct value *tempval;
1260 struct cmd_list_element *cmd;
1261 struct agent_expr *aexpr;
1263 for (; action; action = action->next)
1265 QUIT; /* allow user to bail out with ^C */
1266 action_exp = action->line;
1267 while (isspace ((int) *action_exp))
1270 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1272 error (_("Bad action list item: %s"), action_exp);
1274 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1277 { /* repeat over a comma-separated list */
1278 QUIT; /* allow user to bail out with ^C */
1279 while (isspace ((int) *action_exp))
1282 if (0 == strncasecmp ("$reg", action_exp, 4))
1284 for (i = 0; i < gdbarch_num_regs (t->gdbarch); i++)
1285 add_register (collect, i);
1286 action_exp = strchr (action_exp, ','); /* more? */
1288 else if (0 == strncasecmp ("$arg", action_exp, 4))
1290 add_local_symbols (collect,
1296 action_exp = strchr (action_exp, ','); /* more? */
1298 else if (0 == strncasecmp ("$loc", action_exp, 4))
1300 add_local_symbols (collect,
1306 action_exp = strchr (action_exp, ','); /* more? */
1308 else if (0 == strncasecmp ("$_sdata", action_exp, 7))
1310 add_static_trace_data (collect);
1311 action_exp = strchr (action_exp, ','); /* more? */
1315 unsigned long addr, len;
1316 struct cleanup *old_chain = NULL;
1317 struct cleanup *old_chain1 = NULL;
1319 exp = parse_exp_1 (&action_exp,
1320 block_for_pc (tloc->address), 1);
1321 old_chain = make_cleanup (free_current_contents, &exp);
1323 switch (exp->elts[0].opcode)
1327 const char *name = &exp->elts[2].string;
1329 i = user_reg_map_name_to_regnum (t->gdbarch,
1330 name, strlen (name));
1332 internal_error (__FILE__, __LINE__,
1333 _("Register $%s not available"),
1336 printf_filtered ("OP_REGISTER: ");
1337 add_register (collect, i);
1342 /* safe because we know it's a simple expression */
1343 tempval = evaluate_expression (exp);
1344 addr = value_address (tempval);
1345 len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
1346 add_memrange (collect, memrange_absolute, addr, len);
1350 collect_symbol (collect,
1351 exp->elts[2].symbol,
1358 default: /* full-fledged expression */
1359 aexpr = gen_trace_for_expr (tloc->address, exp);
1361 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1365 report_agent_reqs_errors (aexpr);
1367 discard_cleanups (old_chain1);
1368 add_aexpr (collect, aexpr);
1370 /* take care of the registers */
1371 if (aexpr->reg_mask_len > 0)
1376 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1378 QUIT; /* allow user to bail out with ^C */
1379 if (aexpr->reg_mask[ndx1] != 0)
1381 /* assume chars have 8 bits */
1382 for (ndx2 = 0; ndx2 < 8; ndx2++)
1383 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1384 /* it's used -- record it */
1385 add_register (collect,
1392 do_cleanups (old_chain);
1395 while (action_exp && *action_exp++ == ',');
1397 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1400 { /* repeat over a comma-separated list */
1401 QUIT; /* allow user to bail out with ^C */
1402 while (isspace ((int) *action_exp))
1406 struct cleanup *old_chain = NULL;
1407 struct cleanup *old_chain1 = NULL;
1409 exp = parse_exp_1 (&action_exp,
1410 block_for_pc (tloc->address), 1);
1411 old_chain = make_cleanup (free_current_contents, &exp);
1413 aexpr = gen_eval_for_expr (tloc->address, exp);
1414 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1417 report_agent_reqs_errors (aexpr);
1419 discard_cleanups (old_chain1);
1420 /* Even though we're not officially collecting, add
1421 to the collect list anyway. */
1422 add_aexpr (collect, aexpr);
1424 do_cleanups (old_chain);
1427 while (action_exp && *action_exp++ == ',');
1429 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1431 /* We check against nested while-stepping when setting
1432 breakpoint action, so no way to run into nested
1434 gdb_assert (stepping_list);
1436 encode_actions_1 (action->body_list[0], t, tloc, frame_reg,
1437 frame_offset, stepping_list, NULL);
1440 error (_("Invalid tracepoint command '%s'"), action->line);
1444 /* Render all actions into gdb protocol. */
1446 encode_actions (struct breakpoint *t, struct bp_location *tloc,
1447 char ***tdp_actions, char ***stepping_actions)
1449 static char tdp_buff[2048], step_buff[2048];
1450 char *default_collect_line = NULL;
1451 struct command_line *actions;
1452 struct command_line *default_collect_action = NULL;
1454 LONGEST frame_offset;
1455 struct cleanup *back_to;
1457 back_to = make_cleanup (null_cleanup, NULL);
1459 clear_collection_list (&tracepoint_list);
1460 clear_collection_list (&stepping_list);
1462 *tdp_actions = NULL;
1463 *stepping_actions = NULL;
1465 gdbarch_virtual_frame_pointer (t->gdbarch,
1466 t->loc->address, &frame_reg, &frame_offset);
1468 actions = breakpoint_commands (t);
1470 /* If there are default expressions to collect, make up a collect
1471 action and prepend to the action list to encode. Note that since
1472 validation is per-tracepoint (local var "xyz" might be valid for
1473 one tracepoint and not another, etc), we make up the action on
1474 the fly, and don't cache it. */
1475 if (*default_collect)
1479 default_collect_line = xstrprintf ("collect %s", default_collect);
1480 make_cleanup (xfree, default_collect_line);
1482 line = default_collect_line;
1483 validate_actionline (&line, t);
1485 default_collect_action = xmalloc (sizeof (struct command_line));
1486 make_cleanup (xfree, default_collect_action);
1487 default_collect_action->next = actions;
1488 default_collect_action->line = line;
1489 actions = default_collect_action;
1491 encode_actions_1 (actions, t, tloc, frame_reg, frame_offset,
1492 &tracepoint_list, &stepping_list);
1494 memrange_sortmerge (&tracepoint_list);
1495 memrange_sortmerge (&stepping_list);
1497 *tdp_actions = stringify_collection_list (&tracepoint_list,
1499 *stepping_actions = stringify_collection_list (&stepping_list,
1502 do_cleanups (back_to);
1506 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1508 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1510 collect->aexpr_list =
1511 xrealloc (collect->aexpr_list,
1512 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1513 collect->aexpr_listsize *= 2;
1515 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1516 collect->next_aexpr_elt++;
1521 start_tracing (void)
1523 VEC(breakpoint_p) *tp_vec = NULL;
1525 struct breakpoint *t;
1526 struct trace_state_variable *tsv;
1527 int any_enabled = 0, num_to_download = 0;
1529 tp_vec = all_tracepoints ();
1531 /* No point in tracing without any tracepoints... */
1532 if (VEC_length (breakpoint_p, tp_vec) == 0)
1534 VEC_free (breakpoint_p, tp_vec);
1535 error (_("No tracepoints defined, not starting trace"));
1538 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1540 if (t->enable_state == bp_enabled)
1543 if ((t->type == bp_fast_tracepoint
1544 ? may_insert_fast_tracepoints
1545 : may_insert_tracepoints))
1548 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1549 (t->type == bp_fast_tracepoint ? "fast " : ""), t->number);
1552 /* No point in tracing with only disabled tracepoints. */
1555 VEC_free (breakpoint_p, tp_vec);
1556 error (_("No tracepoints enabled, not starting trace"));
1559 if (num_to_download <= 0)
1561 VEC_free (breakpoint_p, tp_vec);
1562 error (_("No tracepoints that may be downloaded, not starting trace"));
1565 target_trace_init ();
1567 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1569 if ((t->type == bp_fast_tracepoint
1570 ? !may_insert_fast_tracepoints
1571 : !may_insert_tracepoints))
1574 t->number_on_target = 0;
1575 target_download_tracepoint (t);
1576 t->number_on_target = t->number;
1578 VEC_free (breakpoint_p, tp_vec);
1580 /* Send down all the trace state variables too. */
1581 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1583 target_download_trace_state_variable (tsv);
1586 /* Tell target to treat text-like sections as transparent. */
1587 target_trace_set_readonly_regions ();
1588 /* Set some mode flags. */
1589 target_set_disconnected_tracing (disconnected_tracing);
1590 target_set_circular_trace_buffer (circular_trace_buffer);
1592 /* Now insert traps and begin collecting data. */
1593 target_trace_start ();
1595 /* Reset our local state. */
1596 set_traceframe_num (-1);
1597 set_tracepoint_num (-1);
1598 set_traceframe_context (NULL);
1599 current_trace_status()->running = 1;
1604 Tell target to clear any previous trace experiment.
1605 Walk the list of tracepoints, and send them (and their actions)
1606 to the target. If no errors,
1607 Tell target to start a new trace experiment. */
1610 trace_start_command (char *args, int from_tty)
1612 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1614 if (current_trace_status ()->running)
1617 && !query (_("A trace is running already. Start a new run? ")))
1618 error (_("New trace run not started."));
1626 trace_stop_command (char *args, int from_tty)
1628 if (!current_trace_status ()->running)
1629 error (_("Trace is not running."));
1637 target_trace_stop ();
1638 /* should change in response to reply? */
1639 current_trace_status ()->running = 0;
1642 /* tstatus command */
1644 trace_status_command (char *args, int from_tty)
1646 struct trace_status *ts = current_trace_status ();
1649 status = target_get_trace_status (ts);
1654 printf_filtered (_("Using a trace file.\n"));
1657 printf_filtered (_("Trace can not be run on this target.\n"));
1662 if (!ts->running_known)
1664 printf_filtered (_("Run/stop status is unknown.\n"));
1666 else if (ts->running)
1668 printf_filtered (_("Trace is running on the target.\n"));
1672 switch (ts->stop_reason)
1674 case trace_never_run:
1675 printf_filtered (_("No trace has been run on the target.\n"));
1678 printf_filtered (_("Trace stopped by a tstop command.\n"));
1680 case trace_buffer_full:
1681 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1683 case trace_disconnected:
1684 printf_filtered (_("Trace stopped because of disconnection.\n"));
1686 case tracepoint_passcount:
1687 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1688 ts->stopping_tracepoint);
1690 case tracepoint_error:
1691 if (ts->stopping_tracepoint)
1692 printf_filtered (_("Trace stopped by an "
1693 "error (%s, tracepoint %d).\n"),
1694 ts->error_desc, ts->stopping_tracepoint);
1696 printf_filtered (_("Trace stopped by an error (%s).\n"),
1699 case trace_stop_reason_unknown:
1700 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1703 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1709 if (ts->traceframes_created >= 0
1710 && ts->traceframe_count != ts->traceframes_created)
1712 printf_filtered (_("Buffer contains %d trace "
1713 "frames (of %d created total).\n"),
1714 ts->traceframe_count, ts->traceframes_created);
1716 else if (ts->traceframe_count >= 0)
1718 printf_filtered (_("Collected %d trace frames.\n"),
1719 ts->traceframe_count);
1722 if (ts->buffer_free >= 0)
1724 if (ts->buffer_size >= 0)
1726 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1727 ts->buffer_free, ts->buffer_size);
1728 if (ts->buffer_size > 0)
1729 printf_filtered (_(" (%d%% full)"),
1730 ((int) ((((long long) (ts->buffer_size
1731 - ts->buffer_free)) * 100)
1732 / ts->buffer_size)));
1733 printf_filtered (_(".\n"));
1736 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1740 if (ts->disconnected_tracing)
1741 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1743 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1745 if (ts->circular_buffer)
1746 printf_filtered (_("Trace buffer is circular.\n"));
1748 /* Now report on what we're doing with tfind. */
1749 if (traceframe_number >= 0)
1750 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1751 traceframe_number, tracepoint_number);
1753 printf_filtered (_("Not looking at any trace frame.\n"));
1756 /* Report the trace status to uiout, in a way suitable for MI, and not
1757 suitable for CLI. If ON_STOP is true, suppress a few fields that
1758 are not meaningful in the -trace-stop response.
1760 The implementation is essentially parallel to trace_status_command, but
1761 merging them will result in unreadable code. */
1763 trace_status_mi (int on_stop)
1765 struct trace_status *ts = current_trace_status ();
1768 status = target_get_trace_status (ts);
1770 if (status == -1 && !ts->from_file)
1772 ui_out_field_string (uiout, "supported", "0");
1777 ui_out_field_string (uiout, "supported", "file");
1779 ui_out_field_string (uiout, "supported", "1");
1781 gdb_assert (ts->running_known);
1785 ui_out_field_string (uiout, "running", "1");
1787 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1788 Given that the frontend gets the status either on -trace-stop, or from
1789 -trace-status after re-connection, it does not seem like this
1790 information is necessary for anything. It is not necessary for either
1791 figuring the vital state of the target nor for navigation of trace
1792 frames. If the frontend wants to show the current state is some
1793 configure dialog, it can request the value when such dialog is
1794 invoked by the user. */
1798 char *stop_reason = NULL;
1799 int stopping_tracepoint = -1;
1802 ui_out_field_string (uiout, "running", "0");
1804 if (ts->stop_reason != trace_stop_reason_unknown)
1806 switch (ts->stop_reason)
1809 stop_reason = "request";
1811 case trace_buffer_full:
1812 stop_reason = "overflow";
1814 case trace_disconnected:
1815 stop_reason = "disconnection";
1817 case tracepoint_passcount:
1818 stop_reason = "passcount";
1819 stopping_tracepoint = ts->stopping_tracepoint;
1821 case tracepoint_error:
1822 stop_reason = "error";
1823 stopping_tracepoint = ts->stopping_tracepoint;
1829 ui_out_field_string (uiout, "stop-reason", stop_reason);
1830 if (stopping_tracepoint != -1)
1831 ui_out_field_int (uiout, "stopping-tracepoint",
1832 stopping_tracepoint);
1833 if (ts->stop_reason == tracepoint_error)
1834 ui_out_field_string (uiout, "error-description",
1840 if (ts->traceframe_count != -1)
1841 ui_out_field_int (uiout, "frames", ts->traceframe_count);
1842 if (ts->traceframes_created != -1)
1843 ui_out_field_int (uiout, "frames-created", ts->traceframes_created);
1844 if (ts->buffer_size != -1)
1845 ui_out_field_int (uiout, "buffer-size", ts->buffer_size);
1846 if (ts->buffer_free != -1)
1847 ui_out_field_int (uiout, "buffer-free", ts->buffer_free);
1849 ui_out_field_int (uiout, "disconnected", ts->disconnected_tracing);
1850 ui_out_field_int (uiout, "circular", ts->circular_buffer);
1853 /* This function handles the details of what to do about an ongoing
1854 tracing run if the user has asked to detach or otherwise disconnect
1857 disconnect_tracing (int from_tty)
1859 /* It can happen that the target that was tracing went away on its
1860 own, and we didn't notice. Get a status update, and if the
1861 current target doesn't even do tracing, then assume it's not
1863 if (target_get_trace_status (current_trace_status ()) < 0)
1864 current_trace_status ()->running = 0;
1866 /* If running interactively, give the user the option to cancel and
1867 then decide what to do differently with the run. Scripts are
1868 just going to disconnect and let the target deal with it,
1869 according to how it's been instructed previously via
1870 disconnected-tracing. */
1871 if (current_trace_status ()->running && from_tty)
1873 if (current_trace_status ()->disconnected_tracing)
1875 if (!query (_("Trace is running and will "
1876 "continue after detach; detach anyway? ")))
1877 error (_("Not confirmed."));
1881 if (!query (_("Trace is running but will "
1882 "stop on detach; detach anyway? ")))
1883 error (_("Not confirmed."));
1887 /* Also we want to be out of tfind mode, otherwise things can get
1888 confusing upon reconnection. Just use these calls instead of
1889 full tfind_1 behavior because we're in the middle of detaching,
1890 and there's no point to updating current stack frame etc. */
1891 set_traceframe_number (-1);
1892 set_traceframe_context (NULL);
1895 /* Worker function for the various flavors of the tfind command. */
1897 tfind_1 (enum trace_find_type type, int num,
1898 ULONGEST addr1, ULONGEST addr2,
1901 int target_frameno = -1, target_tracept = -1;
1902 struct frame_id old_frame_id = null_frame_id;
1903 struct breakpoint *tp;
1905 /* Only try to get the current stack frame if we have a chance of
1906 succeeding. In particular, if we're trying to get a first trace
1907 frame while all threads are running, it's not going to succeed,
1908 so leave it with a default value and let the frame comparison
1909 below (correctly) decide to print out the source location of the
1911 if (!(type == tfind_number && num == -1)
1912 && (has_stack_frames () || traceframe_number >= 0))
1913 old_frame_id = get_frame_id (get_current_frame ());
1915 target_frameno = target_trace_find (type, num, addr1, addr2,
1918 if (type == tfind_number
1920 && target_frameno == -1)
1922 /* We told the target to get out of tfind mode, and it did. */
1924 else if (target_frameno == -1)
1926 /* A request for a non-existent trace frame has failed.
1927 Our response will be different, depending on FROM_TTY:
1929 If FROM_TTY is true, meaning that this command was
1930 typed interactively by the user, then give an error
1931 and DO NOT change the state of traceframe_number etc.
1933 However if FROM_TTY is false, meaning that we're either
1934 in a script, a loop, or a user-defined command, then
1935 DON'T give an error, but DO change the state of
1936 traceframe_number etc. to invalid.
1938 The rationalle is that if you typed the command, you
1939 might just have committed a typo or something, and you'd
1940 like to NOT lose your current debugging state. However
1941 if you're in a user-defined command or especially in a
1942 loop, then you need a way to detect that the command
1943 failed WITHOUT aborting. This allows you to write
1944 scripts that search thru the trace buffer until the end,
1945 and then continue on to do something else. */
1948 error (_("Target failed to find requested trace frame."));
1952 printf_filtered ("End of trace buffer.\n");
1953 #if 0 /* dubious now? */
1954 /* The following will not recurse, since it's
1956 trace_find_command ("-1", from_tty);
1961 tp = get_tracepoint_by_number_on_target (target_tracept);
1963 reinit_frame_cache ();
1964 registers_changed ();
1965 target_dcache_invalidate ();
1966 set_traceframe_num (target_frameno);
1967 set_tracepoint_num (tp ? tp->number : target_tracept);
1968 if (target_frameno == -1)
1969 set_traceframe_context (NULL);
1971 set_traceframe_context (get_current_frame ());
1973 if (traceframe_number >= 0)
1975 /* Use different branches for MI and CLI to make CLI messages
1977 if (ui_out_is_mi_like_p (uiout))
1979 ui_out_field_string (uiout, "found", "1");
1980 ui_out_field_int (uiout, "tracepoint", tracepoint_number);
1981 ui_out_field_int (uiout, "traceframe", traceframe_number);
1985 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
1986 traceframe_number, tracepoint_number);
1991 if (ui_out_is_mi_like_p (uiout))
1992 ui_out_field_string (uiout, "found", "0");
1993 else if (type == tfind_number && num == -1)
1994 printf_unfiltered (_("No longer looking at any trace frame\n"));
1995 else /* this case may never occur, check */
1996 printf_unfiltered (_("No trace frame found\n"));
1999 /* If we're in nonstop mode and getting out of looking at trace
2000 frames, there won't be any current frame to go back to and
2003 && (has_stack_frames () || traceframe_number >= 0))
2005 enum print_what print_what;
2007 /* NOTE: in imitation of the step command, try to determine
2008 whether we have made a transition from one function to
2009 another. If so, we'll print the "stack frame" (ie. the new
2010 function and it's arguments) -- otherwise we'll just show the
2013 if (frame_id_eq (old_frame_id,
2014 get_frame_id (get_current_frame ())))
2015 print_what = SRC_LINE;
2017 print_what = SRC_AND_LOC;
2019 print_stack_frame (get_selected_frame (NULL), 1, print_what);
2024 /* trace_find_command takes a trace frame number n,
2025 sends "QTFrame:<n>" to the target,
2026 and accepts a reply that may contain several optional pieces
2027 of information: a frame number, a tracepoint number, and an
2028 indication of whether this is a trap frame or a stepping frame.
2030 The minimal response is just "OK" (which indicates that the
2031 target does not give us a frame number or a tracepoint number).
2032 Instead of that, the target may send us a string containing
2034 F<hexnum> (gives the selected frame number)
2035 T<hexnum> (gives the selected tracepoint number)
2040 trace_find_command (char *args, int from_tty)
2041 { /* this should only be called with a numeric argument */
2044 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2045 error (_("May not look at trace frames while trace is running."));
2047 if (args == 0 || *args == 0)
2048 { /* TFIND with no args means find NEXT trace frame. */
2049 if (traceframe_number == -1)
2050 frameno = 0; /* "next" is first one */
2052 frameno = traceframe_number + 1;
2054 else if (0 == strcmp (args, "-"))
2056 if (traceframe_number == -1)
2057 error (_("not debugging trace buffer"));
2058 else if (from_tty && traceframe_number == 0)
2059 error (_("already at start of trace buffer"));
2061 frameno = traceframe_number - 1;
2063 /* A hack to work around eval's need for fp to have been collected. */
2064 else if (0 == strcmp (args, "-1"))
2067 frameno = parse_and_eval_long (args);
2070 error (_("invalid input (%d is less than zero)"), frameno);
2072 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2077 trace_find_end_command (char *args, int from_tty)
2079 trace_find_command ("-1", from_tty);
2084 trace_find_none_command (char *args, int from_tty)
2086 trace_find_command ("-1", from_tty);
2091 trace_find_start_command (char *args, int from_tty)
2093 trace_find_command ("0", from_tty);
2096 /* tfind pc command */
2098 trace_find_pc_command (char *args, int from_tty)
2102 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2103 error (_("May not look at trace frames while trace is running."));
2105 if (args == 0 || *args == 0)
2106 pc = regcache_read_pc (get_current_regcache ());
2108 pc = parse_and_eval_address (args);
2110 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2113 /* tfind tracepoint command */
2115 trace_find_tracepoint_command (char *args, int from_tty)
2118 struct breakpoint *tp;
2120 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2121 error (_("May not look at trace frames while trace is running."));
2123 if (args == 0 || *args == 0)
2125 if (tracepoint_number == -1)
2126 error (_("No current tracepoint -- please supply an argument."));
2128 tdp = tracepoint_number; /* default is current TDP */
2131 tdp = parse_and_eval_long (args);
2133 /* If we have the tracepoint on hand, use the number that the
2134 target knows about (which may be different if we disconnected
2135 and reconnected). */
2136 tp = get_tracepoint (tdp);
2138 tdp = tp->number_on_target;
2140 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2143 /* TFIND LINE command:
2145 This command will take a sourceline for argument, just like BREAK
2146 or TRACE (ie. anything that "decode_line_1" can handle).
2148 With no argument, this command will find the next trace frame
2149 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2152 trace_find_line_command (char *args, int from_tty)
2154 static CORE_ADDR start_pc, end_pc;
2155 struct symtabs_and_lines sals;
2156 struct symtab_and_line sal;
2157 struct cleanup *old_chain;
2159 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2160 error (_("May not look at trace frames while trace is running."));
2162 if (args == 0 || *args == 0)
2164 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2166 sals.sals = (struct symtab_and_line *)
2167 xmalloc (sizeof (struct symtab_and_line));
2172 sals = decode_line_spec (args, 1);
2176 old_chain = make_cleanup (xfree, sals.sals);
2177 if (sal.symtab == 0)
2178 error (_("No line number information available."));
2180 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2182 if (start_pc == end_pc)
2184 printf_filtered ("Line %d of \"%s\"",
2185 sal.line, sal.symtab->filename);
2187 printf_filtered (" is at address ");
2188 print_address (get_current_arch (), start_pc, gdb_stdout);
2190 printf_filtered (" but contains no code.\n");
2191 sal = find_pc_line (start_pc, 0);
2193 && find_line_pc_range (sal, &start_pc, &end_pc)
2194 && start_pc != end_pc)
2195 printf_filtered ("Attempting to find line %d instead.\n",
2198 error (_("Cannot find a good line."));
2202 /* Is there any case in which we get here, and have an address
2203 which the user would want to see? If we have debugging
2204 symbols and no line numbers? */
2205 error (_("Line number %d is out of range for \"%s\"."),
2206 sal.line, sal.symtab->filename);
2208 /* Find within range of stated line. */
2210 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2212 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2213 do_cleanups (old_chain);
2216 /* tfind range command */
2218 trace_find_range_command (char *args, int from_tty)
2220 static CORE_ADDR start, stop;
2223 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2224 error (_("May not look at trace frames while trace is running."));
2226 if (args == 0 || *args == 0)
2227 { /* XXX FIXME: what should default behavior be? */
2228 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2232 if (0 != (tmp = strchr (args, ',')))
2234 *tmp++ = '\0'; /* terminate start address */
2235 while (isspace ((int) *tmp))
2237 start = parse_and_eval_address (args);
2238 stop = parse_and_eval_address (tmp);
2241 { /* no explicit end address? */
2242 start = parse_and_eval_address (args);
2243 stop = start + 1; /* ??? */
2246 tfind_1 (tfind_range, 0, start, stop, from_tty);
2249 /* tfind outside command */
2251 trace_find_outside_command (char *args, int from_tty)
2253 CORE_ADDR start, stop;
2256 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2257 error (_("May not look at trace frames while trace is running."));
2259 if (args == 0 || *args == 0)
2260 { /* XXX FIXME: what should default behavior be? */
2261 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2265 if (0 != (tmp = strchr (args, ',')))
2267 *tmp++ = '\0'; /* terminate start address */
2268 while (isspace ((int) *tmp))
2270 start = parse_and_eval_address (args);
2271 stop = parse_and_eval_address (tmp);
2274 { /* no explicit end address? */
2275 start = parse_and_eval_address (args);
2276 stop = start + 1; /* ??? */
2279 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2282 /* info scope command: list the locals for a scope. */
2284 scope_info (char *args, int from_tty)
2286 struct symtabs_and_lines sals;
2288 struct minimal_symbol *msym;
2289 struct block *block;
2290 char **canonical, *symname, *save_args = args;
2291 struct dict_iterator iter;
2293 struct gdbarch *gdbarch;
2296 if (args == 0 || *args == 0)
2297 error (_("requires an argument (function, "
2298 "line or *addr) to define a scope"));
2300 sals = decode_line_1 (&args, 1, NULL, 0, &canonical, NULL);
2301 if (sals.nelts == 0)
2302 return; /* presumably decode_line_1 has already warned */
2304 /* Resolve line numbers to PC */
2305 resolve_sal_pc (&sals.sals[0]);
2306 block = block_for_pc (sals.sals[0].pc);
2310 QUIT; /* allow user to bail out with ^C */
2311 ALL_BLOCK_SYMBOLS (block, iter, sym)
2313 QUIT; /* allow user to bail out with ^C */
2315 printf_filtered ("Scope for %s:\n", save_args);
2318 symname = SYMBOL_PRINT_NAME (sym);
2319 if (symname == NULL || *symname == '\0')
2320 continue; /* probably botched, certainly useless */
2322 gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
2324 printf_filtered ("Symbol %s is ", symname);
2325 switch (SYMBOL_CLASS (sym))
2328 case LOC_UNDEF: /* messed up symbol? */
2329 printf_filtered ("a bogus symbol, class %d.\n",
2330 SYMBOL_CLASS (sym));
2331 count--; /* don't count this one */
2334 printf_filtered ("a constant with value %ld (0x%lx)",
2335 SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
2337 case LOC_CONST_BYTES:
2338 printf_filtered ("constant bytes: ");
2339 if (SYMBOL_TYPE (sym))
2340 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2341 fprintf_filtered (gdb_stdout, " %02x",
2342 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2345 printf_filtered ("in static storage at address ");
2346 printf_filtered ("%s", paddress (gdbarch,
2347 SYMBOL_VALUE_ADDRESS (sym)));
2350 /* GDBARCH is the architecture associated with the objfile
2351 the symbol is defined in; the target architecture may be
2352 different, and may provide additional registers. However,
2353 we do not know the target architecture at this point.
2354 We assume the objfile architecture will contain all the
2355 standard registers that occur in debug info in that
2357 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2360 if (SYMBOL_IS_ARGUMENT (sym))
2361 printf_filtered ("an argument in register $%s",
2362 gdbarch_register_name (gdbarch, regno));
2364 printf_filtered ("a local variable in register $%s",
2365 gdbarch_register_name (gdbarch, regno));
2368 printf_filtered ("an argument at stack/frame offset %ld",
2369 SYMBOL_VALUE (sym));
2372 printf_filtered ("a local variable at frame offset %ld",
2373 SYMBOL_VALUE (sym));
2376 printf_filtered ("a reference argument at offset %ld",
2377 SYMBOL_VALUE (sym));
2379 case LOC_REGPARM_ADDR:
2380 /* Note comment at LOC_REGISTER. */
2381 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2383 printf_filtered ("the address of an argument, in register $%s",
2384 gdbarch_register_name (gdbarch, regno));
2387 printf_filtered ("a typedef.\n");
2390 printf_filtered ("a label at address ");
2391 printf_filtered ("%s", paddress (gdbarch,
2392 SYMBOL_VALUE_ADDRESS (sym)));
2395 printf_filtered ("a function at address ");
2396 printf_filtered ("%s",
2397 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2399 case LOC_UNRESOLVED:
2400 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2403 printf_filtered ("Unresolved Static");
2406 printf_filtered ("static storage at address ");
2407 printf_filtered ("%s",
2408 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msym)));
2411 case LOC_OPTIMIZED_OUT:
2412 printf_filtered ("optimized out.\n");
2415 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2416 BLOCK_START (block),
2420 if (SYMBOL_TYPE (sym))
2421 printf_filtered (", length %d.\n",
2422 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2424 if (BLOCK_FUNCTION (block))
2427 block = BLOCK_SUPERBLOCK (block);
2430 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2434 /* worker function (cleanup) */
2436 replace_comma (void *data)
2443 /* Helper for trace_dump_command. Dump the action list starting at
2444 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2445 actions of the body of a while-stepping action. STEPPING_FRAME is
2446 set if the current traceframe was determined to be a while-stepping
2450 trace_dump_actions (struct command_line *action,
2451 int stepping_actions, int stepping_frame,
2454 char *action_exp, *next_comma;
2456 for (; action != NULL; action = action->next)
2458 struct cmd_list_element *cmd;
2460 QUIT; /* allow user to bail out with ^C */
2461 action_exp = action->line;
2462 while (isspace ((int) *action_exp))
2465 /* The collection actions to be done while stepping are
2466 bracketed by the commands "while-stepping" and "end". */
2468 if (*action_exp == '#') /* comment line */
2471 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2473 error (_("Bad action list item: %s"), action_exp);
2475 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2479 for (i = 0; i < action->body_count; ++i)
2480 trace_dump_actions (action->body_list[i],
2481 1, stepping_frame, from_tty);
2483 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2485 /* Display the collected data.
2486 For the trap frame, display only what was collected at
2487 the trap. Likewise for stepping frames, display only
2488 what was collected while stepping. This means that the
2489 two boolean variables, STEPPING_FRAME and
2490 STEPPING_ACTIONS should be equal. */
2491 if (stepping_frame == stepping_actions)
2494 { /* repeat over a comma-separated list */
2495 QUIT; /* allow user to bail out with ^C */
2496 if (*action_exp == ',')
2498 while (isspace ((int) *action_exp))
2501 next_comma = strchr (action_exp, ',');
2503 if (0 == strncasecmp (action_exp, "$reg", 4))
2504 registers_info (NULL, from_tty);
2505 else if (0 == strncasecmp (action_exp, "$loc", 4))
2506 locals_info (NULL, from_tty);
2507 else if (0 == strncasecmp (action_exp, "$arg", 4))
2508 args_info (NULL, from_tty);
2513 make_cleanup (replace_comma, next_comma);
2516 printf_filtered ("%s = ", action_exp);
2517 output_command (action_exp, from_tty);
2518 printf_filtered ("\n");
2522 action_exp = next_comma;
2524 while (action_exp && *action_exp == ',');
2530 /* The tdump command. */
2533 trace_dump_command (char *args, int from_tty)
2535 struct regcache *regcache;
2536 struct breakpoint *t;
2537 int stepping_frame = 0;
2538 struct bp_location *loc;
2539 char *line, *default_collect_line = NULL;
2540 struct command_line *actions, *default_collect_action = NULL;
2541 struct cleanup *old_chain = NULL;
2543 if (tracepoint_number == -1)
2545 warning (_("No current trace frame."));
2549 t = get_tracepoint (tracepoint_number);
2552 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2555 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2556 tracepoint_number, traceframe_number);
2558 /* The current frame is a trap frame if the frame PC is equal
2559 to the tracepoint PC. If not, then the current frame was
2560 collected during single-stepping. */
2562 regcache = get_current_regcache ();
2564 /* If the traceframe's address matches any of the tracepoint's
2565 locations, assume it is a direct hit rather than a while-stepping
2566 frame. (FIXME this is not reliable, should record each frame's
2569 for (loc = t->loc; loc; loc = loc->next)
2570 if (loc->address == regcache_read_pc (regcache))
2573 actions = breakpoint_commands (t);
2575 /* If there is a default-collect list, make up a collect command,
2576 prepend to the tracepoint's commands, and pass the whole mess to
2577 the trace dump scanner. We need to validate because
2578 default-collect might have been junked since the trace run. */
2579 if (*default_collect)
2581 default_collect_line = xstrprintf ("collect %s", default_collect);
2582 old_chain = make_cleanup (xfree, default_collect_line);
2583 line = default_collect_line;
2584 validate_actionline (&line, t);
2585 default_collect_action = xmalloc (sizeof (struct command_line));
2586 make_cleanup (xfree, default_collect_action);
2587 default_collect_action->next = actions;
2588 default_collect_action->line = line;
2589 actions = default_collect_action;
2592 trace_dump_actions (actions, 0, stepping_frame, from_tty);
2594 if (*default_collect)
2595 do_cleanups (old_chain);
2598 /* Encode a piece of a tracepoint's source-level definition in a form
2599 that is suitable for both protocol and saving in files. */
2600 /* This version does not do multiple encodes for long strings; it should
2601 return an offset to the next piece to encode. FIXME */
2604 encode_source_string (int tpnum, ULONGEST addr,
2605 char *srctype, char *src, char *buf, int buf_size)
2607 if (80 + strlen (srctype) > buf_size)
2608 error (_("Buffer too small for source encoding"));
2609 sprintf (buf, "%x:%s:%s:%x:%x:",
2610 tpnum, phex_nz (addr, sizeof (addr)),
2611 srctype, 0, (int) strlen (src));
2612 if (strlen (buf) + strlen (src) * 2 >= buf_size)
2613 error (_("Source string too long for buffer"));
2614 bin2hex (src, buf + strlen (buf), 0);
2618 extern int trace_regblock_size;
2620 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2621 non-zero, the save is performed on the target, otherwise GDB obtains all
2622 trace data and saves it locally. */
2625 trace_save (const char *filename, int target_does_save)
2627 struct cleanup *cleanup;
2629 struct trace_status *ts = current_trace_status ();
2632 struct uploaded_tp *uploaded_tps = NULL, *utp;
2633 struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
2637 ULONGEST offset = 0;
2638 #define MAX_TRACE_UPLOAD 2000
2639 gdb_byte buf[MAX_TRACE_UPLOAD];
2642 /* If the target is to save the data to a file on its own, then just
2643 send the command and be done with it. */
2644 if (target_does_save)
2646 err = target_save_trace_data (filename);
2648 error (_("Target failed to save trace data to '%s'."),
2653 /* Get the trace status first before opening the file, so if the
2654 target is losing, we can get out without touching files. */
2655 status = target_get_trace_status (ts);
2657 pathname = tilde_expand (filename);
2658 cleanup = make_cleanup (xfree, pathname);
2660 fp = fopen (pathname, "wb");
2662 error (_("Unable to open file '%s' for saving trace data (%s)"),
2663 filename, safe_strerror (errno));
2664 make_cleanup_fclose (fp);
2666 /* Write a file header, with a high-bit-set char to indicate a
2667 binary file, plus a hint as what this file is, and a version
2668 number in case of future needs. */
2669 written = fwrite ("\x7fTRACE0\n", 8, 1, fp);
2671 perror_with_name (pathname);
2673 /* Write descriptive info. */
2675 /* Write out the size of a register block. */
2676 fprintf (fp, "R %x\n", trace_regblock_size);
2678 /* Write out status of the tracing run (aka "tstatus" info). */
2679 fprintf (fp, "status %c;%s",
2680 (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
2681 if (ts->stop_reason == tracepoint_error)
2683 char *buf = (char *) alloca (strlen (ts->error_desc) * 2 + 1);
2685 bin2hex ((gdb_byte *) ts->error_desc, buf, 0);
2686 fprintf (fp, ":%s", buf);
2688 fprintf (fp, ":%x", ts->stopping_tracepoint);
2689 if (ts->traceframe_count >= 0)
2690 fprintf (fp, ";tframes:%x", ts->traceframe_count);
2691 if (ts->traceframes_created >= 0)
2692 fprintf (fp, ";tcreated:%x", ts->traceframes_created);
2693 if (ts->buffer_free >= 0)
2694 fprintf (fp, ";tfree:%x", ts->buffer_free);
2695 if (ts->buffer_size >= 0)
2696 fprintf (fp, ";tsize:%x", ts->buffer_size);
2697 if (ts->disconnected_tracing)
2698 fprintf (fp, ";disconn:%x", ts->disconnected_tracing);
2699 if (ts->circular_buffer)
2700 fprintf (fp, ";circular:%x", ts->circular_buffer);
2703 /* Note that we want to upload tracepoints and save those, rather
2704 than simply writing out the local ones, because the user may have
2705 changed tracepoints in GDB in preparation for a future tracing
2706 run, or maybe just mass-deleted all types of breakpoints as part
2707 of cleaning up. So as not to contaminate the session, leave the
2708 data in its uploaded form, don't make into real tracepoints. */
2710 /* Get trace state variables first, they may be checked when parsing
2711 uploaded commands. */
2713 target_upload_trace_state_variables (&uploaded_tsvs);
2715 for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
2721 buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
2722 bin2hex ((gdb_byte *) (utsv->name), buf, 0);
2725 fprintf (fp, "tsv %x:%s:%x:%s\n",
2726 utsv->number, phex_nz (utsv->initial_value, 8),
2727 utsv->builtin, buf);
2733 free_uploaded_tsvs (&uploaded_tsvs);
2735 target_upload_tracepoints (&uploaded_tps);
2737 for (utp = uploaded_tps; utp; utp = utp->next)
2739 fprintf (fp, "tp T%x:%s:%c:%x:%x",
2740 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
2741 (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
2742 if (utp->type == bp_fast_tracepoint)
2743 fprintf (fp, ":F%x", utp->orig_size);
2745 fprintf (fp, ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
2748 for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
2749 fprintf (fp, "tp A%x:%s:%s\n",
2750 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
2751 for (a = 0; VEC_iterate (char_ptr, utp->step_actions, a, act); ++a)
2752 fprintf (fp, "tp S%x:%s:%s\n",
2753 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
2756 encode_source_string (utp->number, utp->addr,
2757 "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
2758 fprintf (fp, "tp Z%s\n", buf);
2760 if (utp->cond_string)
2762 encode_source_string (utp->number, utp->addr,
2763 "cond", utp->cond_string,
2764 buf, MAX_TRACE_UPLOAD);
2765 fprintf (fp, "tp Z%s\n", buf);
2767 for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
2769 encode_source_string (utp->number, utp->addr, "cmd", act,
2770 buf, MAX_TRACE_UPLOAD);
2771 fprintf (fp, "tp Z%s\n", buf);
2775 free_uploaded_tps (&uploaded_tps);
2777 /* Mark the end of the definition section. */
2780 /* Get and write the trace data proper. We ask for big blocks, in
2781 the hopes of efficiency, but will take less if the target has
2782 packet size limitations or some such. */
2785 gotten = target_get_raw_trace_data (buf, offset, MAX_TRACE_UPLOAD);
2787 error (_("Failure to get requested trace buffer data"));
2788 /* No more data is forthcoming, we're done. */
2791 written = fwrite (buf, gotten, 1, fp);
2793 perror_with_name (pathname);
2797 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
2798 written = fwrite (&gotten, 4, 1, fp);
2800 perror_with_name (pathname);
2802 do_cleanups (cleanup);
2806 trace_save_command (char *args, int from_tty)
2808 int target_does_save = 0;
2810 char *filename = NULL;
2811 struct cleanup *back_to;
2814 error_no_arg (_("file in which to save trace data"));
2816 argv = gdb_buildargv (args);
2817 back_to = make_cleanup_freeargv (argv);
2819 for (; *argv; ++argv)
2821 if (strcmp (*argv, "-r") == 0)
2822 target_does_save = 1;
2823 else if (**argv == '-')
2824 error (_("unknown option `%s'"), *argv);
2830 error_no_arg (_("file in which to save trace data"));
2832 trace_save (filename, target_does_save);
2835 printf_filtered (_("Trace data saved to file '%s'.\n"), args);
2837 do_cleanups (back_to);
2840 /* Tell the target what to do with an ongoing tracing run if GDB
2841 disconnects for some reason. */
2844 send_disconnected_tracing_value (int value)
2846 target_set_disconnected_tracing (value);
2850 set_disconnected_tracing (char *args, int from_tty,
2851 struct cmd_list_element *c)
2853 send_disconnected_tracing_value (disconnected_tracing);
2857 set_circular_trace_buffer (char *args, int from_tty,
2858 struct cmd_list_element *c)
2860 target_set_circular_trace_buffer (circular_trace_buffer);
2863 /* Convert the memory pointed to by mem into hex, placing result in buf.
2864 * Return a pointer to the last char put in buf (null)
2865 * "stolen" from sparc-stub.c
2868 static const char hexchars[] = "0123456789abcdef";
2871 mem2hex (gdb_byte *mem, char *buf, int count)
2879 *buf++ = hexchars[ch >> 4];
2880 *buf++ = hexchars[ch & 0xf];
2889 get_traceframe_number (void)
2891 return traceframe_number;
2894 /* Make the traceframe NUM be the current trace frame. Does nothing
2895 if NUM is already current. */
2898 set_traceframe_number (int num)
2902 if (traceframe_number == num)
2904 /* Nothing to do. */
2908 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
2911 warning (_("could not change traceframe"));
2913 traceframe_number = newnum;
2915 /* Changing the traceframe changes our view of registers and of the
2917 registers_changed ();
2920 /* A cleanup used when switching away and back from tfind mode. */
2922 struct current_traceframe_cleanup
2924 /* The traceframe we were inspecting. */
2925 int traceframe_number;
2929 do_restore_current_traceframe_cleanup (void *arg)
2931 struct current_traceframe_cleanup *old = arg;
2933 set_traceframe_number (old->traceframe_number);
2937 restore_current_traceframe_cleanup_dtor (void *arg)
2939 struct current_traceframe_cleanup *old = arg;
2945 make_cleanup_restore_current_traceframe (void)
2947 struct current_traceframe_cleanup *old;
2949 old = xmalloc (sizeof (struct current_traceframe_cleanup));
2950 old->traceframe_number = traceframe_number;
2952 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
2953 restore_current_traceframe_cleanup_dtor);
2956 /* Given a number and address, return an uploaded tracepoint with that
2957 number, creating if necessary. */
2959 struct uploaded_tp *
2960 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
2962 struct uploaded_tp *utp;
2964 for (utp = *utpp; utp; utp = utp->next)
2965 if (utp->number == num && utp->addr == addr)
2967 utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
2968 memset (utp, 0, sizeof (struct uploaded_tp));
2971 utp->actions = NULL;
2972 utp->step_actions = NULL;
2973 utp->cmd_strings = NULL;
2980 free_uploaded_tps (struct uploaded_tp **utpp)
2982 struct uploaded_tp *next_one;
2986 next_one = (*utpp)->next;
2992 /* Given a number and address, return an uploaded tracepoint with that
2993 number, creating if necessary. */
2995 struct uploaded_tsv *
2996 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
2998 struct uploaded_tsv *utsv;
3000 for (utsv = *utsvp; utsv; utsv = utsv->next)
3001 if (utsv->number == num)
3003 utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
3004 memset (utsv, 0, sizeof (struct uploaded_tsv));
3006 utsv->next = *utsvp;
3012 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3014 struct uploaded_tsv *next_one;
3018 next_one = (*utsvp)->next;
3024 /* Look for an existing tracepoint that seems similar enough to the
3025 uploaded one. Enablement isn't compared, because the user can
3026 toggle that freely, and may have done so in anticipation of the
3030 find_matching_tracepoint (struct uploaded_tp *utp)
3032 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
3034 struct breakpoint *t;
3035 struct bp_location *loc;
3037 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
3039 if (t->type == utp->type
3040 && t->step_count == utp->step
3041 && t->pass_count == utp->pass
3042 /* FIXME also test conditionals and actions */
3045 /* Scan the locations for an address match. */
3046 for (loc = t->loc; loc; loc = loc->next)
3048 if (loc->address == utp->addr)
3056 /* Given a list of tracepoints uploaded from a target, attempt to
3057 match them up with existing tracepoints, and create new ones if not
3061 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3063 struct uploaded_tp *utp;
3064 struct breakpoint *t;
3066 /* Look for GDB tracepoints that match up with our uploaded versions. */
3067 for (utp = *uploaded_tps; utp; utp = utp->next)
3069 t = find_matching_tracepoint (utp);
3071 printf_filtered (_("Assuming tracepoint %d is same "
3072 "as target's tracepoint %d at %s.\n"),
3073 t->number, utp->number,
3074 paddress (get_current_arch (), utp->addr));
3077 t = create_tracepoint_from_upload (utp);
3079 printf_filtered (_("Created tracepoint %d for "
3080 "target's tracepoint %d at %s.\n"),
3081 t->number, utp->number,
3082 paddress (get_current_arch (), utp->addr));
3084 printf_filtered (_("Failed to create tracepoint for target's "
3085 "tracepoint %d at %s, skipping it.\n"),
3087 paddress (get_current_arch (), utp->addr));
3089 /* Whether found or created, record the number used by the
3090 target, to help with mapping target tracepoints back to their
3091 counterparts here. */
3093 t->number_on_target = utp->number;
3096 free_uploaded_tps (uploaded_tps);
3099 /* Trace state variables don't have much to identify them beyond their
3100 name, so just use that to detect matches. */
3102 struct trace_state_variable *
3103 find_matching_tsv (struct uploaded_tsv *utsv)
3108 return find_trace_state_variable (utsv->name);
3111 struct trace_state_variable *
3112 create_tsv_from_upload (struct uploaded_tsv *utsv)
3114 const char *namebase;
3117 struct trace_state_variable *tsv;
3121 namebase = utsv->name;
3122 sprintf (buf, "%s", namebase);
3127 sprintf (buf, "%s_%d", namebase, try_num++);
3130 /* Fish for a name that is not in use. */
3131 /* (should check against all internal vars?) */
3132 while (find_trace_state_variable (buf))
3133 sprintf (buf, "%s_%d", namebase, try_num++);
3135 /* We have an available name, create the variable. */
3136 tsv = create_trace_state_variable (xstrdup (buf));
3137 tsv->initial_value = utsv->initial_value;
3138 tsv->builtin = utsv->builtin;
3143 /* Given a list of uploaded trace state variables, try to match them
3144 up with existing variables, or create additional ones. */
3147 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
3150 struct uploaded_tsv *utsv;
3151 struct trace_state_variable *tsv;
3154 /* Most likely some numbers will have to be reassigned as part of
3155 the merge, so clear them all in anticipation. */
3156 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3159 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
3161 tsv = find_matching_tsv (utsv);
3165 printf_filtered (_("Assuming trace state variable $%s "
3166 "is same as target's variable %d.\n"),
3167 tsv->name, utsv->number);
3171 tsv = create_tsv_from_upload (utsv);
3173 printf_filtered (_("Created trace state variable "
3174 "$%s for target's variable %d.\n"),
3175 tsv->name, utsv->number);
3177 /* Give precedence to numberings that come from the target. */
3179 tsv->number = utsv->number;
3182 /* Renumber everything that didn't get a target-assigned number. */
3184 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3185 if (tsv->number > highest)
3186 highest = tsv->number;
3189 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3190 if (tsv->number == 0)
3191 tsv->number = highest++;
3193 free_uploaded_tsvs (uploaded_tsvs);
3196 /* target tfile command */
3198 struct target_ops tfile_ops;
3200 /* Fill in tfile_ops with its defined operations and properties. */
3202 #define TRACE_HEADER_SIZE 8
3204 char *trace_filename;
3206 off_t trace_frames_offset;
3209 int trace_regblock_size;
3211 static void tfile_interp_line (char *line,
3212 struct uploaded_tp **utpp,
3213 struct uploaded_tsv **utsvp);
3216 tfile_open (char *filename, int from_tty)
3219 struct cleanup *old_chain;
3222 char header[TRACE_HEADER_SIZE];
3223 char linebuf[1000]; /* should be max remote packet size or so */
3225 int bytes, i, gotten;
3226 struct trace_status *ts;
3227 struct uploaded_tp *uploaded_tps = NULL;
3228 struct uploaded_tsv *uploaded_tsvs = NULL;
3230 target_preopen (from_tty);
3232 error (_("No trace file specified."));
3234 filename = tilde_expand (filename);
3235 if (!IS_ABSOLUTE_PATH(filename))
3237 temp = concat (current_directory, "/", filename, (char *) NULL);
3242 old_chain = make_cleanup (xfree, filename);
3244 flags = O_BINARY | O_LARGEFILE;
3246 scratch_chan = open (filename, flags, 0);
3247 if (scratch_chan < 0)
3248 perror_with_name (filename);
3250 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3252 discard_cleanups (old_chain); /* Don't free filename any more */
3253 unpush_target (&tfile_ops);
3255 push_target (&tfile_ops);
3257 trace_filename = xstrdup (filename);
3258 trace_fd = scratch_chan;
3261 /* Read the file header and test for validity. */
3262 gotten = read (trace_fd, &header, TRACE_HEADER_SIZE);
3264 perror_with_name (trace_filename);
3265 else if (gotten < TRACE_HEADER_SIZE)
3266 error (_("Premature end of file while reading trace file"));
3268 bytes += TRACE_HEADER_SIZE;
3269 if (!(header[0] == 0x7f
3270 && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
3271 error (_("File is not a valid trace file."));
3273 trace_regblock_size = 0;
3274 ts = current_trace_status ();
3275 /* We know we're working with a file. */
3277 /* Set defaults in case there is no status line. */
3278 ts->running_known = 0;
3279 ts->stop_reason = trace_stop_reason_unknown;
3280 ts->traceframe_count = -1;
3281 ts->buffer_free = 0;
3282 ts->disconnected_tracing = 0;
3283 ts->circular_buffer = 0;
3285 /* Read through a section of newline-terminated lines that
3286 define things like tracepoints. */
3290 gotten = read (trace_fd, &byte, 1);
3292 perror_with_name (trace_filename);
3293 else if (gotten < 1)
3294 error (_("Premature end of file while reading trace file"));
3299 /* Empty line marks end of the definition section. */
3304 tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
3307 linebuf[i++] = byte;
3309 error (_("Excessively long lines in trace file"));
3312 /* Add the file's tracepoints and variables into the current mix. */
3314 /* Get trace state variables first, they may be checked when parsing
3315 uploaded commands. */
3316 merge_uploaded_trace_state_variables (&uploaded_tsvs);
3318 merge_uploaded_tracepoints (&uploaded_tps);
3320 /* Record the starting offset of the binary trace data. */
3321 trace_frames_offset = bytes;
3323 /* If we don't have a blocksize, we can't interpret the
3325 if (trace_regblock_size == 0)
3326 error (_("No register block size recorded in trace file"));
3327 if (ts->traceframe_count <= 0)
3329 warning (_("No traceframes present in this file."));
3333 #define TFILE_PID (1)
3334 inferior_appeared (current_inferior (), TFILE_PID);
3335 inferior_ptid = pid_to_ptid (TFILE_PID);
3336 add_thread_silent (inferior_ptid);
3338 post_create_inferior (&tfile_ops, from_tty);
3341 /* FIXME this will get defined in MI patch submission */
3342 tfind_1 (tfind_number, 0, 0, 0, 0);
3346 /* Interpret the given line from the definitions part of the trace
3350 tfile_interp_line (char *line,
3351 struct uploaded_tp **utpp, struct uploaded_tsv **utsvp)
3355 if (strncmp (p, "R ", strlen ("R ")) == 0)
3358 trace_regblock_size = strtol (p, &p, 16);
3360 else if (strncmp (p, "status ", strlen ("status ")) == 0)
3362 p += strlen ("status ");
3363 parse_trace_status (p, current_trace_status ());
3365 else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
3367 p += strlen ("tp ");
3368 parse_tracepoint_definition (p, utpp);
3370 else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
3372 p += strlen ("tsv ");
3373 parse_tsv_definition (p, utsvp);
3376 warning (_("Ignoring trace file definition \"%s\""), line);
3379 /* Parse the part of trace status syntax that is shared between
3380 the remote protocol and the trace file reader. */
3383 parse_trace_status (char *line, struct trace_status *ts)
3385 char *p = line, *p1, *p2, *p_temp;
3388 ts->running_known = 1;
3389 ts->running = (*p++ == '1');
3390 ts->stop_reason = trace_stop_reason_unknown;
3391 xfree (ts->error_desc);
3392 ts->error_desc = NULL;
3393 ts->traceframe_count = -1;
3394 ts->traceframes_created = -1;
3395 ts->buffer_free = -1;
3396 ts->buffer_size = -1;
3397 ts->disconnected_tracing = 0;
3398 ts->circular_buffer = 0;
3402 p1 = strchr (p, ':');
3404 error (_("Malformed trace status, at %s\n\
3405 Status line: '%s'\n"), p, line);
3406 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3408 p = unpack_varlen_hex (++p1, &val);
3409 ts->stop_reason = trace_buffer_full;
3411 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3413 p = unpack_varlen_hex (++p1, &val);
3414 ts->stop_reason = trace_never_run;
3416 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
3419 p = unpack_varlen_hex (++p1, &val);
3420 ts->stop_reason = tracepoint_passcount;
3421 ts->stopping_tracepoint = val;
3423 else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
3425 p = unpack_varlen_hex (++p1, &val);
3426 ts->stop_reason = tstop_command;
3428 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3430 p = unpack_varlen_hex (++p1, &val);
3431 ts->stop_reason = trace_disconnected;
3433 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3435 p2 = strchr (++p1, ':');
3440 ts->error_desc = xmalloc ((p2 - p1) / 2 + 1);
3441 end = hex2bin (p1, ts->error_desc, (p2 - p1) / 2);
3442 ts->error_desc[end] = '\0';
3445 ts->error_desc = xstrdup ("");
3447 p = unpack_varlen_hex (++p2, &val);
3448 ts->stopping_tracepoint = val;
3449 ts->stop_reason = tracepoint_error;
3451 else if (strncmp (p, "tframes", p1 - p) == 0)
3453 p = unpack_varlen_hex (++p1, &val);
3454 ts->traceframe_count = val;
3456 else if (strncmp (p, "tcreated", p1 - p) == 0)
3458 p = unpack_varlen_hex (++p1, &val);
3459 ts->traceframes_created = val;
3461 else if (strncmp (p, "tfree", p1 - p) == 0)
3463 p = unpack_varlen_hex (++p1, &val);
3464 ts->buffer_free = val;
3466 else if (strncmp (p, "tsize", p1 - p) == 0)
3468 p = unpack_varlen_hex (++p1, &val);
3469 ts->buffer_size = val;
3471 else if (strncmp (p, "disconn", p1 - p) == 0)
3473 p = unpack_varlen_hex (++p1, &val);
3474 ts->disconnected_tracing = val;
3476 else if (strncmp (p, "circular", p1 - p) == 0)
3478 p = unpack_varlen_hex (++p1, &val);
3479 ts->circular_buffer = val;
3483 /* Silently skip unknown optional info. */
3484 p_temp = strchr (p1 + 1, ';');
3488 /* Must be at the end. */
3494 /* Given a line of text defining a part of a tracepoint, parse it into
3495 an "uploaded tracepoint". */
3498 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
3502 ULONGEST num, addr, step, pass, orig_size, xlen, start;
3505 char *cond, *srctype, *buf;
3506 struct uploaded_tp *utp = NULL;
3509 /* Both tracepoint and action definitions start with the same number
3510 and address sequence. */
3512 p = unpack_varlen_hex (p, &num);
3513 p++; /* skip a colon */
3514 p = unpack_varlen_hex (p, &addr);
3515 p++; /* skip a colon */
3518 enabled = (*p++ == 'E');
3519 p++; /* skip a colon */
3520 p = unpack_varlen_hex (p, &step);
3521 p++; /* skip a colon */
3522 p = unpack_varlen_hex (p, &pass);
3523 type = bp_tracepoint;
3525 /* Thumb through optional fields. */
3528 p++; /* skip a colon */
3531 type = bp_fast_tracepoint;
3533 p = unpack_varlen_hex (p, &orig_size);
3537 type = bp_static_tracepoint;
3543 p = unpack_varlen_hex (p, &xlen);
3544 p++; /* skip a comma */
3545 cond = (char *) xmalloc (2 * xlen + 1);
3546 strncpy (cond, p, 2 * xlen);
3547 cond[2 * xlen] = '\0';
3551 warning (_("Unrecognized char '%c' in tracepoint "
3552 "definition, skipping rest"), *p);
3554 utp = get_uploaded_tp (num, addr, utpp);
3556 utp->enabled = enabled;
3561 else if (piece == 'A')
3563 utp = get_uploaded_tp (num, addr, utpp);
3564 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
3566 else if (piece == 'S')
3568 utp = get_uploaded_tp (num, addr, utpp);
3569 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
3571 else if (piece == 'Z')
3573 /* Parse a chunk of source form definition. */
3574 utp = get_uploaded_tp (num, addr, utpp);
3576 p = strchr (p, ':');
3577 p++; /* skip a colon */
3578 p = unpack_varlen_hex (p, &start);
3579 p++; /* skip a colon */
3580 p = unpack_varlen_hex (p, &xlen);
3581 p++; /* skip a colon */
3583 buf = alloca (strlen (line));
3585 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3588 if (strncmp (srctype, "at:", strlen ("at:")) == 0)
3589 utp->at_string = xstrdup (buf);
3590 else if (strncmp (srctype, "cond:", strlen ("cond:")) == 0)
3591 utp->cond_string = xstrdup (buf);
3592 else if (strncmp (srctype, "cmd:", strlen ("cmd:")) == 0)
3593 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
3597 /* Don't error out, the target might be sending us optional
3598 info that we don't care about. */
3599 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
3603 /* Convert a textual description of a trace state variable into an
3607 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
3610 ULONGEST num, initval, builtin;
3612 struct uploaded_tsv *utsv = NULL;
3614 buf = alloca (strlen (line));
3617 p = unpack_varlen_hex (p, &num);
3618 p++; /* skip a colon */
3619 p = unpack_varlen_hex (p, &initval);
3620 p++; /* skip a colon */
3621 p = unpack_varlen_hex (p, &builtin);
3622 p++; /* skip a colon */
3623 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3626 utsv = get_uploaded_tsv (num, utsvp);
3627 utsv->initial_value = initval;
3628 utsv->builtin = builtin;
3629 utsv->name = xstrdup (buf);
3632 /* Close the trace file and generally clean up. */
3635 tfile_close (int quitting)
3642 pid = ptid_get_pid (inferior_ptid);
3643 inferior_ptid = null_ptid; /* Avoid confusion from thread stuff */
3644 exit_inferior_silent (pid);
3649 xfree (trace_filename);
3653 tfile_files_info (struct target_ops *t)
3655 /* (it would be useful to mention the name of the file) */
3656 printf_filtered ("Looking at a trace file.\n");
3659 /* The trace status for a file is that tracing can never be run. */
3662 tfile_get_trace_status (struct trace_status *ts)
3664 /* Other bits of trace status were collected as part of opening the
3665 trace files, so nothing to do here. */
3670 /* Given the position of a traceframe in the file, figure out what
3671 address the frame was collected at. This would normally be the
3672 value of a collected PC register, but if not available, we
3676 tfile_get_traceframe_address (off_t tframe_offset)
3680 struct breakpoint *tp;
3681 off_t saved_offset = cur_offset;
3684 /* FIXME dig pc out of collected registers */
3686 /* Fall back to using tracepoint address. */
3687 lseek (trace_fd, tframe_offset, SEEK_SET);
3688 gotten = read (trace_fd, &tpnum, 2);
3690 perror_with_name (trace_filename);
3691 else if (gotten < 2)
3692 error (_("Premature end of file while reading trace file"));
3693 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
3697 tp = get_tracepoint_by_number_on_target (tpnum);
3698 /* FIXME this is a poor heuristic if multiple locations */
3700 addr = tp->loc->address;
3702 /* Restore our seek position. */
3703 cur_offset = saved_offset;
3704 lseek (trace_fd, cur_offset, SEEK_SET);
3708 /* Given a type of search and some parameters, scan the collection of
3709 traceframes in the file looking for a match. When found, return
3710 both the traceframe and tracepoint number, otherwise -1 for
3714 tfile_trace_find (enum trace_find_type type, int num,
3715 ULONGEST addr1, ULONGEST addr2, int *tpp)
3718 int tfnum = 0, found = 0, gotten;
3719 unsigned int data_size;
3720 struct breakpoint *tp;
3721 off_t offset, tframe_offset;
3724 lseek (trace_fd, trace_frames_offset, SEEK_SET);
3725 offset = trace_frames_offset;
3728 tframe_offset = offset;
3729 gotten = read (trace_fd, &tpnum, 2);
3731 perror_with_name (trace_filename);
3732 else if (gotten < 2)
3733 error (_("Premature end of file while reading trace file"));
3734 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
3740 gotten = read (trace_fd, &data_size, 4);
3742 perror_with_name (trace_filename);
3743 else if (gotten < 4)
3744 error (_("Premature end of file while reading trace file"));
3745 data_size = (unsigned int) extract_unsigned_integer
3746 ((gdb_byte *) &data_size, 4,
3747 gdbarch_byte_order (target_gdbarch));
3756 tfaddr = tfile_get_traceframe_address (tframe_offset);
3757 if (tfaddr == addr1)
3761 tp = get_tracepoint (num);
3762 if (tp && tpnum == tp->number_on_target)
3766 tfaddr = tfile_get_traceframe_address (tframe_offset);
3767 if (addr1 <= tfaddr && tfaddr <= addr2)
3771 tfaddr = tfile_get_traceframe_address (tframe_offset);
3772 if (!(addr1 <= tfaddr && tfaddr <= addr2))
3776 internal_error (__FILE__, __LINE__, _("unknown tfind type"));
3782 cur_offset = offset;
3783 cur_data_size = data_size;
3786 /* Skip past the traceframe's data. */
3787 lseek (trace_fd, data_size, SEEK_CUR);
3788 offset += data_size;
3789 /* Update our own count of traceframes. */
3792 /* Did not find what we were looking for. */
3798 /* Look for a block of saved registers in the traceframe, and get the
3799 requested register from it. */
3802 tfile_fetch_registers (struct target_ops *ops,
3803 struct regcache *regcache, int regno)
3805 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3807 int pos, offset, regn, regsize, gotten, pc_regno;
3808 unsigned short mlen;
3811 /* An uninitialized reg size says we're not going to be
3812 successful at getting register blocks. */
3813 if (!trace_regblock_size)
3816 regs = alloca (trace_regblock_size);
3818 lseek (trace_fd, cur_offset, SEEK_SET);
3820 while (pos < cur_data_size)
3822 gotten = read (trace_fd, &block_type, 1);
3824 perror_with_name (trace_filename);
3825 else if (gotten < 1)
3826 error (_("Premature end of file while reading trace file"));
3832 gotten = read (trace_fd, regs, trace_regblock_size);
3834 perror_with_name (trace_filename);
3835 else if (gotten < trace_regblock_size)
3836 error (_("Premature end of file while reading trace file"));
3838 /* Assume the block is laid out in GDB register number order,
3839 each register with the size that it has in GDB. */
3841 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
3843 regsize = register_size (gdbarch, regn);
3844 /* Make sure we stay within block bounds. */
3845 if (offset + regsize >= trace_regblock_size)
3847 if (!regcache_valid_p (regcache, regn))
3851 regcache_raw_supply (regcache, regno, regs + offset);
3854 else if (regno == -1)
3856 regcache_raw_supply (regcache, regn, regs + offset);
3863 lseek (trace_fd, 8, SEEK_CUR);
3864 gotten = read (trace_fd, &mlen, 2);
3866 perror_with_name (trace_filename);
3867 else if (gotten < 2)
3868 error (_("Premature end of file while reading trace file"));
3869 mlen = (unsigned short)
3870 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
3873 lseek (trace_fd, mlen, SEEK_CUR);
3874 pos += (8 + 2 + mlen);
3877 lseek (trace_fd, 4 + 8, SEEK_CUR);
3881 error (_("Unknown block type '%c' (0x%x) in trace frame"),
3882 block_type, block_type);
3887 /* We get here if no register data has been found. Although we
3888 don't like making up numbers, GDB has all manner of troubles when
3889 the target says some register is not available. Filling in with
3890 zeroes is a reasonable fallback. */
3891 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
3892 regcache_raw_supply (regcache, regn, NULL);
3894 /* We can often usefully guess that the PC is going to be the same
3895 as the address of the tracepoint. */
3896 pc_regno = gdbarch_pc_regnum (gdbarch);
3897 if (pc_regno >= 0 && (regno == -1 || regno == pc_regno))
3899 struct breakpoint *tp = get_tracepoint (tracepoint_number);
3903 /* But don't try to guess if tracepoint is multi-location... */
3906 warning (_("Tracepoint %d has multiple "
3907 "locations, cannot infer $pc"),
3911 /* ... or does while-stepping. */
3912 if (tp->step_count > 0)
3914 warning (_("Tracepoint %d does while-stepping, "
3915 "cannot infer $pc"),
3920 store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
3921 gdbarch_byte_order (gdbarch),
3923 regcache_raw_supply (regcache, pc_regno, regs);
3929 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
3930 const char *annex, gdb_byte *readbuf,
3931 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
3935 ULONGEST maddr, amt;
3936 unsigned short mlen;
3938 /* We're only doing regular memory for now. */
3939 if (object != TARGET_OBJECT_MEMORY)
3942 if (readbuf == NULL)
3943 error (_("tfile_xfer_partial: trace file is read-only"));
3945 lseek (trace_fd, cur_offset, SEEK_SET);
3947 while (pos < cur_data_size)
3949 gotten = read (trace_fd, &block_type, 1);
3951 perror_with_name (trace_filename);
3952 else if (gotten < 1)
3953 error (_("Premature end of file while reading trace file"));
3958 lseek (trace_fd, trace_regblock_size, SEEK_CUR);
3959 pos += trace_regblock_size;
3962 gotten = read (trace_fd, &maddr, 8);
3964 perror_with_name (trace_filename);
3965 else if (gotten < 8)
3966 error (_("Premature end of file while reading trace file"));
3967 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
3970 gotten = read (trace_fd, &mlen, 2);
3972 perror_with_name (trace_filename);
3973 else if (gotten < 2)
3974 error (_("Premature end of file while reading trace file"));
3975 mlen = (unsigned short)
3976 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
3979 /* If the block includes the first part of the desired
3980 range, return as much it has; GDB will re-request the
3981 remainder, which might be in a different block of this
3983 if (maddr <= offset && offset < (maddr + mlen))
3985 amt = (maddr + mlen) - offset;
3989 gotten = read (trace_fd, readbuf, amt);
3991 perror_with_name (trace_filename);
3992 /* While it's acceptable to return less than was
3993 originally asked for, it's not acceptable to return
3994 less than what this block claims to contain. */
3995 else if (gotten < amt)
3996 error (_("Premature end of file while reading trace file"));
3999 lseek (trace_fd, mlen, SEEK_CUR);
4000 pos += (8 + 2 + mlen);
4003 lseek (trace_fd, 4 + 8, SEEK_CUR);
4007 error (_("Unknown block type '%c' (0x%x) in traceframe"),
4008 block_type, block_type);
4013 /* It's unduly pedantic to refuse to look at the executable for
4014 read-only pieces; so do the equivalent of readonly regions aka
4016 /* FIXME account for relocation at some point */
4023 for (s = exec_bfd->sections; s; s = s->next)
4025 if ((s->flags & SEC_LOAD) == 0 ||
4026 (s->flags & SEC_READONLY) == 0)
4030 size = bfd_get_section_size (s);
4031 if (vma <= offset && offset < (vma + size))
4033 amt = (vma + size) - offset;
4037 amt = bfd_get_section_contents (exec_bfd, s,
4038 readbuf, offset - vma, amt);
4044 /* Indicate failure to find the requested memory block. */
4048 /* Iterate through the blocks of a trace frame, looking for a 'V'
4049 block with a matching tsv number. */
4052 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
4055 int pos, vnum, gotten;
4056 unsigned short mlen;
4058 lseek (trace_fd, cur_offset, SEEK_SET);
4060 while (pos < cur_data_size)
4062 gotten = read (trace_fd, &block_type, 1);
4064 perror_with_name (trace_filename);
4065 else if (gotten < 1)
4066 error (_("Premature end of file while reading trace file"));
4071 lseek (trace_fd, trace_regblock_size, SEEK_CUR);
4072 pos += trace_regblock_size;
4075 lseek (trace_fd, 8, SEEK_CUR);
4076 gotten = read (trace_fd, &mlen, 2);
4078 perror_with_name (trace_filename);
4079 else if (gotten < 2)
4080 error (_("Premature end of file while reading trace file"));
4081 mlen = (unsigned short)
4082 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
4085 lseek (trace_fd, mlen, SEEK_CUR);
4086 pos += (8 + 2 + mlen);
4089 gotten = read (trace_fd, &vnum, 4);
4091 perror_with_name (trace_filename);
4092 else if (gotten < 4)
4093 error (_("Premature end of file while reading trace file"));
4094 vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
4099 gotten = read (trace_fd, val, 8);
4101 perror_with_name (trace_filename);
4102 else if (gotten < 8)
4103 error (_("Premature end of file while reading trace file"));
4104 *val = extract_signed_integer ((gdb_byte *)val, 8,
4109 lseek (trace_fd, 8, SEEK_CUR);
4113 error (_("Unknown block type '%c' (0x%x) in traceframe"),
4114 block_type, block_type);
4118 /* Didn't find anything. */
4123 tfile_has_all_memory (struct target_ops *ops)
4129 tfile_has_memory (struct target_ops *ops)
4135 tfile_has_stack (struct target_ops *ops)
4141 tfile_has_registers (struct target_ops *ops)
4147 init_tfile_ops (void)
4149 tfile_ops.to_shortname = "tfile";
4150 tfile_ops.to_longname = "Local trace dump file";
4152 = "Use a trace file as a target. Specify the filename of the trace file.";
4153 tfile_ops.to_open = tfile_open;
4154 tfile_ops.to_close = tfile_close;
4155 tfile_ops.to_fetch_registers = tfile_fetch_registers;
4156 tfile_ops.to_xfer_partial = tfile_xfer_partial;
4157 tfile_ops.to_files_info = tfile_files_info;
4158 tfile_ops.to_get_trace_status = tfile_get_trace_status;
4159 tfile_ops.to_trace_find = tfile_trace_find;
4160 tfile_ops.to_get_trace_state_variable_value
4161 = tfile_get_trace_state_variable_value;
4162 tfile_ops.to_stratum = process_stratum;
4163 tfile_ops.to_has_all_memory = tfile_has_all_memory;
4164 tfile_ops.to_has_memory = tfile_has_memory;
4165 tfile_ops.to_has_stack = tfile_has_stack;
4166 tfile_ops.to_has_registers = tfile_has_registers;
4167 tfile_ops.to_magic = OPS_MAGIC;
4170 /* Given a line of text defining a static tracepoint marker, parse it
4171 into a "static tracepoint marker" object. Throws an error is
4172 parsing fails. If PP is non-null, it points to one past the end of
4173 the parsed marker definition. */
4176 parse_static_tracepoint_marker_definition (char *line, char **pp,
4177 struct static_tracepoint_marker *marker)
4184 p = unpack_varlen_hex (p, &addr);
4185 p++; /* skip a colon */
4187 marker->gdbarch = target_gdbarch;
4188 marker->address = (CORE_ADDR) addr;
4190 endp = strchr (p, ':');
4192 error (_("bad marker definition: %s"), line);
4194 marker->str_id = xmalloc (endp - p + 1);
4195 end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
4196 marker->str_id[end] = '\0';
4199 p++; /* skip a colon */
4201 marker->extra = xmalloc (strlen (p) + 1);
4202 end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
4203 marker->extra[end] = '\0';
4209 /* Release a static tracepoint marker's contents. Note that the
4210 object itself isn't released here. There objects are usually on
4214 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
4216 xfree (marker->str_id);
4217 marker->str_id = NULL;
4220 /* Print MARKER to gdb_stdout. */
4223 print_one_static_tracepoint_marker (int count,
4224 struct static_tracepoint_marker *marker)
4226 struct command_line *l;
4229 char wrap_indent[80];
4230 char extra_field_indent[80];
4231 struct ui_stream *stb = ui_out_stream_new (uiout);
4232 struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb);
4233 struct cleanup *bkpt_chain;
4234 VEC(breakpoint_p) *tracepoints;
4236 struct symtab_and_line sal;
4240 sal.pc = marker->address;
4242 tracepoints = static_tracepoints_here (marker->address);
4244 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
4246 /* A counter field to help readability. This is not a stable
4248 ui_out_field_int (uiout, "count", count);
4250 ui_out_field_string (uiout, "marker-id", marker->str_id);
4252 ui_out_field_fmt (uiout, "enabled", "%c",
4253 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
4254 ui_out_spaces (uiout, 2);
4256 strcpy (wrap_indent, " ");
4258 if (gdbarch_addr_bit (marker->gdbarch) <= 32)
4259 strcat (wrap_indent, " ");
4261 strcat (wrap_indent, " ");
4263 strcpy (extra_field_indent, " ");
4265 ui_out_field_core_addr (uiout, "addr", marker->gdbarch, marker->address);
4267 sal = find_pc_line (marker->address, 0);
4268 sym = find_pc_sect_function (marker->address, NULL);
4271 ui_out_text (uiout, "in ");
4272 ui_out_field_string (uiout, "func",
4273 SYMBOL_PRINT_NAME (sym));
4274 ui_out_wrap_hint (uiout, wrap_indent);
4275 ui_out_text (uiout, " at ");
4278 ui_out_field_skip (uiout, "func");
4280 if (sal.symtab != NULL)
4282 ui_out_field_string (uiout, "file", sal.symtab->filename);
4283 ui_out_text (uiout, ":");
4285 if (ui_out_is_mi_like_p (uiout))
4287 char *fullname = symtab_to_fullname (sal.symtab);
4290 ui_out_field_string (uiout, "fullname", fullname);
4293 ui_out_field_skip (uiout, "fullname");
4295 ui_out_field_int (uiout, "line", sal.line);
4299 ui_out_field_skip (uiout, "fullname");
4300 ui_out_field_skip (uiout, "line");
4303 ui_out_text (uiout, "\n");
4304 ui_out_text (uiout, extra_field_indent);
4305 ui_out_text (uiout, _("Data: \""));
4306 ui_out_field_string (uiout, "extra-data", marker->extra);
4307 ui_out_text (uiout, "\"\n");
4309 if (!VEC_empty (breakpoint_p, tracepoints))
4311 struct cleanup *cleanup_chain;
4313 struct breakpoint *b;
4315 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
4318 ui_out_text (uiout, extra_field_indent);
4319 ui_out_text (uiout, _("Probed by static tracepoints: "));
4320 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
4323 ui_out_text (uiout, ", ");
4324 ui_out_text (uiout, "#");
4325 ui_out_field_int (uiout, "tracepoint-id", b->number);
4328 do_cleanups (cleanup_chain);
4330 if (ui_out_is_mi_like_p (uiout))
4331 ui_out_field_int (uiout, "number-of-tracepoints",
4332 VEC_length(breakpoint_p, tracepoints));
4334 ui_out_text (uiout, "\n");
4336 VEC_free (breakpoint_p, tracepoints);
4338 do_cleanups (bkpt_chain);
4339 do_cleanups (old_chain);
4343 info_static_tracepoint_markers_command (char *arg, int from_tty)
4345 VEC(static_tracepoint_marker_p) *markers;
4346 struct cleanup *old_chain;
4347 struct static_tracepoint_marker *marker;
4351 = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
4352 "StaticTracepointMarkersTable");
4354 ui_out_table_header (uiout, 7, ui_left, "counter", "Cnt");
4356 ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
4358 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
4359 if (gdbarch_addr_bit (target_gdbarch) <= 32)
4360 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
4362 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
4363 ui_out_table_header (uiout, 40, ui_noalign, "what", "What");
4365 ui_out_table_body (uiout);
4367 markers = target_static_tracepoint_markers_by_strid (NULL);
4368 make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
4371 VEC_iterate (static_tracepoint_marker_p,
4372 markers, i, marker);
4375 print_one_static_tracepoint_marker (i + 1, marker);
4376 release_static_tracepoint_marker (marker);
4379 do_cleanups (old_chain);
4382 /* The $_sdata convenience variable is a bit special. We don't know
4383 for sure type of the value until we actually have a chance to fetch
4384 the data --- the size of the object depends on what has been
4385 collected. We solve this by making $_sdata be an internalvar that
4386 creates a new value on access. */
4388 /* Return a new value with the correct type for the sdata object of
4389 the current trace frame. Return a void value if there's no object
4392 static struct value *
4393 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var)
4398 /* We need to read the whole object before we know its size. */
4399 size = target_read_alloc (¤t_target,
4400 TARGET_OBJECT_STATIC_TRACE_DATA,
4407 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
4409 v = allocate_value (type);
4410 memcpy (value_contents_raw (v), buf, size);
4415 return allocate_value (builtin_type (gdbarch)->builtin_void);
4418 /* module initialization */
4420 _initialize_tracepoint (void)
4422 struct cmd_list_element *c;
4424 /* Explicitly create without lookup, since that tries to create a
4425 value with a void typed value, and when we get here, gdbarch
4426 isn't initialized yet. At this point, we're quite sure there
4427 isn't another convenience variable of the same name. */
4428 create_internalvar_type_lazy ("_sdata", sdata_make_value);
4430 traceframe_number = -1;
4431 tracepoint_number = -1;
4433 if (tracepoint_list.list == NULL)
4435 tracepoint_list.listsize = 128;
4436 tracepoint_list.list = xmalloc
4437 (tracepoint_list.listsize * sizeof (struct memrange));
4439 if (tracepoint_list.aexpr_list == NULL)
4441 tracepoint_list.aexpr_listsize = 128;
4442 tracepoint_list.aexpr_list = xmalloc
4443 (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
4446 if (stepping_list.list == NULL)
4448 stepping_list.listsize = 128;
4449 stepping_list.list = xmalloc
4450 (stepping_list.listsize * sizeof (struct memrange));
4453 if (stepping_list.aexpr_list == NULL)
4455 stepping_list.aexpr_listsize = 128;
4456 stepping_list.aexpr_list = xmalloc
4457 (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
4460 add_info ("scope", scope_info,
4461 _("List the variables local to a scope"));
4463 add_cmd ("tracepoints", class_trace, NULL,
4464 _("Tracing of program execution without stopping the program."),
4467 add_com ("tdump", class_trace, trace_dump_command,
4468 _("Print everything collected at the current tracepoint."));
4470 add_com ("tsave", class_trace, trace_save_command, _("\
4471 Save the trace data to a file.\n\
4472 Use the '-r' option to direct the target to save directly to the file,\n\
4473 using its own filesystem."));
4475 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
4476 Define a trace state variable.\n\
4477 Argument is a $-prefixed name, optionally followed\n\
4478 by '=' and an expression that sets the initial value\n\
4479 at the start of tracing."));
4480 set_cmd_completer (c, expression_completer);
4482 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
4483 Delete one or more trace state variables.\n\
4484 Arguments are the names of the variables to delete.\n\
4485 If no arguments are supplied, delete all variables."), &deletelist);
4486 /* FIXME add a trace variable completer */
4488 add_info ("tvariables", tvariables_info, _("\
4489 Status of trace state variables and their values.\n\
4492 add_info ("static-tracepoint-markers",
4493 info_static_tracepoint_markers_command, _("\
4494 List target static tracepoints markers.\n\
4497 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
4498 Select a trace frame;\n\
4499 No argument means forward by one frame; '-' means backward by one frame."),
4500 &tfindlist, "tfind ", 1, &cmdlist);
4502 add_cmd ("outside", class_trace, trace_find_outside_command, _("\
4503 Select a trace frame whose PC is outside the given range (exclusive).\n\
4504 Usage: tfind outside addr1, addr2"),
4507 add_cmd ("range", class_trace, trace_find_range_command, _("\
4508 Select a trace frame whose PC is in the given range (inclusive).\n\
4509 Usage: tfind range addr1,addr2"),
4512 add_cmd ("line", class_trace, trace_find_line_command, _("\
4513 Select a trace frame by source line.\n\
4514 Argument can be a line number (with optional source file),\n\
4515 a function name, or '*' followed by an address.\n\
4516 Default argument is 'the next source line that was traced'."),
4519 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
4520 Select a trace frame by tracepoint number.\n\
4521 Default is the tracepoint for the current trace frame."),
4524 add_cmd ("pc", class_trace, trace_find_pc_command, _("\
4525 Select a trace frame by PC.\n\
4526 Default is the current PC, or the PC of the current trace frame."),
4529 add_cmd ("end", class_trace, trace_find_end_command, _("\
4530 Synonym for 'none'.\n\
4531 De-select any trace frame and resume 'live' debugging."),
4534 add_cmd ("none", class_trace, trace_find_none_command,
4535 _("De-select any trace frame and resume 'live' debugging."),
4538 add_cmd ("start", class_trace, trace_find_start_command,
4539 _("Select the first trace frame in the trace buffer."),
4542 add_com ("tstatus", class_trace, trace_status_command,
4543 _("Display the status of the current trace data collection."));
4545 add_com ("tstop", class_trace, trace_stop_command,
4546 _("Stop trace data collection."));
4548 add_com ("tstart", class_trace, trace_start_command,
4549 _("Start trace data collection."));
4551 add_com ("end", class_trace, end_actions_pseudocommand, _("\
4552 Ends a list of commands or actions.\n\
4553 Several GDB commands allow you to enter a list of commands or actions.\n\
4554 Entering \"end\" on a line by itself is the normal way to terminate\n\
4556 Note: the \"end\" command cannot be used at the gdb prompt."));
4558 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
4559 Specify single-stepping behavior at a tracepoint.\n\
4560 Argument is number of instructions to trace in single-step mode\n\
4561 following the tracepoint. This command is normally followed by\n\
4562 one or more \"collect\" commands, to specify what to collect\n\
4563 while single-stepping.\n\n\
4564 Note: this command can only be used in a tracepoint \"actions\" list."));
4566 add_com_alias ("ws", "while-stepping", class_alias, 0);
4567 add_com_alias ("stepping", "while-stepping", class_alias, 0);
4569 add_com ("collect", class_trace, collect_pseudocommand, _("\
4570 Specify one or more data items to be collected at a tracepoint.\n\
4571 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4572 collect all data (variables, registers) referenced by that expression.\n\
4573 Also accepts the following special arguments:\n\
4574 $regs -- all registers.\n\
4575 $args -- all function arguments.\n\
4576 $locals -- all variables local to the block/function scope.\n\
4577 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4578 Note: this command can only be used in a tracepoint \"actions\" list."));
4580 add_com ("teval", class_trace, teval_pseudocommand, _("\
4581 Specify one or more expressions to be evaluated at a tracepoint.\n\
4582 Accepts a comma-separated list of (one or more) expressions.\n\
4583 The result of each evaluation will be discarded.\n\
4584 Note: this command can only be used in a tracepoint \"actions\" list."));
4586 add_com ("actions", class_trace, trace_actions_command, _("\
4587 Specify the actions to be taken at a tracepoint.\n\
4588 Tracepoint actions may include collecting of specified data,\n\
4589 single-stepping, or enabling/disabling other tracepoints,\n\
4590 depending on target's capabilities."));
4592 default_collect = xstrdup ("");
4593 add_setshow_string_cmd ("default-collect", class_trace,
4594 &default_collect, _("\
4595 Set the list of expressions to collect by default"), _("\
4596 Show the list of expressions to collect by default"), NULL,
4598 &setlist, &showlist);
4600 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
4601 &disconnected_tracing, _("\
4602 Set whether tracing continues after GDB disconnects."), _("\
4603 Show whether tracing continues after GDB disconnects."), _("\
4604 Use this to continue a tracing run even if GDB disconnects\n\
4605 or detaches from the target. You can reconnect later and look at\n\
4606 trace data collected in the meantime."),
4607 set_disconnected_tracing,
4612 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
4613 &circular_trace_buffer, _("\
4614 Set target's use of circular trace buffer."), _("\
4615 Show target's use of circular trace buffer."), _("\
4616 Use this to make the trace buffer into a circular buffer,\n\
4617 which will discard traceframes (oldest first) instead of filling\n\
4618 up and stopping the trace run."),
4619 set_circular_trace_buffer,
4626 add_target (&tfile_ops);