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"
54 /* readline include files */
55 #include "readline/readline.h"
56 #include "readline/history.h"
58 /* readline defines this. */
69 extern int hex2bin (const char *hex, gdb_byte *bin, int count);
70 extern int bin2hex (const gdb_byte *bin, char *hex, int count);
72 extern void stop_tracing ();
74 /* Maximum length of an agent aexpression.
75 This accounts for the fact that packets are limited to 400 bytes
76 (which includes everything -- including the checksum), and assumes
77 the worst case of maximum length for each of the pieces of a
80 NOTE: expressions get mem2hex'ed otherwise this would be twice as
81 large. (400 - 31)/2 == 184 */
82 #define MAX_AGENT_EXPR_LEN 184
84 /* A hook used to notify the UI of tracepoint operations. */
86 void (*deprecated_trace_find_hook) (char *arg, int from_tty);
87 void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
89 extern void (*deprecated_readline_begin_hook) (char *, ...);
90 extern char *(*deprecated_readline_hook) (char *);
91 extern void (*deprecated_readline_end_hook) (void);
93 /* GDB commands implemented in other modules:
96 extern void output_command (char *, int);
101 This module defines the following debugger commands:
102 trace : set a tracepoint on a function, line, or address.
103 info trace : list all debugger-defined tracepoints.
104 delete trace : delete one or more tracepoints.
105 enable trace : enable one or more tracepoints.
106 disable trace : disable one or more tracepoints.
107 actions : specify actions to be taken at a tracepoint.
108 passcount : specify a pass count for a tracepoint.
109 tstart : start a trace experiment.
110 tstop : stop a trace experiment.
111 tstatus : query the status of a trace experiment.
112 tfind : find a trace frame in the trace buffer.
113 tdump : print everything collected at the current tracepoint.
114 save-tracepoints : write tracepoint setup into a file.
116 This module defines the following user-visible debugger variables:
117 $trace_frame : sequence number of trace frame currently being debugged.
118 $trace_line : source line of trace frame currently being debugged.
119 $trace_file : source file of trace frame currently being debugged.
120 $tracepoint : tracepoint number of trace frame currently being debugged.
124 /* ======= Important global variables: ======= */
126 /* The list of all trace state variables. We don't retain pointers to
127 any of these for any reason - API is by name or number only - so it
128 works to have a vector of objects. */
130 typedef struct trace_state_variable tsv_s;
133 static VEC(tsv_s) *tvariables;
135 /* The next integer to assign to a variable. */
137 static int next_tsv_number = 1;
139 /* Number of last traceframe collected. */
140 static int traceframe_number;
142 /* Tracepoint for last traceframe collected. */
143 static int tracepoint_number;
145 /* Symbol for function for last traceframe collected */
146 static struct symbol *traceframe_fun;
148 /* Symtab and line for last traceframe collected */
149 static struct symtab_and_line traceframe_sal;
151 /* Tracing command lists */
152 static struct cmd_list_element *tfindlist;
154 /* List of expressions to collect by default at each tracepoint hit. */
155 char *default_collect = "";
157 static int disconnected_tracing;
159 /* This variable controls whether we ask the target for a linear or
160 circular trace buffer. */
162 static int circular_trace_buffer;
164 /* ======= Important command functions: ======= */
165 static void trace_actions_command (char *, int);
166 static void trace_start_command (char *, int);
167 static void trace_stop_command (char *, int);
168 static void trace_status_command (char *, int);
169 static void trace_find_command (char *, int);
170 static void trace_find_pc_command (char *, int);
171 static void trace_find_tracepoint_command (char *, int);
172 static void trace_find_line_command (char *, int);
173 static void trace_find_range_command (char *, int);
174 static void trace_find_outside_command (char *, int);
175 static void trace_dump_command (char *, int);
177 /* support routines */
179 struct collection_list;
180 static void add_aexpr (struct collection_list *, struct agent_expr *);
181 static char *mem2hex (gdb_byte *, char *, int);
182 static void add_register (struct collection_list *collection,
185 extern void send_disconnected_tracing_value (int value);
187 static void free_uploaded_tps (struct uploaded_tp **utpp);
188 static void free_uploaded_tsvs (struct uploaded_tsv **utsvp);
191 extern void _initialize_tracepoint (void);
193 static struct trace_status trace_status;
195 char *stop_reason_names[] = {
205 struct trace_status *
206 current_trace_status ()
208 return &trace_status;
211 /* Set traceframe number to NUM. */
213 set_traceframe_num (int num)
215 traceframe_number = num;
216 set_internalvar_integer (lookup_internalvar ("trace_frame"), num);
219 /* Set tracepoint number to NUM. */
221 set_tracepoint_num (int num)
223 tracepoint_number = num;
224 set_internalvar_integer (lookup_internalvar ("tracepoint"), num);
227 /* Set externally visible debug variables for querying/printing
228 the traceframe context (line, function, file) */
231 set_traceframe_context (struct frame_info *trace_frame)
235 if (trace_frame == NULL) /* Cease debugging any trace buffers. */
238 traceframe_sal.pc = traceframe_sal.line = 0;
239 traceframe_sal.symtab = NULL;
240 clear_internalvar (lookup_internalvar ("trace_func"));
241 clear_internalvar (lookup_internalvar ("trace_file"));
242 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
246 /* Save as globals for internal use. */
247 trace_pc = get_frame_pc (trace_frame);
248 traceframe_sal = find_pc_line (trace_pc, 0);
249 traceframe_fun = find_pc_function (trace_pc);
251 /* Save linenumber as "$trace_line", a debugger variable visible to
253 set_internalvar_integer (lookup_internalvar ("trace_line"),
254 traceframe_sal.line);
256 /* Save func name as "$trace_func", a debugger variable visible to
258 if (traceframe_fun == NULL
259 || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
260 clear_internalvar (lookup_internalvar ("trace_func"));
262 set_internalvar_string (lookup_internalvar ("trace_func"),
263 SYMBOL_LINKAGE_NAME (traceframe_fun));
265 /* Save file name as "$trace_file", a debugger variable visible to
267 if (traceframe_sal.symtab == NULL
268 || traceframe_sal.symtab->filename == NULL)
269 clear_internalvar (lookup_internalvar ("trace_file"));
271 set_internalvar_string (lookup_internalvar ("trace_file"),
272 traceframe_sal.symtab->filename);
275 /* Create a new trace state variable with the given name. */
277 struct trace_state_variable *
278 create_trace_state_variable (const char *name)
280 struct trace_state_variable tsv;
282 memset (&tsv, 0, sizeof (tsv));
283 tsv.name = xstrdup (name);
284 tsv.number = next_tsv_number++;
285 return VEC_safe_push (tsv_s, tvariables, &tsv);
288 /* Look for a trace state variable of the given name. */
290 struct trace_state_variable *
291 find_trace_state_variable (const char *name)
293 struct trace_state_variable *tsv;
296 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
297 if (strcmp (name, tsv->name) == 0)
304 delete_trace_state_variable (const char *name)
306 struct trace_state_variable *tsv;
309 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
310 if (strcmp (name, tsv->name) == 0)
312 xfree ((void *)tsv->name);
313 VEC_unordered_remove (tsv_s, tvariables, ix);
317 warning (_("No trace variable named \"$%s\", not deleting"), name);
320 /* The 'tvariable' command collects a name and optional expression to
321 evaluate into an initial value. */
324 trace_variable_command (char *args, int from_tty)
326 struct expression *expr;
327 struct cleanup *old_chain;
328 struct internalvar *intvar = NULL;
330 struct trace_state_variable *tsv;
333 error_no_arg (_("trace state variable name"));
335 /* All the possible valid arguments are expressions. */
336 expr = parse_expression (args);
337 old_chain = make_cleanup (free_current_contents, &expr);
339 if (expr->nelts == 0)
340 error (_("No expression?"));
342 /* Only allow two syntaxes; "$name" and "$name=value". */
343 if (expr->elts[0].opcode == OP_INTERNALVAR)
345 intvar = expr->elts[1].internalvar;
347 else if (expr->elts[0].opcode == BINOP_ASSIGN
348 && expr->elts[1].opcode == OP_INTERNALVAR)
350 intvar = expr->elts[2].internalvar;
351 initval = value_as_long (evaluate_subexpression_type (expr, 4));
354 error (_("Syntax must be $NAME [ = EXPR ]"));
357 error (_("No name given"));
359 if (strlen (internalvar_name (intvar)) <= 0)
360 error (_("Must supply a non-empty variable name"));
362 /* If the variable already exists, just change its initial value. */
363 tsv = find_trace_state_variable (internalvar_name (intvar));
366 tsv->initial_value = initval;
367 printf_filtered (_("Trace state variable $%s now has initial value %s.\n"),
368 tsv->name, plongest (tsv->initial_value));
369 do_cleanups (old_chain);
373 /* Create a new variable. */
374 tsv = create_trace_state_variable (internalvar_name (intvar));
375 tsv->initial_value = initval;
377 printf_filtered (_("Trace state variable $%s created, with initial value %s.\n"),
378 tsv->name, plongest (tsv->initial_value));
380 do_cleanups (old_chain);
384 delete_trace_variable_command (char *args, int from_tty)
388 struct cleanup *back_to;
392 if (query (_("Delete all trace state variables? ")))
393 VEC_free (tsv_s, tvariables);
398 argv = gdb_buildargv (args);
399 back_to = make_cleanup_freeargv (argv);
401 for (ix = 0; argv[ix] != NULL; ix++)
403 if (*argv[ix] == '$')
404 delete_trace_state_variable (argv[ix] + 1);
406 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv[ix]);
409 do_cleanups (back_to);
415 tvariables_info_1 (void)
417 struct trace_state_variable *tsv;
420 struct cleanup *back_to;
422 if (VEC_length (tsv_s, tvariables) == 0 && !ui_out_is_mi_like_p (uiout))
424 printf_filtered (_("No trace state variables.\n"));
428 /* Try to acquire values from the target. */
429 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix, ++count)
430 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
433 back_to = make_cleanup_ui_out_table_begin_end (uiout, 3,
434 count, "trace-variables");
435 ui_out_table_header (uiout, 15, ui_left, "name", "Name");
436 ui_out_table_header (uiout, 11, ui_left, "initial", "Initial");
437 ui_out_table_header (uiout, 11, ui_left, "current", "Current");
439 ui_out_table_body (uiout);
441 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
443 struct cleanup *back_to2;
447 back_to2 = make_cleanup_ui_out_tuple_begin_end (uiout, "variable");
449 name = concat ("$", tsv->name, (char *) NULL);
450 make_cleanup (xfree, name);
451 ui_out_field_string (uiout, "name", name);
452 ui_out_field_string (uiout, "initial", plongest (tsv->initial_value));
454 if (tsv->value_known)
455 c = plongest (tsv->value);
456 else if (ui_out_is_mi_like_p (uiout))
457 /* For MI, we prefer not to use magic string constants, but rather
458 omit the field completely. The difference between unknown and
459 undefined does not seem important enough to represent. */
461 else if (current_trace_status ()->running || traceframe_number >= 0)
462 /* The value is/was defined, but we don't have it. */
465 /* It is not meaningful to ask about the value. */
468 ui_out_field_string (uiout, "current", c);
469 ui_out_text (uiout, "\n");
471 do_cleanups (back_to2);
474 do_cleanups (back_to);
477 /* List all the trace state variables. */
480 tvariables_info (char *args, int from_tty)
482 tvariables_info_1 ();
485 /* Stash definitions of tsvs into the given file. */
488 save_trace_state_variables (struct ui_file *fp)
490 struct trace_state_variable *tsv;
493 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
495 fprintf_unfiltered (fp, "tvariable $%s", tsv->name);
496 if (tsv->initial_value)
497 fprintf_unfiltered (fp, " = %s", plongest (tsv->initial_value));
498 fprintf_unfiltered (fp, "\n");
502 /* ACTIONS functions: */
504 /* The three functions:
505 collect_pseudocommand,
506 while_stepping_pseudocommand, and
507 end_actions_pseudocommand
508 are placeholders for "commands" that are actually ONLY to be used
509 within a tracepoint action list. If the actual function is ever called,
510 it means that somebody issued the "command" at the top level,
511 which is always an error. */
514 end_actions_pseudocommand (char *args, int from_tty)
516 error (_("This command cannot be used at the top level."));
520 while_stepping_pseudocommand (char *args, int from_tty)
522 error (_("This command can only be used in a tracepoint actions list."));
526 collect_pseudocommand (char *args, int from_tty)
528 error (_("This command can only be used in a tracepoint actions list."));
532 teval_pseudocommand (char *args, int from_tty)
534 error (_("This command can only be used in a tracepoint actions list."));
537 /* Enter a list of actions for a tracepoint. */
539 trace_actions_command (char *args, int from_tty)
541 struct breakpoint *t;
542 struct command_line *l;
544 t = get_tracepoint_by_number (&args, 0, 1);
548 xstrprintf ("Enter actions for tracepoint %d, one per line.",
550 struct cleanup *cleanups = make_cleanup (xfree, tmpbuf);
552 l = read_command_lines (tmpbuf, from_tty, 1, check_tracepoint_command, t);
553 do_cleanups (cleanups);
554 breakpoint_set_commands (t, l);
556 /* else just return */
559 /* Report the results of checking the agent expression, as errors or
563 report_agent_reqs_errors (struct agent_expr *aexpr)
565 /* All of the "flaws" are serious bytecode generation issues that
566 should never occur. */
567 if (aexpr->flaw != agent_flaw_none)
568 internal_error (__FILE__, __LINE__, _("expression is malformed"));
570 /* If analysis shows a stack underflow, GDB must have done something
571 badly wrong in its bytecode generation. */
572 if (aexpr->min_height < 0)
573 internal_error (__FILE__, __LINE__,
574 _("expression has min height < 0"));
576 /* Issue this error if the stack is predicted to get too deep. The
577 limit is rather arbitrary; a better scheme might be for the
578 target to report how much stack it will have available. The
579 depth roughly corresponds to parenthesization, so a limit of 20
580 amounts to 20 levels of expression nesting, which is actually
581 a pretty big hairy expression. */
582 if (aexpr->max_height > 20)
583 error (_("Expression is too complicated."));
586 /* worker function */
588 validate_actionline (char **line, struct breakpoint *t)
590 struct cmd_list_element *c;
591 struct expression *exp = NULL;
592 struct cleanup *old_chain = NULL;
594 struct bp_location *loc;
595 struct agent_expr *aexpr;
597 /* if EOF is typed, *line is NULL */
601 for (p = *line; isspace ((int) *p);)
604 /* Symbol lookup etc. */
605 if (*p == '\0') /* empty line: just prompt for another line. */
608 if (*p == '#') /* comment line */
611 c = lookup_cmd (&p, cmdlist, "", -1, 1);
613 error (_("`%s' is not a tracepoint action, or is ambiguous."), p);
615 if (cmd_cfunc_eq (c, collect_pseudocommand))
618 { /* repeat over a comma-separated list */
619 QUIT; /* allow user to bail out with ^C */
620 while (isspace ((int) *p))
623 if (*p == '$') /* look for special pseudo-symbols */
625 if ((0 == strncasecmp ("reg", p + 1, 3)) ||
626 (0 == strncasecmp ("arg", p + 1, 3)) ||
627 (0 == strncasecmp ("loc", p + 1, 3)))
632 /* else fall thru, treat p as an expression and parse it! */
635 for (loc = t->loc; loc; loc = loc->next)
638 exp = parse_exp_1 (&p, block_for_pc (loc->address), 1);
639 old_chain = make_cleanup (free_current_contents, &exp);
641 if (exp->elts[0].opcode == OP_VAR_VALUE)
643 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
645 error (_("constant `%s' (value %ld) will not be collected."),
646 SYMBOL_PRINT_NAME (exp->elts[2].symbol),
647 SYMBOL_VALUE (exp->elts[2].symbol));
649 else if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_OPTIMIZED_OUT)
651 error (_("`%s' is optimized away and cannot be collected."),
652 SYMBOL_PRINT_NAME (exp->elts[2].symbol));
656 /* We have something to collect, make sure that the expr to
657 bytecode translator can handle it and that it's not too
659 aexpr = gen_trace_for_expr (loc->address, exp);
660 make_cleanup_free_agent_expr (aexpr);
662 if (aexpr->len > MAX_AGENT_EXPR_LEN)
663 error (_("Expression is too complicated."));
667 report_agent_reqs_errors (aexpr);
669 do_cleanups (old_chain);
672 while (p && *p++ == ',');
675 else if (cmd_cfunc_eq (c, teval_pseudocommand))
678 { /* repeat over a comma-separated list */
679 QUIT; /* allow user to bail out with ^C */
680 while (isspace ((int) *p))
684 for (loc = t->loc; loc; loc = loc->next)
687 /* Only expressions are allowed for this action. */
688 exp = parse_exp_1 (&p, block_for_pc (loc->address), 1);
689 old_chain = make_cleanup (free_current_contents, &exp);
691 /* We have something to evaluate, make sure that the expr to
692 bytecode translator can handle it and that it's not too
694 aexpr = gen_eval_for_expr (loc->address, exp);
695 make_cleanup_free_agent_expr (aexpr);
697 if (aexpr->len > MAX_AGENT_EXPR_LEN)
698 error (_("Expression is too complicated."));
701 report_agent_reqs_errors (aexpr);
703 do_cleanups (old_chain);
706 while (p && *p++ == ',');
709 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
711 char *steparg; /* in case warning is necessary */
713 while (isspace ((int) *p))
717 if (*p == '\0' || (t->step_count = strtol (p, &p, 0)) == 0)
718 error (_("while-stepping step count `%s' is malformed."), *line);
721 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
725 error (_("`%s' is not a supported tracepoint action."), *line);
729 memrange_absolute = -1
734 int type; /* memrange_absolute for absolute memory range,
735 else basereg number */
736 bfd_signed_vma start;
740 struct collection_list
742 unsigned char regs_mask[32]; /* room for up to 256 regs */
745 struct memrange *list;
746 long aexpr_listsize; /* size of array pointed to by expr_list elt */
748 struct agent_expr **aexpr_list;
751 tracepoint_list, stepping_list;
753 /* MEMRANGE functions: */
755 static int memrange_cmp (const void *, const void *);
757 /* compare memranges for qsort */
759 memrange_cmp (const void *va, const void *vb)
761 const struct memrange *a = va, *b = vb;
763 if (a->type < b->type)
765 if (a->type > b->type)
767 if (a->type == memrange_absolute)
769 if ((bfd_vma) a->start < (bfd_vma) b->start)
771 if ((bfd_vma) a->start > (bfd_vma) b->start)
776 if (a->start < b->start)
778 if (a->start > b->start)
784 /* Sort the memrange list using qsort, and merge adjacent memranges. */
786 memrange_sortmerge (struct collection_list *memranges)
790 qsort (memranges->list, memranges->next_memrange,
791 sizeof (struct memrange), memrange_cmp);
792 if (memranges->next_memrange > 0)
794 for (a = 0, b = 1; b < memranges->next_memrange; b++)
796 if (memranges->list[a].type == memranges->list[b].type &&
797 memranges->list[b].start - memranges->list[a].end <=
800 /* memrange b starts before memrange a ends; merge them. */
801 if (memranges->list[b].end > memranges->list[a].end)
802 memranges->list[a].end = memranges->list[b].end;
803 continue; /* next b, same a */
807 memcpy (&memranges->list[a], &memranges->list[b],
808 sizeof (struct memrange));
810 memranges->next_memrange = a + 1;
814 /* Add a register to a collection list. */
816 add_register (struct collection_list *collection, unsigned int regno)
819 printf_filtered ("collect register %d\n", regno);
820 if (regno >= (8 * sizeof (collection->regs_mask)))
821 error (_("Internal: register number %d too large for tracepoint"),
823 collection->regs_mask[regno / 8] |= 1 << (regno % 8);
826 /* Add a memrange to a collection list */
828 add_memrange (struct collection_list *memranges,
829 int type, bfd_signed_vma base,
834 printf_filtered ("(%d,", type);
836 printf_filtered (",%ld)\n", len);
839 /* type: memrange_absolute == memory, other n == basereg */
840 memranges->list[memranges->next_memrange].type = type;
841 /* base: addr if memory, offset if reg relative. */
842 memranges->list[memranges->next_memrange].start = base;
843 /* len: we actually save end (base + len) for convenience */
844 memranges->list[memranges->next_memrange].end = base + len;
845 memranges->next_memrange++;
846 if (memranges->next_memrange >= memranges->listsize)
848 memranges->listsize *= 2;
849 memranges->list = xrealloc (memranges->list,
850 memranges->listsize);
853 if (type != memrange_absolute) /* Better collect the base register! */
854 add_register (memranges, type);
857 /* Add a symbol to a collection list. */
859 collect_symbol (struct collection_list *collect,
861 struct gdbarch *gdbarch,
862 long frame_regno, long frame_offset,
867 bfd_signed_vma offset;
868 int treat_as_expr = 0;
870 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
871 switch (SYMBOL_CLASS (sym))
874 printf_filtered ("%s: don't know symbol class %d\n",
875 SYMBOL_PRINT_NAME (sym),
879 printf_filtered ("constant %s (value %ld) will not be collected.\n",
880 SYMBOL_PRINT_NAME (sym), SYMBOL_VALUE (sym));
883 offset = SYMBOL_VALUE_ADDRESS (sym);
888 sprintf_vma (tmp, offset);
889 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
890 SYMBOL_PRINT_NAME (sym), len,
893 /* A struct may be a C++ class with static fields, go to general
894 expression handling. */
895 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
898 add_memrange (collect, memrange_absolute, offset, len);
901 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
903 printf_filtered ("LOC_REG[parm] %s: ",
904 SYMBOL_PRINT_NAME (sym));
905 add_register (collect, reg);
906 /* Check for doubles stored in two registers. */
907 /* FIXME: how about larger types stored in 3 or more regs? */
908 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
909 len > register_size (gdbarch, reg))
910 add_register (collect, reg + 1);
913 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
914 printf_filtered (" (will not collect %s)\n",
915 SYMBOL_PRINT_NAME (sym));
919 offset = frame_offset + SYMBOL_VALUE (sym);
922 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
923 SYMBOL_PRINT_NAME (sym), len);
925 printf_filtered (" from frame ptr reg %d\n", reg);
927 add_memrange (collect, reg, offset, len);
929 case LOC_REGPARM_ADDR:
930 reg = SYMBOL_VALUE (sym);
934 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
935 SYMBOL_PRINT_NAME (sym), len);
937 printf_filtered (" from reg %d\n", reg);
939 add_memrange (collect, reg, offset, len);
943 offset = frame_offset + SYMBOL_VALUE (sym);
946 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
947 SYMBOL_PRINT_NAME (sym), len);
949 printf_filtered (" from frame ptr reg %d\n", reg);
951 add_memrange (collect, reg, offset, len);
958 case LOC_OPTIMIZED_OUT:
959 printf_filtered ("%s has been optimized out of existence.\n",
960 SYMBOL_PRINT_NAME (sym));
968 /* Expressions are the most general case. */
971 struct agent_expr *aexpr;
972 struct cleanup *old_chain1 = NULL;
974 aexpr = gen_trace_for_var (scope, gdbarch, sym);
976 /* It can happen that the symbol is recorded as a computed
977 location, but it's been optimized away and doesn't actually
978 have a location expression. */
981 printf_filtered ("%s has been optimized out of existence.\n",
982 SYMBOL_PRINT_NAME (sym));
986 old_chain1 = make_cleanup_free_agent_expr (aexpr);
990 report_agent_reqs_errors (aexpr);
992 discard_cleanups (old_chain1);
993 add_aexpr (collect, aexpr);
995 /* take care of the registers */
996 if (aexpr->reg_mask_len > 0)
1000 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1002 QUIT; /* allow user to bail out with ^C */
1003 if (aexpr->reg_mask[ndx1] != 0)
1005 /* assume chars have 8 bits */
1006 for (ndx2 = 0; ndx2 < 8; ndx2++)
1007 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1008 /* it's used -- record it */
1009 add_register (collect, ndx1 * 8 + ndx2);
1016 /* Data to be passed around in the calls to the locals and args
1019 struct add_local_symbols_data
1021 struct collection_list *collect;
1022 struct gdbarch *gdbarch;
1029 /* The callback for the locals and args iterators */
1032 do_collect_symbol (const char *print_name,
1036 struct add_local_symbols_data *p = cb_data;
1038 collect_symbol (p->collect, sym, p->gdbarch, p->frame_regno,
1039 p->frame_offset, p->pc);
1043 /* Add all locals (or args) symbols to collection list */
1045 add_local_symbols (struct collection_list *collect,
1046 struct gdbarch *gdbarch, CORE_ADDR pc,
1047 long frame_regno, long frame_offset, int type)
1049 struct block *block;
1050 struct add_local_symbols_data cb_data;
1052 cb_data.collect = collect;
1053 cb_data.gdbarch = gdbarch;
1055 cb_data.frame_regno = frame_regno;
1056 cb_data.frame_offset = frame_offset;
1061 block = block_for_pc (pc);
1064 warning (_("Can't collect locals; "
1065 "no symbol table info available.\n"));
1069 iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1070 if (cb_data.count == 0)
1071 warning (_("No locals found in scope."));
1075 pc = get_pc_function_start (pc);
1076 block = block_for_pc (pc);
1079 warning (_("Can't collect args; no symbol table info available.\n"));
1083 iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1084 if (cb_data.count == 0)
1085 warning (_("No args found in scope."));
1089 /* worker function */
1091 clear_collection_list (struct collection_list *list)
1095 list->next_memrange = 0;
1096 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1098 free_agent_expr (list->aexpr_list[ndx]);
1099 list->aexpr_list[ndx] = NULL;
1101 list->next_aexpr_elt = 0;
1102 memset (list->regs_mask, 0, sizeof (list->regs_mask));
1105 /* reduce a collection list to string form (for gdb protocol) */
1107 stringify_collection_list (struct collection_list *list, char *string)
1109 char temp_buf[2048];
1113 char *(*str_list)[];
1117 count = 1 + list->next_memrange + list->next_aexpr_elt + 1;
1118 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1120 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1121 if (list->regs_mask[i] != 0) /* skip leading zeroes in regs_mask */
1123 if (list->regs_mask[i] != 0) /* prepare to send regs_mask to the stub */
1126 printf_filtered ("\nCollecting registers (mask): 0x");
1131 QUIT; /* allow user to bail out with ^C */
1133 printf_filtered ("%02X", list->regs_mask[i]);
1134 sprintf (end, "%02X", list->regs_mask[i]);
1137 (*str_list)[ndx] = xstrdup (temp_buf);
1141 printf_filtered ("\n");
1142 if (list->next_memrange > 0 && info_verbose)
1143 printf_filtered ("Collecting memranges: \n");
1144 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1146 QUIT; /* allow user to bail out with ^C */
1147 sprintf_vma (tmp2, list->list[i].start);
1150 printf_filtered ("(%d, %s, %ld)\n",
1153 (long) (list->list[i].end - list->list[i].start));
1155 if (count + 27 > MAX_AGENT_EXPR_LEN)
1157 (*str_list)[ndx] = savestring (temp_buf, count);
1164 bfd_signed_vma length = list->list[i].end - list->list[i].start;
1166 /* The "%X" conversion specifier expects an unsigned argument,
1167 so passing -1 (memrange_absolute) to it directly gives you
1168 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1170 if (list->list[i].type == memrange_absolute)
1171 sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
1173 sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
1176 count += strlen (end);
1177 end = temp_buf + count;
1180 for (i = 0; i < list->next_aexpr_elt; i++)
1182 QUIT; /* allow user to bail out with ^C */
1183 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1185 (*str_list)[ndx] = savestring (temp_buf, count);
1190 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1191 end += 10; /* 'X' + 8 hex digits + ',' */
1194 end = mem2hex (list->aexpr_list[i]->buf,
1195 end, list->aexpr_list[i]->len);
1196 count += 2 * list->aexpr_list[i]->len;
1201 (*str_list)[ndx] = savestring (temp_buf, count);
1206 (*str_list)[ndx] = NULL;
1219 encode_actions_1 (struct command_line *action,
1220 struct breakpoint *t,
1221 struct bp_location *tloc,
1223 LONGEST frame_offset,
1224 struct collection_list *collect,
1225 struct collection_list *stepping_list)
1228 struct expression *exp = NULL;
1230 struct value *tempval;
1231 struct cmd_list_element *cmd;
1232 struct agent_expr *aexpr;
1234 for (; action; action = action->next)
1236 QUIT; /* allow user to bail out with ^C */
1237 action_exp = action->line;
1238 while (isspace ((int) *action_exp))
1241 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1243 error (_("Bad action list item: %s"), action_exp);
1245 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1248 { /* repeat over a comma-separated list */
1249 QUIT; /* allow user to bail out with ^C */
1250 while (isspace ((int) *action_exp))
1253 if (0 == strncasecmp ("$reg", action_exp, 4))
1255 for (i = 0; i < gdbarch_num_regs (t->gdbarch); i++)
1256 add_register (collect, i);
1257 action_exp = strchr (action_exp, ','); /* more? */
1259 else if (0 == strncasecmp ("$arg", action_exp, 4))
1261 add_local_symbols (collect,
1267 action_exp = strchr (action_exp, ','); /* more? */
1269 else if (0 == strncasecmp ("$loc", action_exp, 4))
1271 add_local_symbols (collect,
1277 action_exp = strchr (action_exp, ','); /* more? */
1281 unsigned long addr, len;
1282 struct cleanup *old_chain = NULL;
1283 struct cleanup *old_chain1 = NULL;
1285 exp = parse_exp_1 (&action_exp,
1286 block_for_pc (tloc->address), 1);
1287 old_chain = make_cleanup (free_current_contents, &exp);
1289 switch (exp->elts[0].opcode)
1293 const char *name = &exp->elts[2].string;
1295 i = user_reg_map_name_to_regnum (t->gdbarch,
1296 name, strlen (name));
1298 internal_error (__FILE__, __LINE__,
1299 _("Register $%s not available"),
1302 printf_filtered ("OP_REGISTER: ");
1303 add_register (collect, i);
1308 /* safe because we know it's a simple expression */
1309 tempval = evaluate_expression (exp);
1310 addr = value_address (tempval);
1311 len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
1312 add_memrange (collect, memrange_absolute, addr, len);
1316 collect_symbol (collect,
1317 exp->elts[2].symbol,
1324 default: /* full-fledged expression */
1325 aexpr = gen_trace_for_expr (tloc->address, exp);
1327 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1331 report_agent_reqs_errors (aexpr);
1333 discard_cleanups (old_chain1);
1334 add_aexpr (collect, aexpr);
1336 /* take care of the registers */
1337 if (aexpr->reg_mask_len > 0)
1342 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1344 QUIT; /* allow user to bail out with ^C */
1345 if (aexpr->reg_mask[ndx1] != 0)
1347 /* assume chars have 8 bits */
1348 for (ndx2 = 0; ndx2 < 8; ndx2++)
1349 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1350 /* it's used -- record it */
1351 add_register (collect,
1358 do_cleanups (old_chain);
1361 while (action_exp && *action_exp++ == ',');
1363 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1366 { /* repeat over a comma-separated list */
1367 QUIT; /* allow user to bail out with ^C */
1368 while (isspace ((int) *action_exp))
1372 struct cleanup *old_chain = NULL;
1373 struct cleanup *old_chain1 = NULL;
1375 exp = parse_exp_1 (&action_exp,
1376 block_for_pc (tloc->address), 1);
1377 old_chain = make_cleanup (free_current_contents, &exp);
1379 aexpr = gen_eval_for_expr (tloc->address, exp);
1380 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1383 report_agent_reqs_errors (aexpr);
1385 discard_cleanups (old_chain1);
1386 /* Even though we're not officially collecting, add
1387 to the collect list anyway. */
1388 add_aexpr (collect, aexpr);
1390 do_cleanups (old_chain);
1393 while (action_exp && *action_exp++ == ',');
1395 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1397 /* We check against nested while-stepping when setting
1398 breakpoint action, so no way to run into nested
1400 gdb_assert (stepping_list);
1402 encode_actions_1 (action->body_list[0], t, tloc, frame_reg,
1403 frame_offset, stepping_list, NULL);
1406 error (_("Invalid tracepoint command '%s'"), action->line);
1410 /* Render all actions into gdb protocol. */
1412 encode_actions (struct breakpoint *t, struct bp_location *tloc,
1413 char ***tdp_actions, char ***stepping_actions)
1415 static char tdp_buff[2048], step_buff[2048];
1416 char *default_collect_line = NULL;
1417 struct command_line *actions;
1418 struct command_line *default_collect_action = NULL;
1420 LONGEST frame_offset;
1421 struct cleanup *back_to;
1423 back_to = make_cleanup (null_cleanup, NULL);
1425 clear_collection_list (&tracepoint_list);
1426 clear_collection_list (&stepping_list);
1428 *tdp_actions = NULL;
1429 *stepping_actions = NULL;
1431 gdbarch_virtual_frame_pointer (t->gdbarch,
1432 t->loc->address, &frame_reg, &frame_offset);
1434 actions = breakpoint_commands (t);
1436 /* If there are default expressions to collect, make up a collect
1437 action and prepend to the action list to encode. Note that since
1438 validation is per-tracepoint (local var "xyz" might be valid for
1439 one tracepoint and not another, etc), we make up the action on
1440 the fly, and don't cache it. */
1441 if (*default_collect)
1445 default_collect_line = xstrprintf ("collect %s", default_collect);
1446 make_cleanup (xfree, default_collect_line);
1448 line = default_collect_line;
1449 validate_actionline (&line, t);
1451 default_collect_action = xmalloc (sizeof (struct command_line));
1452 make_cleanup (xfree, default_collect_action);
1453 default_collect_action->next = actions;
1454 default_collect_action->line = line;
1455 actions = default_collect_action;
1457 encode_actions_1 (actions, t, tloc, frame_reg, frame_offset,
1458 &tracepoint_list, &stepping_list);
1460 memrange_sortmerge (&tracepoint_list);
1461 memrange_sortmerge (&stepping_list);
1463 *tdp_actions = stringify_collection_list (&tracepoint_list,
1465 *stepping_actions = stringify_collection_list (&stepping_list,
1468 do_cleanups (back_to);
1472 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1474 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1476 collect->aexpr_list =
1477 xrealloc (collect->aexpr_list,
1478 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1479 collect->aexpr_listsize *= 2;
1481 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1482 collect->next_aexpr_elt++;
1487 start_tracing (void)
1489 VEC(breakpoint_p) *tp_vec = NULL;
1491 struct breakpoint *t;
1492 struct trace_state_variable *tsv;
1493 int any_enabled = 0;
1495 tp_vec = all_tracepoints ();
1497 /* No point in tracing without any tracepoints... */
1498 if (VEC_length (breakpoint_p, tp_vec) == 0)
1500 VEC_free (breakpoint_p, tp_vec);
1501 error (_("No tracepoints defined, not starting trace"));
1504 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1506 if (t->enable_state == bp_enabled)
1513 /* No point in tracing with only disabled tracepoints. */
1516 VEC_free (breakpoint_p, tp_vec);
1517 error (_("No tracepoints enabled, not starting trace"));
1520 target_trace_init ();
1522 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1524 t->number_on_target = 0;
1525 target_download_tracepoint (t);
1526 t->number_on_target = t->number;
1528 VEC_free (breakpoint_p, tp_vec);
1530 /* Send down all the trace state variables too. */
1531 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1533 target_download_trace_state_variable (tsv);
1536 /* Tell target to treat text-like sections as transparent. */
1537 target_trace_set_readonly_regions ();
1538 /* Set some mode flags. */
1539 target_set_disconnected_tracing (disconnected_tracing);
1540 target_set_circular_trace_buffer (circular_trace_buffer);
1542 /* Now insert traps and begin collecting data. */
1543 target_trace_start ();
1545 /* Reset our local state. */
1546 set_traceframe_num (-1);
1547 set_tracepoint_num (-1);
1548 set_traceframe_context (NULL);
1549 current_trace_status()->running = 1;
1554 Tell target to clear any previous trace experiment.
1555 Walk the list of tracepoints, and send them (and their actions)
1556 to the target. If no errors,
1557 Tell target to start a new trace experiment. */
1560 trace_start_command (char *args, int from_tty)
1562 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1564 if (current_trace_status ()->running)
1567 && !query (_("A trace is running already. Start a new run? ")))
1568 error (_("New trace run not started."));
1576 trace_stop_command (char *args, int from_tty)
1578 if (!current_trace_status ()->running)
1579 error (_("Trace is not running."));
1587 target_trace_stop ();
1588 /* should change in response to reply? */
1589 current_trace_status ()->running = 0;
1592 /* tstatus command */
1594 trace_status_command (char *args, int from_tty)
1596 struct trace_status *ts = current_trace_status ();
1599 status = target_get_trace_status (ts);
1604 printf_filtered (_("Using a trace file.\n"));
1607 printf_filtered (_("Trace can not be run on this target.\n"));
1612 if (!ts->running_known)
1614 printf_filtered (_("Run/stop status is unknown.\n"));
1616 else if (ts->running)
1618 printf_filtered (_("Trace is running on the target.\n"));
1622 switch (ts->stop_reason)
1624 case trace_never_run:
1625 printf_filtered (_("No trace has been run on the target.\n"));
1628 printf_filtered (_("Trace stopped by a tstop command.\n"));
1630 case trace_buffer_full:
1631 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1633 case trace_disconnected:
1634 printf_filtered (_("Trace stopped because of disconnection.\n"));
1636 case tracepoint_passcount:
1637 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1638 ts->stopping_tracepoint);
1640 case tracepoint_error:
1641 if (ts->stopping_tracepoint)
1642 printf_filtered (_("Trace stopped by an error (%s, tracepoint %d).\n"),
1643 ts->error_desc, ts->stopping_tracepoint);
1645 printf_filtered (_("Trace stopped by an error (%s).\n"),
1648 case trace_stop_reason_unknown:
1649 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1652 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1658 if (ts->traceframes_created >= 0
1659 && ts->traceframe_count != ts->traceframes_created)
1661 printf_filtered (_("Buffer contains %d trace frames (of %d created total).\n"),
1662 ts->traceframe_count, ts->traceframes_created);
1664 else if (ts->traceframe_count >= 0)
1666 printf_filtered (_("Collected %d trace frames.\n"),
1667 ts->traceframe_count);
1670 if (ts->buffer_free >= 0)
1672 if (ts->buffer_size >= 0)
1674 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1675 ts->buffer_free, ts->buffer_size);
1676 if (ts->buffer_size > 0)
1677 printf_filtered (_(" (%d%% full)"),
1678 ((int) ((((long long) (ts->buffer_size
1679 - ts->buffer_free)) * 100)
1680 / ts->buffer_size)));
1681 printf_filtered (_(".\n"));
1684 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1688 if (ts->disconnected_tracing)
1689 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1691 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1693 if (ts->circular_buffer)
1694 printf_filtered (_("Trace buffer is circular.\n"));
1696 /* Now report on what we're doing with tfind. */
1697 if (traceframe_number >= 0)
1698 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1699 traceframe_number, tracepoint_number);
1701 printf_filtered (_("Not looking at any trace frame.\n"));
1704 /* Report the trace status to uiout, in a way suitable for MI, and not
1705 suitable for CLI. If ON_STOP is true, suppress a few fields that
1706 are not meaningful in the -trace-stop response.
1708 The implementation is essentially parallel to trace_status_command, but
1709 merging them will result in unreadable code. */
1711 trace_status_mi (int on_stop)
1713 struct trace_status *ts = current_trace_status ();
1716 status = target_get_trace_status (ts);
1718 if (status == -1 && !ts->from_file)
1720 ui_out_field_string (uiout, "supported", "0");
1725 ui_out_field_string (uiout, "supported", "file");
1727 ui_out_field_string (uiout, "supported", "1");
1729 gdb_assert (ts->running_known);
1733 ui_out_field_string (uiout, "running", "1");
1735 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1736 Given that the frontend gets the status either on -trace-stop, or from
1737 -trace-status after re-connection, it does not seem like this
1738 information is necessary for anything. It is not necessary for either
1739 figuring the vital state of the target nor for navigation of trace
1740 frames. If the frontend wants to show the current state is some
1741 configure dialog, it can request the value when such dialog is
1742 invoked by the user. */
1746 char *stop_reason = NULL;
1747 int stopping_tracepoint = -1;
1750 ui_out_field_string (uiout, "running", "0");
1752 if (ts->stop_reason != trace_stop_reason_unknown)
1754 switch (ts->stop_reason)
1757 stop_reason = "request";
1759 case trace_buffer_full:
1760 stop_reason = "overflow";
1762 case trace_disconnected:
1763 stop_reason = "disconnection";
1765 case tracepoint_passcount:
1766 stop_reason = "passcount";
1767 stopping_tracepoint = ts->stopping_tracepoint;
1769 case tracepoint_error:
1770 stop_reason = "error";
1771 stopping_tracepoint = ts->stopping_tracepoint;
1777 ui_out_field_string (uiout, "stop-reason", stop_reason);
1778 if (stopping_tracepoint != -1)
1779 ui_out_field_int (uiout, "stopping-tracepoint",
1780 stopping_tracepoint);
1781 if (ts->stop_reason == tracepoint_error)
1782 ui_out_field_string (uiout, "error-description",
1788 if (ts->traceframe_count != -1)
1789 ui_out_field_int (uiout, "frames", ts->traceframe_count);
1790 if (ts->traceframes_created != -1)
1791 ui_out_field_int (uiout, "frames-created", ts->traceframes_created);
1792 if (ts->buffer_size != -1)
1793 ui_out_field_int (uiout, "buffer-size", ts->buffer_size);
1794 if (ts->buffer_free != -1)
1795 ui_out_field_int (uiout, "buffer-free", ts->buffer_free);
1797 ui_out_field_int (uiout, "disconnected", ts->disconnected_tracing);
1798 ui_out_field_int (uiout, "circular", ts->circular_buffer);
1801 /* This function handles the details of what to do about an ongoing
1802 tracing run if the user has asked to detach or otherwise disconnect
1805 disconnect_tracing (int from_tty)
1807 /* It can happen that the target that was tracing went away on its
1808 own, and we didn't notice. Get a status update, and if the
1809 current target doesn't even do tracing, then assume it's not
1811 if (target_get_trace_status (current_trace_status ()) < 0)
1812 current_trace_status ()->running = 0;
1814 /* If running interactively, give the user the option to cancel and
1815 then decide what to do differently with the run. Scripts are
1816 just going to disconnect and let the target deal with it,
1817 according to how it's been instructed previously via
1818 disconnected-tracing. */
1819 if (current_trace_status ()->running && from_tty)
1821 if (current_trace_status ()->disconnected_tracing)
1823 if (!query (_("Trace is running and will continue after detach; detach anyway? ")))
1824 error (_("Not confirmed."));
1828 if (!query (_("Trace is running but will stop on detach; detach anyway? ")))
1829 error (_("Not confirmed."));
1833 /* Also we want to be out of tfind mode, otherwise things can get
1834 confusing upon reconnection. Just use these calls instead of
1835 full tfind_1 behavior because we're in the middle of detaching,
1836 and there's no point to updating current stack frame etc. */
1837 set_traceframe_number (-1);
1838 set_traceframe_context (NULL);
1841 /* Worker function for the various flavors of the tfind command. */
1843 tfind_1 (enum trace_find_type type, int num,
1844 ULONGEST addr1, ULONGEST addr2,
1847 int target_frameno = -1, target_tracept = -1;
1848 struct frame_id old_frame_id = null_frame_id;
1849 struct breakpoint *tp;
1851 /* Only try to get the current stack frame if we have a chance of
1852 succeeding. In particular, if we're trying to get a first trace
1853 frame while all threads are running, it's not going to succeed,
1854 so leave it with a default value and let the frame comparison
1855 below (correctly) decide to print out the source location of the
1857 if (!(type == tfind_number && num == -1)
1858 && (has_stack_frames () || traceframe_number >= 0))
1859 old_frame_id = get_frame_id (get_current_frame ());
1861 target_frameno = target_trace_find (type, num, addr1, addr2,
1864 if (type == tfind_number
1866 && target_frameno == -1)
1868 /* We told the target to get out of tfind mode, and it did. */
1870 else if (target_frameno == -1)
1872 /* A request for a non-existent trace frame has failed.
1873 Our response will be different, depending on FROM_TTY:
1875 If FROM_TTY is true, meaning that this command was
1876 typed interactively by the user, then give an error
1877 and DO NOT change the state of traceframe_number etc.
1879 However if FROM_TTY is false, meaning that we're either
1880 in a script, a loop, or a user-defined command, then
1881 DON'T give an error, but DO change the state of
1882 traceframe_number etc. to invalid.
1884 The rationalle is that if you typed the command, you
1885 might just have committed a typo or something, and you'd
1886 like to NOT lose your current debugging state. However
1887 if you're in a user-defined command or especially in a
1888 loop, then you need a way to detect that the command
1889 failed WITHOUT aborting. This allows you to write
1890 scripts that search thru the trace buffer until the end,
1891 and then continue on to do something else. */
1894 error (_("Target failed to find requested trace frame."));
1898 printf_filtered ("End of trace buffer.\n");
1899 #if 0 /* dubious now? */
1900 /* The following will not recurse, since it's
1902 trace_find_command ("-1", from_tty);
1907 tp = get_tracepoint_by_number_on_target (target_tracept);
1909 reinit_frame_cache ();
1910 registers_changed ();
1911 target_dcache_invalidate ();
1912 set_traceframe_num (target_frameno);
1913 set_tracepoint_num (tp ? tp->number : target_tracept);
1914 if (target_frameno == -1)
1915 set_traceframe_context (NULL);
1917 set_traceframe_context (get_current_frame ());
1919 if (traceframe_number >= 0)
1921 /* Use different branches for MI and CLI to make CLI messages
1923 if (ui_out_is_mi_like_p (uiout))
1925 ui_out_field_string (uiout, "found", "1");
1926 ui_out_field_int (uiout, "tracepoint", tracepoint_number);
1927 ui_out_field_int (uiout, "traceframe", traceframe_number);
1931 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
1932 traceframe_number, tracepoint_number);
1937 if (ui_out_is_mi_like_p (uiout))
1938 ui_out_field_string (uiout, "found", "0");
1939 else if (type == tfind_number && num == -1)
1940 printf_unfiltered (_("No longer looking at any trace frame\n"));
1941 else /* this case may never occur, check */
1942 printf_unfiltered (_("No trace frame found\n"));
1945 /* If we're in nonstop mode and getting out of looking at trace
1946 frames, there won't be any current frame to go back to and
1949 && (has_stack_frames () || traceframe_number >= 0))
1951 enum print_what print_what;
1953 /* NOTE: in imitation of the step command, try to determine
1954 whether we have made a transition from one function to
1955 another. If so, we'll print the "stack frame" (ie. the new
1956 function and it's arguments) -- otherwise we'll just show the
1959 if (frame_id_eq (old_frame_id,
1960 get_frame_id (get_current_frame ())))
1961 print_what = SRC_LINE;
1963 print_what = SRC_AND_LOC;
1965 print_stack_frame (get_selected_frame (NULL), 1, print_what);
1970 /* trace_find_command takes a trace frame number n,
1971 sends "QTFrame:<n>" to the target,
1972 and accepts a reply that may contain several optional pieces
1973 of information: a frame number, a tracepoint number, and an
1974 indication of whether this is a trap frame or a stepping frame.
1976 The minimal response is just "OK" (which indicates that the
1977 target does not give us a frame number or a tracepoint number).
1978 Instead of that, the target may send us a string containing
1980 F<hexnum> (gives the selected frame number)
1981 T<hexnum> (gives the selected tracepoint number)
1986 trace_find_command (char *args, int from_tty)
1987 { /* this should only be called with a numeric argument */
1990 if (current_trace_status ()->running && !current_trace_status ()->from_file)
1991 error ("May not look at trace frames while trace is running.");
1993 if (args == 0 || *args == 0)
1994 { /* TFIND with no args means find NEXT trace frame. */
1995 if (traceframe_number == -1)
1996 frameno = 0; /* "next" is first one */
1998 frameno = traceframe_number + 1;
2000 else if (0 == strcmp (args, "-"))
2002 if (traceframe_number == -1)
2003 error (_("not debugging trace buffer"));
2004 else if (from_tty && traceframe_number == 0)
2005 error (_("already at start of trace buffer"));
2007 frameno = traceframe_number - 1;
2009 /* A hack to work around eval's need for fp to have been collected. */
2010 else if (0 == strcmp (args, "-1"))
2013 frameno = parse_and_eval_long (args);
2016 error (_("invalid input (%d is less than zero)"), frameno);
2018 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2023 trace_find_end_command (char *args, int from_tty)
2025 trace_find_command ("-1", from_tty);
2030 trace_find_none_command (char *args, int from_tty)
2032 trace_find_command ("-1", from_tty);
2037 trace_find_start_command (char *args, int from_tty)
2039 trace_find_command ("0", from_tty);
2042 /* tfind pc command */
2044 trace_find_pc_command (char *args, int from_tty)
2048 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2049 error ("May not look at trace frames while trace is running.");
2051 if (args == 0 || *args == 0)
2052 pc = regcache_read_pc (get_current_regcache ());
2054 pc = parse_and_eval_address (args);
2056 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2059 /* tfind tracepoint command */
2061 trace_find_tracepoint_command (char *args, int from_tty)
2064 struct breakpoint *tp;
2066 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2067 error ("May not look at trace frames while trace is running.");
2069 if (args == 0 || *args == 0)
2071 if (tracepoint_number == -1)
2072 error (_("No current tracepoint -- please supply an argument."));
2074 tdp = tracepoint_number; /* default is current TDP */
2077 tdp = parse_and_eval_long (args);
2079 /* If we have the tracepoint on hand, use the number that the
2080 target knows about (which may be different if we disconnected
2081 and reconnected). */
2082 tp = get_tracepoint (tdp);
2084 tdp = tp->number_on_target;
2086 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2089 /* TFIND LINE command:
2091 This command will take a sourceline for argument, just like BREAK
2092 or TRACE (ie. anything that "decode_line_1" can handle).
2094 With no argument, this command will find the next trace frame
2095 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2098 trace_find_line_command (char *args, int from_tty)
2100 static CORE_ADDR start_pc, end_pc;
2101 struct symtabs_and_lines sals;
2102 struct symtab_and_line sal;
2103 struct cleanup *old_chain;
2105 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2106 error ("May not look at trace frames while trace is running.");
2108 if (args == 0 || *args == 0)
2110 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2112 sals.sals = (struct symtab_and_line *)
2113 xmalloc (sizeof (struct symtab_and_line));
2118 sals = decode_line_spec (args, 1);
2122 old_chain = make_cleanup (xfree, sals.sals);
2123 if (sal.symtab == 0)
2124 error (_("No line number information available."));
2126 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2128 if (start_pc == end_pc)
2130 printf_filtered ("Line %d of \"%s\"",
2131 sal.line, sal.symtab->filename);
2133 printf_filtered (" is at address ");
2134 print_address (get_current_arch (), start_pc, gdb_stdout);
2136 printf_filtered (" but contains no code.\n");
2137 sal = find_pc_line (start_pc, 0);
2139 && find_line_pc_range (sal, &start_pc, &end_pc)
2140 && start_pc != end_pc)
2141 printf_filtered ("Attempting to find line %d instead.\n",
2144 error (_("Cannot find a good line."));
2148 /* Is there any case in which we get here, and have an address
2149 which the user would want to see? If we have debugging
2150 symbols and no line numbers? */
2151 error (_("Line number %d is out of range for \"%s\"."),
2152 sal.line, sal.symtab->filename);
2154 /* Find within range of stated line. */
2156 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2158 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2159 do_cleanups (old_chain);
2162 /* tfind range command */
2164 trace_find_range_command (char *args, int from_tty)
2166 static CORE_ADDR start, stop;
2169 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2170 error ("May not look at trace frames while trace is running.");
2172 if (args == 0 || *args == 0)
2173 { /* XXX FIXME: what should default behavior be? */
2174 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2178 if (0 != (tmp = strchr (args, ',')))
2180 *tmp++ = '\0'; /* terminate start address */
2181 while (isspace ((int) *tmp))
2183 start = parse_and_eval_address (args);
2184 stop = parse_and_eval_address (tmp);
2187 { /* no explicit end address? */
2188 start = parse_and_eval_address (args);
2189 stop = start + 1; /* ??? */
2192 tfind_1 (tfind_range, 0, start, stop, from_tty);
2195 /* tfind outside command */
2197 trace_find_outside_command (char *args, int from_tty)
2199 CORE_ADDR start, stop;
2202 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2203 error ("May not look at trace frames while trace is running.");
2205 if (args == 0 || *args == 0)
2206 { /* XXX FIXME: what should default behavior be? */
2207 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2211 if (0 != (tmp = strchr (args, ',')))
2213 *tmp++ = '\0'; /* terminate start address */
2214 while (isspace ((int) *tmp))
2216 start = parse_and_eval_address (args);
2217 stop = parse_and_eval_address (tmp);
2220 { /* no explicit end address? */
2221 start = parse_and_eval_address (args);
2222 stop = start + 1; /* ??? */
2225 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2228 /* info scope command: list the locals for a scope. */
2230 scope_info (char *args, int from_tty)
2232 struct symtabs_and_lines sals;
2234 struct minimal_symbol *msym;
2235 struct block *block;
2236 char **canonical, *symname, *save_args = args;
2237 struct dict_iterator iter;
2239 struct gdbarch *gdbarch;
2242 if (args == 0 || *args == 0)
2243 error (_("requires an argument (function, line or *addr) to define a scope"));
2245 sals = decode_line_1 (&args, 1, NULL, 0, &canonical, NULL);
2246 if (sals.nelts == 0)
2247 return; /* presumably decode_line_1 has already warned */
2249 /* Resolve line numbers to PC */
2250 resolve_sal_pc (&sals.sals[0]);
2251 block = block_for_pc (sals.sals[0].pc);
2255 QUIT; /* allow user to bail out with ^C */
2256 ALL_BLOCK_SYMBOLS (block, iter, sym)
2258 QUIT; /* allow user to bail out with ^C */
2260 printf_filtered ("Scope for %s:\n", save_args);
2263 symname = SYMBOL_PRINT_NAME (sym);
2264 if (symname == NULL || *symname == '\0')
2265 continue; /* probably botched, certainly useless */
2267 gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
2269 printf_filtered ("Symbol %s is ", symname);
2270 switch (SYMBOL_CLASS (sym))
2273 case LOC_UNDEF: /* messed up symbol? */
2274 printf_filtered ("a bogus symbol, class %d.\n",
2275 SYMBOL_CLASS (sym));
2276 count--; /* don't count this one */
2279 printf_filtered ("a constant with value %ld (0x%lx)",
2280 SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
2282 case LOC_CONST_BYTES:
2283 printf_filtered ("constant bytes: ");
2284 if (SYMBOL_TYPE (sym))
2285 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2286 fprintf_filtered (gdb_stdout, " %02x",
2287 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2290 printf_filtered ("in static storage at address ");
2291 printf_filtered ("%s", paddress (gdbarch,
2292 SYMBOL_VALUE_ADDRESS (sym)));
2295 /* GDBARCH is the architecture associated with the objfile
2296 the symbol is defined in; the target architecture may be
2297 different, and may provide additional registers. However,
2298 we do not know the target architecture at this point.
2299 We assume the objfile architecture will contain all the
2300 standard registers that occur in debug info in that
2302 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
2304 if (SYMBOL_IS_ARGUMENT (sym))
2305 printf_filtered ("an argument in register $%s",
2306 gdbarch_register_name (gdbarch, regno));
2308 printf_filtered ("a local variable in register $%s",
2309 gdbarch_register_name (gdbarch, regno));
2312 printf_filtered ("an argument at stack/frame offset %ld",
2313 SYMBOL_VALUE (sym));
2316 printf_filtered ("a local variable at frame offset %ld",
2317 SYMBOL_VALUE (sym));
2320 printf_filtered ("a reference argument at offset %ld",
2321 SYMBOL_VALUE (sym));
2323 case LOC_REGPARM_ADDR:
2324 /* Note comment at LOC_REGISTER. */
2325 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
2326 printf_filtered ("the address of an argument, in register $%s",
2327 gdbarch_register_name (gdbarch, regno));
2330 printf_filtered ("a typedef.\n");
2333 printf_filtered ("a label at address ");
2334 printf_filtered ("%s", paddress (gdbarch,
2335 SYMBOL_VALUE_ADDRESS (sym)));
2338 printf_filtered ("a function at address ");
2339 printf_filtered ("%s",
2340 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2342 case LOC_UNRESOLVED:
2343 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2346 printf_filtered ("Unresolved Static");
2349 printf_filtered ("static storage at address ");
2350 printf_filtered ("%s",
2351 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msym)));
2354 case LOC_OPTIMIZED_OUT:
2355 printf_filtered ("optimized out.\n");
2358 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2359 BLOCK_START (block),
2363 if (SYMBOL_TYPE (sym))
2364 printf_filtered (", length %d.\n",
2365 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2367 if (BLOCK_FUNCTION (block))
2370 block = BLOCK_SUPERBLOCK (block);
2373 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2377 /* worker function (cleanup) */
2379 replace_comma (void *data)
2386 /* Helper for trace_dump_command. Dump the action list starting at
2387 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2388 actions of the body of a while-stepping action. STEPPING_FRAME is
2389 set if the current traceframe was determined to be a while-stepping
2393 trace_dump_actions (struct command_line *action,
2394 int stepping_actions, int stepping_frame,
2397 char *action_exp, *next_comma;
2399 for (; action != NULL; action = action->next)
2401 struct cmd_list_element *cmd;
2403 QUIT; /* allow user to bail out with ^C */
2404 action_exp = action->line;
2405 while (isspace ((int) *action_exp))
2408 /* The collection actions to be done while stepping are
2409 bracketed by the commands "while-stepping" and "end". */
2411 if (*action_exp == '#') /* comment line */
2414 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2416 error (_("Bad action list item: %s"), action_exp);
2418 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2422 for (i = 0; i < action->body_count; ++i)
2423 trace_dump_actions (action->body_list[i],
2424 1, stepping_frame, from_tty);
2426 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2428 /* Display the collected data.
2429 For the trap frame, display only what was collected at
2430 the trap. Likewise for stepping frames, display only
2431 what was collected while stepping. This means that the
2432 two boolean variables, STEPPING_FRAME and
2433 STEPPING_ACTIONS should be equal. */
2434 if (stepping_frame == stepping_actions)
2437 { /* repeat over a comma-separated list */
2438 QUIT; /* allow user to bail out with ^C */
2439 if (*action_exp == ',')
2441 while (isspace ((int) *action_exp))
2444 next_comma = strchr (action_exp, ',');
2446 if (0 == strncasecmp (action_exp, "$reg", 4))
2447 registers_info (NULL, from_tty);
2448 else if (0 == strncasecmp (action_exp, "$loc", 4))
2449 locals_info (NULL, from_tty);
2450 else if (0 == strncasecmp (action_exp, "$arg", 4))
2451 args_info (NULL, from_tty);
2456 make_cleanup (replace_comma, next_comma);
2459 printf_filtered ("%s = ", action_exp);
2460 output_command (action_exp, from_tty);
2461 printf_filtered ("\n");
2465 action_exp = next_comma;
2467 while (action_exp && *action_exp == ',');
2473 /* The tdump command. */
2476 trace_dump_command (char *args, int from_tty)
2478 struct regcache *regcache;
2479 struct breakpoint *t;
2480 int stepping_frame = 0;
2481 struct bp_location *loc;
2482 char *line, *default_collect_line = NULL;
2483 struct command_line *actions, *default_collect_action = NULL;
2484 struct cleanup *old_chain = NULL;
2486 if (tracepoint_number == -1)
2488 warning (_("No current trace frame."));
2492 t = get_tracepoint (tracepoint_number);
2495 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2498 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2499 tracepoint_number, traceframe_number);
2501 /* The current frame is a trap frame if the frame PC is equal
2502 to the tracepoint PC. If not, then the current frame was
2503 collected during single-stepping. */
2505 regcache = get_current_regcache ();
2507 /* If the traceframe's address matches any of the tracepoint's
2508 locations, assume it is a direct hit rather than a while-stepping
2509 frame. (FIXME this is not reliable, should record each frame's
2512 for (loc = t->loc; loc; loc = loc->next)
2513 if (loc->address == regcache_read_pc (regcache))
2516 actions = breakpoint_commands (t);
2518 /* If there is a default-collect list, make up a collect command,
2519 prepend to the tracepoint's commands, and pass the whole mess to
2520 the trace dump scanner. We need to validate because
2521 default-collect might have been junked since the trace run. */
2522 if (*default_collect)
2524 default_collect_line = xstrprintf ("collect %s", default_collect);
2525 old_chain = make_cleanup (xfree, default_collect_line);
2526 line = default_collect_line;
2527 validate_actionline (&line, t);
2528 default_collect_action = xmalloc (sizeof (struct command_line));
2529 make_cleanup (xfree, default_collect_action);
2530 default_collect_action->next = actions;
2531 default_collect_action->line = line;
2532 actions = default_collect_action;
2535 trace_dump_actions (actions, 0, stepping_frame, from_tty);
2537 if (*default_collect)
2538 do_cleanups (old_chain);
2541 /* Encode a piece of a tracepoint's source-level definition in a form
2542 that is suitable for both protocol and saving in files. */
2543 /* This version does not do multiple encodes for long strings; it should
2544 return an offset to the next piece to encode. FIXME */
2547 encode_source_string (int tpnum, ULONGEST addr,
2548 char *srctype, char *src, char *buf, int buf_size)
2550 if (80 + strlen (srctype) > buf_size)
2551 error (_("Buffer too small for source encoding"));
2552 sprintf (buf, "%x:%s:%s:%x:%x:",
2553 tpnum, phex_nz (addr, sizeof (addr)), srctype, 0, (int) strlen (src));
2554 if (strlen (buf) + strlen (src) * 2 >= buf_size)
2555 error (_("Source string too long for buffer"));
2556 bin2hex (src, buf + strlen (buf), 0);
2560 extern int trace_regblock_size;
2562 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2563 non-zero, the save is performed on the target, otherwise GDB obtains all
2564 trace data and saves it locally. */
2567 trace_save (const char *filename, int target_does_save)
2569 struct cleanup *cleanup;
2571 struct trace_status *ts = current_trace_status ();
2574 struct uploaded_tp *uploaded_tps = NULL, *utp;
2575 struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
2579 ULONGEST offset = 0;
2580 #define MAX_TRACE_UPLOAD 2000
2581 gdb_byte buf[MAX_TRACE_UPLOAD];
2584 /* If the target is to save the data to a file on its own, then just
2585 send the command and be done with it. */
2586 if (target_does_save)
2588 err = target_save_trace_data (filename);
2590 error (_("Target failed to save trace data to '%s'."),
2595 /* Get the trace status first before opening the file, so if the
2596 target is losing, we can get out without touching files. */
2597 status = target_get_trace_status (ts);
2599 pathname = tilde_expand (filename);
2600 cleanup = make_cleanup (xfree, pathname);
2602 fp = fopen (pathname, "wb");
2604 error (_("Unable to open file '%s' for saving trace data (%s)"),
2605 filename, safe_strerror (errno));
2606 make_cleanup_fclose (fp);
2608 /* Write a file header, with a high-bit-set char to indicate a
2609 binary file, plus a hint as what this file is, and a version
2610 number in case of future needs. */
2611 written = fwrite ("\x7fTRACE0\n", 8, 1, fp);
2613 perror_with_name (pathname);
2615 /* Write descriptive info. */
2617 /* Write out the size of a register block. */
2618 fprintf (fp, "R %x\n", trace_regblock_size);
2620 /* Write out status of the tracing run (aka "tstatus" info). */
2621 fprintf (fp, "status %c;%s",
2622 (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
2623 if (ts->stop_reason == tracepoint_error)
2625 char *buf = (char *) alloca (strlen (ts->error_desc) * 2 + 1);
2627 bin2hex ((gdb_byte *) ts->error_desc, buf, 0);
2628 fprintf (fp, ":%s", buf);
2630 fprintf (fp, ":%x", ts->stopping_tracepoint);
2631 if (ts->traceframe_count >= 0)
2632 fprintf (fp, ";tframes:%x", ts->traceframe_count);
2633 if (ts->traceframes_created >= 0)
2634 fprintf (fp, ";tcreated:%x", ts->traceframes_created);
2635 if (ts->buffer_free >= 0)
2636 fprintf (fp, ";tfree:%x", ts->buffer_free);
2637 if (ts->buffer_size >= 0)
2638 fprintf (fp, ";tsize:%x", ts->buffer_size);
2639 if (ts->disconnected_tracing)
2640 fprintf (fp, ";disconn:%x", ts->disconnected_tracing);
2641 if (ts->circular_buffer)
2642 fprintf (fp, ";circular:%x", ts->circular_buffer);
2645 /* Note that we want to upload tracepoints and save those, rather
2646 than simply writing out the local ones, because the user may have
2647 changed tracepoints in GDB in preparation for a future tracing
2648 run, or maybe just mass-deleted all types of breakpoints as part
2649 of cleaning up. So as not to contaminate the session, leave the
2650 data in its uploaded form, don't make into real tracepoints. */
2652 /* Get trace state variables first, they may be checked when parsing
2653 uploaded commands. */
2655 target_upload_trace_state_variables (&uploaded_tsvs);
2657 for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
2663 buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
2664 bin2hex ((gdb_byte *) (utsv->name), buf, 0);
2667 fprintf (fp, "tsv %x:%s:%x:%s\n",
2668 utsv->number, phex_nz (utsv->initial_value, 8),
2669 utsv->builtin, buf);
2675 free_uploaded_tsvs (&uploaded_tsvs);
2677 target_upload_tracepoints (&uploaded_tps);
2679 for (utp = uploaded_tps; utp; utp = utp->next)
2681 fprintf (fp, "tp T%x:%s:%c:%x:%x",
2682 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
2683 (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
2684 if (utp->type == bp_fast_tracepoint)
2685 fprintf (fp, ":F%x", utp->orig_size);
2687 fprintf (fp, ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
2690 for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
2691 fprintf (fp, "tp A%x:%s:%s\n",
2692 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
2693 for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
2694 fprintf (fp, "tp S%x:%s:%s\n",
2695 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
2698 encode_source_string (utp->number, utp->addr,
2699 "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
2700 fprintf (fp, "tp Z%s\n", buf);
2702 if (utp->cond_string)
2704 encode_source_string (utp->number, utp->addr,
2705 "cond", utp->cond_string, buf, MAX_TRACE_UPLOAD);
2706 fprintf (fp, "tp Z%s\n", buf);
2708 for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
2710 encode_source_string (utp->number, utp->addr, "cmd", act,
2711 buf, MAX_TRACE_UPLOAD);
2712 fprintf (fp, "tp Z%s\n", buf);
2716 free_uploaded_tps (&uploaded_tps);
2718 /* Mark the end of the definition section. */
2721 /* Get and write the trace data proper. We ask for big blocks, in
2722 the hopes of efficiency, but will take less if the target has
2723 packet size limitations or some such. */
2726 gotten = target_get_raw_trace_data (buf, offset, MAX_TRACE_UPLOAD);
2728 error (_("Failure to get requested trace buffer data"));
2729 /* No more data is forthcoming, we're done. */
2732 written = fwrite (buf, gotten, 1, fp);
2734 perror_with_name (pathname);
2738 /* Mark the end of trace data. (We know that gotten is 0 at this point.) */
2739 written = fwrite (&gotten, 4, 1, fp);
2741 perror_with_name (pathname);
2743 do_cleanups (cleanup);
2747 trace_save_command (char *args, int from_tty)
2749 int target_does_save = 0;
2751 char *filename = NULL;
2752 struct cleanup *back_to;
2755 error_no_arg (_("file in which to save trace data"));
2757 argv = gdb_buildargv (args);
2758 back_to = make_cleanup_freeargv (argv);
2760 for (; *argv; ++argv)
2762 if (strcmp (*argv, "-r") == 0)
2763 target_does_save = 1;
2764 else if (**argv == '-')
2765 error (_("unknown option `%s'"), *argv);
2771 error_no_arg (_("file in which to save trace data"));
2773 trace_save (filename, target_does_save);
2776 printf_filtered (_("Trace data saved to file '%s'.\n"), args);
2778 do_cleanups (back_to);
2781 /* Tell the target what to do with an ongoing tracing run if GDB
2782 disconnects for some reason. */
2785 send_disconnected_tracing_value (int value)
2787 target_set_disconnected_tracing (value);
2791 set_disconnected_tracing (char *args, int from_tty,
2792 struct cmd_list_element *c)
2794 send_disconnected_tracing_value (disconnected_tracing);
2798 set_circular_trace_buffer (char *args, int from_tty,
2799 struct cmd_list_element *c)
2801 target_set_circular_trace_buffer (circular_trace_buffer);
2804 /* Convert the memory pointed to by mem into hex, placing result in buf.
2805 * Return a pointer to the last char put in buf (null)
2806 * "stolen" from sparc-stub.c
2809 static const char hexchars[] = "0123456789abcdef";
2812 mem2hex (gdb_byte *mem, char *buf, int count)
2820 *buf++ = hexchars[ch >> 4];
2821 *buf++ = hexchars[ch & 0xf];
2830 get_traceframe_number (void)
2832 return traceframe_number;
2835 /* Make the traceframe NUM be the current trace frame. Does nothing
2836 if NUM is already current. */
2839 set_traceframe_number (int num)
2843 if (traceframe_number == num)
2845 /* Nothing to do. */
2849 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
2852 warning (_("could not change traceframe"));
2854 traceframe_number = newnum;
2856 /* Changing the traceframe changes our view of registers and of the
2858 registers_changed ();
2861 /* A cleanup used when switching away and back from tfind mode. */
2863 struct current_traceframe_cleanup
2865 /* The traceframe we were inspecting. */
2866 int traceframe_number;
2870 do_restore_current_traceframe_cleanup (void *arg)
2872 struct current_traceframe_cleanup *old = arg;
2874 set_traceframe_number (old->traceframe_number);
2878 restore_current_traceframe_cleanup_dtor (void *arg)
2880 struct current_traceframe_cleanup *old = arg;
2886 make_cleanup_restore_current_traceframe (void)
2888 struct current_traceframe_cleanup *old;
2890 old = xmalloc (sizeof (struct current_traceframe_cleanup));
2891 old->traceframe_number = traceframe_number;
2893 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
2894 restore_current_traceframe_cleanup_dtor);
2897 /* Given a number and address, return an uploaded tracepoint with that
2898 number, creating if necessary. */
2900 struct uploaded_tp *
2901 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
2903 struct uploaded_tp *utp;
2905 for (utp = *utpp; utp; utp = utp->next)
2906 if (utp->number == num && utp->addr == addr)
2908 utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
2909 memset (utp, 0, sizeof (struct uploaded_tp));
2912 utp->actions = NULL;
2913 utp->step_actions = NULL;
2914 utp->cmd_strings = NULL;
2921 free_uploaded_tps (struct uploaded_tp **utpp)
2923 struct uploaded_tp *next_one;
2927 next_one = (*utpp)->next;
2933 /* Given a number and address, return an uploaded tracepoint with that
2934 number, creating if necessary. */
2936 struct uploaded_tsv *
2937 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
2939 struct uploaded_tsv *utsv;
2941 for (utsv = *utsvp; utsv; utsv = utsv->next)
2942 if (utsv->number == num)
2944 utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
2945 memset (utsv, 0, sizeof (struct uploaded_tsv));
2947 utsv->next = *utsvp;
2953 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
2955 struct uploaded_tsv *next_one;
2959 next_one = (*utsvp)->next;
2965 /* Look for an existing tracepoint that seems similar enough to the
2966 uploaded one. Enablement isn't compared, because the user can
2967 toggle that freely, and may have done so in anticipation of the
2971 find_matching_tracepoint (struct uploaded_tp *utp)
2973 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
2975 struct breakpoint *t;
2976 struct bp_location *loc;
2978 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
2980 if (t->type == utp->type
2981 && t->step_count == utp->step
2982 && t->pass_count == utp->pass
2983 /* FIXME also test conditionals and actions */
2986 /* Scan the locations for an address match. */
2987 for (loc = t->loc; loc; loc = loc->next)
2989 if (loc->address == utp->addr)
2997 /* Given a list of tracepoints uploaded from a target, attempt to
2998 match them up with existing tracepoints, and create new ones if not
3002 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3004 struct uploaded_tp *utp;
3005 struct breakpoint *t;
3007 /* Look for GDB tracepoints that match up with our uploaded versions. */
3008 for (utp = *uploaded_tps; utp; utp = utp->next)
3010 t = find_matching_tracepoint (utp);
3012 printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
3013 t->number, utp->number, paddress (get_current_arch (), utp->addr));
3016 t = create_tracepoint_from_upload (utp);
3018 printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
3019 t->number, utp->number, paddress (get_current_arch (), utp->addr));
3021 printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
3022 utp->number, paddress (get_current_arch (), utp->addr));
3024 /* Whether found or created, record the number used by the
3025 target, to help with mapping target tracepoints back to their
3026 counterparts here. */
3028 t->number_on_target = utp->number;
3031 free_uploaded_tps (uploaded_tps);
3034 /* Trace state variables don't have much to identify them beyond their
3035 name, so just use that to detect matches. */
3037 struct trace_state_variable *
3038 find_matching_tsv (struct uploaded_tsv *utsv)
3043 return find_trace_state_variable (utsv->name);
3046 struct trace_state_variable *
3047 create_tsv_from_upload (struct uploaded_tsv *utsv)
3049 const char *namebase;
3052 struct trace_state_variable *tsv;
3056 namebase = utsv->name;
3057 sprintf (buf, "%s", namebase);
3062 sprintf (buf, "%s_%d", namebase, try_num++);
3065 /* Fish for a name that is not in use. */
3066 /* (should check against all internal vars?) */
3067 while (find_trace_state_variable (buf))
3068 sprintf (buf, "%s_%d", namebase, try_num++);
3070 /* We have an available name, create the variable. */
3071 tsv = create_trace_state_variable (xstrdup (buf));
3072 tsv->initial_value = utsv->initial_value;
3073 tsv->builtin = utsv->builtin;
3078 /* Given a list of uploaded trace state variables, try to match them
3079 up with existing variables, or create additional ones. */
3082 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
3085 struct uploaded_tsv *utsv;
3086 struct trace_state_variable *tsv;
3089 /* Most likely some numbers will have to be reassigned as part of
3090 the merge, so clear them all in anticipation. */
3091 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3094 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
3096 tsv = find_matching_tsv (utsv);
3098 printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
3099 tsv->name, utsv->number);
3102 tsv = create_tsv_from_upload (utsv);
3103 printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
3104 tsv->name, utsv->number);
3106 /* Give precedence to numberings that come from the target. */
3108 tsv->number = utsv->number;
3111 /* Renumber everything that didn't get a target-assigned number. */
3113 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3114 if (tsv->number > highest)
3115 highest = tsv->number;
3118 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
3119 if (tsv->number == 0)
3120 tsv->number = highest++;
3122 free_uploaded_tsvs (uploaded_tsvs);
3125 /* target tfile command */
3127 struct target_ops tfile_ops;
3129 /* Fill in tfile_ops with its defined operations and properties. */
3131 #define TRACE_HEADER_SIZE 8
3133 char *trace_filename;
3135 off_t trace_frames_offset;
3138 int trace_regblock_size;
3140 static void tfile_interp_line (char *line,
3141 struct uploaded_tp **utpp,
3142 struct uploaded_tsv **utsvp);
3145 tfile_open (char *filename, int from_tty)
3148 struct cleanup *old_chain;
3151 char header[TRACE_HEADER_SIZE];
3152 char linebuf[1000]; /* should be max remote packet size or so */
3154 int bytes, i, gotten;
3155 struct trace_status *ts;
3156 struct uploaded_tp *uploaded_tps = NULL;
3157 struct uploaded_tsv *uploaded_tsvs = NULL;
3159 target_preopen (from_tty);
3161 error (_("No trace file specified."));
3163 filename = tilde_expand (filename);
3164 if (!IS_ABSOLUTE_PATH(filename))
3166 temp = concat (current_directory, "/", filename, (char *) NULL);
3171 old_chain = make_cleanup (xfree, filename);
3173 flags = O_BINARY | O_LARGEFILE;
3175 scratch_chan = open (filename, flags, 0);
3176 if (scratch_chan < 0)
3177 perror_with_name (filename);
3179 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3181 discard_cleanups (old_chain); /* Don't free filename any more */
3182 unpush_target (&tfile_ops);
3184 push_target (&tfile_ops);
3186 trace_filename = xstrdup (filename);
3187 trace_fd = scratch_chan;
3190 /* Read the file header and test for validity. */
3191 gotten = read (trace_fd, &header, TRACE_HEADER_SIZE);
3193 perror_with_name (trace_filename);
3194 else if (gotten < TRACE_HEADER_SIZE)
3195 error (_("Premature end of file while reading trace file"));
3197 bytes += TRACE_HEADER_SIZE;
3198 if (!(header[0] == 0x7f
3199 && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
3200 error (_("File is not a valid trace file."));
3202 trace_regblock_size = 0;
3203 ts = current_trace_status ();
3204 /* We know we're working with a file. */
3206 /* Set defaults in case there is no status line. */
3207 ts->running_known = 0;
3208 ts->stop_reason = trace_stop_reason_unknown;
3209 ts->traceframe_count = -1;
3210 ts->buffer_free = 0;
3211 ts->disconnected_tracing = 0;
3212 ts->circular_buffer = 0;
3214 /* Read through a section of newline-terminated lines that
3215 define things like tracepoints. */
3219 gotten = read (trace_fd, &byte, 1);
3221 perror_with_name (trace_filename);
3222 else if (gotten < 1)
3223 error (_("Premature end of file while reading trace file"));
3228 /* Empty line marks end of the definition section. */
3233 tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
3236 linebuf[i++] = byte;
3238 error (_("Excessively long lines in trace file"));
3241 /* Add the file's tracepoints and variables into the current mix. */
3243 /* Get trace state variables first, they may be checked when parsing
3244 uploaded commands. */
3245 merge_uploaded_trace_state_variables (&uploaded_tsvs);
3247 merge_uploaded_tracepoints (&uploaded_tps);
3249 /* Record the starting offset of the binary trace data. */
3250 trace_frames_offset = bytes;
3252 /* If we don't have a blocksize, we can't interpret the
3254 if (trace_regblock_size == 0)
3255 error (_("No register block size recorded in trace file"));
3256 if (ts->traceframe_count <= 0)
3258 warning ("No traceframes present in this file.");
3262 #define TFILE_PID (1)
3263 inferior_appeared (current_inferior (), TFILE_PID);
3264 inferior_ptid = pid_to_ptid (TFILE_PID);
3265 add_thread_silent (inferior_ptid);
3267 post_create_inferior (&tfile_ops, from_tty);
3270 /* FIXME this will get defined in MI patch submission */
3271 tfind_1 (tfind_number, 0, 0, 0, 0);
3275 /* Interpret the given line from the definitions part of the trace
3279 tfile_interp_line (char *line,
3280 struct uploaded_tp **utpp, struct uploaded_tsv **utsvp)
3284 if (strncmp (p, "R ", strlen ("R ")) == 0)
3287 trace_regblock_size = strtol (p, &p, 16);
3289 else if (strncmp (p, "status ", strlen ("status ")) == 0)
3291 p += strlen ("status ");
3292 parse_trace_status (p, current_trace_status ());
3294 else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
3296 p += strlen ("tp ");
3297 parse_tracepoint_definition (p, utpp);
3299 else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
3301 p += strlen ("tsv ");
3302 parse_tsv_definition (p, utsvp);
3305 warning ("Ignoring trace file definition \"%s\"", line);
3308 /* Parse the part of trace status syntax that is shared between
3309 the remote protocol and the trace file reader. */
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);