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);
3215 /* Read SIZE bytes into READBUF from the trace frame, starting at
3216 TRACE_FD's current position. Note that this call `read'
3217 underneath, hence it advances the file's seek position. Throws an
3218 error if the `read' syscall fails, or less than SIZE bytes are
3222 tfile_read (gdb_byte *readbuf, int size)
3226 gotten = read (trace_fd, readbuf, size);
3228 perror_with_name (trace_filename);
3229 else if (gotten < size)
3230 error (_("Premature end of file while reading trace file"));
3234 tfile_open (char *filename, int from_tty)
3237 struct cleanup *old_chain;
3240 char header[TRACE_HEADER_SIZE];
3241 char linebuf[1000]; /* Should be max remote packet size or so. */
3244 struct trace_status *ts;
3245 struct uploaded_tp *uploaded_tps = NULL;
3246 struct uploaded_tsv *uploaded_tsvs = NULL;
3248 target_preopen (from_tty);
3250 error (_("No trace file specified."));
3252 filename = tilde_expand (filename);
3253 if (!IS_ABSOLUTE_PATH(filename))
3255 temp = concat (current_directory, "/", filename, (char *) NULL);
3260 old_chain = make_cleanup (xfree, filename);
3262 flags = O_BINARY | O_LARGEFILE;
3264 scratch_chan = open (filename, flags, 0);
3265 if (scratch_chan < 0)
3266 perror_with_name (filename);
3268 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3270 discard_cleanups (old_chain); /* Don't free filename any more. */
3271 unpush_target (&tfile_ops);
3273 push_target (&tfile_ops);
3275 trace_filename = xstrdup (filename);
3276 trace_fd = scratch_chan;
3279 /* Read the file header and test for validity. */
3280 tfile_read ((gdb_byte *) &header, TRACE_HEADER_SIZE);
3282 bytes += TRACE_HEADER_SIZE;
3283 if (!(header[0] == 0x7f
3284 && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
3285 error (_("File is not a valid trace file."));
3287 trace_regblock_size = 0;
3288 ts = current_trace_status ();
3289 /* We know we're working with a file. */
3291 /* Set defaults in case there is no status line. */
3292 ts->running_known = 0;
3293 ts->stop_reason = trace_stop_reason_unknown;
3294 ts->traceframe_count = -1;
3295 ts->buffer_free = 0;
3296 ts->disconnected_tracing = 0;
3297 ts->circular_buffer = 0;
3299 /* Read through a section of newline-terminated lines that
3300 define things like tracepoints. */
3304 tfile_read (&byte, 1);
3309 /* Empty line marks end of the definition section. */
3314 tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
3317 linebuf[i++] = byte;
3319 error (_("Excessively long lines in trace file"));
3322 /* Add the file's tracepoints and variables into the current mix. */
3324 /* Get trace state variables first, they may be checked when parsing
3325 uploaded commands. */
3326 merge_uploaded_trace_state_variables (&uploaded_tsvs);
3328 merge_uploaded_tracepoints (&uploaded_tps);
3330 /* Record the starting offset of the binary trace data. */
3331 trace_frames_offset = bytes;
3333 /* If we don't have a blocksize, we can't interpret the
3335 if (trace_regblock_size == 0)
3336 error (_("No register block size recorded in trace file"));
3337 if (ts->traceframe_count <= 0)
3339 warning (_("No traceframes present in this file."));
3343 #define TFILE_PID (1)
3344 inferior_appeared (current_inferior (), TFILE_PID);
3345 inferior_ptid = pid_to_ptid (TFILE_PID);
3346 add_thread_silent (inferior_ptid);
3348 post_create_inferior (&tfile_ops, from_tty);
3351 /* FIXME this will get defined in MI patch submission. */
3352 tfind_1 (tfind_number, 0, 0, 0, 0);
3356 /* Interpret the given line from the definitions part of the trace
3360 tfile_interp_line (char *line,
3361 struct uploaded_tp **utpp, struct uploaded_tsv **utsvp)
3365 if (strncmp (p, "R ", strlen ("R ")) == 0)
3368 trace_regblock_size = strtol (p, &p, 16);
3370 else if (strncmp (p, "status ", strlen ("status ")) == 0)
3372 p += strlen ("status ");
3373 parse_trace_status (p, current_trace_status ());
3375 else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
3377 p += strlen ("tp ");
3378 parse_tracepoint_definition (p, utpp);
3380 else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
3382 p += strlen ("tsv ");
3383 parse_tsv_definition (p, utsvp);
3386 warning (_("Ignoring trace file definition \"%s\""), line);
3389 /* Parse the part of trace status syntax that is shared between
3390 the remote protocol and the trace file reader. */
3393 parse_trace_status (char *line, struct trace_status *ts)
3395 char *p = line, *p1, *p2, *p_temp;
3398 ts->running_known = 1;
3399 ts->running = (*p++ == '1');
3400 ts->stop_reason = trace_stop_reason_unknown;
3401 xfree (ts->error_desc);
3402 ts->error_desc = NULL;
3403 ts->traceframe_count = -1;
3404 ts->traceframes_created = -1;
3405 ts->buffer_free = -1;
3406 ts->buffer_size = -1;
3407 ts->disconnected_tracing = 0;
3408 ts->circular_buffer = 0;
3412 p1 = strchr (p, ':');
3414 error (_("Malformed trace status, at %s\n\
3415 Status line: '%s'\n"), p, line);
3416 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3418 p = unpack_varlen_hex (++p1, &val);
3419 ts->stop_reason = trace_buffer_full;
3421 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3423 p = unpack_varlen_hex (++p1, &val);
3424 ts->stop_reason = trace_never_run;
3426 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
3429 p = unpack_varlen_hex (++p1, &val);
3430 ts->stop_reason = tracepoint_passcount;
3431 ts->stopping_tracepoint = val;
3433 else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
3435 p = unpack_varlen_hex (++p1, &val);
3436 ts->stop_reason = tstop_command;
3438 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3440 p = unpack_varlen_hex (++p1, &val);
3441 ts->stop_reason = trace_disconnected;
3443 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3445 p2 = strchr (++p1, ':');
3450 ts->error_desc = xmalloc ((p2 - p1) / 2 + 1);
3451 end = hex2bin (p1, ts->error_desc, (p2 - p1) / 2);
3452 ts->error_desc[end] = '\0';
3455 ts->error_desc = xstrdup ("");
3457 p = unpack_varlen_hex (++p2, &val);
3458 ts->stopping_tracepoint = val;
3459 ts->stop_reason = tracepoint_error;
3461 else if (strncmp (p, "tframes", p1 - p) == 0)
3463 p = unpack_varlen_hex (++p1, &val);
3464 ts->traceframe_count = val;
3466 else if (strncmp (p, "tcreated", p1 - p) == 0)
3468 p = unpack_varlen_hex (++p1, &val);
3469 ts->traceframes_created = val;
3471 else if (strncmp (p, "tfree", p1 - p) == 0)
3473 p = unpack_varlen_hex (++p1, &val);
3474 ts->buffer_free = val;
3476 else if (strncmp (p, "tsize", p1 - p) == 0)
3478 p = unpack_varlen_hex (++p1, &val);
3479 ts->buffer_size = val;
3481 else if (strncmp (p, "disconn", p1 - p) == 0)
3483 p = unpack_varlen_hex (++p1, &val);
3484 ts->disconnected_tracing = val;
3486 else if (strncmp (p, "circular", p1 - p) == 0)
3488 p = unpack_varlen_hex (++p1, &val);
3489 ts->circular_buffer = val;
3493 /* Silently skip unknown optional info. */
3494 p_temp = strchr (p1 + 1, ';');
3498 /* Must be at the end. */
3504 /* Given a line of text defining a part of a tracepoint, parse it into
3505 an "uploaded tracepoint". */
3508 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
3512 ULONGEST num, addr, step, pass, orig_size, xlen, start;
3515 char *cond, *srctype, *buf;
3516 struct uploaded_tp *utp = NULL;
3519 /* Both tracepoint and action definitions start with the same number
3520 and address sequence. */
3522 p = unpack_varlen_hex (p, &num);
3523 p++; /* skip a colon */
3524 p = unpack_varlen_hex (p, &addr);
3525 p++; /* skip a colon */
3528 enabled = (*p++ == 'E');
3529 p++; /* skip a colon */
3530 p = unpack_varlen_hex (p, &step);
3531 p++; /* skip a colon */
3532 p = unpack_varlen_hex (p, &pass);
3533 type = bp_tracepoint;
3535 /* Thumb through optional fields. */
3538 p++; /* skip a colon */
3541 type = bp_fast_tracepoint;
3543 p = unpack_varlen_hex (p, &orig_size);
3547 type = bp_static_tracepoint;
3553 p = unpack_varlen_hex (p, &xlen);
3554 p++; /* skip a comma */
3555 cond = (char *) xmalloc (2 * xlen + 1);
3556 strncpy (cond, p, 2 * xlen);
3557 cond[2 * xlen] = '\0';
3561 warning (_("Unrecognized char '%c' in tracepoint "
3562 "definition, skipping rest"), *p);
3564 utp = get_uploaded_tp (num, addr, utpp);
3566 utp->enabled = enabled;
3571 else if (piece == 'A')
3573 utp = get_uploaded_tp (num, addr, utpp);
3574 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
3576 else if (piece == 'S')
3578 utp = get_uploaded_tp (num, addr, utpp);
3579 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
3581 else if (piece == 'Z')
3583 /* Parse a chunk of source form definition. */
3584 utp = get_uploaded_tp (num, addr, utpp);
3586 p = strchr (p, ':');
3587 p++; /* skip a colon */
3588 p = unpack_varlen_hex (p, &start);
3589 p++; /* skip a colon */
3590 p = unpack_varlen_hex (p, &xlen);
3591 p++; /* skip a colon */
3593 buf = alloca (strlen (line));
3595 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3598 if (strncmp (srctype, "at:", strlen ("at:")) == 0)
3599 utp->at_string = xstrdup (buf);
3600 else if (strncmp (srctype, "cond:", strlen ("cond:")) == 0)
3601 utp->cond_string = xstrdup (buf);
3602 else if (strncmp (srctype, "cmd:", strlen ("cmd:")) == 0)
3603 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
3607 /* Don't error out, the target might be sending us optional
3608 info that we don't care about. */
3609 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
3613 /* Convert a textual description of a trace state variable into an
3617 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
3620 ULONGEST num, initval, builtin;
3622 struct uploaded_tsv *utsv = NULL;
3624 buf = alloca (strlen (line));
3627 p = unpack_varlen_hex (p, &num);
3628 p++; /* skip a colon */
3629 p = unpack_varlen_hex (p, &initval);
3630 p++; /* skip a colon */
3631 p = unpack_varlen_hex (p, &builtin);
3632 p++; /* skip a colon */
3633 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3636 utsv = get_uploaded_tsv (num, utsvp);
3637 utsv->initial_value = initval;
3638 utsv->builtin = builtin;
3639 utsv->name = xstrdup (buf);
3642 /* Close the trace file and generally clean up. */
3645 tfile_close (int quitting)
3652 pid = ptid_get_pid (inferior_ptid);
3653 inferior_ptid = null_ptid; /* Avoid confusion from thread stuff. */
3654 exit_inferior_silent (pid);
3659 xfree (trace_filename);
3663 tfile_files_info (struct target_ops *t)
3665 /* (it would be useful to mention the name of the file). */
3666 printf_filtered ("Looking at a trace file.\n");
3669 /* The trace status for a file is that tracing can never be run. */
3672 tfile_get_trace_status (struct trace_status *ts)
3674 /* Other bits of trace status were collected as part of opening the
3675 trace files, so nothing to do here. */
3680 /* Given the position of a traceframe in the file, figure out what
3681 address the frame was collected at. This would normally be the
3682 value of a collected PC register, but if not available, we
3686 tfile_get_traceframe_address (off_t tframe_offset)
3690 struct breakpoint *tp;
3691 off_t saved_offset = cur_offset;
3693 /* FIXME dig pc out of collected registers. */
3695 /* Fall back to using tracepoint address. */
3696 lseek (trace_fd, tframe_offset, SEEK_SET);
3697 tfile_read ((gdb_byte *) &tpnum, 2);
3698 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
3702 tp = get_tracepoint_by_number_on_target (tpnum);
3703 /* FIXME this is a poor heuristic if multiple locations. */
3705 addr = tp->loc->address;
3707 /* Restore our seek position. */
3708 cur_offset = saved_offset;
3709 lseek (trace_fd, cur_offset, SEEK_SET);
3713 /* Given a type of search and some parameters, scan the collection of
3714 traceframes in the file looking for a match. When found, return
3715 both the traceframe and tracepoint number, otherwise -1 for
3719 tfile_trace_find (enum trace_find_type type, int num,
3720 ULONGEST addr1, ULONGEST addr2, int *tpp)
3723 int tfnum = 0, found = 0;
3724 unsigned int data_size;
3725 struct breakpoint *tp;
3726 off_t offset, tframe_offset;
3729 lseek (trace_fd, trace_frames_offset, SEEK_SET);
3730 offset = trace_frames_offset;
3733 tframe_offset = offset;
3734 tfile_read ((gdb_byte *) &tpnum, 2);
3735 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
3741 tfile_read ((gdb_byte *) &data_size, 4);
3742 data_size = (unsigned int) extract_unsigned_integer
3743 ((gdb_byte *) &data_size, 4,
3744 gdbarch_byte_order (target_gdbarch));
3753 tfaddr = tfile_get_traceframe_address (tframe_offset);
3754 if (tfaddr == addr1)
3758 tp = get_tracepoint (num);
3759 if (tp && tpnum == tp->number_on_target)
3763 tfaddr = tfile_get_traceframe_address (tframe_offset);
3764 if (addr1 <= tfaddr && tfaddr <= addr2)
3768 tfaddr = tfile_get_traceframe_address (tframe_offset);
3769 if (!(addr1 <= tfaddr && tfaddr <= addr2))
3773 internal_error (__FILE__, __LINE__, _("unknown tfind type"));
3779 cur_offset = offset;
3780 cur_data_size = data_size;
3783 /* Skip past the traceframe's data. */
3784 lseek (trace_fd, data_size, SEEK_CUR);
3785 offset += data_size;
3786 /* Update our own count of traceframes. */
3789 /* Did not find what we were looking for. */
3795 /* Prototype of the callback passed to tframe_walk_blocks. */
3796 typedef int (*walk_blocks_callback_func) (char blocktype, void *data);
3798 /* Callback for traceframe_walk_blocks, used to find a given block
3799 type in a traceframe. */
3802 match_blocktype (char blocktype, void *data)
3804 char *wantedp = data;
3806 if (*wantedp == blocktype)
3812 /* Walk over all traceframe block starting at POS offset from
3813 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
3814 unmodified. If CALLBACK returns true, this returns the position in
3815 the traceframe where the block is found, relative to the start of
3816 the traceframe (cur_offset). Returns -1 if no callback call
3817 returned true, indicating that all blocks have been walked. */
3820 traceframe_walk_blocks (walk_blocks_callback_func callback,
3821 int pos, void *data)
3823 /* Iterate through a traceframe's blocks, looking for a block of the
3826 lseek (trace_fd, cur_offset + pos, SEEK_SET);
3827 while (pos < cur_data_size)
3829 unsigned short mlen;
3832 tfile_read (&block_type, 1);
3836 if ((*callback) (block_type, data))
3842 lseek (trace_fd, cur_offset + pos + trace_regblock_size, SEEK_SET);
3843 pos += trace_regblock_size;
3846 lseek (trace_fd, cur_offset + pos + 8, SEEK_SET);
3847 tfile_read ((gdb_byte *) &mlen, 2);
3848 mlen = (unsigned short)
3849 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
3852 lseek (trace_fd, mlen, SEEK_CUR);
3853 pos += (8 + 2 + mlen);
3856 lseek (trace_fd, cur_offset + pos + 4 + 8, SEEK_SET);
3860 error ("Unknown block type '%c' (0x%x) in trace frame",
3861 block_type, block_type);
3869 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
3870 position offset of a block of type TYPE_WANTED in the current trace
3871 frame, starting at POS. Returns -1 if no such block was found. */
3874 traceframe_find_block_type (char type_wanted, int pos)
3876 return traceframe_walk_blocks (match_blocktype, pos, &type_wanted);
3879 /* Look for a block of saved registers in the traceframe, and get the
3880 requested register from it. */
3883 tfile_fetch_registers (struct target_ops *ops,
3884 struct regcache *regcache, int regno)
3886 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3888 int pos, offset, regn, regsize, pc_regno;
3889 unsigned short mlen;
3892 /* An uninitialized reg size says we're not going to be
3893 successful at getting register blocks. */
3894 if (!trace_regblock_size)
3897 regs = alloca (trace_regblock_size);
3899 if (traceframe_find_block_type ('R', 0) >= 0)
3901 tfile_read (regs, trace_regblock_size);
3903 /* Assume the block is laid out in GDB register number order,
3904 each register with the size that it has in GDB. */
3906 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
3908 regsize = register_size (gdbarch, regn);
3909 /* Make sure we stay within block bounds. */
3910 if (offset + regsize >= trace_regblock_size)
3912 if (regcache_register_status (regcache, regn) == REG_UNKNOWN)
3916 regcache_raw_supply (regcache, regno, regs + offset);
3919 else if (regno == -1)
3921 regcache_raw_supply (regcache, regn, regs + offset);
3929 /* We get here if no register data has been found. Mark registers
3931 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
3932 regcache_raw_supply (regcache, regn, NULL);
3934 /* We can often usefully guess that the PC is going to be the same
3935 as the address of the tracepoint. */
3936 pc_regno = gdbarch_pc_regnum (gdbarch);
3937 if (pc_regno >= 0 && (regno == -1 || regno == pc_regno))
3939 struct breakpoint *tp = get_tracepoint (tracepoint_number);
3943 /* But don't try to guess if tracepoint is multi-location... */
3946 warning (_("Tracepoint %d has multiple "
3947 "locations, cannot infer $pc"),
3951 /* ... or does while-stepping. */
3952 if (tp->step_count > 0)
3954 warning (_("Tracepoint %d does while-stepping, "
3955 "cannot infer $pc"),
3960 store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
3961 gdbarch_byte_order (gdbarch),
3963 regcache_raw_supply (regcache, pc_regno, regs);
3969 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
3970 const char *annex, gdb_byte *readbuf,
3971 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
3975 /* We're only doing regular memory for now. */
3976 if (object != TARGET_OBJECT_MEMORY)
3979 if (readbuf == NULL)
3980 error (_("tfile_xfer_partial: trace file is read-only"));
3982 /* Iterate through the traceframe's blocks, looking for memory. */
3984 while ((pos = traceframe_find_block_type ('M', pos)) >= 0)
3986 ULONGEST maddr, amt;
3987 unsigned short mlen;
3989 tfile_read ((gdb_byte *) &maddr, 8);
3990 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
3991 gdbarch_byte_order (target_gdbarch));
3992 tfile_read ((gdb_byte *) &mlen, 2);
3993 mlen = (unsigned short)
3994 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
3995 gdbarch_byte_order (target_gdbarch));
3997 /* If the block includes the first part of the desired range,
3998 return as much it has; GDB will re-request the remainder,
3999 which might be in a different block of this trace frame. */
4000 if (maddr <= offset && offset < (maddr + mlen))
4002 amt = (maddr + mlen) - offset;
4006 tfile_read (readbuf, amt);
4010 /* Skip over this block. */
4011 pos += (8 + 2 + mlen);
4014 /* It's unduly pedantic to refuse to look at the executable for
4015 read-only pieces; so do the equivalent of readonly regions aka
4017 /* FIXME account for relocation at some point. */
4024 for (s = exec_bfd->sections; s; s = s->next)
4026 if ((s->flags & SEC_LOAD) == 0
4027 || (s->flags & SEC_READONLY) == 0)
4031 size = bfd_get_section_size (s);
4032 if (vma <= offset && offset < (vma + size))
4036 amt = (vma + size) - offset;
4040 amt = bfd_get_section_contents (exec_bfd, s,
4041 readbuf, offset - vma, amt);
4047 /* Indicate failure to find the requested memory block. */
4051 /* Iterate through the blocks of a trace frame, looking for a 'V'
4052 block with a matching tsv number. */
4055 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
4060 while ((pos = traceframe_find_block_type ('V', pos)) >= 0)
4064 tfile_read ((gdb_byte *) &vnum, 4);
4065 vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
4070 tfile_read ((gdb_byte *) val, 8);
4071 *val = extract_signed_integer ((gdb_byte *) val, 8,
4079 /* Didn't find anything. */
4084 tfile_has_all_memory (struct target_ops *ops)
4090 tfile_has_memory (struct target_ops *ops)
4096 tfile_has_stack (struct target_ops *ops)
4102 tfile_has_registers (struct target_ops *ops)
4108 init_tfile_ops (void)
4110 tfile_ops.to_shortname = "tfile";
4111 tfile_ops.to_longname = "Local trace dump file";
4113 = "Use a trace file as a target. Specify the filename of the trace file.";
4114 tfile_ops.to_open = tfile_open;
4115 tfile_ops.to_close = tfile_close;
4116 tfile_ops.to_fetch_registers = tfile_fetch_registers;
4117 tfile_ops.to_xfer_partial = tfile_xfer_partial;
4118 tfile_ops.to_files_info = tfile_files_info;
4119 tfile_ops.to_get_trace_status = tfile_get_trace_status;
4120 tfile_ops.to_trace_find = tfile_trace_find;
4121 tfile_ops.to_get_trace_state_variable_value
4122 = tfile_get_trace_state_variable_value;
4123 tfile_ops.to_stratum = process_stratum;
4124 tfile_ops.to_has_all_memory = tfile_has_all_memory;
4125 tfile_ops.to_has_memory = tfile_has_memory;
4126 tfile_ops.to_has_stack = tfile_has_stack;
4127 tfile_ops.to_has_registers = tfile_has_registers;
4128 tfile_ops.to_magic = OPS_MAGIC;
4131 /* Given a line of text defining a static tracepoint marker, parse it
4132 into a "static tracepoint marker" object. Throws an error is
4133 parsing fails. If PP is non-null, it points to one past the end of
4134 the parsed marker definition. */
4137 parse_static_tracepoint_marker_definition (char *line, char **pp,
4138 struct static_tracepoint_marker *marker)
4145 p = unpack_varlen_hex (p, &addr);
4146 p++; /* skip a colon */
4148 marker->gdbarch = target_gdbarch;
4149 marker->address = (CORE_ADDR) addr;
4151 endp = strchr (p, ':');
4153 error (_("bad marker definition: %s"), line);
4155 marker->str_id = xmalloc (endp - p + 1);
4156 end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
4157 marker->str_id[end] = '\0';
4160 p++; /* skip a colon */
4162 marker->extra = xmalloc (strlen (p) + 1);
4163 end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
4164 marker->extra[end] = '\0';
4170 /* Release a static tracepoint marker's contents. Note that the
4171 object itself isn't released here. There objects are usually on
4175 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
4177 xfree (marker->str_id);
4178 marker->str_id = NULL;
4181 /* Print MARKER to gdb_stdout. */
4184 print_one_static_tracepoint_marker (int count,
4185 struct static_tracepoint_marker *marker)
4187 struct command_line *l;
4190 char wrap_indent[80];
4191 char extra_field_indent[80];
4192 struct ui_stream *stb = ui_out_stream_new (uiout);
4193 struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb);
4194 struct cleanup *bkpt_chain;
4195 VEC(breakpoint_p) *tracepoints;
4197 struct symtab_and_line sal;
4201 sal.pc = marker->address;
4203 tracepoints = static_tracepoints_here (marker->address);
4205 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
4207 /* A counter field to help readability. This is not a stable
4209 ui_out_field_int (uiout, "count", count);
4211 ui_out_field_string (uiout, "marker-id", marker->str_id);
4213 ui_out_field_fmt (uiout, "enabled", "%c",
4214 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
4215 ui_out_spaces (uiout, 2);
4217 strcpy (wrap_indent, " ");
4219 if (gdbarch_addr_bit (marker->gdbarch) <= 32)
4220 strcat (wrap_indent, " ");
4222 strcat (wrap_indent, " ");
4224 strcpy (extra_field_indent, " ");
4226 ui_out_field_core_addr (uiout, "addr", marker->gdbarch, marker->address);
4228 sal = find_pc_line (marker->address, 0);
4229 sym = find_pc_sect_function (marker->address, NULL);
4232 ui_out_text (uiout, "in ");
4233 ui_out_field_string (uiout, "func",
4234 SYMBOL_PRINT_NAME (sym));
4235 ui_out_wrap_hint (uiout, wrap_indent);
4236 ui_out_text (uiout, " at ");
4239 ui_out_field_skip (uiout, "func");
4241 if (sal.symtab != NULL)
4243 ui_out_field_string (uiout, "file", sal.symtab->filename);
4244 ui_out_text (uiout, ":");
4246 if (ui_out_is_mi_like_p (uiout))
4248 char *fullname = symtab_to_fullname (sal.symtab);
4251 ui_out_field_string (uiout, "fullname", fullname);
4254 ui_out_field_skip (uiout, "fullname");
4256 ui_out_field_int (uiout, "line", sal.line);
4260 ui_out_field_skip (uiout, "fullname");
4261 ui_out_field_skip (uiout, "line");
4264 ui_out_text (uiout, "\n");
4265 ui_out_text (uiout, extra_field_indent);
4266 ui_out_text (uiout, _("Data: \""));
4267 ui_out_field_string (uiout, "extra-data", marker->extra);
4268 ui_out_text (uiout, "\"\n");
4270 if (!VEC_empty (breakpoint_p, tracepoints))
4272 struct cleanup *cleanup_chain;
4274 struct breakpoint *b;
4276 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
4279 ui_out_text (uiout, extra_field_indent);
4280 ui_out_text (uiout, _("Probed by static tracepoints: "));
4281 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
4284 ui_out_text (uiout, ", ");
4285 ui_out_text (uiout, "#");
4286 ui_out_field_int (uiout, "tracepoint-id", b->number);
4289 do_cleanups (cleanup_chain);
4291 if (ui_out_is_mi_like_p (uiout))
4292 ui_out_field_int (uiout, "number-of-tracepoints",
4293 VEC_length(breakpoint_p, tracepoints));
4295 ui_out_text (uiout, "\n");
4297 VEC_free (breakpoint_p, tracepoints);
4299 do_cleanups (bkpt_chain);
4300 do_cleanups (old_chain);
4304 info_static_tracepoint_markers_command (char *arg, int from_tty)
4306 VEC(static_tracepoint_marker_p) *markers;
4307 struct cleanup *old_chain;
4308 struct static_tracepoint_marker *marker;
4312 = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
4313 "StaticTracepointMarkersTable");
4315 ui_out_table_header (uiout, 7, ui_left, "counter", "Cnt");
4317 ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
4319 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
4320 if (gdbarch_addr_bit (target_gdbarch) <= 32)
4321 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
4323 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
4324 ui_out_table_header (uiout, 40, ui_noalign, "what", "What");
4326 ui_out_table_body (uiout);
4328 markers = target_static_tracepoint_markers_by_strid (NULL);
4329 make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
4332 VEC_iterate (static_tracepoint_marker_p,
4333 markers, i, marker);
4336 print_one_static_tracepoint_marker (i + 1, marker);
4337 release_static_tracepoint_marker (marker);
4340 do_cleanups (old_chain);
4343 /* The $_sdata convenience variable is a bit special. We don't know
4344 for sure type of the value until we actually have a chance to fetch
4345 the data --- the size of the object depends on what has been
4346 collected. We solve this by making $_sdata be an internalvar that
4347 creates a new value on access. */
4349 /* Return a new value with the correct type for the sdata object of
4350 the current trace frame. Return a void value if there's no object
4353 static struct value *
4354 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var)
4359 /* We need to read the whole object before we know its size. */
4360 size = target_read_alloc (¤t_target,
4361 TARGET_OBJECT_STATIC_TRACE_DATA,
4368 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
4370 v = allocate_value (type);
4371 memcpy (value_contents_raw (v), buf, size);
4376 return allocate_value (builtin_type (gdbarch)->builtin_void);
4379 /* module initialization */
4381 _initialize_tracepoint (void)
4383 struct cmd_list_element *c;
4385 /* Explicitly create without lookup, since that tries to create a
4386 value with a void typed value, and when we get here, gdbarch
4387 isn't initialized yet. At this point, we're quite sure there
4388 isn't another convenience variable of the same name. */
4389 create_internalvar_type_lazy ("_sdata", sdata_make_value);
4391 traceframe_number = -1;
4392 tracepoint_number = -1;
4394 if (tracepoint_list.list == NULL)
4396 tracepoint_list.listsize = 128;
4397 tracepoint_list.list = xmalloc
4398 (tracepoint_list.listsize * sizeof (struct memrange));
4400 if (tracepoint_list.aexpr_list == NULL)
4402 tracepoint_list.aexpr_listsize = 128;
4403 tracepoint_list.aexpr_list = xmalloc
4404 (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
4407 if (stepping_list.list == NULL)
4409 stepping_list.listsize = 128;
4410 stepping_list.list = xmalloc
4411 (stepping_list.listsize * sizeof (struct memrange));
4414 if (stepping_list.aexpr_list == NULL)
4416 stepping_list.aexpr_listsize = 128;
4417 stepping_list.aexpr_list = xmalloc
4418 (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
4421 add_info ("scope", scope_info,
4422 _("List the variables local to a scope"));
4424 add_cmd ("tracepoints", class_trace, NULL,
4425 _("Tracing of program execution without stopping the program."),
4428 add_com ("tdump", class_trace, trace_dump_command,
4429 _("Print everything collected at the current tracepoint."));
4431 add_com ("tsave", class_trace, trace_save_command, _("\
4432 Save the trace data to a file.\n\
4433 Use the '-r' option to direct the target to save directly to the file,\n\
4434 using its own filesystem."));
4436 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
4437 Define a trace state variable.\n\
4438 Argument is a $-prefixed name, optionally followed\n\
4439 by '=' and an expression that sets the initial value\n\
4440 at the start of tracing."));
4441 set_cmd_completer (c, expression_completer);
4443 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
4444 Delete one or more trace state variables.\n\
4445 Arguments are the names of the variables to delete.\n\
4446 If no arguments are supplied, delete all variables."), &deletelist);
4447 /* FIXME add a trace variable completer. */
4449 add_info ("tvariables", tvariables_info, _("\
4450 Status of trace state variables and their values.\n\
4453 add_info ("static-tracepoint-markers",
4454 info_static_tracepoint_markers_command, _("\
4455 List target static tracepoints markers.\n\
4458 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
4459 Select a trace frame;\n\
4460 No argument means forward by one frame; '-' means backward by one frame."),
4461 &tfindlist, "tfind ", 1, &cmdlist);
4463 add_cmd ("outside", class_trace, trace_find_outside_command, _("\
4464 Select a trace frame whose PC is outside the given range (exclusive).\n\
4465 Usage: tfind outside addr1, addr2"),
4468 add_cmd ("range", class_trace, trace_find_range_command, _("\
4469 Select a trace frame whose PC is in the given range (inclusive).\n\
4470 Usage: tfind range addr1,addr2"),
4473 add_cmd ("line", class_trace, trace_find_line_command, _("\
4474 Select a trace frame by source line.\n\
4475 Argument can be a line number (with optional source file),\n\
4476 a function name, or '*' followed by an address.\n\
4477 Default argument is 'the next source line that was traced'."),
4480 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
4481 Select a trace frame by tracepoint number.\n\
4482 Default is the tracepoint for the current trace frame."),
4485 add_cmd ("pc", class_trace, trace_find_pc_command, _("\
4486 Select a trace frame by PC.\n\
4487 Default is the current PC, or the PC of the current trace frame."),
4490 add_cmd ("end", class_trace, trace_find_end_command, _("\
4491 Synonym for 'none'.\n\
4492 De-select any trace frame and resume 'live' debugging."),
4495 add_cmd ("none", class_trace, trace_find_none_command,
4496 _("De-select any trace frame and resume 'live' debugging."),
4499 add_cmd ("start", class_trace, trace_find_start_command,
4500 _("Select the first trace frame in the trace buffer."),
4503 add_com ("tstatus", class_trace, trace_status_command,
4504 _("Display the status of the current trace data collection."));
4506 add_com ("tstop", class_trace, trace_stop_command,
4507 _("Stop trace data collection."));
4509 add_com ("tstart", class_trace, trace_start_command,
4510 _("Start trace data collection."));
4512 add_com ("end", class_trace, end_actions_pseudocommand, _("\
4513 Ends a list of commands or actions.\n\
4514 Several GDB commands allow you to enter a list of commands or actions.\n\
4515 Entering \"end\" on a line by itself is the normal way to terminate\n\
4517 Note: the \"end\" command cannot be used at the gdb prompt."));
4519 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
4520 Specify single-stepping behavior at a tracepoint.\n\
4521 Argument is number of instructions to trace in single-step mode\n\
4522 following the tracepoint. This command is normally followed by\n\
4523 one or more \"collect\" commands, to specify what to collect\n\
4524 while single-stepping.\n\n\
4525 Note: this command can only be used in a tracepoint \"actions\" list."));
4527 add_com_alias ("ws", "while-stepping", class_alias, 0);
4528 add_com_alias ("stepping", "while-stepping", class_alias, 0);
4530 add_com ("collect", class_trace, collect_pseudocommand, _("\
4531 Specify one or more data items to be collected at a tracepoint.\n\
4532 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4533 collect all data (variables, registers) referenced by that expression.\n\
4534 Also accepts the following special arguments:\n\
4535 $regs -- all registers.\n\
4536 $args -- all function arguments.\n\
4537 $locals -- all variables local to the block/function scope.\n\
4538 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
4539 Note: this command can only be used in a tracepoint \"actions\" list."));
4541 add_com ("teval", class_trace, teval_pseudocommand, _("\
4542 Specify one or more expressions to be evaluated at a tracepoint.\n\
4543 Accepts a comma-separated list of (one or more) expressions.\n\
4544 The result of each evaluation will be discarded.\n\
4545 Note: this command can only be used in a tracepoint \"actions\" list."));
4547 add_com ("actions", class_trace, trace_actions_command, _("\
4548 Specify the actions to be taken at a tracepoint.\n\
4549 Tracepoint actions may include collecting of specified data,\n\
4550 single-stepping, or enabling/disabling other tracepoints,\n\
4551 depending on target's capabilities."));
4553 default_collect = xstrdup ("");
4554 add_setshow_string_cmd ("default-collect", class_trace,
4555 &default_collect, _("\
4556 Set the list of expressions to collect by default"), _("\
4557 Show the list of expressions to collect by default"), NULL,
4559 &setlist, &showlist);
4561 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
4562 &disconnected_tracing, _("\
4563 Set whether tracing continues after GDB disconnects."), _("\
4564 Show whether tracing continues after GDB disconnects."), _("\
4565 Use this to continue a tracing run even if GDB disconnects\n\
4566 or detaches from the target. You can reconnect later and look at\n\
4567 trace data collected in the meantime."),
4568 set_disconnected_tracing,
4573 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
4574 &circular_trace_buffer, _("\
4575 Set target's use of circular trace buffer."), _("\
4576 Show target's use of circular trace buffer."), _("\
4577 Use this to make the trace buffer into a circular buffer,\n\
4578 which will discard traceframes (oldest first) instead of filling\n\
4579 up and stopping the trace run."),
4580 set_circular_trace_buffer,
4587 add_target (&tfile_ops);