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 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"
53 /* readline include files */
54 #include "readline/readline.h"
55 #include "readline/history.h"
57 /* readline defines this. */
68 extern int hex2bin (const char *hex, gdb_byte *bin, int count);
69 extern int bin2hex (const gdb_byte *bin, char *hex, int count);
71 extern void stop_tracing ();
73 /* Maximum length of an agent aexpression.
74 This accounts for the fact that packets are limited to 400 bytes
75 (which includes everything -- including the checksum), and assumes
76 the worst case of maximum length for each of the pieces of a
79 NOTE: expressions get mem2hex'ed otherwise this would be twice as
80 large. (400 - 31)/2 == 184 */
81 #define MAX_AGENT_EXPR_LEN 184
83 /* A hook used to notify the UI of tracepoint operations. */
85 void (*deprecated_trace_find_hook) (char *arg, int from_tty);
86 void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
88 extern void (*deprecated_readline_begin_hook) (char *, ...);
89 extern char *(*deprecated_readline_hook) (char *);
90 extern void (*deprecated_readline_end_hook) (void);
92 /* GDB commands implemented in other modules:
95 extern void output_command (char *, int);
100 This module defines the following debugger commands:
101 trace : set a tracepoint on a function, line, or address.
102 info trace : list all debugger-defined tracepoints.
103 delete trace : delete one or more tracepoints.
104 enable trace : enable one or more tracepoints.
105 disable trace : disable one or more tracepoints.
106 actions : specify actions to be taken at a tracepoint.
107 passcount : specify a pass count for a tracepoint.
108 tstart : start a trace experiment.
109 tstop : stop a trace experiment.
110 tstatus : query the status of a trace experiment.
111 tfind : find a trace frame in the trace buffer.
112 tdump : print everything collected at the current tracepoint.
113 save-tracepoints : write tracepoint setup into a file.
115 This module defines the following user-visible debugger variables:
116 $trace_frame : sequence number of trace frame currently being debugged.
117 $trace_line : source line of trace frame currently being debugged.
118 $trace_file : source file of trace frame currently being debugged.
119 $tracepoint : tracepoint number of trace frame currently being debugged.
123 /* ======= Important global variables: ======= */
125 /* The list of all trace state variables. We don't retain pointers to
126 any of these for any reason - API is by name or number only - so it
127 works to have a vector of objects. */
129 typedef struct trace_state_variable tsv_s;
132 static VEC(tsv_s) *tvariables;
134 /* The next integer to assign to a variable. */
136 static int next_tsv_number = 1;
138 /* Number of last traceframe collected. */
139 static int traceframe_number;
141 /* Tracepoint for last traceframe collected. */
142 static int tracepoint_number;
144 /* Symbol for function for last traceframe collected */
145 static struct symbol *traceframe_fun;
147 /* Symtab and line for last traceframe collected */
148 static struct symtab_and_line traceframe_sal;
150 /* Tracing command lists */
151 static struct cmd_list_element *tfindlist;
153 /* List of expressions to collect by default at each tracepoint hit. */
154 char *default_collect = "";
156 static int disconnected_tracing;
158 /* This variable controls whether we ask the target for a linear or
159 circular trace buffer. */
161 static int circular_trace_buffer;
163 /* ======= Important command functions: ======= */
164 static void trace_actions_command (char *, int);
165 static void trace_start_command (char *, int);
166 static void trace_stop_command (char *, int);
167 static void trace_status_command (char *, int);
168 static void trace_find_command (char *, int);
169 static void trace_find_pc_command (char *, int);
170 static void trace_find_tracepoint_command (char *, int);
171 static void trace_find_line_command (char *, int);
172 static void trace_find_range_command (char *, int);
173 static void trace_find_outside_command (char *, int);
174 static void trace_dump_command (char *, int);
176 /* support routines */
178 struct collection_list;
179 static void add_aexpr (struct collection_list *, struct agent_expr *);
180 static char *mem2hex (gdb_byte *, char *, int);
181 static void add_register (struct collection_list *collection,
184 extern void send_disconnected_tracing_value (int value);
186 static void free_uploaded_tps (struct uploaded_tp **utpp);
187 static void free_uploaded_tsvs (struct uploaded_tsv **utsvp);
190 extern void _initialize_tracepoint (void);
192 static struct trace_status trace_status;
194 char *stop_reason_names[] = {
204 struct trace_status *
205 current_trace_status ()
207 return &trace_status;
210 /* Set traceframe number to NUM. */
212 set_traceframe_num (int num)
214 traceframe_number = num;
215 set_internalvar_integer (lookup_internalvar ("trace_frame"), num);
218 /* Set tracepoint number to NUM. */
220 set_tracepoint_num (int num)
222 tracepoint_number = num;
223 set_internalvar_integer (lookup_internalvar ("tracepoint"), num);
226 /* Set externally visible debug variables for querying/printing
227 the traceframe context (line, function, file) */
230 set_traceframe_context (struct frame_info *trace_frame)
234 if (trace_frame == NULL) /* Cease debugging any trace buffers. */
237 traceframe_sal.pc = traceframe_sal.line = 0;
238 traceframe_sal.symtab = NULL;
239 clear_internalvar (lookup_internalvar ("trace_func"));
240 clear_internalvar (lookup_internalvar ("trace_file"));
241 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
245 /* Save as globals for internal use. */
246 trace_pc = get_frame_pc (trace_frame);
247 traceframe_sal = find_pc_line (trace_pc, 0);
248 traceframe_fun = find_pc_function (trace_pc);
250 /* Save linenumber as "$trace_line", a debugger variable visible to
252 set_internalvar_integer (lookup_internalvar ("trace_line"),
253 traceframe_sal.line);
255 /* Save func name as "$trace_func", a debugger variable visible to
257 if (traceframe_fun == NULL
258 || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
259 clear_internalvar (lookup_internalvar ("trace_func"));
261 set_internalvar_string (lookup_internalvar ("trace_func"),
262 SYMBOL_LINKAGE_NAME (traceframe_fun));
264 /* Save file name as "$trace_file", a debugger variable visible to
266 if (traceframe_sal.symtab == NULL
267 || traceframe_sal.symtab->filename == NULL)
268 clear_internalvar (lookup_internalvar ("trace_file"));
270 set_internalvar_string (lookup_internalvar ("trace_file"),
271 traceframe_sal.symtab->filename);
274 /* Create a new trace state variable with the given name. */
276 struct trace_state_variable *
277 create_trace_state_variable (const char *name)
279 struct trace_state_variable tsv;
281 memset (&tsv, 0, sizeof (tsv));
282 tsv.name = xstrdup (name);
283 tsv.number = next_tsv_number++;
284 return VEC_safe_push (tsv_s, tvariables, &tsv);
287 /* Look for a trace state variable of the given name. */
289 struct trace_state_variable *
290 find_trace_state_variable (const char *name)
292 struct trace_state_variable *tsv;
295 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
296 if (strcmp (name, tsv->name) == 0)
303 delete_trace_state_variable (const char *name)
305 struct trace_state_variable *tsv;
308 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
309 if (strcmp (name, tsv->name) == 0)
311 xfree ((void *)tsv->name);
312 VEC_unordered_remove (tsv_s, tvariables, ix);
316 warning (_("No trace variable named \"$%s\", not deleting"), name);
319 /* The 'tvariable' command collects a name and optional expression to
320 evaluate into an initial value. */
323 trace_variable_command (char *args, int from_tty)
325 struct expression *expr;
326 struct cleanup *old_chain;
327 struct internalvar *intvar = NULL;
329 struct trace_state_variable *tsv;
332 error_no_arg (_("trace state variable name"));
334 /* All the possible valid arguments are expressions. */
335 expr = parse_expression (args);
336 old_chain = make_cleanup (free_current_contents, &expr);
338 if (expr->nelts == 0)
339 error (_("No expression?"));
341 /* Only allow two syntaxes; "$name" and "$name=value". */
342 if (expr->elts[0].opcode == OP_INTERNALVAR)
344 intvar = expr->elts[1].internalvar;
346 else if (expr->elts[0].opcode == BINOP_ASSIGN
347 && expr->elts[1].opcode == OP_INTERNALVAR)
349 intvar = expr->elts[2].internalvar;
350 initval = value_as_long (evaluate_subexpression_type (expr, 4));
353 error (_("Syntax must be $NAME [ = EXPR ]"));
356 error (_("No name given"));
358 if (strlen (internalvar_name (intvar)) <= 0)
359 error (_("Must supply a non-empty variable name"));
361 /* If the variable already exists, just change its initial value. */
362 tsv = find_trace_state_variable (internalvar_name (intvar));
365 tsv->initial_value = initval;
366 printf_filtered (_("Trace state variable $%s now has initial value %s.\n"),
367 tsv->name, plongest (tsv->initial_value));
368 do_cleanups (old_chain);
372 /* Create a new variable. */
373 tsv = create_trace_state_variable (internalvar_name (intvar));
374 tsv->initial_value = initval;
376 printf_filtered (_("Trace state variable $%s created, with initial value %s.\n"),
377 tsv->name, plongest (tsv->initial_value));
379 do_cleanups (old_chain);
383 delete_trace_variable_command (char *args, int from_tty)
387 struct cleanup *back_to;
391 if (query (_("Delete all trace state variables? ")))
392 VEC_free (tsv_s, tvariables);
397 argv = gdb_buildargv (args);
398 back_to = make_cleanup_freeargv (argv);
400 for (ix = 0; argv[ix] != NULL; ix++)
402 if (*argv[ix] == '$')
403 delete_trace_state_variable (argv[ix] + 1);
405 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv[ix]);
408 do_cleanups (back_to);
414 tvariables_info_1 (void)
416 struct trace_state_variable *tsv;
419 struct cleanup *back_to;
421 if (VEC_length (tsv_s, tvariables) == 0 && !ui_out_is_mi_like_p (uiout))
423 printf_filtered (_("No trace state variables.\n"));
427 /* Try to acquire values from the target. */
428 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix, ++count)
429 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
432 back_to = make_cleanup_ui_out_table_begin_end (uiout, 3,
433 count, "trace-variables");
434 ui_out_table_header (uiout, 15, ui_left, "name", "Name");
435 ui_out_table_header (uiout, 11, ui_left, "initial", "Initial");
436 ui_out_table_header (uiout, 11, ui_left, "current", "Current");
438 ui_out_table_body (uiout);
440 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
442 struct cleanup *back_to2;
446 back_to2 = make_cleanup_ui_out_tuple_begin_end (uiout, "variable");
448 name = concat ("$", tsv->name, (char *) NULL);
449 make_cleanup (xfree, name);
450 ui_out_field_string (uiout, "name", name);
451 ui_out_field_string (uiout, "initial", plongest (tsv->initial_value));
453 if (tsv->value_known)
454 c = plongest (tsv->value);
455 else if (ui_out_is_mi_like_p (uiout))
456 /* For MI, we prefer not to use magic string constants, but rather
457 omit the field completely. The difference between unknown and
458 undefined does not seem important enough to represent. */
460 else if (current_trace_status ()->running || traceframe_number >= 0)
461 /* The value is/was defined, but we don't have it. */
464 /* It is not meaningful to ask about the value. */
467 ui_out_field_string (uiout, "current", c);
468 ui_out_text (uiout, "\n");
470 do_cleanups (back_to2);
473 do_cleanups (back_to);
476 /* List all the trace state variables. */
479 tvariables_info (char *args, int from_tty)
481 tvariables_info_1 ();
484 /* Stash definitions of tsvs into the given file. */
487 save_trace_state_variables (struct ui_file *fp)
489 struct trace_state_variable *tsv;
492 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
494 fprintf_unfiltered (fp, "tvariable $%s", tsv->name);
495 if (tsv->initial_value)
496 fprintf_unfiltered (fp, " = %s", plongest (tsv->initial_value));
497 fprintf_unfiltered (fp, "\n");
501 /* ACTIONS functions: */
503 /* The three functions:
504 collect_pseudocommand,
505 while_stepping_pseudocommand, and
506 end_actions_pseudocommand
507 are placeholders for "commands" that are actually ONLY to be used
508 within a tracepoint action list. If the actual function is ever called,
509 it means that somebody issued the "command" at the top level,
510 which is always an error. */
513 end_actions_pseudocommand (char *args, int from_tty)
515 error (_("This command cannot be used at the top level."));
519 while_stepping_pseudocommand (char *args, int from_tty)
521 error (_("This command can only be used in a tracepoint actions list."));
525 collect_pseudocommand (char *args, int from_tty)
527 error (_("This command can only be used in a tracepoint actions list."));
531 teval_pseudocommand (char *args, int from_tty)
533 error (_("This command can only be used in a tracepoint actions list."));
536 /* Enter a list of actions for a tracepoint. */
538 trace_actions_command (char *args, int from_tty)
540 struct breakpoint *t;
541 struct command_line *l;
543 t = get_tracepoint_by_number (&args, 0, 1);
547 xstrprintf ("Enter actions for tracepoint %d, one per line.",
549 struct cleanup *cleanups = make_cleanup (xfree, tmpbuf);
551 l = read_command_lines (tmpbuf, from_tty, 1, check_tracepoint_command, t);
552 do_cleanups (cleanups);
553 breakpoint_set_commands (t, l);
555 /* else just return */
558 /* Report the results of checking the agent expression, as errors or
562 report_agent_reqs_errors (struct agent_expr *aexpr)
564 /* All of the "flaws" are serious bytecode generation issues that
565 should never occur. */
566 if (aexpr->flaw != agent_flaw_none)
567 internal_error (__FILE__, __LINE__, _("expression is malformed"));
569 /* If analysis shows a stack underflow, GDB must have done something
570 badly wrong in its bytecode generation. */
571 if (aexpr->min_height < 0)
572 internal_error (__FILE__, __LINE__,
573 _("expression has min height < 0"));
575 /* Issue this error if the stack is predicted to get too deep. The
576 limit is rather arbitrary; a better scheme might be for the
577 target to report how much stack it will have available. The
578 depth roughly corresponds to parenthesization, so a limit of 20
579 amounts to 20 levels of expression nesting, which is actually
580 a pretty big hairy expression. */
581 if (aexpr->max_height > 20)
582 error (_("Expression is too complicated."));
585 /* worker function */
587 validate_actionline (char **line, struct breakpoint *t)
589 struct cmd_list_element *c;
590 struct expression *exp = NULL;
591 struct cleanup *old_chain = NULL;
593 struct bp_location *loc;
594 struct agent_expr *aexpr;
596 /* if EOF is typed, *line is NULL */
600 for (p = *line; isspace ((int) *p);)
603 /* Symbol lookup etc. */
604 if (*p == '\0') /* empty line: just prompt for another line. */
607 if (*p == '#') /* comment line */
610 c = lookup_cmd (&p, cmdlist, "", -1, 1);
612 error (_("`%s' is not a tracepoint action, or is ambiguous."), p);
614 if (cmd_cfunc_eq (c, collect_pseudocommand))
617 { /* repeat over a comma-separated list */
618 QUIT; /* allow user to bail out with ^C */
619 while (isspace ((int) *p))
622 if (*p == '$') /* look for special pseudo-symbols */
624 if ((0 == strncasecmp ("reg", p + 1, 3)) ||
625 (0 == strncasecmp ("arg", p + 1, 3)) ||
626 (0 == strncasecmp ("loc", p + 1, 3)))
631 /* else fall thru, treat p as an expression and parse it! */
634 for (loc = t->loc; loc; loc = loc->next)
637 exp = parse_exp_1 (&p, block_for_pc (loc->address), 1);
638 old_chain = make_cleanup (free_current_contents, &exp);
640 if (exp->elts[0].opcode == OP_VAR_VALUE)
642 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
644 error (_("constant `%s' (value %ld) will not be collected."),
645 SYMBOL_PRINT_NAME (exp->elts[2].symbol),
646 SYMBOL_VALUE (exp->elts[2].symbol));
648 else if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_OPTIMIZED_OUT)
650 error (_("`%s' is optimized away and cannot be collected."),
651 SYMBOL_PRINT_NAME (exp->elts[2].symbol));
655 /* We have something to collect, make sure that the expr to
656 bytecode translator can handle it and that it's not too
658 aexpr = gen_trace_for_expr (loc->address, exp);
659 make_cleanup_free_agent_expr (aexpr);
661 if (aexpr->len > MAX_AGENT_EXPR_LEN)
662 error (_("Expression is too complicated."));
666 report_agent_reqs_errors (aexpr);
668 do_cleanups (old_chain);
671 while (p && *p++ == ',');
674 else if (cmd_cfunc_eq (c, teval_pseudocommand))
677 { /* repeat over a comma-separated list */
678 QUIT; /* allow user to bail out with ^C */
679 while (isspace ((int) *p))
683 for (loc = t->loc; loc; loc = loc->next)
686 /* Only expressions are allowed for this action. */
687 exp = parse_exp_1 (&p, block_for_pc (loc->address), 1);
688 old_chain = make_cleanup (free_current_contents, &exp);
690 /* We have something to evaluate, make sure that the expr to
691 bytecode translator can handle it and that it's not too
693 aexpr = gen_eval_for_expr (loc->address, exp);
694 make_cleanup_free_agent_expr (aexpr);
696 if (aexpr->len > MAX_AGENT_EXPR_LEN)
697 error (_("Expression is too complicated."));
700 report_agent_reqs_errors (aexpr);
702 do_cleanups (old_chain);
705 while (p && *p++ == ',');
708 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
710 char *steparg; /* in case warning is necessary */
712 while (isspace ((int) *p))
716 if (*p == '\0' || (t->step_count = strtol (p, &p, 0)) == 0)
717 error (_("while-stepping step count `%s' is malformed."), *line);
720 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
724 error (_("`%s' is not a supported tracepoint action."), *line);
728 memrange_absolute = -1
733 int type; /* memrange_absolute for absolute memory range,
734 else basereg number */
735 bfd_signed_vma start;
739 struct collection_list
741 unsigned char regs_mask[32]; /* room for up to 256 regs */
744 struct memrange *list;
745 long aexpr_listsize; /* size of array pointed to by expr_list elt */
747 struct agent_expr **aexpr_list;
750 tracepoint_list, stepping_list;
752 /* MEMRANGE functions: */
754 static int memrange_cmp (const void *, const void *);
756 /* compare memranges for qsort */
758 memrange_cmp (const void *va, const void *vb)
760 const struct memrange *a = va, *b = vb;
762 if (a->type < b->type)
764 if (a->type > b->type)
766 if (a->type == memrange_absolute)
768 if ((bfd_vma) a->start < (bfd_vma) b->start)
770 if ((bfd_vma) a->start > (bfd_vma) b->start)
775 if (a->start < b->start)
777 if (a->start > b->start)
783 /* Sort the memrange list using qsort, and merge adjacent memranges. */
785 memrange_sortmerge (struct collection_list *memranges)
789 qsort (memranges->list, memranges->next_memrange,
790 sizeof (struct memrange), memrange_cmp);
791 if (memranges->next_memrange > 0)
793 for (a = 0, b = 1; b < memranges->next_memrange; b++)
795 if (memranges->list[a].type == memranges->list[b].type &&
796 memranges->list[b].start - memranges->list[a].end <=
799 /* memrange b starts before memrange a ends; merge them. */
800 if (memranges->list[b].end > memranges->list[a].end)
801 memranges->list[a].end = memranges->list[b].end;
802 continue; /* next b, same a */
806 memcpy (&memranges->list[a], &memranges->list[b],
807 sizeof (struct memrange));
809 memranges->next_memrange = a + 1;
813 /* Add a register to a collection list. */
815 add_register (struct collection_list *collection, unsigned int regno)
818 printf_filtered ("collect register %d\n", regno);
819 if (regno >= (8 * sizeof (collection->regs_mask)))
820 error (_("Internal: register number %d too large for tracepoint"),
822 collection->regs_mask[regno / 8] |= 1 << (regno % 8);
825 /* Add a memrange to a collection list */
827 add_memrange (struct collection_list *memranges,
828 int type, bfd_signed_vma base,
833 printf_filtered ("(%d,", type);
835 printf_filtered (",%ld)\n", len);
838 /* type: memrange_absolute == memory, other n == basereg */
839 memranges->list[memranges->next_memrange].type = type;
840 /* base: addr if memory, offset if reg relative. */
841 memranges->list[memranges->next_memrange].start = base;
842 /* len: we actually save end (base + len) for convenience */
843 memranges->list[memranges->next_memrange].end = base + len;
844 memranges->next_memrange++;
845 if (memranges->next_memrange >= memranges->listsize)
847 memranges->listsize *= 2;
848 memranges->list = xrealloc (memranges->list,
849 memranges->listsize);
852 if (type != memrange_absolute) /* Better collect the base register! */
853 add_register (memranges, type);
856 /* Add a symbol to a collection list. */
858 collect_symbol (struct collection_list *collect,
860 struct gdbarch *gdbarch,
861 long frame_regno, long frame_offset,
866 bfd_signed_vma offset;
867 int treat_as_expr = 0;
869 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
870 switch (SYMBOL_CLASS (sym))
873 printf_filtered ("%s: don't know symbol class %d\n",
874 SYMBOL_PRINT_NAME (sym),
878 printf_filtered ("constant %s (value %ld) will not be collected.\n",
879 SYMBOL_PRINT_NAME (sym), SYMBOL_VALUE (sym));
882 offset = SYMBOL_VALUE_ADDRESS (sym);
887 sprintf_vma (tmp, offset);
888 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
889 SYMBOL_PRINT_NAME (sym), len,
892 /* A struct may be a C++ class with static fields, go to general
893 expression handling. */
894 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
897 add_memrange (collect, memrange_absolute, offset, len);
900 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
902 printf_filtered ("LOC_REG[parm] %s: ",
903 SYMBOL_PRINT_NAME (sym));
904 add_register (collect, reg);
905 /* Check for doubles stored in two registers. */
906 /* FIXME: how about larger types stored in 3 or more regs? */
907 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
908 len > register_size (gdbarch, reg))
909 add_register (collect, reg + 1);
912 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
913 printf_filtered (" (will not collect %s)\n",
914 SYMBOL_PRINT_NAME (sym));
918 offset = frame_offset + SYMBOL_VALUE (sym);
921 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
922 SYMBOL_PRINT_NAME (sym), len);
924 printf_filtered (" from frame ptr reg %d\n", reg);
926 add_memrange (collect, reg, offset, len);
928 case LOC_REGPARM_ADDR:
929 reg = SYMBOL_VALUE (sym);
933 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
934 SYMBOL_PRINT_NAME (sym), len);
936 printf_filtered (" from reg %d\n", reg);
938 add_memrange (collect, reg, offset, len);
942 offset = frame_offset + SYMBOL_VALUE (sym);
945 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
946 SYMBOL_PRINT_NAME (sym), len);
948 printf_filtered (" from frame ptr reg %d\n", reg);
950 add_memrange (collect, reg, offset, len);
957 case LOC_OPTIMIZED_OUT:
958 printf_filtered ("%s has been optimized out of existence.\n",
959 SYMBOL_PRINT_NAME (sym));
967 /* Expressions are the most general case. */
970 struct agent_expr *aexpr;
971 struct cleanup *old_chain1 = NULL;
973 aexpr = gen_trace_for_var (scope, gdbarch, sym);
975 /* It can happen that the symbol is recorded as a computed
976 location, but it's been optimized away and doesn't actually
977 have a location expression. */
980 printf_filtered ("%s has been optimized out of existence.\n",
981 SYMBOL_PRINT_NAME (sym));
985 old_chain1 = make_cleanup_free_agent_expr (aexpr);
989 report_agent_reqs_errors (aexpr);
991 discard_cleanups (old_chain1);
992 add_aexpr (collect, aexpr);
994 /* take care of the registers */
995 if (aexpr->reg_mask_len > 0)
999 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1001 QUIT; /* allow user to bail out with ^C */
1002 if (aexpr->reg_mask[ndx1] != 0)
1004 /* assume chars have 8 bits */
1005 for (ndx2 = 0; ndx2 < 8; ndx2++)
1006 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1007 /* it's used -- record it */
1008 add_register (collect, ndx1 * 8 + ndx2);
1015 /* Data to be passed around in the calls to the locals and args
1018 struct add_local_symbols_data
1020 struct collection_list *collect;
1021 struct gdbarch *gdbarch;
1028 /* The callback for the locals and args iterators */
1031 do_collect_symbol (const char *print_name,
1035 struct add_local_symbols_data *p = cb_data;
1037 collect_symbol (p->collect, sym, p->gdbarch, p->frame_regno,
1038 p->frame_offset, p->pc);
1042 /* Add all locals (or args) symbols to collection list */
1044 add_local_symbols (struct collection_list *collect,
1045 struct gdbarch *gdbarch, CORE_ADDR pc,
1046 long frame_regno, long frame_offset, int type)
1048 struct block *block;
1049 struct add_local_symbols_data cb_data;
1051 cb_data.collect = collect;
1052 cb_data.gdbarch = gdbarch;
1054 cb_data.frame_regno = frame_regno;
1055 cb_data.frame_offset = frame_offset;
1060 block = block_for_pc (pc);
1063 warning (_("Can't collect locals; "
1064 "no symbol table info available.\n"));
1068 iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1069 if (cb_data.count == 0)
1070 warning (_("No locals found in scope."));
1074 pc = get_pc_function_start (pc);
1075 block = block_for_pc (pc);
1078 warning (_("Can't collect args; no symbol table info available.\n"));
1082 iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1083 if (cb_data.count == 0)
1084 warning (_("No args found in scope."));
1088 /* worker function */
1090 clear_collection_list (struct collection_list *list)
1094 list->next_memrange = 0;
1095 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1097 free_agent_expr (list->aexpr_list[ndx]);
1098 list->aexpr_list[ndx] = NULL;
1100 list->next_aexpr_elt = 0;
1101 memset (list->regs_mask, 0, sizeof (list->regs_mask));
1104 /* reduce a collection list to string form (for gdb protocol) */
1106 stringify_collection_list (struct collection_list *list, char *string)
1108 char temp_buf[2048];
1112 char *(*str_list)[];
1116 count = 1 + list->next_memrange + list->next_aexpr_elt + 1;
1117 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1119 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1120 if (list->regs_mask[i] != 0) /* skip leading zeroes in regs_mask */
1122 if (list->regs_mask[i] != 0) /* prepare to send regs_mask to the stub */
1125 printf_filtered ("\nCollecting registers (mask): 0x");
1130 QUIT; /* allow user to bail out with ^C */
1132 printf_filtered ("%02X", list->regs_mask[i]);
1133 sprintf (end, "%02X", list->regs_mask[i]);
1136 (*str_list)[ndx] = xstrdup (temp_buf);
1140 printf_filtered ("\n");
1141 if (list->next_memrange > 0 && info_verbose)
1142 printf_filtered ("Collecting memranges: \n");
1143 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1145 QUIT; /* allow user to bail out with ^C */
1146 sprintf_vma (tmp2, list->list[i].start);
1149 printf_filtered ("(%d, %s, %ld)\n",
1152 (long) (list->list[i].end - list->list[i].start));
1154 if (count + 27 > MAX_AGENT_EXPR_LEN)
1156 (*str_list)[ndx] = savestring (temp_buf, count);
1163 bfd_signed_vma length = list->list[i].end - list->list[i].start;
1165 /* The "%X" conversion specifier expects an unsigned argument,
1166 so passing -1 (memrange_absolute) to it directly gives you
1167 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1169 if (list->list[i].type == memrange_absolute)
1170 sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
1172 sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
1175 count += strlen (end);
1176 end = temp_buf + count;
1179 for (i = 0; i < list->next_aexpr_elt; i++)
1181 QUIT; /* allow user to bail out with ^C */
1182 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1184 (*str_list)[ndx] = savestring (temp_buf, count);
1189 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1190 end += 10; /* 'X' + 8 hex digits + ',' */
1193 end = mem2hex (list->aexpr_list[i]->buf,
1194 end, list->aexpr_list[i]->len);
1195 count += 2 * list->aexpr_list[i]->len;
1200 (*str_list)[ndx] = savestring (temp_buf, count);
1205 (*str_list)[ndx] = NULL;
1218 encode_actions_1 (struct command_line *action,
1219 struct breakpoint *t,
1220 struct bp_location *tloc,
1222 LONGEST frame_offset,
1223 struct collection_list *collect,
1224 struct collection_list *stepping_list)
1227 struct expression *exp = NULL;
1229 struct value *tempval;
1230 struct cmd_list_element *cmd;
1231 struct agent_expr *aexpr;
1233 for (; action; action = action->next)
1235 QUIT; /* allow user to bail out with ^C */
1236 action_exp = action->line;
1237 while (isspace ((int) *action_exp))
1240 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1242 error (_("Bad action list item: %s"), action_exp);
1244 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1247 { /* repeat over a comma-separated list */
1248 QUIT; /* allow user to bail out with ^C */
1249 while (isspace ((int) *action_exp))
1252 if (0 == strncasecmp ("$reg", action_exp, 4))
1254 for (i = 0; i < gdbarch_num_regs (t->gdbarch); i++)
1255 add_register (collect, i);
1256 action_exp = strchr (action_exp, ','); /* more? */
1258 else if (0 == strncasecmp ("$arg", action_exp, 4))
1260 add_local_symbols (collect,
1266 action_exp = strchr (action_exp, ','); /* more? */
1268 else if (0 == strncasecmp ("$loc", action_exp, 4))
1270 add_local_symbols (collect,
1276 action_exp = strchr (action_exp, ','); /* more? */
1280 unsigned long addr, len;
1281 struct cleanup *old_chain = NULL;
1282 struct cleanup *old_chain1 = NULL;
1284 exp = parse_exp_1 (&action_exp,
1285 block_for_pc (tloc->address), 1);
1286 old_chain = make_cleanup (free_current_contents, &exp);
1288 switch (exp->elts[0].opcode)
1292 const char *name = &exp->elts[2].string;
1294 i = user_reg_map_name_to_regnum (t->gdbarch,
1295 name, strlen (name));
1297 internal_error (__FILE__, __LINE__,
1298 _("Register $%s not available"),
1301 printf_filtered ("OP_REGISTER: ");
1302 add_register (collect, i);
1307 /* safe because we know it's a simple expression */
1308 tempval = evaluate_expression (exp);
1309 addr = value_address (tempval);
1310 len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
1311 add_memrange (collect, memrange_absolute, addr, len);
1315 collect_symbol (collect,
1316 exp->elts[2].symbol,
1323 default: /* full-fledged expression */
1324 aexpr = gen_trace_for_expr (tloc->address, exp);
1326 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1330 report_agent_reqs_errors (aexpr);
1332 discard_cleanups (old_chain1);
1333 add_aexpr (collect, aexpr);
1335 /* take care of the registers */
1336 if (aexpr->reg_mask_len > 0)
1341 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1343 QUIT; /* allow user to bail out with ^C */
1344 if (aexpr->reg_mask[ndx1] != 0)
1346 /* assume chars have 8 bits */
1347 for (ndx2 = 0; ndx2 < 8; ndx2++)
1348 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1349 /* it's used -- record it */
1350 add_register (collect,
1357 do_cleanups (old_chain);
1360 while (action_exp && *action_exp++ == ',');
1362 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1365 { /* repeat over a comma-separated list */
1366 QUIT; /* allow user to bail out with ^C */
1367 while (isspace ((int) *action_exp))
1371 struct cleanup *old_chain = NULL;
1372 struct cleanup *old_chain1 = NULL;
1374 exp = parse_exp_1 (&action_exp,
1375 block_for_pc (tloc->address), 1);
1376 old_chain = make_cleanup (free_current_contents, &exp);
1378 aexpr = gen_eval_for_expr (tloc->address, exp);
1379 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1382 report_agent_reqs_errors (aexpr);
1384 discard_cleanups (old_chain1);
1385 /* Even though we're not officially collecting, add
1386 to the collect list anyway. */
1387 add_aexpr (collect, aexpr);
1389 do_cleanups (old_chain);
1392 while (action_exp && *action_exp++ == ',');
1394 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1396 /* We check against nested while-stepping when setting
1397 breakpoint action, so no way to run into nested
1399 gdb_assert (stepping_list);
1401 encode_actions_1 (action->body_list[0], t, tloc, frame_reg,
1402 frame_offset, stepping_list, NULL);
1405 error (_("Invalid tracepoint command '%s'"), action->line);
1409 /* Render all actions into gdb protocol. */
1411 encode_actions (struct breakpoint *t, struct bp_location *tloc,
1412 char ***tdp_actions, char ***stepping_actions)
1414 static char tdp_buff[2048], step_buff[2048];
1415 char *default_collect_line = NULL;
1416 struct command_line *actions;
1417 struct command_line *default_collect_action = NULL;
1419 LONGEST frame_offset;
1420 struct cleanup *back_to;
1422 back_to = make_cleanup (null_cleanup, NULL);
1424 clear_collection_list (&tracepoint_list);
1425 clear_collection_list (&stepping_list);
1427 *tdp_actions = NULL;
1428 *stepping_actions = NULL;
1430 gdbarch_virtual_frame_pointer (t->gdbarch,
1431 t->loc->address, &frame_reg, &frame_offset);
1433 actions = breakpoint_commands (t);
1435 /* If there are default expressions to collect, make up a collect
1436 action and prepend to the action list to encode. Note that since
1437 validation is per-tracepoint (local var "xyz" might be valid for
1438 one tracepoint and not another, etc), we make up the action on
1439 the fly, and don't cache it. */
1440 if (*default_collect)
1444 default_collect_line = xstrprintf ("collect %s", default_collect);
1445 make_cleanup (xfree, default_collect_line);
1447 line = default_collect_line;
1448 validate_actionline (&line, t);
1450 default_collect_action = xmalloc (sizeof (struct command_line));
1451 make_cleanup (xfree, default_collect_action);
1452 default_collect_action->next = actions;
1453 default_collect_action->line = line;
1454 actions = default_collect_action;
1456 encode_actions_1 (actions, t, tloc, frame_reg, frame_offset,
1457 &tracepoint_list, &stepping_list);
1459 memrange_sortmerge (&tracepoint_list);
1460 memrange_sortmerge (&stepping_list);
1462 *tdp_actions = stringify_collection_list (&tracepoint_list,
1464 *stepping_actions = stringify_collection_list (&stepping_list,
1467 do_cleanups (back_to);
1471 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1473 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1475 collect->aexpr_list =
1476 xrealloc (collect->aexpr_list,
1477 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1478 collect->aexpr_listsize *= 2;
1480 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1481 collect->next_aexpr_elt++;
1486 start_tracing (void)
1488 VEC(breakpoint_p) *tp_vec = NULL;
1490 struct breakpoint *t;
1491 struct trace_state_variable *tsv;
1492 int any_enabled = 0;
1494 tp_vec = all_tracepoints ();
1496 /* No point in tracing without any tracepoints... */
1497 if (VEC_length (breakpoint_p, tp_vec) == 0)
1499 VEC_free (breakpoint_p, tp_vec);
1500 error (_("No tracepoints defined, not starting trace"));
1503 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1505 if (t->enable_state == bp_enabled)
1512 /* No point in tracing with only disabled tracepoints. */
1515 VEC_free (breakpoint_p, tp_vec);
1516 error (_("No tracepoints enabled, not starting trace"));
1519 target_trace_init ();
1521 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1523 t->number_on_target = 0;
1524 target_download_tracepoint (t);
1525 t->number_on_target = t->number;
1527 VEC_free (breakpoint_p, tp_vec);
1529 /* Send down all the trace state variables too. */
1530 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1532 target_download_trace_state_variable (tsv);
1535 /* Tell target to treat text-like sections as transparent. */
1536 target_trace_set_readonly_regions ();
1537 /* Set some mode flags. */
1538 target_set_disconnected_tracing (disconnected_tracing);
1539 target_set_circular_trace_buffer (circular_trace_buffer);
1541 /* Now insert traps and begin collecting data. */
1542 target_trace_start ();
1544 /* Reset our local state. */
1545 set_traceframe_num (-1);
1546 set_tracepoint_num (-1);
1547 set_traceframe_context (NULL);
1548 current_trace_status()->running = 1;
1553 Tell target to clear any previous trace experiment.
1554 Walk the list of tracepoints, and send them (and their actions)
1555 to the target. If no errors,
1556 Tell target to start a new trace experiment. */
1559 trace_start_command (char *args, int from_tty)
1561 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1563 if (current_trace_status ()->running)
1566 && !query (_("A trace is running already. Start a new run? ")))
1567 error (_("New trace run not started."));
1575 trace_stop_command (char *args, int from_tty)
1577 if (!current_trace_status ()->running)
1578 error (_("Trace is not running."));
1586 target_trace_stop ();
1587 /* should change in response to reply? */
1588 current_trace_status ()->running = 0;
1591 /* tstatus command */
1593 trace_status_command (char *args, int from_tty)
1595 struct trace_status *ts = current_trace_status ();
1598 status = target_get_trace_status (ts);
1603 printf_filtered (_("Using a trace file.\n"));
1606 printf_filtered (_("Trace can not be run on this target.\n"));
1611 if (!ts->running_known)
1613 printf_filtered (_("Run/stop status is unknown.\n"));
1615 else if (ts->running)
1617 printf_filtered (_("Trace is running on the target.\n"));
1621 switch (ts->stop_reason)
1623 case trace_never_run:
1624 printf_filtered (_("No trace has been run on the target.\n"));
1627 printf_filtered (_("Trace stopped by a tstop command.\n"));
1629 case trace_buffer_full:
1630 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1632 case trace_disconnected:
1633 printf_filtered (_("Trace stopped because of disconnection.\n"));
1635 case tracepoint_passcount:
1636 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1637 ts->stopping_tracepoint);
1639 case tracepoint_error:
1640 if (ts->stopping_tracepoint)
1641 printf_filtered (_("Trace stopped by an error (%s, tracepoint %d).\n"),
1642 ts->error_desc, ts->stopping_tracepoint);
1644 printf_filtered (_("Trace stopped by an error (%s).\n"),
1647 case trace_stop_reason_unknown:
1648 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1651 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1657 if (ts->traceframes_created >= 0
1658 && ts->traceframe_count != ts->traceframes_created)
1660 printf_filtered (_("Buffer contains %d trace frames (of %d created total).\n"),
1661 ts->traceframe_count, ts->traceframes_created);
1663 else if (ts->traceframe_count >= 0)
1665 printf_filtered (_("Collected %d trace frames.\n"),
1666 ts->traceframe_count);
1669 if (ts->buffer_free >= 0)
1671 if (ts->buffer_size >= 0)
1673 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1674 ts->buffer_free, ts->buffer_size);
1675 if (ts->buffer_size > 0)
1676 printf_filtered (_(" (%d%% full)"),
1677 ((int) ((((long long) (ts->buffer_size
1678 - ts->buffer_free)) * 100)
1679 / ts->buffer_size)));
1680 printf_filtered (_(".\n"));
1683 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1687 if (ts->disconnected_tracing)
1688 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1690 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1692 if (ts->circular_buffer)
1693 printf_filtered (_("Trace buffer is circular.\n"));
1695 /* Now report on what we're doing with tfind. */
1696 if (traceframe_number >= 0)
1697 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1698 traceframe_number, tracepoint_number);
1700 printf_filtered (_("Not looking at any trace frame.\n"));
1703 /* Report the trace status to uiout, in a way suitable for MI, and not
1704 suitable for CLI. If ON_STOP is true, suppress a few fields that
1705 are not meaningful in the -trace-stop response.
1707 The implementation is essentially parallel to trace_status_command, but
1708 merging them will result in unreadable code. */
1710 trace_status_mi (int on_stop)
1712 struct trace_status *ts = current_trace_status ();
1715 status = target_get_trace_status (ts);
1717 if (status == -1 && !ts->from_file)
1719 ui_out_field_string (uiout, "supported", "0");
1724 ui_out_field_string (uiout, "supported", "file");
1726 ui_out_field_string (uiout, "supported", "1");
1728 gdb_assert (ts->running_known);
1732 ui_out_field_string (uiout, "running", "1");
1734 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1735 Given that the frontend gets the status either on -trace-stop, or from
1736 -trace-status after re-connection, it does not seem like this
1737 information is necessary for anything. It is not necessary for either
1738 figuring the vital state of the target nor for navigation of trace
1739 frames. If the frontend wants to show the current state is some
1740 configure dialog, it can request the value when such dialog is
1741 invoked by the user. */
1745 char *stop_reason = NULL;
1746 int stopping_tracepoint = -1;
1749 ui_out_field_string (uiout, "running", "0");
1751 if (ts->stop_reason != trace_stop_reason_unknown)
1753 switch (ts->stop_reason)
1756 stop_reason = "request";
1758 case trace_buffer_full:
1759 stop_reason = "overflow";
1761 case trace_disconnected:
1762 stop_reason = "disconnection";
1764 case tracepoint_passcount:
1765 stop_reason = "passcount";
1766 stopping_tracepoint = ts->stopping_tracepoint;
1768 case tracepoint_error:
1769 stop_reason = "error";
1770 stopping_tracepoint = ts->stopping_tracepoint;
1776 ui_out_field_string (uiout, "stop-reason", stop_reason);
1777 if (stopping_tracepoint != -1)
1778 ui_out_field_int (uiout, "stopping-tracepoint",
1779 stopping_tracepoint);
1780 if (ts->stop_reason == tracepoint_error)
1781 ui_out_field_string (uiout, "error-description",
1787 if (ts->traceframe_count != -1)
1788 ui_out_field_int (uiout, "frames", ts->traceframe_count);
1789 if (ts->traceframes_created != -1)
1790 ui_out_field_int (uiout, "frames-created", ts->traceframes_created);
1791 if (ts->buffer_size != -1)
1792 ui_out_field_int (uiout, "buffer-size", ts->buffer_size);
1793 if (ts->buffer_free != -1)
1794 ui_out_field_int (uiout, "buffer-free", ts->buffer_free);
1796 ui_out_field_int (uiout, "disconnected", ts->disconnected_tracing);
1797 ui_out_field_int (uiout, "circular", ts->circular_buffer);
1800 /* This function handles the details of what to do about an ongoing
1801 tracing run if the user has asked to detach or otherwise disconnect
1804 disconnect_tracing (int from_tty)
1806 /* It can happen that the target that was tracing went away on its
1807 own, and we didn't notice. Get a status update, and if the
1808 current target doesn't even do tracing, then assume it's not
1810 if (target_get_trace_status (current_trace_status ()) < 0)
1811 current_trace_status ()->running = 0;
1813 /* If running interactively, give the user the option to cancel and
1814 then decide what to do differently with the run. Scripts are
1815 just going to disconnect and let the target deal with it,
1816 according to how it's been instructed previously via
1817 disconnected-tracing. */
1818 if (current_trace_status ()->running && from_tty)
1820 if (current_trace_status ()->disconnected_tracing)
1822 if (!query (_("Trace is running and will continue after detach; detach anyway? ")))
1823 error (_("Not confirmed."));
1827 if (!query (_("Trace is running but will stop on detach; detach anyway? ")))
1828 error (_("Not confirmed."));
1832 /* Also we want to be out of tfind mode, otherwise things can get
1833 confusing upon reconnection. Just use these calls instead of
1834 full tfind_1 behavior because we're in the middle of detaching,
1835 and there's no point to updating current stack frame etc. */
1836 set_traceframe_number (-1);
1837 set_traceframe_context (NULL);
1840 /* Worker function for the various flavors of the tfind command. */
1842 tfind_1 (enum trace_find_type type, int num,
1843 ULONGEST addr1, ULONGEST addr2,
1846 int target_frameno = -1, target_tracept = -1;
1847 struct frame_id old_frame_id = null_frame_id;
1848 struct breakpoint *tp;
1850 /* Only try to get the current stack frame if we have a chance of
1851 succeeding. In particular, if we're trying to get a first trace
1852 frame while all threads are running, it's not going to succeed,
1853 so leave it with a default value and let the frame comparison
1854 below (correctly) decide to print out the source location of the
1856 if (!(type == tfind_number && num == -1)
1857 && (has_stack_frames () || traceframe_number >= 0))
1858 old_frame_id = get_frame_id (get_current_frame ());
1860 target_frameno = target_trace_find (type, num, addr1, addr2,
1863 if (type == tfind_number
1865 && target_frameno == -1)
1867 /* We told the target to get out of tfind mode, and it did. */
1869 else if (target_frameno == -1)
1871 /* A request for a non-existent trace frame has failed.
1872 Our response will be different, depending on FROM_TTY:
1874 If FROM_TTY is true, meaning that this command was
1875 typed interactively by the user, then give an error
1876 and DO NOT change the state of traceframe_number etc.
1878 However if FROM_TTY is false, meaning that we're either
1879 in a script, a loop, or a user-defined command, then
1880 DON'T give an error, but DO change the state of
1881 traceframe_number etc. to invalid.
1883 The rationalle is that if you typed the command, you
1884 might just have committed a typo or something, and you'd
1885 like to NOT lose your current debugging state. However
1886 if you're in a user-defined command or especially in a
1887 loop, then you need a way to detect that the command
1888 failed WITHOUT aborting. This allows you to write
1889 scripts that search thru the trace buffer until the end,
1890 and then continue on to do something else. */
1893 error (_("Target failed to find requested trace frame."));
1897 printf_filtered ("End of trace buffer.\n");
1898 #if 0 /* dubious now? */
1899 /* The following will not recurse, since it's
1901 trace_find_command ("-1", from_tty);
1906 tp = get_tracepoint_by_number_on_target (target_tracept);
1908 reinit_frame_cache ();
1909 registers_changed ();
1910 target_dcache_invalidate ();
1911 set_traceframe_num (target_frameno);
1912 set_tracepoint_num (tp ? tp->number : target_tracept);
1913 if (target_frameno == -1)
1914 set_traceframe_context (NULL);
1916 set_traceframe_context (get_current_frame ());
1918 if (traceframe_number >= 0)
1920 /* Use different branches for MI and CLI to make CLI messages
1922 if (ui_out_is_mi_like_p (uiout))
1924 ui_out_field_string (uiout, "found", "1");
1925 ui_out_field_int (uiout, "tracepoint", tracepoint_number);
1926 ui_out_field_int (uiout, "traceframe", traceframe_number);
1930 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
1931 traceframe_number, tracepoint_number);
1936 if (ui_out_is_mi_like_p (uiout))
1937 ui_out_field_string (uiout, "found", "0");
1938 else if (type == tfind_number && num == -1)
1939 printf_unfiltered (_("No longer looking at any trace frame\n"));
1940 else /* this case may never occur, check */
1941 printf_unfiltered (_("No trace frame found\n"));
1944 /* If we're in nonstop mode and getting out of looking at trace
1945 frames, there won't be any current frame to go back to and
1948 && (has_stack_frames () || traceframe_number >= 0))
1950 enum print_what print_what;
1952 /* NOTE: in imitation of the step command, try to determine
1953 whether we have made a transition from one function to
1954 another. If so, we'll print the "stack frame" (ie. the new
1955 function and it's arguments) -- otherwise we'll just show the
1958 if (frame_id_eq (old_frame_id,
1959 get_frame_id (get_current_frame ())))
1960 print_what = SRC_LINE;
1962 print_what = SRC_AND_LOC;
1964 print_stack_frame (get_selected_frame (NULL), 1, print_what);
1969 /* trace_find_command takes a trace frame number n,
1970 sends "QTFrame:<n>" to the target,
1971 and accepts a reply that may contain several optional pieces
1972 of information: a frame number, a tracepoint number, and an
1973 indication of whether this is a trap frame or a stepping frame.
1975 The minimal response is just "OK" (which indicates that the
1976 target does not give us a frame number or a tracepoint number).
1977 Instead of that, the target may send us a string containing
1979 F<hexnum> (gives the selected frame number)
1980 T<hexnum> (gives the selected tracepoint number)
1985 trace_find_command (char *args, int from_tty)
1986 { /* this should only be called with a numeric argument */
1989 if (current_trace_status ()->running && !current_trace_status ()->from_file)
1990 error ("May not look at trace frames while trace is running.");
1992 if (args == 0 || *args == 0)
1993 { /* TFIND with no args means find NEXT trace frame. */
1994 if (traceframe_number == -1)
1995 frameno = 0; /* "next" is first one */
1997 frameno = traceframe_number + 1;
1999 else if (0 == strcmp (args, "-"))
2001 if (traceframe_number == -1)
2002 error (_("not debugging trace buffer"));
2003 else if (from_tty && traceframe_number == 0)
2004 error (_("already at start of trace buffer"));
2006 frameno = traceframe_number - 1;
2008 /* A hack to work around eval's need for fp to have been collected. */
2009 else if (0 == strcmp (args, "-1"))
2012 frameno = parse_and_eval_long (args);
2015 error (_("invalid input (%d is less than zero)"), frameno);
2017 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2022 trace_find_end_command (char *args, int from_tty)
2024 trace_find_command ("-1", from_tty);
2029 trace_find_none_command (char *args, int from_tty)
2031 trace_find_command ("-1", from_tty);
2036 trace_find_start_command (char *args, int from_tty)
2038 trace_find_command ("0", from_tty);
2041 /* tfind pc command */
2043 trace_find_pc_command (char *args, int from_tty)
2047 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2048 error ("May not look at trace frames while trace is running.");
2050 if (args == 0 || *args == 0)
2051 pc = regcache_read_pc (get_current_regcache ());
2053 pc = parse_and_eval_address (args);
2055 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2058 /* tfind tracepoint command */
2060 trace_find_tracepoint_command (char *args, int from_tty)
2063 struct breakpoint *tp;
2065 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2066 error ("May not look at trace frames while trace is running.");
2068 if (args == 0 || *args == 0)
2070 if (tracepoint_number == -1)
2071 error (_("No current tracepoint -- please supply an argument."));
2073 tdp = tracepoint_number; /* default is current TDP */
2076 tdp = parse_and_eval_long (args);
2078 /* If we have the tracepoint on hand, use the number that the
2079 target knows about (which may be different if we disconnected
2080 and reconnected). */
2081 tp = get_tracepoint (tdp);
2083 tdp = tp->number_on_target;
2085 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2088 /* TFIND LINE command:
2090 This command will take a sourceline for argument, just like BREAK
2091 or TRACE (ie. anything that "decode_line_1" can handle).
2093 With no argument, this command will find the next trace frame
2094 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2097 trace_find_line_command (char *args, int from_tty)
2099 static CORE_ADDR start_pc, end_pc;
2100 struct symtabs_and_lines sals;
2101 struct symtab_and_line sal;
2102 struct cleanup *old_chain;
2104 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2105 error ("May not look at trace frames while trace is running.");
2107 if (args == 0 || *args == 0)
2109 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2111 sals.sals = (struct symtab_and_line *)
2112 xmalloc (sizeof (struct symtab_and_line));
2117 sals = decode_line_spec (args, 1);
2121 old_chain = make_cleanup (xfree, sals.sals);
2122 if (sal.symtab == 0)
2123 error (_("No line number information available."));
2125 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2127 if (start_pc == end_pc)
2129 printf_filtered ("Line %d of \"%s\"",
2130 sal.line, sal.symtab->filename);
2132 printf_filtered (" is at address ");
2133 print_address (get_current_arch (), start_pc, gdb_stdout);
2135 printf_filtered (" but contains no code.\n");
2136 sal = find_pc_line (start_pc, 0);
2138 && find_line_pc_range (sal, &start_pc, &end_pc)
2139 && start_pc != end_pc)
2140 printf_filtered ("Attempting to find line %d instead.\n",
2143 error (_("Cannot find a good line."));
2147 /* Is there any case in which we get here, and have an address
2148 which the user would want to see? If we have debugging
2149 symbols and no line numbers? */
2150 error (_("Line number %d is out of range for \"%s\"."),
2151 sal.line, sal.symtab->filename);
2153 /* Find within range of stated line. */
2155 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2157 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2158 do_cleanups (old_chain);
2161 /* tfind range command */
2163 trace_find_range_command (char *args, int from_tty)
2165 static CORE_ADDR start, stop;
2168 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2169 error ("May not look at trace frames while trace is running.");
2171 if (args == 0 || *args == 0)
2172 { /* XXX FIXME: what should default behavior be? */
2173 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2177 if (0 != (tmp = strchr (args, ',')))
2179 *tmp++ = '\0'; /* terminate start address */
2180 while (isspace ((int) *tmp))
2182 start = parse_and_eval_address (args);
2183 stop = parse_and_eval_address (tmp);
2186 { /* no explicit end address? */
2187 start = parse_and_eval_address (args);
2188 stop = start + 1; /* ??? */
2191 tfind_1 (tfind_range, 0, start, stop, from_tty);
2194 /* tfind outside command */
2196 trace_find_outside_command (char *args, int from_tty)
2198 CORE_ADDR start, stop;
2201 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2202 error ("May not look at trace frames while trace is running.");
2204 if (args == 0 || *args == 0)
2205 { /* XXX FIXME: what should default behavior be? */
2206 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2210 if (0 != (tmp = strchr (args, ',')))
2212 *tmp++ = '\0'; /* terminate start address */
2213 while (isspace ((int) *tmp))
2215 start = parse_and_eval_address (args);
2216 stop = parse_and_eval_address (tmp);
2219 { /* no explicit end address? */
2220 start = parse_and_eval_address (args);
2221 stop = start + 1; /* ??? */
2224 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2227 /* info scope command: list the locals for a scope. */
2229 scope_info (char *args, int from_tty)
2231 struct symtabs_and_lines sals;
2233 struct minimal_symbol *msym;
2234 struct block *block;
2235 char **canonical, *symname, *save_args = args;
2236 struct dict_iterator iter;
2238 struct gdbarch *gdbarch;
2241 if (args == 0 || *args == 0)
2242 error (_("requires an argument (function, line or *addr) to define a scope"));
2244 sals = decode_line_1 (&args, 1, NULL, 0, &canonical, NULL);
2245 if (sals.nelts == 0)
2246 return; /* presumably decode_line_1 has already warned */
2248 /* Resolve line numbers to PC */
2249 resolve_sal_pc (&sals.sals[0]);
2250 block = block_for_pc (sals.sals[0].pc);
2254 QUIT; /* allow user to bail out with ^C */
2255 ALL_BLOCK_SYMBOLS (block, iter, sym)
2257 QUIT; /* allow user to bail out with ^C */
2259 printf_filtered ("Scope for %s:\n", save_args);
2262 symname = SYMBOL_PRINT_NAME (sym);
2263 if (symname == NULL || *symname == '\0')
2264 continue; /* probably botched, certainly useless */
2266 gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
2268 printf_filtered ("Symbol %s is ", symname);
2269 switch (SYMBOL_CLASS (sym))
2272 case LOC_UNDEF: /* messed up symbol? */
2273 printf_filtered ("a bogus symbol, class %d.\n",
2274 SYMBOL_CLASS (sym));
2275 count--; /* don't count this one */
2278 printf_filtered ("a constant with value %ld (0x%lx)",
2279 SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
2281 case LOC_CONST_BYTES:
2282 printf_filtered ("constant bytes: ");
2283 if (SYMBOL_TYPE (sym))
2284 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2285 fprintf_filtered (gdb_stdout, " %02x",
2286 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2289 printf_filtered ("in static storage at address ");
2290 printf_filtered ("%s", paddress (gdbarch,
2291 SYMBOL_VALUE_ADDRESS (sym)));
2294 /* GDBARCH is the architecture associated with the objfile
2295 the symbol is defined in; the target architecture may be
2296 different, and may provide additional registers. However,
2297 we do not know the target architecture at this point.
2298 We assume the objfile architecture will contain all the
2299 standard registers that occur in debug info in that
2301 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
2303 if (SYMBOL_IS_ARGUMENT (sym))
2304 printf_filtered ("an argument in register $%s",
2305 gdbarch_register_name (gdbarch, regno));
2307 printf_filtered ("a local variable in register $%s",
2308 gdbarch_register_name (gdbarch, regno));
2311 printf_filtered ("an argument at stack/frame offset %ld",
2312 SYMBOL_VALUE (sym));
2315 printf_filtered ("a local variable at frame offset %ld",
2316 SYMBOL_VALUE (sym));
2319 printf_filtered ("a reference argument at offset %ld",
2320 SYMBOL_VALUE (sym));
2322 case LOC_REGPARM_ADDR:
2323 /* Note comment at LOC_REGISTER. */
2324 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
2325 printf_filtered ("the address of an argument, in register $%s",
2326 gdbarch_register_name (gdbarch, regno));
2329 printf_filtered ("a typedef.\n");
2332 printf_filtered ("a label at address ");
2333 printf_filtered ("%s", paddress (gdbarch,
2334 SYMBOL_VALUE_ADDRESS (sym)));
2337 printf_filtered ("a function at address ");
2338 printf_filtered ("%s",
2339 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2341 case LOC_UNRESOLVED:
2342 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2345 printf_filtered ("Unresolved Static");
2348 printf_filtered ("static storage at address ");
2349 printf_filtered ("%s",
2350 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msym)));
2353 case LOC_OPTIMIZED_OUT:
2354 printf_filtered ("optimized out.\n");
2357 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2358 BLOCK_START (block),
2362 if (SYMBOL_TYPE (sym))
2363 printf_filtered (", length %d.\n",
2364 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2366 if (BLOCK_FUNCTION (block))
2369 block = BLOCK_SUPERBLOCK (block);
2372 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2376 /* worker function (cleanup) */
2378 replace_comma (void *data)
2385 /* Helper for trace_dump_command. Dump the action list starting at
2386 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2387 actions of the body of a while-stepping action. STEPPING_FRAME is
2388 set if the current traceframe was determined to be a while-stepping
2392 trace_dump_actions (struct command_line *action,
2393 int stepping_actions, int stepping_frame,
2396 char *action_exp, *next_comma;
2398 for (; action != NULL; action = action->next)
2400 struct cmd_list_element *cmd;
2402 QUIT; /* allow user to bail out with ^C */
2403 action_exp = action->line;
2404 while (isspace ((int) *action_exp))
2407 /* The collection actions to be done while stepping are
2408 bracketed by the commands "while-stepping" and "end". */
2410 if (*action_exp == '#') /* comment line */
2413 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2415 error (_("Bad action list item: %s"), action_exp);
2417 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2421 for (i = 0; i < action->body_count; ++i)
2422 trace_dump_actions (action->body_list[i],
2423 1, stepping_frame, from_tty);
2425 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2427 /* Display the collected data.
2428 For the trap frame, display only what was collected at
2429 the trap. Likewise for stepping frames, display only
2430 what was collected while stepping. This means that the
2431 two boolean variables, STEPPING_FRAME and
2432 STEPPING_ACTIONS should be equal. */
2433 if (stepping_frame == stepping_actions)
2436 { /* repeat over a comma-separated list */
2437 QUIT; /* allow user to bail out with ^C */
2438 if (*action_exp == ',')
2440 while (isspace ((int) *action_exp))
2443 next_comma = strchr (action_exp, ',');
2445 if (0 == strncasecmp (action_exp, "$reg", 4))
2446 registers_info (NULL, from_tty);
2447 else if (0 == strncasecmp (action_exp, "$loc", 4))
2448 locals_info (NULL, from_tty);
2449 else if (0 == strncasecmp (action_exp, "$arg", 4))
2450 args_info (NULL, from_tty);
2455 make_cleanup (replace_comma, next_comma);
2458 printf_filtered ("%s = ", action_exp);
2459 output_command (action_exp, from_tty);
2460 printf_filtered ("\n");
2464 action_exp = next_comma;
2466 while (action_exp && *action_exp == ',');
2472 /* The tdump command. */
2475 trace_dump_command (char *args, int from_tty)
2477 struct regcache *regcache;
2478 struct breakpoint *t;
2479 int stepping_frame = 0;
2480 struct bp_location *loc;
2481 char *line, *default_collect_line = NULL;
2482 struct command_line *actions, *default_collect_action = NULL;
2483 struct cleanup *old_chain = NULL;
2485 if (tracepoint_number == -1)
2487 warning (_("No current trace frame."));
2491 t = get_tracepoint (tracepoint_number);
2494 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2497 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2498 tracepoint_number, traceframe_number);
2500 /* The current frame is a trap frame if the frame PC is equal
2501 to the tracepoint PC. If not, then the current frame was
2502 collected during single-stepping. */
2504 regcache = get_current_regcache ();
2506 /* If the traceframe's address matches any of the tracepoint's
2507 locations, assume it is a direct hit rather than a while-stepping
2508 frame. (FIXME this is not reliable, should record each frame's
2511 for (loc = t->loc; loc; loc = loc->next)
2512 if (loc->address == regcache_read_pc (regcache))
2515 actions = breakpoint_commands (t);
2517 /* If there is a default-collect list, make up a collect command,
2518 prepend to the tracepoint's commands, and pass the whole mess to
2519 the trace dump scanner. We need to validate because
2520 default-collect might have been junked since the trace run. */
2521 if (*default_collect)
2523 default_collect_line = xstrprintf ("collect %s", default_collect);
2524 old_chain = make_cleanup (xfree, default_collect_line);
2525 line = default_collect_line;
2526 validate_actionline (&line, t);
2527 default_collect_action = xmalloc (sizeof (struct command_line));
2528 make_cleanup (xfree, default_collect_action);
2529 default_collect_action->next = actions;
2530 default_collect_action->line = line;
2531 actions = default_collect_action;
2534 trace_dump_actions (actions, 0, stepping_frame, from_tty);
2536 if (*default_collect)
2537 do_cleanups (old_chain);
2540 /* Encode a piece of a tracepoint's source-level definition in a form
2541 that is suitable for both protocol and saving in files. */
2542 /* This version does not do multiple encodes for long strings; it should
2543 return an offset to the next piece to encode. FIXME */
2546 encode_source_string (int tpnum, ULONGEST addr,
2547 char *srctype, char *src, char *buf, int buf_size)
2549 if (80 + strlen (srctype) > buf_size)
2550 error (_("Buffer too small for source encoding"));
2551 sprintf (buf, "%x:%s:%s:%x:%x:",
2552 tpnum, phex_nz (addr, sizeof (addr)), srctype, 0, (int) strlen (src));
2553 if (strlen (buf) + strlen (src) * 2 >= buf_size)
2554 error (_("Source string too long for buffer"));
2555 bin2hex (src, buf + strlen (buf), 0);
2559 extern int trace_regblock_size;
2561 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2562 non-zero, the save is performed on the target, otherwise GDB obtains all
2563 trace data and saves it locally. */
2566 trace_save (const char *filename, int target_does_save)
2568 struct cleanup *cleanup;
2570 struct trace_status *ts = current_trace_status ();
2573 struct uploaded_tp *uploaded_tps = NULL, *utp;
2574 struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
2578 ULONGEST offset = 0;
2579 #define MAX_TRACE_UPLOAD 2000
2580 gdb_byte buf[MAX_TRACE_UPLOAD];
2583 /* If the target is to save the data to a file on its own, then just
2584 send the command and be done with it. */
2585 if (target_does_save)
2587 err = target_save_trace_data (filename);
2589 error (_("Target failed to save trace data to '%s'."),
2594 /* Get the trace status first before opening the file, so if the
2595 target is losing, we can get out without touching files. */
2596 status = target_get_trace_status (ts);
2598 pathname = tilde_expand (filename);
2599 cleanup = make_cleanup (xfree, pathname);
2601 fp = fopen (pathname, "wb");
2603 error (_("Unable to open file '%s' for saving trace data (%s)"),
2604 filename, safe_strerror (errno));
2605 make_cleanup_fclose (fp);
2607 /* Write a file header, with a high-bit-set char to indicate a
2608 binary file, plus a hint as what this file is, and a version
2609 number in case of future needs. */
2610 written = fwrite ("\x7fTRACE0\n", 8, 1, fp);
2612 perror_with_name (pathname);
2614 /* Write descriptive info. */
2616 /* Write out the size of a register block. */
2617 fprintf (fp, "R %x\n", trace_regblock_size);
2619 /* Write out status of the tracing run (aka "tstatus" info). */
2620 fprintf (fp, "status %c;%s",
2621 (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
2622 if (ts->stop_reason == tracepoint_error)
2624 char *buf = (char *) alloca (strlen (ts->error_desc) * 2 + 1);
2625 bin2hex ((gdb_byte *) ts->error_desc, buf, 0);
2626 fprintf (fp, ":%s", buf);
2628 fprintf (fp, ":%x", ts->stopping_tracepoint);
2629 if (ts->traceframe_count >= 0)
2630 fprintf (fp, ";tframes:%x", ts->traceframe_count);
2631 if (ts->traceframes_created >= 0)
2632 fprintf (fp, ";tcreated:%x", ts->traceframes_created);
2633 if (ts->buffer_free >= 0)
2634 fprintf (fp, ";tfree:%x", ts->buffer_free);
2635 if (ts->buffer_size >= 0)
2636 fprintf (fp, ";tsize:%x", ts->buffer_size);
2637 if (ts->disconnected_tracing)
2638 fprintf (fp, ";disconn:%x", ts->disconnected_tracing);
2639 if (ts->circular_buffer)
2640 fprintf (fp, ";circular:%x", ts->circular_buffer);
2643 /* Note that we want to upload tracepoints and save those, rather
2644 than simply writing out the local ones, because the user may have
2645 changed tracepoints in GDB in preparation for a future tracing
2646 run, or maybe just mass-deleted all types of breakpoints as part
2647 of cleaning up. So as not to contaminate the session, leave the
2648 data in its uploaded form, don't make into real tracepoints. */
2650 /* Get trace state variables first, they may be checked when parsing
2651 uploaded commands. */
2653 target_upload_trace_state_variables (&uploaded_tsvs);
2655 for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
2661 buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
2662 bin2hex ((gdb_byte *) (utsv->name), buf, 0);
2665 fprintf (fp, "tsv %x:%s:%x:%s\n",
2666 utsv->number, phex_nz (utsv->initial_value, 8),
2667 utsv->builtin, buf);
2673 free_uploaded_tsvs (&uploaded_tsvs);
2675 target_upload_tracepoints (&uploaded_tps);
2677 for (utp = uploaded_tps; utp; utp = utp->next)
2679 fprintf (fp, "tp T%x:%s:%c:%x:%x",
2680 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
2681 (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
2682 if (utp->type == bp_fast_tracepoint)
2683 fprintf (fp, ":F%x", utp->orig_size);
2685 fprintf (fp, ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
2688 for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
2689 fprintf (fp, "tp A%x:%s:%s\n",
2690 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
2691 for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
2692 fprintf (fp, "tp S%x:%s:%s\n",
2693 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
2696 encode_source_string (utp->number, utp->addr,
2697 "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
2698 fprintf (fp, "tp Z%s\n", buf);
2700 if (utp->cond_string)
2702 encode_source_string (utp->number, utp->addr,
2703 "cond", utp->cond_string, buf, MAX_TRACE_UPLOAD);
2704 fprintf (fp, "tp Z%s\n", buf);
2706 for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
2708 encode_source_string (utp->number, utp->addr, "cmd", act,
2709 buf, MAX_TRACE_UPLOAD);
2710 fprintf (fp, "tp Z%s\n", buf);
2714 free_uploaded_tps (&uploaded_tps);
2716 /* Mark the end of the definition section. */
2719 /* Get and write the trace data proper. We ask for big blocks, in
2720 the hopes of efficiency, but will take less if the target has
2721 packet size limitations or some such. */
2724 gotten = target_get_raw_trace_data (buf, offset, MAX_TRACE_UPLOAD);
2726 error (_("Failure to get requested trace buffer data"));
2727 /* No more data is forthcoming, we're done. */
2730 written = fwrite (buf, gotten, 1, fp);
2732 perror_with_name (pathname);
2736 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
2737 written = fwrite (&gotten, 4, 1, fp);
2739 perror_with_name (pathname);
2741 do_cleanups (cleanup);
2745 trace_save_command (char *args, int from_tty)
2747 int target_does_save = 0;
2749 char *filename = NULL;
2750 struct cleanup *back_to;
2753 error_no_arg (_("file in which to save trace data"));
2755 argv = gdb_buildargv (args);
2756 back_to = make_cleanup_freeargv (argv);
2758 for (; *argv; ++argv)
2760 if (strcmp (*argv, "-r") == 0)
2761 target_does_save = 1;
2762 else if (**argv == '-')
2763 error (_("unknown option `%s'"), *argv);
2769 error_no_arg (_("file in which to save trace data"));
2771 trace_save (filename, target_does_save);
2774 printf_filtered (_("Trace data saved to file '%s'.\n"), args);
2776 do_cleanups (back_to);
2779 /* Tell the target what to do with an ongoing tracing run if GDB
2780 disconnects for some reason. */
2783 send_disconnected_tracing_value (int value)
2785 target_set_disconnected_tracing (value);
2789 set_disconnected_tracing (char *args, int from_tty,
2790 struct cmd_list_element *c)
2792 send_disconnected_tracing_value (disconnected_tracing);
2796 set_circular_trace_buffer (char *args, int from_tty,
2797 struct cmd_list_element *c)
2799 target_set_circular_trace_buffer (circular_trace_buffer);
2802 /* Convert the memory pointed to by mem into hex, placing result in buf.
2803 * Return a pointer to the last char put in buf (null)
2804 * "stolen" from sparc-stub.c
2807 static const char hexchars[] = "0123456789abcdef";
2810 mem2hex (gdb_byte *mem, char *buf, int count)
2818 *buf++ = hexchars[ch >> 4];
2819 *buf++ = hexchars[ch & 0xf];
2828 get_traceframe_number (void)
2830 return traceframe_number;
2833 /* Make the traceframe NUM be the current trace frame. Does nothing
2834 if NUM is already current. */
2837 set_traceframe_number (int num)
2841 if (traceframe_number == num)
2843 /* Nothing to do. */
2847 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
2850 warning (_("could not change traceframe"));
2852 traceframe_number = newnum;
2854 /* Changing the traceframe changes our view of registers and of the
2856 registers_changed ();
2859 /* A cleanup used when switching away and back from tfind mode. */
2861 struct current_traceframe_cleanup
2863 /* The traceframe we were inspecting. */
2864 int traceframe_number;
2868 do_restore_current_traceframe_cleanup (void *arg)
2870 struct current_traceframe_cleanup *old = arg;
2872 set_traceframe_number (old->traceframe_number);
2876 restore_current_traceframe_cleanup_dtor (void *arg)
2878 struct current_traceframe_cleanup *old = arg;
2884 make_cleanup_restore_current_traceframe (void)
2886 struct current_traceframe_cleanup *old;
2888 old = xmalloc (sizeof (struct current_traceframe_cleanup));
2889 old->traceframe_number = traceframe_number;
2891 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
2892 restore_current_traceframe_cleanup_dtor);
2895 /* Given a number and address, return an uploaded tracepoint with that
2896 number, creating if necessary. */
2898 struct uploaded_tp *
2899 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
2901 struct uploaded_tp *utp;
2903 for (utp = *utpp; utp; utp = utp->next)
2904 if (utp->number == num && utp->addr == addr)
2906 utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
2907 memset (utp, 0, sizeof (struct uploaded_tp));
2910 utp->actions = NULL;
2911 utp->step_actions = NULL;
2912 utp->cmd_strings = NULL;
2919 free_uploaded_tps (struct uploaded_tp **utpp)
2921 struct uploaded_tp *next_one;
2925 next_one = (*utpp)->next;
2931 /* Given a number and address, return an uploaded tracepoint with that
2932 number, creating if necessary. */
2934 struct uploaded_tsv *
2935 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
2937 struct uploaded_tsv *utsv;
2939 for (utsv = *utsvp; utsv; utsv = utsv->next)
2940 if (utsv->number == num)
2942 utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
2943 memset (utsv, 0, sizeof (struct uploaded_tsv));
2945 utsv->next = *utsvp;
2951 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
2953 struct uploaded_tsv *next_one;
2957 next_one = (*utsvp)->next;
2963 /* Look for an existing tracepoint that seems similar enough to the
2964 uploaded one. Enablement isn't compared, because the user can
2965 toggle that freely, and may have done so in anticipation of the
2969 find_matching_tracepoint (struct uploaded_tp *utp)
2971 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
2973 struct breakpoint *t;
2974 struct bp_location *loc;
2976 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
2978 if (t->type == utp->type
2979 && t->step_count == utp->step
2980 && t->pass_count == utp->pass
2981 /* FIXME also test conditionals and actions */
2984 /* Scan the locations for an address match. */
2985 for (loc = t->loc; loc; loc = loc->next)
2987 if (loc->address == utp->addr)
2995 /* Given a list of tracepoints uploaded from a target, attempt to
2996 match them up with existing tracepoints, and create new ones if not
3000 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3002 struct uploaded_tp *utp;
3003 struct breakpoint *t;
3005 /* Look for GDB tracepoints that match up with our uploaded versions. */
3006 for (utp = *uploaded_tps; utp; utp = utp->next)
3008 t = find_matching_tracepoint (utp);
3010 printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
3011 t->number, utp->number, paddress (get_current_arch (), utp->addr));
3014 t = create_tracepoint_from_upload (utp);
3016 printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
3017 t->number, utp->number, paddress (get_current_arch (), utp->addr));
3019 printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
3020 utp->number, paddress (get_current_arch (), utp->addr));
3022 /* Whether found or created, record the number used by the
3023 target, to help with mapping target tracepoints back to their
3024 counterparts here. */
3026 t->number_on_target = utp->number;
3029 free_uploaded_tps (uploaded_tps);
3032 /* Trace state variables don't have much to identify them beyond their
3033 name, so just use that to detect matches. */
3035 struct trace_state_variable *
3036 find_matching_tsv (struct uploaded_tsv *utsv)
3041 return find_trace_state_variable (utsv->name);
3044 struct trace_state_variable *
3045 create_tsv_from_upload (struct uploaded_tsv *utsv)
3047 const char *namebase;
3050 struct trace_state_variable *tsv;
3054 namebase = utsv->name;
3055 sprintf (buf, "%s", namebase);
3060 sprintf (buf, "%s_%d", namebase, try_num++);
3063 /* Fish for a name that is not in use. */
3064 /* (should check against all internal vars?) */
3065 while (find_trace_state_variable (buf))
3066 sprintf (buf, "%s_%d", namebase, try_num++);
3068 /* We have an available name, create the variable. */
3069 tsv = create_trace_state_variable (xstrdup (buf));
3070 tsv->initial_value = utsv->initial_value;
3071 tsv->builtin = utsv->builtin;
3076 /* Given a list of uploaded trace state variables, try to match them
3077 up with existing variables, or create additional ones. */
3080 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
3083 struct uploaded_tsv *utsv;
3084 struct trace_state_variable *tsv;
3087 /* Most likely some numbers will have to be reassigned as part of
3088 the merge, so clear them all in anticipation. */
3089 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3092 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
3094 tsv = find_matching_tsv (utsv);
3096 printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
3097 tsv->name, utsv->number);
3100 tsv = create_tsv_from_upload (utsv);
3101 printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
3102 tsv->name, utsv->number);
3104 /* Give precedence to numberings that come from the target. */
3106 tsv->number = utsv->number;
3109 /* Renumber everything that didn't get a target-assigned number. */
3111 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3112 if (tsv->number > highest)
3113 highest = tsv->number;
3116 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3117 if (tsv->number == 0)
3118 tsv->number = highest++;
3120 free_uploaded_tsvs (uploaded_tsvs);
3123 /* target tfile command */
3125 struct target_ops tfile_ops;
3127 /* Fill in tfile_ops with its defined operations and properties. */
3129 #define TRACE_HEADER_SIZE 8
3131 char *trace_filename;
3133 off_t trace_frames_offset;
3136 int trace_regblock_size;
3138 static void tfile_interp_line (char *line,
3139 struct uploaded_tp **utpp,
3140 struct uploaded_tsv **utsvp);
3143 tfile_open (char *filename, int from_tty)
3146 struct cleanup *old_chain;
3149 char header[TRACE_HEADER_SIZE];
3150 char linebuf[1000]; /* should be max remote packet size or so */
3152 int bytes, i, gotten;
3153 struct trace_status *ts;
3154 struct uploaded_tp *uploaded_tps = NULL;
3155 struct uploaded_tsv *uploaded_tsvs = NULL;
3157 target_preopen (from_tty);
3159 error (_("No trace file specified."));
3161 filename = tilde_expand (filename);
3162 if (!IS_ABSOLUTE_PATH(filename))
3164 temp = concat (current_directory, "/", filename, (char *) NULL);
3169 old_chain = make_cleanup (xfree, filename);
3171 flags = O_BINARY | O_LARGEFILE;
3173 scratch_chan = open (filename, flags, 0);
3174 if (scratch_chan < 0)
3175 perror_with_name (filename);
3177 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3179 discard_cleanups (old_chain); /* Don't free filename any more */
3180 unpush_target (&tfile_ops);
3182 push_target (&tfile_ops);
3184 trace_filename = xstrdup (filename);
3185 trace_fd = scratch_chan;
3188 /* Read the file header and test for validity. */
3189 gotten = read (trace_fd, &header, TRACE_HEADER_SIZE);
3191 perror_with_name (trace_filename);
3192 else if (gotten < TRACE_HEADER_SIZE)
3193 error (_("Premature end of file while reading trace file"));
3195 bytes += TRACE_HEADER_SIZE;
3196 if (!(header[0] == 0x7f
3197 && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
3198 error (_("File is not a valid trace file."));
3200 trace_regblock_size = 0;
3201 ts = current_trace_status ();
3202 /* We know we're working with a file. */
3204 /* Set defaults in case there is no status line. */
3205 ts->running_known = 0;
3206 ts->stop_reason = trace_stop_reason_unknown;
3207 ts->traceframe_count = -1;
3208 ts->buffer_free = 0;
3209 ts->disconnected_tracing = 0;
3210 ts->circular_buffer = 0;
3212 /* Read through a section of newline-terminated lines that
3213 define things like tracepoints. */
3217 gotten = read (trace_fd, &byte, 1);
3219 perror_with_name (trace_filename);
3220 else if (gotten < 1)
3221 error (_("Premature end of file while reading trace file"));
3226 /* Empty line marks end of the definition section. */
3231 tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
3234 linebuf[i++] = byte;
3236 error (_("Excessively long lines in trace file"));
3239 /* Add the file's tracepoints and variables into the current mix. */
3241 /* Get trace state variables first, they may be checked when parsing
3242 uploaded commands. */
3243 merge_uploaded_trace_state_variables (&uploaded_tsvs);
3245 merge_uploaded_tracepoints (&uploaded_tps);
3247 /* Record the starting offset of the binary trace data. */
3248 trace_frames_offset = bytes;
3250 /* If we don't have a blocksize, we can't interpret the
3252 if (trace_regblock_size == 0)
3253 error (_("No register block size recorded in trace file"));
3254 if (ts->traceframe_count <= 0)
3256 warning ("No traceframes present in this file.");
3260 #define TFILE_PID (1)
3261 inferior_appeared (current_inferior (), TFILE_PID);
3262 inferior_ptid = pid_to_ptid (TFILE_PID);
3263 add_thread_silent (inferior_ptid);
3265 post_create_inferior (&tfile_ops, from_tty);
3268 /* FIXME this will get defined in MI patch submission */
3269 tfind_1 (tfind_number, 0, 0, 0, 0);
3273 /* Interpret the given line from the definitions part of the trace
3277 tfile_interp_line (char *line,
3278 struct uploaded_tp **utpp, struct uploaded_tsv **utsvp)
3282 if (strncmp (p, "R ", strlen ("R ")) == 0)
3285 trace_regblock_size = strtol (p, &p, 16);
3287 else if (strncmp (p, "status ", strlen ("status ")) == 0)
3289 p += strlen ("status ");
3290 parse_trace_status (p, current_trace_status ());
3292 else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
3294 p += strlen ("tp ");
3295 parse_tracepoint_definition (p, utpp);
3297 else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
3299 p += strlen ("tsv ");
3300 parse_tsv_definition (p, utsvp);
3303 warning ("Ignoring trace file definition \"%s\"", line);
3306 /* Parse the part of trace status syntax that is shared between
3307 the remote protocol and the trace file reader. */
3309 extern char *unpack_varlen_hex (char *buff, ULONGEST *result);
3312 parse_trace_status (char *line, struct trace_status *ts)
3314 char *p = line, *p1, *p2, *p_temp;
3317 ts->running_known = 1;
3318 ts->running = (*p++ == '1');
3319 ts->stop_reason = trace_stop_reason_unknown;
3320 xfree (ts->error_desc);
3321 ts->error_desc = NULL;
3322 ts->traceframe_count = -1;
3323 ts->traceframes_created = -1;
3324 ts->buffer_free = -1;
3325 ts->buffer_size = -1;
3326 ts->disconnected_tracing = 0;
3327 ts->circular_buffer = 0;
3331 p1 = strchr (p, ':');
3333 error (_("Malformed trace status, at %s\n\
3334 Status line: '%s'\n"), p, line);
3335 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3337 p = unpack_varlen_hex (++p1, &val);
3338 ts->stop_reason = trace_buffer_full;
3340 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3342 p = unpack_varlen_hex (++p1, &val);
3343 ts->stop_reason = trace_never_run;
3345 else if (strncmp (p, stop_reason_names[tracepoint_passcount], p1 - p) == 0)
3347 p = unpack_varlen_hex (++p1, &val);
3348 ts->stop_reason = tracepoint_passcount;
3349 ts->stopping_tracepoint = val;
3351 else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
3353 p = unpack_varlen_hex (++p1, &val);
3354 ts->stop_reason = tstop_command;
3356 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
3358 p = unpack_varlen_hex (++p1, &val);
3359 ts->stop_reason = trace_disconnected;
3361 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3363 p2 = strchr (++p1, ':');
3368 ts->error_desc = xmalloc ((p2 - p1) / 2 + 1);
3369 end = hex2bin (p1, ts->error_desc, (p2 - p1) / 2);
3370 ts->error_desc[end] = '\0';
3373 ts->error_desc = xstrdup ("");
3375 p = unpack_varlen_hex (++p2, &val);
3376 ts->stopping_tracepoint = val;
3377 ts->stop_reason = tracepoint_error;
3379 else if (strncmp (p, "tframes", p1 - p) == 0)
3381 p = unpack_varlen_hex (++p1, &val);
3382 ts->traceframe_count = val;
3384 else if (strncmp (p, "tcreated", p1 - p) == 0)
3386 p = unpack_varlen_hex (++p1, &val);
3387 ts->traceframes_created = val;
3389 else if (strncmp (p, "tfree", p1 - p) == 0)
3391 p = unpack_varlen_hex (++p1, &val);
3392 ts->buffer_free = val;
3394 else if (strncmp (p, "tsize", p1 - p) == 0)
3396 p = unpack_varlen_hex (++p1, &val);
3397 ts->buffer_size = val;
3399 else if (strncmp (p, "disconn", p1 - p) == 0)
3401 p = unpack_varlen_hex (++p1, &val);
3402 ts->disconnected_tracing = val;
3404 else if (strncmp (p, "circular", p1 - p) == 0)
3406 p = unpack_varlen_hex (++p1, &val);
3407 ts->circular_buffer = val;
3411 /* Silently skip unknown optional info. */
3412 p_temp = strchr (p1 + 1, ';');
3416 /* Must be at the end. */
3422 /* Given a line of text defining a part of a tracepoint, parse it into
3423 an "uploaded tracepoint". */
3426 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
3430 ULONGEST num, addr, step, pass, orig_size, xlen, start;
3433 char *cond, *srctype, *buf;
3434 struct uploaded_tp *utp = NULL;
3437 /* Both tracepoint and action definitions start with the same number
3438 and address sequence. */
3440 p = unpack_varlen_hex (p, &num);
3441 p++; /* skip a colon */
3442 p = unpack_varlen_hex (p, &addr);
3443 p++; /* skip a colon */
3446 enabled = (*p++ == 'E');
3447 p++; /* skip a colon */
3448 p = unpack_varlen_hex (p, &step);
3449 p++; /* skip a colon */
3450 p = unpack_varlen_hex (p, &pass);
3451 type = bp_tracepoint;
3453 /* Thumb through optional fields. */
3456 p++; /* skip a colon */
3459 type = bp_fast_tracepoint;
3461 p = unpack_varlen_hex (p, &orig_size);
3466 p = unpack_varlen_hex (p, &xlen);
3467 p++; /* skip a comma */
3468 cond = (char *) xmalloc (2 * xlen + 1);
3469 strncpy (cond, p, 2 * xlen);
3470 cond[2 * xlen] = '\0';
3474 warning (_("Unrecognized char '%c' in tracepoint definition, skipping rest"), *p);
3476 utp = get_uploaded_tp (num, addr, utpp);
3478 utp->enabled = enabled;
3483 else if (piece == 'A')
3485 utp = get_uploaded_tp (num, addr, utpp);
3486 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
3488 else if (piece == 'S')
3490 utp = get_uploaded_tp (num, addr, utpp);
3491 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
3493 else if (piece == 'Z')
3495 /* Parse a chunk of source form definition. */
3496 utp = get_uploaded_tp (num, addr, utpp);
3498 p = strchr (p, ':');
3499 p++; /* skip a colon */
3500 p = unpack_varlen_hex (p, &start);
3501 p++; /* skip a colon */
3502 p = unpack_varlen_hex (p, &xlen);
3503 p++; /* skip a colon */
3505 buf = alloca (strlen (line));
3507 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3510 if (strncmp (srctype, "at:", strlen ("at:")) == 0)
3511 utp->at_string = xstrdup (buf);
3512 else if (strncmp (srctype, "cond:", strlen ("cond:")) == 0)
3513 utp->cond_string = xstrdup (buf);
3514 else if (strncmp (srctype, "cmd:", strlen ("cmd:")) == 0)
3515 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
3519 /* Don't error out, the target might be sending us optional
3520 info that we don't care about. */
3521 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
3525 /* Convert a textual description of a trace state variable into an
3529 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
3532 ULONGEST num, initval, builtin;
3534 struct uploaded_tsv *utsv = NULL;
3536 buf = alloca (strlen (line));
3539 p = unpack_varlen_hex (p, &num);
3540 p++; /* skip a colon */
3541 p = unpack_varlen_hex (p, &initval);
3542 p++; /* skip a colon */
3543 p = unpack_varlen_hex (p, &builtin);
3544 p++; /* skip a colon */
3545 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3548 utsv = get_uploaded_tsv (num, utsvp);
3549 utsv->initial_value = initval;
3550 utsv->builtin = builtin;
3551 utsv->name = xstrdup (buf);
3554 /* Close the trace file and generally clean up. */
3557 tfile_close (int quitting)
3564 pid = ptid_get_pid (inferior_ptid);
3565 inferior_ptid = null_ptid; /* Avoid confusion from thread stuff */
3566 exit_inferior_silent (pid);
3571 xfree (trace_filename);
3575 tfile_files_info (struct target_ops *t)
3577 /* (it would be useful to mention the name of the file) */
3578 printf_filtered ("Looking at a trace file.\n");
3581 /* The trace status for a file is that tracing can never be run. */
3584 tfile_get_trace_status (struct trace_status *ts)
3586 /* Other bits of trace status were collected as part of opening the
3587 trace files, so nothing to do here. */
3592 /* Given the position of a traceframe in the file, figure out what
3593 address the frame was collected at. This would normally be the
3594 value of a collected PC register, but if not available, we
3598 tfile_get_traceframe_address (off_t tframe_offset)
3602 struct breakpoint *tp;
3603 off_t saved_offset = cur_offset;
3606 /* FIXME dig pc out of collected registers */
3608 /* Fall back to using tracepoint address. */
3609 lseek (trace_fd, tframe_offset, SEEK_SET);
3610 gotten = read (trace_fd, &tpnum, 2);
3612 perror_with_name (trace_filename);
3613 else if (gotten < 2)
3614 error (_("Premature end of file while reading trace file"));
3616 tp = get_tracepoint_by_number_on_target (tpnum);
3617 /* FIXME this is a poor heuristic if multiple locations */
3619 addr = tp->loc->address;
3621 /* Restore our seek position. */
3622 cur_offset = saved_offset;
3623 lseek (trace_fd, cur_offset, SEEK_SET);
3627 /* Given a type of search and some parameters, scan the collection of
3628 traceframes in the file looking for a match. When found, return
3629 both the traceframe and tracepoint number, otherwise -1 for
3633 tfile_trace_find (enum trace_find_type type, int num,
3634 ULONGEST addr1, ULONGEST addr2, int *tpp)
3637 int tfnum = 0, found = 0, gotten;
3639 struct breakpoint *tp;
3640 off_t offset, tframe_offset;
3643 lseek (trace_fd, trace_frames_offset, SEEK_SET);
3644 offset = trace_frames_offset;
3647 tframe_offset = offset;
3648 gotten = read (trace_fd, &tpnum, 2);
3650 perror_with_name (trace_filename);
3651 else if (gotten < 2)
3652 error (_("Premature end of file while reading trace file"));
3656 gotten = read (trace_fd, &data_size, 4);
3658 perror_with_name (trace_filename);
3659 else if (gotten < 4)
3660 error (_("Premature end of file while reading trace file"));
3669 tfaddr = tfile_get_traceframe_address (tframe_offset);
3670 if (tfaddr == addr1)
3674 tp = get_tracepoint (num);
3675 if (tp && tpnum == tp->number_on_target)
3679 tfaddr = tfile_get_traceframe_address (tframe_offset);
3680 if (addr1 <= tfaddr && tfaddr <= addr2)
3684 tfaddr = tfile_get_traceframe_address (tframe_offset);
3685 if (!(addr1 <= tfaddr && tfaddr <= addr2))
3689 internal_error (__FILE__, __LINE__, _("unknown tfind type"));
3695 cur_offset = offset;
3696 cur_data_size = data_size;
3699 /* Skip past the traceframe's data. */
3700 lseek (trace_fd, data_size, SEEK_CUR);
3701 offset += data_size;
3702 /* Update our own count of traceframes. */
3705 /* Did not find what we were looking for. */
3711 /* Look for a block of saved registers in the traceframe, and get the
3712 requested register from it. */
3715 tfile_fetch_registers (struct target_ops *ops,
3716 struct regcache *regcache, int regno)
3718 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3720 int pos, offset, regn, regsize, gotten, pc_regno;
3721 unsigned short mlen;
3724 /* An uninitialized reg size says we're not going to be
3725 successful at getting register blocks. */
3726 if (!trace_regblock_size)
3729 regs = alloca (trace_regblock_size);
3731 lseek (trace_fd, cur_offset, SEEK_SET);
3733 while (pos < cur_data_size)
3735 gotten = read (trace_fd, &block_type, 1);
3737 perror_with_name (trace_filename);
3738 else if (gotten < 1)
3739 error (_("Premature end of file while reading trace file"));
3745 gotten = read (trace_fd, regs, trace_regblock_size);
3747 perror_with_name (trace_filename);
3748 else if (gotten < trace_regblock_size)
3749 error (_("Premature end of file while reading trace file"));
3751 /* Assume the block is laid out in GDB register number order,
3752 each register with the size that it has in GDB. */
3754 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
3756 regsize = register_size (gdbarch, regn);
3757 /* Make sure we stay within block bounds. */
3758 if (offset + regsize >= trace_regblock_size)
3760 if (!regcache_valid_p (regcache, regn))
3764 regcache_raw_supply (regcache, regno, regs + offset);
3767 else if (regno == -1)
3769 regcache_raw_supply (regcache, regn, regs + offset);
3776 lseek (trace_fd, 8, SEEK_CUR);
3777 gotten = read (trace_fd, &mlen, 2);
3779 perror_with_name (trace_filename);
3780 else if (gotten < 2)
3781 error (_("Premature end of file while reading trace file"));
3782 lseek (trace_fd, mlen, SEEK_CUR);
3783 pos += (8 + 2 + mlen);
3786 lseek (trace_fd, 4 + 8, SEEK_CUR);
3790 error ("Unknown block type '%c' (0x%x) in trace frame",
3791 block_type, block_type);
3796 /* We get here if no register data has been found. Although we
3797 don't like making up numbers, GDB has all manner of troubles when
3798 the target says some register is not available. Filling in with
3799 zeroes is a reasonable fallback. */
3800 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
3801 regcache_raw_supply (regcache, regn, NULL);
3803 /* We can often usefully guess that the PC is going to be the same
3804 as the address of the tracepoint. */
3805 pc_regno = gdbarch_pc_regnum (gdbarch);
3806 if (pc_regno >= 0 && (regno == -1 || regno == pc_regno))
3808 struct breakpoint *tp = get_tracepoint (tracepoint_number);
3812 /* But don't try to guess if tracepoint is multi-location... */
3815 warning ("Tracepoint %d has multiple locations, cannot infer $pc",
3819 /* ... or does while-stepping. */
3820 if (tp->step_count > 0)
3822 warning ("Tracepoint %d does while-stepping, cannot infer $pc",
3827 store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
3828 gdbarch_byte_order (gdbarch),
3830 regcache_raw_supply (regcache, pc_regno, regs);
3836 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
3837 const char *annex, gdb_byte *readbuf,
3838 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
3842 ULONGEST maddr, amt;
3843 unsigned short mlen;
3845 /* We're only doing regular memory for now. */
3846 if (object != TARGET_OBJECT_MEMORY)
3849 if (readbuf == NULL)
3850 error ("tfile_xfer_partial: trace file is read-only");
3852 lseek (trace_fd, cur_offset, SEEK_SET);
3854 while (pos < cur_data_size)
3856 gotten = read (trace_fd, &block_type, 1);
3858 perror_with_name (trace_filename);
3859 else if (gotten < 1)
3860 error (_("Premature end of file while reading trace file"));
3865 lseek (trace_fd, trace_regblock_size, SEEK_CUR);
3866 pos += trace_regblock_size;
3869 gotten = read (trace_fd, &maddr, 8);
3871 perror_with_name (trace_filename);
3872 else if (gotten < 8)
3873 error (_("Premature end of file while reading trace file"));
3875 gotten = read (trace_fd, &mlen, 2);
3877 perror_with_name (trace_filename);
3878 else if (gotten < 2)
3879 error (_("Premature end of file while reading trace file"));
3880 /* If the block includes the first part of the desired
3881 range, return as much it has; GDB will re-request the
3882 remainder, which might be in a different block of this
3884 if (maddr <= offset && offset < (maddr + mlen))
3886 amt = (maddr + mlen) - offset;
3890 gotten = read (trace_fd, readbuf, amt);
3892 perror_with_name (trace_filename);
3893 /* While it's acceptable to return less than was
3894 originally asked for, it's not acceptable to return
3895 less than what this block claims to contain. */
3896 else if (gotten < amt)
3897 error (_("Premature end of file while reading trace file"));
3900 lseek (trace_fd, mlen, SEEK_CUR);
3901 pos += (8 + 2 + mlen);
3904 lseek (trace_fd, 4 + 8, SEEK_CUR);
3908 error ("Unknown block type '%c' (0x%x) in traceframe",
3909 block_type, block_type);
3914 /* It's unduly pedantic to refuse to look at the executable for
3915 read-only pieces; so do the equivalent of readonly regions aka
3917 /* FIXME account for relocation at some point */
3924 for (s = exec_bfd->sections; s; s = s->next)
3926 if ((s->flags & SEC_LOAD) == 0 ||
3927 (s->flags & SEC_READONLY) == 0)
3931 size = bfd_get_section_size (s);
3932 if (lma <= offset && offset < (lma + size))
3934 amt = (lma + size) - offset;
3938 amt = bfd_get_section_contents (exec_bfd, s,
3939 readbuf, offset - lma, amt);
3945 /* Indicate failure to find the requested memory block. */
3949 /* Iterate through the blocks of a trace frame, looking for a 'V'
3950 block with a matching tsv number. */
3953 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
3956 int pos, vnum, gotten;
3957 unsigned short mlen;
3959 lseek (trace_fd, cur_offset, SEEK_SET);
3961 while (pos < cur_data_size)
3963 gotten = read (trace_fd, &block_type, 1);
3965 perror_with_name (trace_filename);
3966 else if (gotten < 1)
3967 error (_("Premature end of file while reading trace file"));
3972 lseek (trace_fd, trace_regblock_size, SEEK_CUR);
3973 pos += trace_regblock_size;
3976 lseek (trace_fd, 8, SEEK_CUR);
3977 gotten = read (trace_fd, &mlen, 2);
3979 perror_with_name (trace_filename);
3980 else if (gotten < 2)
3981 error (_("Premature end of file while reading trace file"));
3982 lseek (trace_fd, mlen, SEEK_CUR);
3983 pos += (8 + 2 + mlen);
3986 gotten = read (trace_fd, &vnum, 4);
3988 perror_with_name (trace_filename);
3989 else if (gotten < 4)
3990 error (_("Premature end of file while reading trace file"));
3993 gotten = read (trace_fd, val, 8);
3995 perror_with_name (trace_filename);
3996 else if (gotten < 8)
3997 error (_("Premature end of file while reading trace file"));
4000 lseek (trace_fd, 8, SEEK_CUR);
4004 error ("Unknown block type '%c' (0x%x) in traceframe",
4005 block_type, block_type);
4009 /* Didn't find anything. */
4014 tfile_has_all_memory (struct target_ops *ops)
4020 tfile_has_memory (struct target_ops *ops)
4026 tfile_has_stack (struct target_ops *ops)
4032 tfile_has_registers (struct target_ops *ops)
4038 init_tfile_ops (void)
4040 tfile_ops.to_shortname = "tfile";
4041 tfile_ops.to_longname = "Local trace dump file";
4043 "Use a trace file as a target. Specify the filename of the trace file.";
4044 tfile_ops.to_open = tfile_open;
4045 tfile_ops.to_close = tfile_close;
4046 tfile_ops.to_fetch_registers = tfile_fetch_registers;
4047 tfile_ops.to_xfer_partial = tfile_xfer_partial;
4048 tfile_ops.to_files_info = tfile_files_info;
4049 tfile_ops.to_get_trace_status = tfile_get_trace_status;
4050 tfile_ops.to_trace_find = tfile_trace_find;
4051 tfile_ops.to_get_trace_state_variable_value = tfile_get_trace_state_variable_value;
4052 /* core_stratum might seem more logical, but GDB doesn't like having
4053 more than one core_stratum vector. */
4054 tfile_ops.to_stratum = process_stratum;
4055 tfile_ops.to_has_all_memory = tfile_has_all_memory;
4056 tfile_ops.to_has_memory = tfile_has_memory;
4057 tfile_ops.to_has_stack = tfile_has_stack;
4058 tfile_ops.to_has_registers = tfile_has_registers;
4059 tfile_ops.to_magic = OPS_MAGIC;
4062 /* module initialization */
4064 _initialize_tracepoint (void)
4066 struct cmd_list_element *c;
4068 traceframe_number = -1;
4069 tracepoint_number = -1;
4071 if (tracepoint_list.list == NULL)
4073 tracepoint_list.listsize = 128;
4074 tracepoint_list.list = xmalloc
4075 (tracepoint_list.listsize * sizeof (struct memrange));
4077 if (tracepoint_list.aexpr_list == NULL)
4079 tracepoint_list.aexpr_listsize = 128;
4080 tracepoint_list.aexpr_list = xmalloc
4081 (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
4084 if (stepping_list.list == NULL)
4086 stepping_list.listsize = 128;
4087 stepping_list.list = xmalloc
4088 (stepping_list.listsize * sizeof (struct memrange));
4091 if (stepping_list.aexpr_list == NULL)
4093 stepping_list.aexpr_listsize = 128;
4094 stepping_list.aexpr_list = xmalloc
4095 (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
4098 add_info ("scope", scope_info,
4099 _("List the variables local to a scope"));
4101 add_cmd ("tracepoints", class_trace, NULL,
4102 _("Tracing of program execution without stopping the program."),
4105 add_com ("tdump", class_trace, trace_dump_command,
4106 _("Print everything collected at the current tracepoint."));
4108 add_com ("tsave", class_trace, trace_save_command, _("\
4109 Save the trace data to a file.\n\
4110 Use the '-r' option to direct the target to save directly to the file,\n\
4111 using its own filesystem."));
4113 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
4114 Define a trace state variable.\n\
4115 Argument is a $-prefixed name, optionally followed\n\
4116 by '=' and an expression that sets the initial value\n\
4117 at the start of tracing."));
4118 set_cmd_completer (c, expression_completer);
4120 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
4121 Delete one or more trace state variables.\n\
4122 Arguments are the names of the variables to delete.\n\
4123 If no arguments are supplied, delete all variables."), &deletelist);
4124 /* FIXME add a trace variable completer */
4126 add_info ("tvariables", tvariables_info, _("\
4127 Status of trace state variables and their values.\n\
4130 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
4131 Select a trace frame;\n\
4132 No argument means forward by one frame; '-' means backward by one frame."),
4133 &tfindlist, "tfind ", 1, &cmdlist);
4135 add_cmd ("outside", class_trace, trace_find_outside_command, _("\
4136 Select a trace frame whose PC is outside the given range (exclusive).\n\
4137 Usage: tfind outside addr1, addr2"),
4140 add_cmd ("range", class_trace, trace_find_range_command, _("\
4141 Select a trace frame whose PC is in the given range (inclusive).\n\
4142 Usage: tfind range addr1,addr2"),
4145 add_cmd ("line", class_trace, trace_find_line_command, _("\
4146 Select a trace frame by source line.\n\
4147 Argument can be a line number (with optional source file), \n\
4148 a function name, or '*' followed by an address.\n\
4149 Default argument is 'the next source line that was traced'."),
4152 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
4153 Select a trace frame by tracepoint number.\n\
4154 Default is the tracepoint for the current trace frame."),
4157 add_cmd ("pc", class_trace, trace_find_pc_command, _("\
4158 Select a trace frame by PC.\n\
4159 Default is the current PC, or the PC of the current trace frame."),
4162 add_cmd ("end", class_trace, trace_find_end_command, _("\
4163 Synonym for 'none'.\n\
4164 De-select any trace frame and resume 'live' debugging."),
4167 add_cmd ("none", class_trace, trace_find_none_command,
4168 _("De-select any trace frame and resume 'live' debugging."),
4171 add_cmd ("start", class_trace, trace_find_start_command,
4172 _("Select the first trace frame in the trace buffer."),
4175 add_com ("tstatus", class_trace, trace_status_command,
4176 _("Display the status of the current trace data collection."));
4178 add_com ("tstop", class_trace, trace_stop_command,
4179 _("Stop trace data collection."));
4181 add_com ("tstart", class_trace, trace_start_command,
4182 _("Start trace data collection."));
4184 add_com ("end", class_trace, end_actions_pseudocommand, _("\
4185 Ends a list of commands or actions.\n\
4186 Several GDB commands allow you to enter a list of commands or actions.\n\
4187 Entering \"end\" on a line by itself is the normal way to terminate\n\
4189 Note: the \"end\" command cannot be used at the gdb prompt."));
4191 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
4192 Specify single-stepping behavior at a tracepoint.\n\
4193 Argument is number of instructions to trace in single-step mode\n\
4194 following the tracepoint. This command is normally followed by\n\
4195 one or more \"collect\" commands, to specify what to collect\n\
4196 while single-stepping.\n\n\
4197 Note: this command can only be used in a tracepoint \"actions\" list."));
4199 add_com_alias ("ws", "while-stepping", class_alias, 0);
4200 add_com_alias ("stepping", "while-stepping", class_alias, 0);
4202 add_com ("collect", class_trace, collect_pseudocommand, _("\
4203 Specify one or more data items to be collected at a tracepoint.\n\
4204 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
4205 collect all data (variables, registers) referenced by that expression.\n\
4206 Also accepts the following special arguments:\n\
4207 $regs -- all registers.\n\
4208 $args -- all function arguments.\n\
4209 $locals -- all variables local to the block/function scope.\n\
4210 Note: this command can only be used in a tracepoint \"actions\" list."));
4212 add_com ("teval", class_trace, teval_pseudocommand, _("\
4213 Specify one or more expressions to be evaluated at a tracepoint.\n\
4214 Accepts a comma-separated list of (one or more) expressions.\n\
4215 The result of each evaluation will be discarded.\n\
4216 Note: this command can only be used in a tracepoint \"actions\" list."));
4218 add_com ("actions", class_trace, trace_actions_command, _("\
4219 Specify the actions to be taken at a tracepoint.\n\
4220 Tracepoint actions may include collecting of specified data, \n\
4221 single-stepping, or enabling/disabling other tracepoints, \n\
4222 depending on target's capabilities."));
4224 default_collect = xstrdup ("");
4225 add_setshow_string_cmd ("default-collect", class_trace,
4226 &default_collect, _("\
4227 Set the list of expressions to collect by default"), _("\
4228 Show the list of expressions to collect by default"), NULL,
4230 &setlist, &showlist);
4232 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
4233 &disconnected_tracing, _("\
4234 Set whether tracing continues after GDB disconnects."), _("\
4235 Show whether tracing continues after GDB disconnects."), _("\
4236 Use this to continue a tracing run even if GDB disconnects\n\
4237 or detaches from the target. You can reconnect later and look at\n\
4238 trace data collected in the meantime."),
4239 set_disconnected_tracing,
4244 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
4245 &circular_trace_buffer, _("\
4246 Set target's use of circular trace buffer."), _("\
4247 Show target's use of circular trace buffer."), _("\
4248 Use this to make the trace buffer into a circular buffer,\n\
4249 which will discard traceframes (oldest first) instead of filling\n\
4250 up and stopping the trace run."),
4251 set_circular_trace_buffer,
4258 add_target (&tfile_ops);