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"
51 /* readline include files */
52 #include "readline/readline.h"
53 #include "readline/history.h"
55 /* readline defines this. */
66 extern int hex2bin (const char *hex, gdb_byte *bin, int count);
67 extern int bin2hex (const gdb_byte *bin, char *hex, int count);
69 extern void stop_tracing ();
71 /* Maximum length of an agent aexpression.
72 This accounts for the fact that packets are limited to 400 bytes
73 (which includes everything -- including the checksum), and assumes
74 the worst case of maximum length for each of the pieces of a
77 NOTE: expressions get mem2hex'ed otherwise this would be twice as
78 large. (400 - 31)/2 == 184 */
79 #define MAX_AGENT_EXPR_LEN 184
81 /* A hook used to notify the UI of tracepoint operations. */
83 void (*deprecated_trace_find_hook) (char *arg, int from_tty);
84 void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
86 extern void (*deprecated_readline_begin_hook) (char *, ...);
87 extern char *(*deprecated_readline_hook) (char *);
88 extern void (*deprecated_readline_end_hook) (void);
90 /* GDB commands implemented in other modules:
93 extern void output_command (char *, int);
98 This module defines the following debugger commands:
99 trace : set a tracepoint on a function, line, or address.
100 info trace : list all debugger-defined tracepoints.
101 delete trace : delete one or more tracepoints.
102 enable trace : enable one or more tracepoints.
103 disable trace : disable one or more tracepoints.
104 actions : specify actions to be taken at a tracepoint.
105 passcount : specify a pass count for a tracepoint.
106 tstart : start a trace experiment.
107 tstop : stop a trace experiment.
108 tstatus : query the status of a trace experiment.
109 tfind : find a trace frame in the trace buffer.
110 tdump : print everything collected at the current tracepoint.
111 save-tracepoints : write tracepoint setup into a file.
113 This module defines the following user-visible debugger variables:
114 $trace_frame : sequence number of trace frame currently being debugged.
115 $trace_line : source line of trace frame currently being debugged.
116 $trace_file : source file of trace frame currently being debugged.
117 $tracepoint : tracepoint number of trace frame currently being debugged.
121 /* ======= Important global variables: ======= */
123 /* The list of all trace state variables. We don't retain pointers to
124 any of these for any reason - API is by name or number only - so it
125 works to have a vector of objects. */
127 typedef struct trace_state_variable tsv_s;
130 static VEC(tsv_s) *tvariables;
132 /* The next integer to assign to a variable. */
134 static int next_tsv_number = 1;
136 /* Number of last traceframe collected. */
137 static int traceframe_number;
139 /* Tracepoint for last traceframe collected. */
140 static int tracepoint_number;
142 /* Symbol for function for last traceframe collected */
143 static struct symbol *traceframe_fun;
145 /* Symtab and line for last traceframe collected */
146 static struct symtab_and_line traceframe_sal;
148 /* Tracing command lists */
149 static struct cmd_list_element *tfindlist;
151 /* List of expressions to collect by default at each tracepoint hit. */
152 char *default_collect = "";
154 static int disconnected_tracing;
156 /* This variable controls whether we ask the target for a linear or
157 circular trace buffer. */
159 static int circular_trace_buffer;
161 /* ======= Important command functions: ======= */
162 static void trace_actions_command (char *, int);
163 static void trace_start_command (char *, int);
164 static void trace_stop_command (char *, int);
165 static void trace_status_command (char *, int);
166 static void trace_find_command (char *, int);
167 static void trace_find_pc_command (char *, int);
168 static void trace_find_tracepoint_command (char *, int);
169 static void trace_find_line_command (char *, int);
170 static void trace_find_range_command (char *, int);
171 static void trace_find_outside_command (char *, int);
172 static void trace_dump_command (char *, int);
174 /* support routines */
176 struct collection_list;
177 static void add_aexpr (struct collection_list *, struct agent_expr *);
178 static char *mem2hex (gdb_byte *, char *, int);
179 static void add_register (struct collection_list *collection,
182 extern void send_disconnected_tracing_value (int value);
184 static void free_uploaded_tps (struct uploaded_tp **utpp);
185 static void free_uploaded_tsvs (struct uploaded_tsv **utsvp);
188 extern void _initialize_tracepoint (void);
190 static struct trace_status trace_status;
192 char *stop_reason_names[] = {
202 struct trace_status *
203 current_trace_status ()
205 /* Ensure this is never NULL. */
206 if (!trace_status.error_desc)
207 trace_status.error_desc = "";
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));
372 /* Create a new variable. */
373 tsv = create_trace_state_variable (internalvar_name (intvar));
374 tsv->initial_value = initval;
376 printf_filtered (_("Trace state variable $%s created, with initial value %s.\n"),
377 tsv->name, plongest (tsv->initial_value));
379 do_cleanups (old_chain);
383 delete_trace_variable_command (char *args, int from_tty)
387 struct cleanup *back_to;
388 struct trace_state_variable *tsv;
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 (i = 0; argv[i] != NULL; i++)
404 delete_trace_state_variable (argv[i] + 1);
406 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv[i]);
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, 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 /* ACTIONS functions: */
487 /* The three functions:
488 collect_pseudocommand,
489 while_stepping_pseudocommand, and
490 end_actions_pseudocommand
491 are placeholders for "commands" that are actually ONLY to be used
492 within a tracepoint action list. If the actual function is ever called,
493 it means that somebody issued the "command" at the top level,
494 which is always an error. */
497 end_actions_pseudocommand (char *args, int from_tty)
499 error (_("This command cannot be used at the top level."));
503 while_stepping_pseudocommand (char *args, int from_tty)
505 error (_("This command can only be used in a tracepoint actions list."));
509 collect_pseudocommand (char *args, int from_tty)
511 error (_("This command can only be used in a tracepoint actions list."));
515 teval_pseudocommand (char *args, int from_tty)
517 error (_("This command can only be used in a tracepoint actions list."));
520 /* Enter a list of actions for a tracepoint. */
522 trace_actions_command (char *args, int from_tty)
524 struct breakpoint *t;
525 struct command_line *l;
527 t = get_tracepoint_by_number (&args, 0, 1);
531 xstrprintf ("Enter actions for tracepoint %d, one per line.",
533 struct cleanup *cleanups = make_cleanup (xfree, tmpbuf);
535 l = read_command_lines (tmpbuf, from_tty, 1, check_tracepoint_command, t);
536 do_cleanups (cleanups);
537 breakpoint_set_commands (t, l);
539 /* else just return */
542 /* worker function */
544 validate_actionline (char **line, struct breakpoint *t)
546 struct cmd_list_element *c;
547 struct expression *exp = NULL;
548 struct cleanup *old_chain = NULL;
550 struct bp_location *loc;
552 /* if EOF is typed, *line is NULL */
556 for (p = *line; isspace ((int) *p);)
559 /* Symbol lookup etc. */
560 if (*p == '\0') /* empty line: just prompt for another line. */
563 if (*p == '#') /* comment line */
566 c = lookup_cmd (&p, cmdlist, "", -1, 1);
569 warning (_("'%s' is not an action that I know, or is ambiguous."),
574 if (cmd_cfunc_eq (c, collect_pseudocommand))
576 struct agent_expr *aexpr;
577 struct agent_reqs areqs;
580 { /* repeat over a comma-separated list */
581 QUIT; /* allow user to bail out with ^C */
582 while (isspace ((int) *p))
585 if (*p == '$') /* look for special pseudo-symbols */
587 if ((0 == strncasecmp ("reg", p + 1, 3)) ||
588 (0 == strncasecmp ("arg", p + 1, 3)) ||
589 (0 == strncasecmp ("loc", p + 1, 3)))
594 /* else fall thru, treat p as an expression and parse it! */
597 for (loc = t->loc; loc; loc = loc->next)
600 exp = parse_exp_1 (&p, block_for_pc (loc->address), 1);
601 old_chain = make_cleanup (free_current_contents, &exp);
603 if (exp->elts[0].opcode == OP_VAR_VALUE)
605 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
607 warning (_("constant %s (value %ld) will not be collected."),
608 SYMBOL_PRINT_NAME (exp->elts[2].symbol),
609 SYMBOL_VALUE (exp->elts[2].symbol));
612 else if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_OPTIMIZED_OUT)
614 warning (_("%s is optimized away and cannot be collected."),
615 SYMBOL_PRINT_NAME (exp->elts[2].symbol));
620 /* We have something to collect, make sure that the expr to
621 bytecode translator can handle it and that it's not too
623 aexpr = gen_trace_for_expr (loc->address, exp);
624 make_cleanup_free_agent_expr (aexpr);
626 if (aexpr->len > MAX_AGENT_EXPR_LEN)
627 error (_("expression too complicated, try simplifying"));
629 ax_reqs (aexpr, &areqs);
630 (void) make_cleanup (xfree, areqs.reg_mask);
632 if (areqs.flaw != agent_flaw_none)
633 error (_("malformed expression"));
635 if (areqs.min_height < 0)
636 error (_("gdb: Internal error: expression has min height < 0"));
638 if (areqs.max_height > 20)
639 error (_("expression too complicated, try simplifying"));
641 do_cleanups (old_chain);
644 while (p && *p++ == ',');
647 else if (cmd_cfunc_eq (c, teval_pseudocommand))
649 struct agent_expr *aexpr;
652 { /* repeat over a comma-separated list */
653 QUIT; /* allow user to bail out with ^C */
654 while (isspace ((int) *p))
658 for (loc = t->loc; loc; loc = loc->next)
661 /* Only expressions are allowed for this action. */
662 exp = parse_exp_1 (&p, block_for_pc (loc->address), 1);
663 old_chain = make_cleanup (free_current_contents, &exp);
665 /* We have something to evaluate, make sure that the expr to
666 bytecode translator can handle it and that it's not too
668 aexpr = gen_eval_for_expr (loc->address, exp);
669 make_cleanup_free_agent_expr (aexpr);
671 if (aexpr->len > MAX_AGENT_EXPR_LEN)
672 error (_("expression too complicated, try simplifying"));
674 do_cleanups (old_chain);
677 while (p && *p++ == ',');
680 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
682 char *steparg; /* in case warning is necessary */
684 while (isspace ((int) *p))
689 (t->step_count = strtol (p, &p, 0)) == 0)
691 error (_("'%s': bad step-count."), *line);
695 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
699 error (_("'%s' is not a supported tracepoint action."), *line);
704 memrange_absolute = -1
709 int type; /* memrange_absolute for absolute memory range,
710 else basereg number */
711 bfd_signed_vma start;
715 struct collection_list
717 unsigned char regs_mask[32]; /* room for up to 256 regs */
720 struct memrange *list;
721 long aexpr_listsize; /* size of array pointed to by expr_list elt */
723 struct agent_expr **aexpr_list;
726 tracepoint_list, stepping_list;
728 /* MEMRANGE functions: */
730 static int memrange_cmp (const void *, const void *);
732 /* compare memranges for qsort */
734 memrange_cmp (const void *va, const void *vb)
736 const struct memrange *a = va, *b = vb;
738 if (a->type < b->type)
740 if (a->type > b->type)
742 if (a->type == memrange_absolute)
744 if ((bfd_vma) a->start < (bfd_vma) b->start)
746 if ((bfd_vma) a->start > (bfd_vma) b->start)
751 if (a->start < b->start)
753 if (a->start > b->start)
759 /* Sort the memrange list using qsort, and merge adjacent memranges. */
761 memrange_sortmerge (struct collection_list *memranges)
765 qsort (memranges->list, memranges->next_memrange,
766 sizeof (struct memrange), memrange_cmp);
767 if (memranges->next_memrange > 0)
769 for (a = 0, b = 1; b < memranges->next_memrange; b++)
771 if (memranges->list[a].type == memranges->list[b].type &&
772 memranges->list[b].start - memranges->list[a].end <=
775 /* memrange b starts before memrange a ends; merge them. */
776 if (memranges->list[b].end > memranges->list[a].end)
777 memranges->list[a].end = memranges->list[b].end;
778 continue; /* next b, same a */
782 memcpy (&memranges->list[a], &memranges->list[b],
783 sizeof (struct memrange));
785 memranges->next_memrange = a + 1;
789 /* Add a register to a collection list. */
791 add_register (struct collection_list *collection, unsigned int regno)
794 printf_filtered ("collect register %d\n", regno);
795 if (regno >= (8 * sizeof (collection->regs_mask)))
796 error (_("Internal: register number %d too large for tracepoint"),
798 collection->regs_mask[regno / 8] |= 1 << (regno % 8);
801 /* Add a memrange to a collection list */
803 add_memrange (struct collection_list *memranges,
804 int type, bfd_signed_vma base,
809 printf_filtered ("(%d,", type);
811 printf_filtered (",%ld)\n", len);
814 /* type: memrange_absolute == memory, other n == basereg */
815 memranges->list[memranges->next_memrange].type = type;
816 /* base: addr if memory, offset if reg relative. */
817 memranges->list[memranges->next_memrange].start = base;
818 /* len: we actually save end (base + len) for convenience */
819 memranges->list[memranges->next_memrange].end = base + len;
820 memranges->next_memrange++;
821 if (memranges->next_memrange >= memranges->listsize)
823 memranges->listsize *= 2;
824 memranges->list = xrealloc (memranges->list,
825 memranges->listsize);
828 if (type != memrange_absolute) /* Better collect the base register! */
829 add_register (memranges, type);
832 /* Add a symbol to a collection list. */
834 collect_symbol (struct collection_list *collect,
836 struct gdbarch *gdbarch,
837 long frame_regno, long frame_offset,
842 bfd_signed_vma offset;
843 int treat_as_expr = 0;
845 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
846 switch (SYMBOL_CLASS (sym))
849 printf_filtered ("%s: don't know symbol class %d\n",
850 SYMBOL_PRINT_NAME (sym),
854 printf_filtered ("constant %s (value %ld) will not be collected.\n",
855 SYMBOL_PRINT_NAME (sym), SYMBOL_VALUE (sym));
858 offset = SYMBOL_VALUE_ADDRESS (sym);
863 sprintf_vma (tmp, offset);
864 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
865 SYMBOL_PRINT_NAME (sym), len,
868 /* A struct may be a C++ class with static fields, go to general
869 expression handling. */
870 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
873 add_memrange (collect, memrange_absolute, offset, len);
876 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
878 printf_filtered ("LOC_REG[parm] %s: ",
879 SYMBOL_PRINT_NAME (sym));
880 add_register (collect, reg);
881 /* Check for doubles stored in two registers. */
882 /* FIXME: how about larger types stored in 3 or more regs? */
883 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
884 len > register_size (gdbarch, reg))
885 add_register (collect, reg + 1);
888 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
889 printf_filtered (" (will not collect %s)\n",
890 SYMBOL_PRINT_NAME (sym));
894 offset = frame_offset + SYMBOL_VALUE (sym);
897 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
898 SYMBOL_PRINT_NAME (sym), len);
900 printf_filtered (" from frame ptr reg %d\n", reg);
902 add_memrange (collect, reg, offset, len);
904 case LOC_REGPARM_ADDR:
905 reg = SYMBOL_VALUE (sym);
909 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
910 SYMBOL_PRINT_NAME (sym), len);
912 printf_filtered (" from reg %d\n", reg);
914 add_memrange (collect, reg, offset, len);
918 offset = frame_offset + SYMBOL_VALUE (sym);
921 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
922 SYMBOL_PRINT_NAME (sym), len);
924 printf_filtered (" from frame ptr reg %d\n", reg);
926 add_memrange (collect, reg, offset, len);
929 printf_filtered ("Don't know LOC_UNRESOLVED %s\n",
930 SYMBOL_PRINT_NAME (sym));
932 case LOC_OPTIMIZED_OUT:
933 printf_filtered ("%s has been optimized out of existence.\n",
934 SYMBOL_PRINT_NAME (sym));
942 /* Expressions are the most general case. */
945 struct agent_expr *aexpr;
946 struct cleanup *old_chain1 = NULL;
947 struct agent_reqs areqs;
949 aexpr = gen_trace_for_var (scope, gdbarch, sym);
951 /* It can happen that the symbol is recorded as a computed
952 location, but it's been optimized away and doesn't actually
953 have a location expression. */
956 printf_filtered ("%s has been optimized out of existence.\n",
957 SYMBOL_PRINT_NAME (sym));
961 old_chain1 = make_cleanup_free_agent_expr (aexpr);
963 ax_reqs (aexpr, &areqs);
964 if (areqs.flaw != agent_flaw_none)
965 error (_("malformed expression"));
967 if (areqs.min_height < 0)
968 error (_("gdb: Internal error: expression has min height < 0"));
969 if (areqs.max_height > 20)
970 error (_("expression too complicated, try simplifying"));
972 discard_cleanups (old_chain1);
973 add_aexpr (collect, aexpr);
975 /* take care of the registers */
976 if (areqs.reg_mask_len > 0)
980 for (ndx1 = 0; ndx1 < areqs.reg_mask_len; ndx1++)
982 QUIT; /* allow user to bail out with ^C */
983 if (areqs.reg_mask[ndx1] != 0)
985 /* assume chars have 8 bits */
986 for (ndx2 = 0; ndx2 < 8; ndx2++)
987 if (areqs.reg_mask[ndx1] & (1 << ndx2))
988 /* it's used -- record it */
989 add_register (collect, ndx1 * 8 + ndx2);
996 /* Add all locals (or args) symbols to collection list */
998 add_local_symbols (struct collection_list *collect,
999 struct gdbarch *gdbarch, CORE_ADDR pc,
1000 long frame_regno, long frame_offset, int type)
1003 struct block *block;
1004 struct dict_iterator iter;
1007 block = block_for_pc (pc);
1010 QUIT; /* allow user to bail out with ^C */
1011 ALL_BLOCK_SYMBOLS (block, iter, sym)
1013 if (SYMBOL_IS_ARGUMENT (sym)
1014 ? type == 'A' /* collecting Arguments */
1015 : type == 'L') /* collecting Locals */
1018 collect_symbol (collect, sym, gdbarch,
1019 frame_regno, frame_offset, pc);
1022 if (BLOCK_FUNCTION (block))
1025 block = BLOCK_SUPERBLOCK (block);
1028 warning (_("No %s found in scope."),
1029 type == 'L' ? "locals" : "args");
1032 /* worker function */
1034 clear_collection_list (struct collection_list *list)
1038 list->next_memrange = 0;
1039 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1041 free_agent_expr (list->aexpr_list[ndx]);
1042 list->aexpr_list[ndx] = NULL;
1044 list->next_aexpr_elt = 0;
1045 memset (list->regs_mask, 0, sizeof (list->regs_mask));
1048 /* reduce a collection list to string form (for gdb protocol) */
1050 stringify_collection_list (struct collection_list *list, char *string)
1052 char temp_buf[2048];
1056 char *(*str_list)[];
1060 count = 1 + list->next_memrange + list->next_aexpr_elt + 1;
1061 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1063 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1064 if (list->regs_mask[i] != 0) /* skip leading zeroes in regs_mask */
1066 if (list->regs_mask[i] != 0) /* prepare to send regs_mask to the stub */
1069 printf_filtered ("\nCollecting registers (mask): 0x");
1074 QUIT; /* allow user to bail out with ^C */
1076 printf_filtered ("%02X", list->regs_mask[i]);
1077 sprintf (end, "%02X", list->regs_mask[i]);
1080 (*str_list)[ndx] = xstrdup (temp_buf);
1084 printf_filtered ("\n");
1085 if (list->next_memrange > 0 && info_verbose)
1086 printf_filtered ("Collecting memranges: \n");
1087 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1089 QUIT; /* allow user to bail out with ^C */
1090 sprintf_vma (tmp2, list->list[i].start);
1093 printf_filtered ("(%d, %s, %ld)\n",
1096 (long) (list->list[i].end - list->list[i].start));
1098 if (count + 27 > MAX_AGENT_EXPR_LEN)
1100 (*str_list)[ndx] = savestring (temp_buf, count);
1107 bfd_signed_vma length = list->list[i].end - list->list[i].start;
1109 /* The "%X" conversion specifier expects an unsigned argument,
1110 so passing -1 (memrange_absolute) to it directly gives you
1111 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1113 if (list->list[i].type == memrange_absolute)
1114 sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
1116 sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
1119 count += strlen (end);
1120 end = temp_buf + count;
1123 for (i = 0; i < list->next_aexpr_elt; i++)
1125 QUIT; /* allow user to bail out with ^C */
1126 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1128 (*str_list)[ndx] = savestring (temp_buf, count);
1133 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1134 end += 10; /* 'X' + 8 hex digits + ',' */
1137 end = mem2hex (list->aexpr_list[i]->buf,
1138 end, list->aexpr_list[i]->len);
1139 count += 2 * list->aexpr_list[i]->len;
1144 (*str_list)[ndx] = savestring (temp_buf, count);
1149 (*str_list)[ndx] = NULL;
1162 encode_actions_1 (struct command_line *action,
1163 struct breakpoint *t,
1164 struct bp_location *tloc,
1166 LONGEST frame_offset,
1167 struct collection_list *collect,
1168 struct collection_list *stepping_list)
1171 struct expression *exp = NULL;
1172 struct command_line *actions;
1174 struct value *tempval;
1175 struct cmd_list_element *cmd;
1176 struct agent_expr *aexpr;
1178 for (; action; action = action->next)
1180 QUIT; /* allow user to bail out with ^C */
1181 action_exp = action->line;
1182 while (isspace ((int) *action_exp))
1185 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1187 error (_("Bad action list item: %s"), action_exp);
1189 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1192 { /* repeat over a comma-separated list */
1193 QUIT; /* allow user to bail out with ^C */
1194 while (isspace ((int) *action_exp))
1197 if (0 == strncasecmp ("$reg", action_exp, 4))
1199 for (i = 0; i < gdbarch_num_regs (t->gdbarch); i++)
1200 add_register (collect, i);
1201 action_exp = strchr (action_exp, ','); /* more? */
1203 else if (0 == strncasecmp ("$arg", action_exp, 4))
1205 add_local_symbols (collect,
1211 action_exp = strchr (action_exp, ','); /* more? */
1213 else if (0 == strncasecmp ("$loc", action_exp, 4))
1215 add_local_symbols (collect,
1221 action_exp = strchr (action_exp, ','); /* more? */
1225 unsigned long addr, len;
1226 struct cleanup *old_chain = NULL;
1227 struct cleanup *old_chain1 = NULL;
1228 struct agent_reqs areqs;
1230 exp = parse_exp_1 (&action_exp,
1231 block_for_pc (tloc->address), 1);
1232 old_chain = make_cleanup (free_current_contents, &exp);
1234 switch (exp->elts[0].opcode)
1238 const char *name = &exp->elts[2].string;
1240 i = user_reg_map_name_to_regnum (t->gdbarch,
1241 name, strlen (name));
1243 internal_error (__FILE__, __LINE__,
1244 _("Register $%s not available"),
1247 printf_filtered ("OP_REGISTER: ");
1248 add_register (collect, i);
1253 /* safe because we know it's a simple expression */
1254 tempval = evaluate_expression (exp);
1255 addr = value_address (tempval);
1256 len = TYPE_LENGTH (check_typedef (exp->elts[1].type));
1257 add_memrange (collect, memrange_absolute, addr, len);
1261 collect_symbol (collect,
1262 exp->elts[2].symbol,
1269 default: /* full-fledged expression */
1270 aexpr = gen_trace_for_expr (tloc->address, exp);
1272 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1274 ax_reqs (aexpr, &areqs);
1275 if (areqs.flaw != agent_flaw_none)
1276 error (_("malformed expression"));
1278 if (areqs.min_height < 0)
1279 error (_("gdb: Internal error: expression has min height < 0"));
1280 if (areqs.max_height > 20)
1281 error (_("expression too complicated, try simplifying"));
1283 discard_cleanups (old_chain1);
1284 add_aexpr (collect, aexpr);
1286 /* take care of the registers */
1287 if (areqs.reg_mask_len > 0)
1292 for (ndx1 = 0; ndx1 < areqs.reg_mask_len; ndx1++)
1294 QUIT; /* allow user to bail out with ^C */
1295 if (areqs.reg_mask[ndx1] != 0)
1297 /* assume chars have 8 bits */
1298 for (ndx2 = 0; ndx2 < 8; ndx2++)
1299 if (areqs.reg_mask[ndx1] & (1 << ndx2))
1300 /* it's used -- record it */
1301 add_register (collect,
1308 do_cleanups (old_chain);
1311 while (action_exp && *action_exp++ == ',');
1313 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1316 { /* repeat over a comma-separated list */
1317 QUIT; /* allow user to bail out with ^C */
1318 while (isspace ((int) *action_exp))
1322 unsigned long addr, len;
1323 struct cleanup *old_chain = NULL;
1324 struct cleanup *old_chain1 = NULL;
1325 struct agent_reqs areqs;
1327 exp = parse_exp_1 (&action_exp,
1328 block_for_pc (tloc->address), 1);
1329 old_chain = make_cleanup (free_current_contents, &exp);
1331 aexpr = gen_eval_for_expr (tloc->address, exp);
1332 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1334 ax_reqs (aexpr, &areqs);
1335 if (areqs.flaw != agent_flaw_none)
1336 error (_("malformed expression"));
1338 if (areqs.min_height < 0)
1339 error (_("gdb: Internal error: expression has min height < 0"));
1340 if (areqs.max_height > 20)
1341 error (_("expression too complicated, try simplifying"));
1343 discard_cleanups (old_chain1);
1344 /* Even though we're not officially collecting, add
1345 to the collect list anyway. */
1346 add_aexpr (collect, aexpr);
1348 do_cleanups (old_chain);
1351 while (action_exp && *action_exp++ == ',');
1353 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1355 /* We check against nested while-stepping when setting
1356 breakpoint action, so no way to run into nested
1358 gdb_assert (stepping_list);
1360 encode_actions_1 (action->body_list[0], t, tloc, frame_reg, frame_offset,
1361 stepping_list, NULL);
1364 error (_("Invalid tracepoint command '%s'"), action->line);
1368 /* Render all actions into gdb protocol. */
1370 encode_actions (struct breakpoint *t, struct bp_location *tloc,
1371 char ***tdp_actions, char ***stepping_actions)
1373 static char tdp_buff[2048], step_buff[2048];
1374 char *default_collect_line = NULL;
1375 struct command_line *actions;
1376 struct command_line *default_collect_action = NULL;
1378 LONGEST frame_offset;
1379 struct cleanup *back_to;
1381 back_to = make_cleanup (null_cleanup, NULL);
1383 clear_collection_list (&tracepoint_list);
1384 clear_collection_list (&stepping_list);
1386 *tdp_actions = NULL;
1387 *stepping_actions = NULL;
1389 gdbarch_virtual_frame_pointer (t->gdbarch,
1390 t->loc->address, &frame_reg, &frame_offset);
1392 actions = t->commands->commands;
1394 /* If there are default expressions to collect, make up a collect
1395 action and prepend to the action list to encode. Note that since
1396 validation is per-tracepoint (local var "xyz" might be valid for
1397 one tracepoint and not another, etc), we make up the action on
1398 the fly, and don't cache it. */
1399 if (*default_collect)
1402 enum actionline_type linetype;
1404 default_collect_line = xstrprintf ("collect %s", default_collect);
1405 make_cleanup (xfree, default_collect_line);
1407 line = default_collect_line;
1408 linetype = validate_actionline (&line, t);
1409 if (linetype != BADLINE)
1411 default_collect_action = xmalloc (sizeof (struct command_line));
1412 make_cleanup (xfree, default_collect_action);
1413 default_collect_action->next = t->commands->commands;
1414 default_collect_action->line = line;
1415 actions = default_collect_action;
1418 encode_actions_1 (actions, t, tloc, frame_reg, frame_offset,
1419 &tracepoint_list, &stepping_list);
1421 memrange_sortmerge (&tracepoint_list);
1422 memrange_sortmerge (&stepping_list);
1424 *tdp_actions = stringify_collection_list (&tracepoint_list,
1426 *stepping_actions = stringify_collection_list (&stepping_list,
1429 do_cleanups (back_to);
1433 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1435 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1437 collect->aexpr_list =
1438 xrealloc (collect->aexpr_list,
1439 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1440 collect->aexpr_listsize *= 2;
1442 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1443 collect->next_aexpr_elt++;
1448 start_tracing (void)
1451 VEC(breakpoint_p) *tp_vec = NULL;
1453 struct breakpoint *t;
1454 struct trace_state_variable *tsv;
1455 int any_downloaded = 0;
1457 target_trace_init ();
1459 tp_vec = all_tracepoints ();
1460 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1462 t->number_on_target = 0;
1463 target_download_tracepoint (t);
1464 t->number_on_target = t->number;
1467 VEC_free (breakpoint_p, tp_vec);
1469 /* No point in tracing without any tracepoints... */
1470 if (!any_downloaded)
1471 error ("No tracepoints downloaded, not starting trace");
1473 /* Send down all the trace state variables too. */
1474 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1476 target_download_trace_state_variable (tsv);
1479 /* Tell target to treat text-like sections as transparent. */
1480 target_trace_set_readonly_regions ();
1481 /* Set some mode flags. */
1482 target_set_disconnected_tracing (disconnected_tracing);
1483 target_set_circular_trace_buffer (circular_trace_buffer);
1485 /* Now insert traps and begin collecting data. */
1486 target_trace_start ();
1488 /* Reset our local state. */
1489 set_traceframe_num (-1);
1490 set_tracepoint_num (-1);
1491 set_traceframe_context (NULL);
1492 current_trace_status()->running = 1;
1497 Tell target to clear any previous trace experiment.
1498 Walk the list of tracepoints, and send them (and their actions)
1499 to the target. If no errors,
1500 Tell target to start a new trace experiment. */
1503 trace_start_command (char *args, int from_tty)
1505 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1512 trace_stop_command (char *args, int from_tty)
1520 target_trace_stop ();
1521 /* should change in response to reply? */
1522 current_trace_status ()->running = 0;
1525 /* tstatus command */
1527 trace_status_command (char *args, int from_tty)
1529 struct trace_status *ts = current_trace_status ();
1532 status = target_get_trace_status (ts);
1537 printf_filtered (_("Using a trace file.\n"));
1540 printf_filtered (_("Trace can not be run on this target.\n"));
1545 if (!ts->running_known)
1547 printf_filtered (_("Run/stop status is unknown.\n"));
1549 else if (ts->running)
1551 printf_filtered (_("Trace is running on the target.\n"));
1552 if (disconnected_tracing)
1553 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
1555 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
1559 switch (ts->stop_reason)
1561 case trace_never_run:
1562 printf_filtered (_("No trace has been run on the target.\n"));
1565 printf_filtered (_("Trace stopped by a tstop command.\n"));
1567 case trace_buffer_full:
1568 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1570 case trace_disconnected:
1571 printf_filtered (_("Trace stopped because of disconnection.\n"));
1573 case tracepoint_passcount:
1574 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1575 ts->stopping_tracepoint);
1577 case tracepoint_error:
1578 if (ts->stopping_tracepoint)
1579 printf_filtered (_("Trace stopped by an error (%s, tracepoint %d).\n"),
1580 ts->error_desc, ts->stopping_tracepoint);
1582 printf_filtered (_("Trace stopped by an error (%s).\n"),
1585 case trace_stop_reason_unknown:
1586 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1589 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1595 if (ts->traceframes_created >= 0
1596 && ts->traceframe_count != ts->traceframes_created)
1598 printf_filtered (_("Buffer contains %d trace frames (of %d created total).\n"),
1599 ts->traceframe_count, ts->traceframes_created);
1601 else if (ts->traceframe_count >= 0)
1603 printf_filtered (_("Collected %d trace frames.\n"),
1604 ts->traceframe_count);
1607 if (ts->buffer_free >= 0)
1609 if (ts->buffer_size >= 0)
1611 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
1612 ts->buffer_free, ts->buffer_size);
1613 if (ts->buffer_size > 0)
1614 printf_filtered (_(" (%d%% full)"),
1615 ((int) ((((long long) (ts->buffer_size
1616 - ts->buffer_free)) * 100)
1617 / ts->buffer_size)));
1618 printf_filtered (_(".\n"));
1621 printf_filtered (_("Trace buffer has %d bytes free.\n"),
1625 /* Now report on what we're doing with tfind. */
1626 if (traceframe_number >= 0)
1627 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
1628 traceframe_number, tracepoint_number);
1630 printf_filtered (_("Not looking at any trace frame.\n"));
1633 /* Report the trace status to uiout, in a way suitable for MI, and not
1634 suitable for CLI. If ON_STOP is true, suppress a few fields that
1635 are not meaningful in the -trace-stop response.
1637 The implementation is essentially parallel to trace_status_command, but
1638 merging them will result in unreadable code. */
1640 trace_status_mi (int on_stop)
1642 struct trace_status *ts = current_trace_status ();
1644 char *string_status;
1646 status = target_get_trace_status (ts);
1648 if (status == -1 && !ts->from_file)
1650 ui_out_field_string (uiout, "supported", "0");
1655 ui_out_field_string (uiout, "supported", "file");
1657 ui_out_field_string (uiout, "supported", "1");
1659 gdb_assert (ts->running_known);
1663 ui_out_field_string (uiout, "running", "1");
1665 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
1666 Given that the frontend gets the status either on -trace-stop, or from
1667 -trace-status after re-connection, it does not seem like this
1668 information is necessary for anything. It is not necessary for either
1669 figuring the vital state of the target nor for navigation of trace
1670 frames. If the frontend wants to show the current state is some
1671 configure dialog, it can request the value when such dialog is
1672 invoked by the user. */
1676 char *stop_reason = NULL;
1677 int stopping_tracepoint = -1;
1680 ui_out_field_string (uiout, "running", "0");
1682 if (ts->stop_reason != trace_stop_reason_unknown)
1684 switch (ts->stop_reason)
1687 stop_reason = "request";
1689 case trace_buffer_full:
1690 stop_reason = "overflow";
1692 case trace_disconnected:
1693 stop_reason = "disconnection";
1695 case tracepoint_passcount:
1696 stop_reason = "passcount";
1697 stopping_tracepoint = ts->stopping_tracepoint;
1699 case tracepoint_error:
1700 stop_reason = "error";
1701 stopping_tracepoint = ts->stopping_tracepoint;
1707 ui_out_field_string (uiout, "stop-reason", stop_reason);
1708 if (stopping_tracepoint != -1)
1709 ui_out_field_int (uiout, "stopping-tracepoint",
1710 stopping_tracepoint);
1711 if (ts->stop_reason == tracepoint_error)
1712 ui_out_field_string (uiout, "error-description",
1719 if ((int) ts->traceframe_count != -1)
1720 ui_out_field_int (uiout, "frames", ts->traceframe_count);
1721 if ((int) ts->buffer_size != -1)
1722 ui_out_field_int (uiout, "buffer-size", (int) ts->buffer_size);
1723 if ((int) ts->buffer_free != -1)
1724 ui_out_field_int (uiout, "buffer-free", (int) ts->buffer_free);
1729 disconnect_or_stop_tracing (int from_tty)
1731 /* It can happen that the target that was tracing went away on its
1732 own, and we didn't notice. Get a status update, and if the
1733 current target doesn't even do tracing, then assume it's not
1735 if (target_get_trace_status (current_trace_status ()) < 0)
1736 current_trace_status ()->running = 0;
1738 if (current_trace_status ()->running && from_tty)
1740 int cont = query (_("Trace is running. Continue tracing after detach? "));
1741 /* Note that we send the query result without affecting the
1742 user's setting of disconnected_tracing, so that the answer is
1744 send_disconnected_tracing_value (cont);
1746 /* Also ensure that we do the equivalent of a tstop command if
1747 tracing is not to continue after the detach. */
1753 /* Worker function for the various flavors of the tfind command. */
1755 tfind_1 (enum trace_find_type type, int num,
1756 ULONGEST addr1, ULONGEST addr2,
1759 int target_frameno = -1, target_tracept = -1;
1760 struct frame_id old_frame_id;
1762 struct breakpoint *tp;
1764 old_frame_id = get_frame_id (get_current_frame ());
1766 target_frameno = target_trace_find (type, num, addr1, addr2,
1769 if (type == tfind_number
1771 && target_frameno == -1)
1773 /* We told the target to get out of tfind mode, and it did. */
1775 else if (target_frameno == -1)
1777 /* A request for a non-existant trace frame has failed.
1778 Our response will be different, depending on FROM_TTY:
1780 If FROM_TTY is true, meaning that this command was
1781 typed interactively by the user, then give an error
1782 and DO NOT change the state of traceframe_number etc.
1784 However if FROM_TTY is false, meaning that we're either
1785 in a script, a loop, or a user-defined command, then
1786 DON'T give an error, but DO change the state of
1787 traceframe_number etc. to invalid.
1789 The rationalle is that if you typed the command, you
1790 might just have committed a typo or something, and you'd
1791 like to NOT lose your current debugging state. However
1792 if you're in a user-defined command or especially in a
1793 loop, then you need a way to detect that the command
1794 failed WITHOUT aborting. This allows you to write
1795 scripts that search thru the trace buffer until the end,
1796 and then continue on to do something else. */
1799 error (_("Target failed to find requested trace frame."));
1803 printf_filtered ("End of trace buffer.\n");
1804 #if 0 /* dubious now? */
1805 /* The following will not recurse, since it's
1807 trace_find_command ("-1", from_tty);
1812 tp = get_tracepoint_by_number_on_target (target_tracept);
1814 reinit_frame_cache ();
1815 registers_changed ();
1816 target_dcache_invalidate ();
1817 set_traceframe_num (target_frameno);
1818 set_tracepoint_num (tp ? tp->number : target_tracept);
1819 if (target_frameno == -1)
1820 set_traceframe_context (NULL);
1822 set_traceframe_context (get_current_frame ());
1824 if (traceframe_number >= 0)
1826 /* Use different branches for MI and CLI to make CLI messages
1828 if (ui_out_is_mi_like_p (uiout))
1830 ui_out_field_string (uiout, "found", "1");
1831 ui_out_field_int (uiout, "tracepoint", tracepoint_number);
1832 ui_out_field_int (uiout, "traceframe", traceframe_number);
1836 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
1837 traceframe_number, tracepoint_number);
1842 if (ui_out_is_mi_like_p (uiout))
1843 ui_out_field_string (uiout, "found", "0");
1845 printf_unfiltered (_("No trace frame found"));
1848 /* If we're in nonstop mode and getting out of looking at trace
1849 frames, there won't be any current frame to go back to and
1852 && (has_stack_frames () || traceframe_number >= 0))
1854 enum print_what print_what;
1856 /* NOTE: in immitation of the step command, try to determine
1857 whether we have made a transition from one function to
1858 another. If so, we'll print the "stack frame" (ie. the new
1859 function and it's arguments) -- otherwise we'll just show the
1862 if (frame_id_eq (old_frame_id,
1863 get_frame_id (get_current_frame ())))
1864 print_what = SRC_LINE;
1866 print_what = SRC_AND_LOC;
1868 print_stack_frame (get_selected_frame (NULL), 1, print_what);
1873 /* trace_find_command takes a trace frame number n,
1874 sends "QTFrame:<n>" to the target,
1875 and accepts a reply that may contain several optional pieces
1876 of information: a frame number, a tracepoint number, and an
1877 indication of whether this is a trap frame or a stepping frame.
1879 The minimal response is just "OK" (which indicates that the
1880 target does not give us a frame number or a tracepoint number).
1881 Instead of that, the target may send us a string containing
1883 F<hexnum> (gives the selected frame number)
1884 T<hexnum> (gives the selected tracepoint number)
1889 trace_find_command (char *args, int from_tty)
1890 { /* this should only be called with a numeric argument */
1893 if (current_trace_status ()->running && !current_trace_status ()->from_file)
1894 error ("May not look at trace frames while trace is running.");
1896 if (args == 0 || *args == 0)
1897 { /* TFIND with no args means find NEXT trace frame. */
1898 if (traceframe_number == -1)
1899 frameno = 0; /* "next" is first one */
1901 frameno = traceframe_number + 1;
1903 else if (0 == strcmp (args, "-"))
1905 if (traceframe_number == -1)
1906 error (_("not debugging trace buffer"));
1907 else if (from_tty && traceframe_number == 0)
1908 error (_("already at start of trace buffer"));
1910 frameno = traceframe_number - 1;
1912 /* A hack to work around eval's need for fp to have been collected. */
1913 else if (0 == strcmp (args, "-1"))
1916 frameno = parse_and_eval_long (args);
1919 error (_("invalid input (%d is less than zero)"), frameno);
1921 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
1926 trace_find_end_command (char *args, int from_tty)
1928 trace_find_command ("-1", from_tty);
1933 trace_find_none_command (char *args, int from_tty)
1935 trace_find_command ("-1", from_tty);
1940 trace_find_start_command (char *args, int from_tty)
1942 trace_find_command ("0", from_tty);
1945 /* tfind pc command */
1947 trace_find_pc_command (char *args, int from_tty)
1952 if (current_trace_status ()->running && !current_trace_status ()->from_file)
1953 error ("May not look at trace frames while trace is running.");
1955 if (args == 0 || *args == 0)
1956 pc = regcache_read_pc (get_current_regcache ());
1958 pc = parse_and_eval_address (args);
1960 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
1963 /* tfind tracepoint command */
1965 trace_find_tracepoint_command (char *args, int from_tty)
1968 struct breakpoint *tp;
1970 if (current_trace_status ()->running && !current_trace_status ()->from_file)
1971 error ("May not look at trace frames while trace is running.");
1973 if (args == 0 || *args == 0)
1975 if (tracepoint_number == -1)
1976 error (_("No current tracepoint -- please supply an argument."));
1978 tdp = tracepoint_number; /* default is current TDP */
1981 tdp = parse_and_eval_long (args);
1983 /* If we have the tracepoint on hand, use the number that the
1984 target knows about (which may be different if we disconnected
1985 and reconnected). */
1986 tp = get_tracepoint (tdp);
1988 tdp = tp->number_on_target;
1990 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
1993 /* TFIND LINE command:
1995 This command will take a sourceline for argument, just like BREAK
1996 or TRACE (ie. anything that "decode_line_1" can handle).
1998 With no argument, this command will find the next trace frame
1999 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2002 trace_find_line_command (char *args, int from_tty)
2004 static CORE_ADDR start_pc, end_pc;
2005 struct symtabs_and_lines sals;
2006 struct symtab_and_line sal;
2007 struct cleanup *old_chain;
2008 char startpc_str[40], endpc_str[40];
2010 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2011 error ("May not look at trace frames while trace is running.");
2013 if (args == 0 || *args == 0)
2015 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2017 sals.sals = (struct symtab_and_line *)
2018 xmalloc (sizeof (struct symtab_and_line));
2023 sals = decode_line_spec (args, 1);
2027 old_chain = make_cleanup (xfree, sals.sals);
2028 if (sal.symtab == 0)
2030 printf_filtered ("TFIND: No line number information available");
2033 /* This is useful for "info line *0x7f34". If we can't
2034 tell the user about a source line, at least let them
2035 have the symbolic address. */
2036 printf_filtered (" for address ");
2038 print_address (get_current_arch (), sal.pc, gdb_stdout);
2039 printf_filtered (";\n -- will attempt to find by PC. \n");
2043 printf_filtered (".\n");
2044 return; /* No line, no PC; what can we do? */
2047 else if (sal.line > 0
2048 && find_line_pc_range (sal, &start_pc, &end_pc))
2050 if (start_pc == end_pc)
2052 printf_filtered ("Line %d of \"%s\"",
2053 sal.line, sal.symtab->filename);
2055 printf_filtered (" is at address ");
2056 print_address (get_current_arch (), start_pc, gdb_stdout);
2058 printf_filtered (" but contains no code.\n");
2059 sal = find_pc_line (start_pc, 0);
2061 && find_line_pc_range (sal, &start_pc, &end_pc)
2062 && start_pc != end_pc)
2063 printf_filtered ("Attempting to find line %d instead.\n",
2066 error (_("Cannot find a good line."));
2070 /* Is there any case in which we get here, and have an address
2071 which the user would want to see? If we have debugging
2072 symbols and no line numbers? */
2073 error (_("Line number %d is out of range for \"%s\"."),
2074 sal.line, sal.symtab->filename);
2076 /* Find within range of stated line. */
2078 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2080 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2081 do_cleanups (old_chain);
2084 /* tfind range command */
2086 trace_find_range_command (char *args, int from_tty)
2088 static CORE_ADDR start, stop;
2089 char start_str[40], stop_str[40];
2092 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2093 error ("May not look at trace frames while trace is running.");
2095 if (args == 0 || *args == 0)
2096 { /* XXX FIXME: what should default behavior be? */
2097 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2101 if (0 != (tmp = strchr (args, ',')))
2103 *tmp++ = '\0'; /* terminate start address */
2104 while (isspace ((int) *tmp))
2106 start = parse_and_eval_address (args);
2107 stop = parse_and_eval_address (tmp);
2110 { /* no explicit end address? */
2111 start = parse_and_eval_address (args);
2112 stop = start + 1; /* ??? */
2115 tfind_1 (tfind_range, 0, start, stop, from_tty);
2118 /* tfind outside command */
2120 trace_find_outside_command (char *args, int from_tty)
2122 CORE_ADDR start, stop;
2123 char start_str[40], stop_str[40];
2126 if (current_trace_status ()->running && !current_trace_status ()->from_file)
2127 error ("May not look at trace frames while trace is running.");
2129 if (args == 0 || *args == 0)
2130 { /* XXX FIXME: what should default behavior be? */
2131 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2135 if (0 != (tmp = strchr (args, ',')))
2137 *tmp++ = '\0'; /* terminate start address */
2138 while (isspace ((int) *tmp))
2140 start = parse_and_eval_address (args);
2141 stop = parse_and_eval_address (tmp);
2144 { /* no explicit end address? */
2145 start = parse_and_eval_address (args);
2146 stop = start + 1; /* ??? */
2149 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2152 /* info scope command: list the locals for a scope. */
2154 scope_info (char *args, int from_tty)
2156 struct symtabs_and_lines sals;
2158 struct minimal_symbol *msym;
2159 struct block *block;
2160 char **canonical, *symname, *save_args = args;
2161 struct dict_iterator iter;
2163 struct gdbarch *gdbarch;
2166 if (args == 0 || *args == 0)
2167 error (_("requires an argument (function, line or *addr) to define a scope"));
2169 sals = decode_line_1 (&args, 1, NULL, 0, &canonical, NULL);
2170 if (sals.nelts == 0)
2171 return; /* presumably decode_line_1 has already warned */
2173 /* Resolve line numbers to PC */
2174 resolve_sal_pc (&sals.sals[0]);
2175 block = block_for_pc (sals.sals[0].pc);
2179 QUIT; /* allow user to bail out with ^C */
2180 ALL_BLOCK_SYMBOLS (block, iter, sym)
2182 QUIT; /* allow user to bail out with ^C */
2184 printf_filtered ("Scope for %s:\n", save_args);
2187 symname = SYMBOL_PRINT_NAME (sym);
2188 if (symname == NULL || *symname == '\0')
2189 continue; /* probably botched, certainly useless */
2191 gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
2193 printf_filtered ("Symbol %s is ", symname);
2194 switch (SYMBOL_CLASS (sym))
2197 case LOC_UNDEF: /* messed up symbol? */
2198 printf_filtered ("a bogus symbol, class %d.\n",
2199 SYMBOL_CLASS (sym));
2200 count--; /* don't count this one */
2203 printf_filtered ("a constant with value %ld (0x%lx)",
2204 SYMBOL_VALUE (sym), SYMBOL_VALUE (sym));
2206 case LOC_CONST_BYTES:
2207 printf_filtered ("constant bytes: ");
2208 if (SYMBOL_TYPE (sym))
2209 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2210 fprintf_filtered (gdb_stdout, " %02x",
2211 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2214 printf_filtered ("in static storage at address ");
2215 printf_filtered ("%s", paddress (gdbarch,
2216 SYMBOL_VALUE_ADDRESS (sym)));
2219 /* GDBARCH is the architecture associated with the objfile
2220 the symbol is defined in; the target architecture may be
2221 different, and may provide additional registers. However,
2222 we do not know the target architecture at this point.
2223 We assume the objfile architecture will contain all the
2224 standard registers that occur in debug info in that
2226 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
2228 if (SYMBOL_IS_ARGUMENT (sym))
2229 printf_filtered ("an argument in register $%s",
2230 gdbarch_register_name (gdbarch, regno));
2232 printf_filtered ("a local variable in register $%s",
2233 gdbarch_register_name (gdbarch, regno));
2236 printf_filtered ("an argument at stack/frame offset %ld",
2237 SYMBOL_VALUE (sym));
2240 printf_filtered ("a local variable at frame offset %ld",
2241 SYMBOL_VALUE (sym));
2244 printf_filtered ("a reference argument at offset %ld",
2245 SYMBOL_VALUE (sym));
2247 case LOC_REGPARM_ADDR:
2248 /* Note comment at LOC_REGISTER. */
2249 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
2250 printf_filtered ("the address of an argument, in register $%s",
2251 gdbarch_register_name (gdbarch, regno));
2254 printf_filtered ("a typedef.\n");
2257 printf_filtered ("a label at address ");
2258 printf_filtered ("%s", paddress (gdbarch,
2259 SYMBOL_VALUE_ADDRESS (sym)));
2262 printf_filtered ("a function at address ");
2263 printf_filtered ("%s",
2264 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2266 case LOC_UNRESOLVED:
2267 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2270 printf_filtered ("Unresolved Static");
2273 printf_filtered ("static storage at address ");
2274 printf_filtered ("%s",
2275 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msym)));
2278 case LOC_OPTIMIZED_OUT:
2279 printf_filtered ("optimized out.\n");
2282 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym, gdb_stdout);
2285 if (SYMBOL_TYPE (sym))
2286 printf_filtered (", length %d.\n",
2287 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2289 if (BLOCK_FUNCTION (block))
2292 block = BLOCK_SUPERBLOCK (block);
2295 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2299 /* worker function (cleanup) */
2301 replace_comma (void *data)
2309 trace_dump_command (char *args, int from_tty)
2311 struct regcache *regcache;
2312 struct gdbarch *gdbarch;
2313 struct breakpoint *t;
2314 struct command_line *action;
2315 char *action_exp, *next_comma;
2316 struct cleanup *old_cleanups;
2317 int stepping_actions = 0;
2318 int stepping_frame = 0;
2319 struct bp_location *loc;
2321 if (tracepoint_number == -1)
2323 warning (_("No current trace frame."));
2327 t = get_tracepoint (tracepoint_number);
2330 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2333 old_cleanups = make_cleanup (null_cleanup, NULL);
2335 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2336 tracepoint_number, traceframe_number);
2338 /* The current frame is a trap frame if the frame PC is equal
2339 to the tracepoint PC. If not, then the current frame was
2340 collected during single-stepping. */
2342 regcache = get_current_regcache ();
2343 gdbarch = get_regcache_arch (regcache);
2345 /* If the traceframe's address matches any of the tracepoint's
2346 locations, assume it is a direct hit rather than a while-stepping
2347 frame. (FIXME this is not reliable, should record each frame's
2350 for (loc = t->loc; loc; loc = loc->next)
2351 if (loc->address == regcache_read_pc (regcache))
2354 for (action = t->commands->commands; action; action = action->next)
2356 struct cmd_list_element *cmd;
2358 QUIT; /* allow user to bail out with ^C */
2359 action_exp = action->line;
2360 while (isspace ((int) *action_exp))
2363 /* The collection actions to be done while stepping are
2364 bracketed by the commands "while-stepping" and "end". */
2366 if (*action_exp == '#') /* comment line */
2369 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2371 error (_("Bad action list item: %s"), action_exp);
2373 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2374 stepping_actions = 1;
2375 else if (cmd_cfunc_eq (cmd, end_actions_pseudocommand))
2376 stepping_actions = 0;
2377 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2379 /* Display the collected data.
2380 For the trap frame, display only what was collected at
2381 the trap. Likewise for stepping frames, display only
2382 what was collected while stepping. This means that the
2383 two boolean variables, STEPPING_FRAME and
2384 STEPPING_ACTIONS should be equal. */
2385 if (stepping_frame == stepping_actions)
2388 { /* repeat over a comma-separated list */
2389 QUIT; /* allow user to bail out with ^C */
2390 if (*action_exp == ',')
2392 while (isspace ((int) *action_exp))
2395 next_comma = strchr (action_exp, ',');
2397 if (0 == strncasecmp (action_exp, "$reg", 4))
2398 registers_info (NULL, from_tty);
2399 else if (0 == strncasecmp (action_exp, "$loc", 4))
2400 locals_info (NULL, from_tty);
2401 else if (0 == strncasecmp (action_exp, "$arg", 4))
2402 args_info (NULL, from_tty);
2407 make_cleanup (replace_comma, next_comma);
2410 printf_filtered ("%s = ", action_exp);
2411 output_command (action_exp, from_tty);
2412 printf_filtered ("\n");
2416 action_exp = next_comma;
2418 while (action_exp && *action_exp == ',');
2422 discard_cleanups (old_cleanups);
2425 extern int trace_regblock_size;
2427 /* Save tracepoint data to file named FILENAME. If TARGET_DOES_SAVE is
2428 non-zero, the save is performed on the target, otherwise GDB obtains all
2429 trace data and saves it locally. */
2432 trace_save (const char *filename, int target_does_save)
2434 struct cleanup *cleanup;
2436 struct trace_status *ts = current_trace_status ();
2439 struct uploaded_tp *uploaded_tps = NULL, *utp;
2440 struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
2443 ULONGEST offset = 0;
2444 #define MAX_TRACE_UPLOAD 2000
2445 gdb_byte buf[MAX_TRACE_UPLOAD];
2448 /* If the target is to save the data to a file on its own, then just
2449 send the command and be done with it. */
2450 if (target_does_save)
2452 err = target_save_trace_data (filename);
2454 error (_("Target failed to save trace data to '%s'."),
2459 /* Get the trace status first before opening the file, so if the
2460 target is losing, we can get out without touching files. */
2461 status = target_get_trace_status (ts);
2463 pathname = tilde_expand (filename);
2464 cleanup = make_cleanup (xfree, pathname);
2466 fp = fopen (pathname, "w");
2468 error (_("Unable to open file '%s' for saving trace data (%s)"),
2469 filename, safe_strerror (errno));
2470 make_cleanup_fclose (fp);
2472 /* Write a file header, with a high-bit-set char to indicate a
2473 binary file, plus a hint as what this file is, and a version
2474 number in case of future needs. */
2475 written = fwrite ("\x7fTRACE0\n", 8, 1, fp);
2477 perror_with_name (pathname);
2479 /* Write descriptive info. */
2481 /* Write out the size of a register block. */
2482 fprintf (fp, "R %x\n", trace_regblock_size);
2484 /* Write out status of the tracing run (aka "tstatus" info). */
2485 fprintf (fp, "status %c;%s",
2486 (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
2487 if (ts->stop_reason == tracepoint_error)
2489 char *buf = (char *) alloca (strlen (ts->error_desc) * 2 + 1);
2490 bin2hex ((gdb_byte *) ts->error_desc, buf, 0);
2491 fprintf (fp, ":%s", buf);
2493 fprintf (fp, ":%x", ts->stopping_tracepoint);
2494 if (ts->traceframe_count >= 0)
2495 fprintf (fp, ";tframes:%x", ts->traceframe_count);
2496 if (ts->traceframes_created >= 0)
2497 fprintf (fp, ";tcreated:%x", ts->traceframes_created);
2498 if (ts->buffer_free >= 0)
2499 fprintf (fp, ";tfree:%x", ts->buffer_free);
2500 if (ts->buffer_size >= 0)
2501 fprintf (fp, ";tsize:%x", ts->buffer_size);
2504 /* Note that we want to upload tracepoints and save those, rather
2505 than simply writing out the local ones, because the user may have
2506 changed tracepoints in GDB in preparation for a future tracing
2507 run, or maybe just mass-deleted all types of breakpoints as part
2508 of cleaning up. So as not to contaminate the session, leave the
2509 data in its uploaded form, don't make into real tracepoints. */
2511 /* Get trace state variables first, they may be checked when parsing
2512 uploaded commands. */
2514 target_upload_trace_state_variables (&uploaded_tsvs);
2516 for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
2522 buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
2523 bin2hex ((gdb_byte *) (utsv->name), buf, 0);
2526 fprintf (fp, "tsv %x:%s:%x:%s\n",
2527 utsv->number, phex_nz (utsv->initial_value, 8),
2528 utsv->builtin, buf);
2534 free_uploaded_tsvs (&uploaded_tsvs);
2536 target_upload_tracepoints (&uploaded_tps);
2538 for (utp = uploaded_tps; utp; utp = utp->next)
2540 fprintf (fp, "tp T%x:%s:%c:%x:%x",
2541 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
2542 (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
2543 if (utp->type == bp_fast_tracepoint)
2544 fprintf (fp, ":F%x", utp->orig_size);
2546 fprintf (fp, ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
2549 for (a = 0; a < utp->numactions; ++a)
2550 fprintf (fp, "tp A%x:%s:%s\n",
2551 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
2553 for (a = 0; a < utp->num_step_actions; ++a)
2554 fprintf (fp, "tp S%x:%s:%s\n",
2555 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
2556 utp->step_actions[a]);
2559 free_uploaded_tps (&uploaded_tps);
2561 /* Mark the end of the definition section. */
2564 /* Get and write the trace data proper. We ask for big blocks, in
2565 the hopes of efficiency, but will take less if the target has
2566 packet size limitations or some such. */
2569 gotten = target_get_raw_trace_data (buf, offset, MAX_TRACE_UPLOAD);
2571 error (_("Failure to get requested trace buffer data"));
2572 /* No more data is forthcoming, we're done. */
2575 written = fwrite (buf, gotten, 1, fp);
2576 if (written < gotten)
2577 perror_with_name (pathname);
2581 /* Mark the end of trace data. */
2582 written = fwrite (&gotten, 4, 1, fp);
2584 perror_with_name (pathname);
2586 do_cleanups (cleanup);
2590 trace_save_command (char *args, int from_tty)
2592 int target_does_save = 0;
2594 char *filename = NULL;
2595 struct cleanup *back_to;
2598 error_no_arg (_("file in which to save trace data"));
2600 argv = gdb_buildargv (args);
2601 back_to = make_cleanup_freeargv (argv);
2603 for (; *argv; ++argv)
2605 if (strcmp (*argv, "-r") == 0)
2606 target_does_save = 1;
2607 else if (**argv == '-')
2608 error (_("unknown option `%s'"), *argv);
2614 error_no_arg (_("file in which to save trace data"));
2616 trace_save (filename, target_does_save);
2619 printf_filtered (_("Trace data saved to file '%s'.\n"), args);
2621 do_cleanups (back_to);
2624 /* Tell the target what to do with an ongoing tracing run if GDB
2625 disconnects for some reason. */
2628 send_disconnected_tracing_value (int value)
2630 target_set_disconnected_tracing (value);
2634 set_disconnected_tracing (char *args, int from_tty,
2635 struct cmd_list_element *c)
2637 send_disconnected_tracing_value (disconnected_tracing);
2641 set_circular_trace_buffer (char *args, int from_tty,
2642 struct cmd_list_element *c)
2644 target_set_circular_trace_buffer (circular_trace_buffer);
2647 /* Convert the memory pointed to by mem into hex, placing result in buf.
2648 * Return a pointer to the last char put in buf (null)
2649 * "stolen" from sparc-stub.c
2652 static const char hexchars[] = "0123456789abcdef";
2655 mem2hex (gdb_byte *mem, char *buf, int count)
2663 *buf++ = hexchars[ch >> 4];
2664 *buf++ = hexchars[ch & 0xf];
2673 get_traceframe_number (void)
2675 return traceframe_number;
2678 /* Make the traceframe NUM be the current trace frame. Does nothing
2679 if NUM is already current. */
2682 set_traceframe_number (int num)
2686 if (traceframe_number == num)
2688 /* Nothing to do. */
2692 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
2695 warning (_("could not change traceframe"));
2697 traceframe_number = newnum;
2699 /* Changing the traceframe changes our view of registers and of the
2701 registers_changed ();
2704 /* A cleanup used when switching away and back from tfind mode. */
2706 struct current_traceframe_cleanup
2708 /* The traceframe we were inspecting. */
2709 int traceframe_number;
2713 do_restore_current_traceframe_cleanup (void *arg)
2715 struct current_traceframe_cleanup *old = arg;
2717 set_traceframe_number (old->traceframe_number);
2721 restore_current_traceframe_cleanup_dtor (void *arg)
2723 struct current_traceframe_cleanup *old = arg;
2729 make_cleanup_restore_current_traceframe (void)
2731 struct current_traceframe_cleanup *old;
2733 old = xmalloc (sizeof (struct current_traceframe_cleanup));
2734 old->traceframe_number = traceframe_number;
2736 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
2737 restore_current_traceframe_cleanup_dtor);
2740 /* Given a number and address, return an uploaded tracepoint with that
2741 number, creating if necessary. */
2743 struct uploaded_tp *
2744 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
2746 struct uploaded_tp *utp;
2748 for (utp = *utpp; utp; utp = utp->next)
2749 if (utp->number == num && utp->addr == addr)
2751 utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
2752 memset (utp, 0, sizeof (struct uploaded_tp));
2761 free_uploaded_tps (struct uploaded_tp **utpp)
2763 struct uploaded_tp *next_one;
2767 next_one = (*utpp)->next;
2773 /* Given a number and address, return an uploaded tracepoint with that
2774 number, creating if necessary. */
2776 struct uploaded_tsv *
2777 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
2779 struct uploaded_tsv *utsv;
2781 for (utsv = *utsvp; utsv; utsv = utsv->next)
2782 if (utsv->number == num)
2784 utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
2785 memset (utsv, 0, sizeof (struct uploaded_tsv));
2787 utsv->next = *utsvp;
2793 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
2795 struct uploaded_tsv *next_one;
2799 next_one = (*utsvp)->next;
2805 /* Look for an existing tracepoint that seems similar enough to the
2806 uploaded one. Enablement isn't compared, because the user can
2807 toggle that freely, and may have done so in anticipation of the
2811 find_matching_tracepoint (struct uploaded_tp *utp)
2813 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
2815 struct breakpoint *t;
2816 struct bp_location *loc;
2818 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
2820 if (t->type == utp->type
2821 && t->step_count == utp->step
2822 && t->pass_count == utp->pass
2823 /* FIXME also test conditionals and actions */
2826 /* Scan the locations for an address match. */
2827 for (loc = t->loc; loc; loc = loc->next)
2829 if (loc->address == utp->addr)
2837 /* Given a list of tracepoints uploaded from a target, attempt to
2838 match them up with existing tracepoints, and create new ones if not
2842 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
2844 struct uploaded_tp *utp;
2845 struct breakpoint *t;
2847 /* Look for GDB tracepoints that match up with our uploaded versions. */
2848 for (utp = *uploaded_tps; utp; utp = utp->next)
2850 t = find_matching_tracepoint (utp);
2852 printf_filtered (_("Assuming tracepoint %d is same as target's tracepoint %d at %s.\n"),
2853 t->number, utp->number, paddress (get_current_arch (), utp->addr));
2856 t = create_tracepoint_from_upload (utp);
2858 printf_filtered (_("Created tracepoint %d for target's tracepoint %d at %s.\n"),
2859 t->number, utp->number, paddress (get_current_arch (), utp->addr));
2861 printf_filtered (_("Failed to create tracepoint for target's tracepoint %d at %s, skipping it.\n"),
2862 utp->number, paddress (get_current_arch (), utp->addr));
2864 /* Whether found or created, record the number used by the
2865 target, to help with mapping target tracepoints back to their
2866 counterparts here. */
2868 t->number_on_target = utp->number;
2871 free_uploaded_tps (uploaded_tps);
2874 /* Trace state variables don't have much to identify them beyond their
2875 name, so just use that to detect matches. */
2877 struct trace_state_variable *
2878 find_matching_tsv (struct uploaded_tsv *utsv)
2883 return find_trace_state_variable (utsv->name);
2886 struct trace_state_variable *
2887 create_tsv_from_upload (struct uploaded_tsv *utsv)
2889 const char *namebase;
2892 struct trace_state_variable *tsv;
2896 namebase = utsv->name;
2897 sprintf (buf, "%s", namebase);
2902 sprintf (buf, "%s_%d", namebase, try_num++);
2905 /* Fish for a name that is not in use. */
2906 /* (should check against all internal vars?) */
2907 while (find_trace_state_variable (buf))
2908 sprintf (buf, "%s_%d", namebase, try_num++);
2910 /* We have an available name, create the variable. */
2911 tsv = create_trace_state_variable (xstrdup (buf));
2912 tsv->initial_value = utsv->initial_value;
2913 tsv->builtin = utsv->builtin;
2918 /* Given a list of uploaded trace state variables, try to match them
2919 up with existing variables, or create additional ones. */
2922 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
2925 struct uploaded_tsv *utsv;
2926 struct trace_state_variable *tsv;
2929 /* Most likely some numbers will have to be reassigned as part of
2930 the merge, so clear them all in anticipation. */
2931 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
2934 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
2936 tsv = find_matching_tsv (utsv);
2938 printf_filtered (_("Assuming trace state variable $%s is same as target's variable %d.\n"),
2939 tsv->name, utsv->number);
2942 tsv = create_tsv_from_upload (utsv);
2943 printf_filtered (_("Created trace state variable $%s for target's variable %d.\n"),
2944 tsv->name, utsv->number);
2946 /* Give precedence to numberings that come from the target. */
2948 tsv->number = utsv->number;
2951 /* Renumber everything that didn't get a target-assigned number. */
2953 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
2954 if (tsv->number > highest)
2955 highest = tsv->number;
2958 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
2959 if (tsv->number == 0)
2960 tsv->number = highest++;
2962 free_uploaded_tsvs (uploaded_tsvs);
2965 /* target tfile command */
2967 struct target_ops tfile_ops;
2969 /* Fill in tfile_ops with its defined operations and properties. */
2971 #define TRACE_HEADER_SIZE 8
2973 char *trace_filename;
2975 off_t trace_frames_offset;
2978 int trace_regblock_size;
2980 static void tfile_interp_line (char *line,
2981 struct uploaded_tp **utpp,
2982 struct uploaded_tsv **utsvp);
2985 tfile_open (char *filename, int from_tty)
2988 struct cleanup *old_chain;
2991 char header[TRACE_HEADER_SIZE];
2992 char linebuf[1000]; /* should be max remote packet size or so */
2994 int bytes, i, gotten;
2995 struct trace_status *ts;
2996 struct uploaded_tp *uploaded_tps = NULL;
2997 struct uploaded_tsv *uploaded_tsvs = NULL;
2999 target_preopen (from_tty);
3001 error (_("No trace file specified."));
3003 filename = tilde_expand (filename);
3004 if (!IS_ABSOLUTE_PATH(filename))
3006 temp = concat (current_directory, "/", filename, (char *)NULL);
3011 old_chain = make_cleanup (xfree, filename);
3013 flags = O_BINARY | O_LARGEFILE;
3015 scratch_chan = open (filename, flags, 0);
3016 if (scratch_chan < 0)
3017 perror_with_name (filename);
3019 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
3021 discard_cleanups (old_chain); /* Don't free filename any more */
3022 unpush_target (&tfile_ops);
3024 push_target (&tfile_ops);
3026 trace_filename = xstrdup (filename);
3027 trace_fd = scratch_chan;
3030 /* Read the file header and test for validity. */
3031 gotten = read (trace_fd, &header, TRACE_HEADER_SIZE);
3033 perror_with_name (trace_filename);
3034 else if (gotten < TRACE_HEADER_SIZE)
3035 error (_("Premature end of file while reading trace file"));
3037 bytes += TRACE_HEADER_SIZE;
3038 if (!(header[0] == 0x7f
3039 && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
3040 error (_("File is not a valid trace file."));
3042 trace_regblock_size = 0;
3043 ts = current_trace_status ();
3044 /* We know we're working with a file. */
3046 /* Set defaults in case there is no status line. */
3047 ts->running_known = 0;
3048 ts->stop_reason = trace_stop_reason_unknown;
3049 ts->traceframe_count = -1;
3050 ts->buffer_free = 0;
3052 /* Read through a section of newline-terminated lines that
3053 define things like tracepoints. */
3057 gotten = read (trace_fd, &byte, 1);
3059 perror_with_name (trace_filename);
3060 else if (gotten < 1)
3061 error (_("Premature end of file while reading trace file"));
3066 /* Empty line marks end of the definition section. */
3071 tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
3074 linebuf[i++] = byte;
3076 error (_("Excessively long lines in trace file"));
3079 /* Add the file's tracepoints and variables into the current mix. */
3081 /* Get trace state variables first, they may be checked when parsing
3082 uploaded commands. */
3083 merge_uploaded_trace_state_variables (&uploaded_tsvs);
3085 merge_uploaded_tracepoints (&uploaded_tps);
3087 /* Record the starting offset of the binary trace data. */
3088 trace_frames_offset = bytes;
3090 /* If we don't have a blocksize, we can't interpret the
3092 if (trace_regblock_size == 0)
3093 error (_("No register block size recorded in trace file"));
3094 if (ts->traceframe_count <= 0)
3096 warning ("No traceframes present in this file.");
3100 #define TFILE_PID (1)
3101 inferior_appeared (current_inferior (), TFILE_PID);
3102 inferior_ptid = pid_to_ptid (TFILE_PID);
3103 add_thread_silent (inferior_ptid);
3105 post_create_inferior (&tfile_ops, from_tty);
3108 /* FIXME this will get defined in MI patch submission */
3109 tfind_1 (tfind_number, 0, 0, 0, 0);
3113 /* Interpret the given line from the definitions part of the trace
3117 tfile_interp_line (char *line,
3118 struct uploaded_tp **utpp, struct uploaded_tsv **utsvp)
3122 if (strncmp (p, "R ", strlen ("R ")) == 0)
3125 trace_regblock_size = strtol (p, &p, 16);
3127 else if (strncmp (p, "status ", strlen ("status ")) == 0)
3129 p += strlen ("status ");
3130 parse_trace_status (p, current_trace_status ());
3132 else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
3134 p += strlen ("tp ");
3135 parse_tracepoint_definition (p, utpp);
3137 else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
3139 p += strlen ("tsv ");
3140 parse_tsv_definition (p, utsvp);
3143 warning ("Ignoring trace file definition \"%s\"", line);
3146 /* Parse the part of trace status syntax that is shared between
3147 the remote protocol and the trace file reader. */
3149 extern char *unpack_varlen_hex (char *buff, ULONGEST *result);
3152 parse_trace_status (char *line, struct trace_status *ts)
3154 char *p = line, *p1, *p2, *p_temp;
3157 ts->running_known = 1;
3158 ts->running = (*p++ == '1');
3159 ts->stop_reason = trace_stop_reason_unknown;
3160 ts->error_desc = "";
3161 ts->traceframe_count = -1;
3162 ts->traceframes_created = -1;
3163 ts->buffer_free = -1;
3164 ts->buffer_size = -1;
3168 p1 = strchr (p, ':');
3170 error (_("Malformed trace status, at %s\n\
3171 Status line: '%s'\n"), p, line);
3172 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
3174 p = unpack_varlen_hex (++p1, &val);
3175 ts->stop_reason = trace_buffer_full;
3177 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
3179 p = unpack_varlen_hex (++p1, &val);
3180 ts->stop_reason = trace_never_run;
3182 else if (strncmp (p, stop_reason_names[tracepoint_passcount], p1 - p) == 0)
3184 p = unpack_varlen_hex (++p1, &val);
3185 ts->stop_reason = tracepoint_passcount;
3186 ts->stopping_tracepoint = val;
3188 else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
3190 p = unpack_varlen_hex (++p1, &val);
3191 ts->stop_reason = tstop_command;
3193 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
3195 p2 = strchr (++p1, ':');
3200 ts->error_desc = xmalloc ((p2 - p1) / 2 + 1);
3201 end = hex2bin (p1, ts->error_desc, (p2 - p1) / 2);
3202 ts->error_desc[end] = '\0';
3204 p = unpack_varlen_hex (++p2, &val);
3205 ts->stopping_tracepoint = val;
3206 ts->stop_reason = tracepoint_error;
3208 else if (strncmp (p, "tframes", p1 - p) == 0)
3210 p = unpack_varlen_hex (++p1, &val);
3211 ts->traceframe_count = val;
3213 else if (strncmp (p, "tcreated", p1 - p) == 0)
3215 p = unpack_varlen_hex (++p1, &val);
3216 ts->traceframes_created = val;
3218 else if (strncmp (p, "tfree", p1 - p) == 0)
3220 p = unpack_varlen_hex (++p1, &val);
3221 ts->buffer_free = val;
3223 else if (strncmp (p, "tsize", p1 - p) == 0)
3225 p = unpack_varlen_hex (++p1, &val);
3226 ts->buffer_size = val;
3230 /* Silently skip unknown optional info. */
3231 p_temp = strchr (p1 + 1, ';');
3235 /* Must be at the end. */
3241 /* Given a line of text defining a tracepoint or tracepoint action, parse
3242 it into an "uploaded tracepoint". */
3245 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
3249 ULONGEST num, addr, step, pass, orig_size, xlen;
3253 struct uploaded_tp *utp = NULL;
3256 /* Both tracepoint and action definitions start with the same number
3257 and address sequence. */
3259 p = unpack_varlen_hex (p, &num);
3260 p++; /* skip a colon */
3261 p = unpack_varlen_hex (p, &addr);
3262 p++; /* skip a colon */
3265 enabled = (*p++ == 'E');
3266 p++; /* skip a colon */
3267 p = unpack_varlen_hex (p, &step);
3268 p++; /* skip a colon */
3269 p = unpack_varlen_hex (p, &pass);
3270 type = bp_tracepoint;
3272 /* Thumb through optional fields. */
3275 p++; /* skip a colon */
3278 type = bp_fast_tracepoint;
3280 p = unpack_varlen_hex (p, &orig_size);
3285 p = unpack_varlen_hex (p, &xlen);
3286 p++; /* skip a comma */
3287 cond = (char *) xmalloc (2 * xlen + 1);
3288 strncpy (cond, p, 2 * xlen);
3289 cond[2 * xlen] = '\0';
3293 warning ("Unrecognized char '%c' in tracepoint definition, skipping rest", *p);
3295 utp = get_uploaded_tp (num, addr, utpp);
3297 utp->enabled = enabled;
3302 else if (piece == 'A')
3304 utp = get_uploaded_tp (num, addr, utpp);
3305 utp->actions[utp->numactions++] = xstrdup (p);
3307 else if (piece == 'S')
3309 utp = get_uploaded_tp (num, addr, utpp);
3310 utp->step_actions[utp->num_step_actions++] = xstrdup (p);
3314 error ("Invalid tracepoint piece");
3318 /* Convert a textual description of a trace state variable into an
3322 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
3325 ULONGEST num, initval, builtin;
3327 struct uploaded_tsv *utsv = NULL;
3329 buf = alloca (strlen (line));
3332 p = unpack_varlen_hex (p, &num);
3333 p++; /* skip a colon */
3334 p = unpack_varlen_hex (p, &initval);
3335 p++; /* skip a colon */
3336 p = unpack_varlen_hex (p, &builtin);
3337 p++; /* skip a colon */
3338 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
3341 utsv = get_uploaded_tsv (num, utsvp);
3342 utsv->initial_value = initval;
3343 utsv->builtin = builtin;
3344 utsv->name = xstrdup (buf);
3347 /* Close the trace file and generally clean up. */
3350 tfile_close (int quitting)
3357 pid = ptid_get_pid (inferior_ptid);
3358 inferior_ptid = null_ptid; /* Avoid confusion from thread stuff */
3359 exit_inferior_silent (pid);
3364 xfree (trace_filename);
3368 tfile_files_info (struct target_ops *t)
3370 /* (it would be useful to mention the name of the file) */
3371 printf_filtered ("Looking at a trace file.\n");
3374 /* The trace status for a file is that tracing can never be run. */
3377 tfile_get_trace_status (struct trace_status *ts)
3379 /* Other bits of trace status were collected as part of opening the
3380 trace files, so nothing to do here. */
3385 /* Given the position of a traceframe in the file, figure out what
3386 address the frame was collected at. This would normally be the
3387 value of a collected PC register, but if not available, we
3391 tfile_get_traceframe_address (off_t tframe_offset)
3395 struct breakpoint *tp;
3396 off_t saved_offset = cur_offset;
3399 /* FIXME dig pc out of collected registers */
3401 /* Fall back to using tracepoint address. */
3402 lseek (trace_fd, tframe_offset, SEEK_SET);
3403 gotten = read (trace_fd, &tpnum, 2);
3405 perror_with_name (trace_filename);
3406 else if (gotten < 2)
3407 error (_("Premature end of file while reading trace file"));
3409 tp = get_tracepoint_by_number_on_target (tpnum);
3410 /* FIXME this is a poor heuristic if multiple locations */
3412 addr = tp->loc->address;
3414 /* Restore our seek position. */
3415 cur_offset = saved_offset;
3416 lseek (trace_fd, cur_offset, SEEK_SET);
3420 /* Given a type of search and some parameters, scan the collection of
3421 traceframes in the file looking for a match. When found, return
3422 both the traceframe and tracepoint number, otherwise -1 for
3426 tfile_trace_find (enum trace_find_type type, int num,
3427 ULONGEST addr1, ULONGEST addr2, int *tpp)
3430 int tfnum = 0, found = 0, gotten;
3432 struct breakpoint *tp;
3433 off_t offset, tframe_offset;
3436 lseek (trace_fd, trace_frames_offset, SEEK_SET);
3437 offset = trace_frames_offset;
3440 tframe_offset = offset;
3441 gotten = read (trace_fd, &tpnum, 2);
3443 perror_with_name (trace_filename);
3444 else if (gotten < 2)
3445 error (_("Premature end of file while reading trace file"));
3449 gotten = read (trace_fd, &data_size, 4);
3451 perror_with_name (trace_filename);
3452 else if (gotten < 4)
3453 error (_("Premature end of file while reading trace file"));
3462 tfaddr = tfile_get_traceframe_address (tframe_offset);
3463 if (tfaddr == addr1)
3467 tp = get_tracepoint (num);
3468 if (tp && tpnum == tp->number_on_target)
3472 tfaddr = tfile_get_traceframe_address (tframe_offset);
3473 if (addr1 <= tfaddr && tfaddr <= addr2)
3477 tfaddr = tfile_get_traceframe_address (tframe_offset);
3478 if (!(addr1 <= tfaddr && tfaddr <= addr2))
3482 internal_error (__FILE__, __LINE__, _("unknown tfind type"));
3488 cur_offset = offset;
3489 cur_data_size = data_size;
3492 /* Skip past the traceframe's data. */
3493 lseek (trace_fd, data_size, SEEK_CUR);
3494 offset += data_size;
3495 /* Update our own count of traceframes. */
3498 /* Did not find what we were looking for. */
3504 /* Look for a block of saved registers in the traceframe, and get the
3505 requested register from it. */
3508 tfile_fetch_registers (struct target_ops *ops,
3509 struct regcache *regcache, int regno)
3511 struct gdbarch *gdbarch = get_regcache_arch (regcache);
3513 int i, pos, offset, regn, regsize, gotten;
3514 unsigned short mlen;
3517 /* An uninitialized reg size says we're not going to be
3518 successful at getting register blocks. */
3519 if (!trace_regblock_size)
3522 regs = alloca (trace_regblock_size);
3524 lseek (trace_fd, cur_offset, SEEK_SET);
3526 while (pos < cur_data_size)
3528 gotten = read (trace_fd, &block_type, 1);
3530 perror_with_name (trace_filename);
3531 else if (gotten < 1)
3532 error (_("Premature end of file while reading trace file"));
3538 gotten = read (trace_fd, regs, trace_regblock_size);
3540 perror_with_name (trace_filename);
3541 else if (gotten < trace_regblock_size)
3542 error (_("Premature end of file while reading trace file"));
3544 /* Assume the block is laid out in GDB register number order,
3545 each register with the size that it has in GDB. */
3547 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
3549 regsize = register_size (gdbarch, regn);
3550 /* Make sure we stay within block bounds. */
3551 if (offset + regsize >= trace_regblock_size)
3553 if (!regcache_valid_p (regcache, regn))
3557 regcache_raw_supply (regcache, regno, regs + offset);
3560 else if (regno == -1)
3562 regcache_raw_supply (regcache, regn, regs + offset);
3569 lseek (trace_fd, 8, SEEK_CUR);
3570 gotten = read (trace_fd, &mlen, 2);
3572 perror_with_name (trace_filename);
3573 else if (gotten < 2)
3574 error (_("Premature end of file while reading trace file"));
3575 lseek (trace_fd, mlen, SEEK_CUR);
3576 pos += (8 + 2 + mlen);
3579 lseek (trace_fd, 4 + 8, SEEK_CUR);
3583 error ("Unknown block type '%c' (0x%x) in trace frame",
3584 block_type, block_type);
3591 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
3592 const char *annex, gdb_byte *readbuf,
3593 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
3598 unsigned short mlen;
3600 /* We're only doing regular memory for now. */
3601 if (object != TARGET_OBJECT_MEMORY)
3604 if (readbuf == NULL)
3605 error ("tfile_xfer_partial: trace file is read-only");
3607 lseek (trace_fd, cur_offset, SEEK_SET);
3609 while (pos < cur_data_size)
3611 gotten = read (trace_fd, &block_type, 1);
3613 perror_with_name (trace_filename);
3614 else if (gotten < 1)
3615 error (_("Premature end of file while reading trace file"));
3620 lseek (trace_fd, trace_regblock_size, SEEK_CUR);
3621 pos += trace_regblock_size;
3624 gotten = read (trace_fd, &maddr, 8);
3626 perror_with_name (trace_filename);
3627 else if (gotten < 8)
3628 error (_("Premature end of file while reading trace file"));
3630 gotten = read (trace_fd, &mlen, 2);
3632 perror_with_name (trace_filename);
3633 else if (gotten < 2)
3634 error (_("Premature end of file while reading trace file"));
3635 if (maddr <= offset && (offset + len) <= (maddr + mlen))
3637 gotten = read (trace_fd, readbuf, mlen);
3639 perror_with_name (trace_filename);
3640 else if (gotten < mlen)
3641 error (_("Premature end of file qwhile reading trace file"));
3645 lseek (trace_fd, mlen, SEEK_CUR);
3646 pos += (8 + 2 + mlen);
3649 lseek (trace_fd, 4 + 8, SEEK_CUR);
3653 error ("Unknown block type '%c' (0x%x) in traceframe",
3654 block_type, block_type);
3658 /* Indicate failure to find the requested memory block. */
3662 /* Iterate through the blocks of a trace frame, looking for a 'V'
3663 block with a matching tsv number. */
3666 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
3669 int pos, vnum, gotten;
3670 unsigned short mlen;
3672 lseek (trace_fd, cur_offset, SEEK_SET);
3674 while (pos < cur_data_size)
3676 gotten = read (trace_fd, &block_type, 1);
3678 perror_with_name (trace_filename);
3679 else if (gotten < 1)
3680 error (_("Premature end of file while reading trace file"));
3685 lseek (trace_fd, trace_regblock_size, SEEK_CUR);
3686 pos += trace_regblock_size;
3689 lseek (trace_fd, 8, SEEK_CUR);
3690 gotten = read (trace_fd, &mlen, 2);
3692 perror_with_name (trace_filename);
3693 else if (gotten < 2)
3694 error (_("Premature end of file while reading trace file"));
3695 lseek (trace_fd, mlen, SEEK_CUR);
3696 pos += (8 + 2 + mlen);
3699 gotten = read (trace_fd, &vnum, 4);
3701 perror_with_name (trace_filename);
3702 else if (gotten < 4)
3703 error (_("Premature end of file while reading trace file"));
3706 gotten = read (trace_fd, val, 8);
3708 perror_with_name (trace_filename);
3709 else if (gotten < 8)
3710 error (_("Premature end of file while reading trace file"));
3713 lseek (trace_fd, 8, SEEK_CUR);
3717 error ("Unknown block type '%c' (0x%x) in traceframe",
3718 block_type, block_type);
3722 /* Didn't find anything. */
3727 tfile_has_memory (struct target_ops *ops)
3733 tfile_has_stack (struct target_ops *ops)
3739 tfile_has_registers (struct target_ops *ops)
3745 init_tfile_ops (void)
3747 tfile_ops.to_shortname = "tfile";
3748 tfile_ops.to_longname = "Local trace dump file";
3750 "Use a trace file as a target. Specify the filename of the trace file.";
3751 tfile_ops.to_open = tfile_open;
3752 tfile_ops.to_close = tfile_close;
3753 tfile_ops.to_fetch_registers = tfile_fetch_registers;
3754 tfile_ops.to_xfer_partial = tfile_xfer_partial;
3755 tfile_ops.to_files_info = tfile_files_info;
3756 tfile_ops.to_get_trace_status = tfile_get_trace_status;
3757 tfile_ops.to_trace_find = tfile_trace_find;
3758 tfile_ops.to_get_trace_state_variable_value = tfile_get_trace_state_variable_value;
3759 /* core_stratum might seem more logical, but GDB doesn't like having
3760 more than one core_stratum vector. */
3761 tfile_ops.to_stratum = process_stratum;
3762 tfile_ops.to_has_memory = tfile_has_memory;
3763 tfile_ops.to_has_stack = tfile_has_stack;
3764 tfile_ops.to_has_registers = tfile_has_registers;
3765 tfile_ops.to_magic = OPS_MAGIC;
3768 /* module initialization */
3770 _initialize_tracepoint (void)
3772 struct cmd_list_element *c;
3774 traceframe_number = -1;
3775 tracepoint_number = -1;
3777 if (tracepoint_list.list == NULL)
3779 tracepoint_list.listsize = 128;
3780 tracepoint_list.list = xmalloc
3781 (tracepoint_list.listsize * sizeof (struct memrange));
3783 if (tracepoint_list.aexpr_list == NULL)
3785 tracepoint_list.aexpr_listsize = 128;
3786 tracepoint_list.aexpr_list = xmalloc
3787 (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
3790 if (stepping_list.list == NULL)
3792 stepping_list.listsize = 128;
3793 stepping_list.list = xmalloc
3794 (stepping_list.listsize * sizeof (struct memrange));
3797 if (stepping_list.aexpr_list == NULL)
3799 stepping_list.aexpr_listsize = 128;
3800 stepping_list.aexpr_list = xmalloc
3801 (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
3804 add_info ("scope", scope_info,
3805 _("List the variables local to a scope"));
3807 add_cmd ("tracepoints", class_trace, NULL,
3808 _("Tracing of program execution without stopping the program."),
3811 add_com ("tdump", class_trace, trace_dump_command,
3812 _("Print everything collected at the current tracepoint."));
3814 add_com ("tsave", class_trace, trace_save_command, _("\
3815 Save the trace data to a file.\n\
3816 Use the '-r' option to direct the target to save directly to the file,\n\
3817 using its own filesystem."));
3819 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
3820 Define a trace state variable.\n\
3821 Argument is a $-prefixed name, optionally followed\n\
3822 by '=' and an expression that sets the initial value\n\
3823 at the start of tracing."));
3824 set_cmd_completer (c, expression_completer);
3826 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
3827 Delete one or more trace state variables.\n\
3828 Arguments are the names of the variables to delete.\n\
3829 If no arguments are supplied, delete all variables."), &deletelist);
3830 /* FIXME add a trace variable completer */
3832 add_info ("tvariables", tvariables_info, _("\
3833 Status of trace state variables and their values.\n\
3836 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
3837 Select a trace frame;\n\
3838 No argument means forward by one frame; '-' means backward by one frame."),
3839 &tfindlist, "tfind ", 1, &cmdlist);
3841 add_cmd ("outside", class_trace, trace_find_outside_command, _("\
3842 Select a trace frame whose PC is outside the given range (exclusive).\n\
3843 Usage: tfind outside addr1, addr2"),
3846 add_cmd ("range", class_trace, trace_find_range_command, _("\
3847 Select a trace frame whose PC is in the given range (inclusive).\n\
3848 Usage: tfind range addr1,addr2"),
3851 add_cmd ("line", class_trace, trace_find_line_command, _("\
3852 Select a trace frame by source line.\n\
3853 Argument can be a line number (with optional source file), \n\
3854 a function name, or '*' followed by an address.\n\
3855 Default argument is 'the next source line that was traced'."),
3858 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
3859 Select a trace frame by tracepoint number.\n\
3860 Default is the tracepoint for the current trace frame."),
3863 add_cmd ("pc", class_trace, trace_find_pc_command, _("\
3864 Select a trace frame by PC.\n\
3865 Default is the current PC, or the PC of the current trace frame."),
3868 add_cmd ("end", class_trace, trace_find_end_command, _("\
3869 Synonym for 'none'.\n\
3870 De-select any trace frame and resume 'live' debugging."),
3873 add_cmd ("none", class_trace, trace_find_none_command,
3874 _("De-select any trace frame and resume 'live' debugging."),
3877 add_cmd ("start", class_trace, trace_find_start_command,
3878 _("Select the first trace frame in the trace buffer."),
3881 add_com ("tstatus", class_trace, trace_status_command,
3882 _("Display the status of the current trace data collection."));
3884 add_com ("tstop", class_trace, trace_stop_command,
3885 _("Stop trace data collection."));
3887 add_com ("tstart", class_trace, trace_start_command,
3888 _("Start trace data collection."));
3890 add_com ("end", class_trace, end_actions_pseudocommand, _("\
3891 Ends a list of commands or actions.\n\
3892 Several GDB commands allow you to enter a list of commands or actions.\n\
3893 Entering \"end\" on a line by itself is the normal way to terminate\n\
3895 Note: the \"end\" command cannot be used at the gdb prompt."));
3897 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
3898 Specify single-stepping behavior at a tracepoint.\n\
3899 Argument is number of instructions to trace in single-step mode\n\
3900 following the tracepoint. This command is normally followed by\n\
3901 one or more \"collect\" commands, to specify what to collect\n\
3902 while single-stepping.\n\n\
3903 Note: this command can only be used in a tracepoint \"actions\" list."));
3905 add_com_alias ("ws", "while-stepping", class_alias, 0);
3906 add_com_alias ("stepping", "while-stepping", class_alias, 0);
3908 add_com ("collect", class_trace, collect_pseudocommand, _("\
3909 Specify one or more data items to be collected at a tracepoint.\n\
3910 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
3911 collect all data (variables, registers) referenced by that expression.\n\
3912 Also accepts the following special arguments:\n\
3913 $regs -- all registers.\n\
3914 $args -- all function arguments.\n\
3915 $locals -- all variables local to the block/function scope.\n\
3916 Note: this command can only be used in a tracepoint \"actions\" list."));
3918 add_com ("teval", class_trace, teval_pseudocommand, _("\
3919 Specify one or more expressions to be evaluated at a tracepoint.\n\
3920 Accepts a comma-separated list of (one or more) expressions.\n\
3921 The result of each evaluation will be discarded.\n\
3922 Note: this command can only be used in a tracepoint \"actions\" list."));
3924 add_com ("actions", class_trace, trace_actions_command, _("\
3925 Specify the actions to be taken at a tracepoint.\n\
3926 Tracepoint actions may include collecting of specified data, \n\
3927 single-stepping, or enabling/disabling other tracepoints, \n\
3928 depending on target's capabilities."));
3930 default_collect = xstrdup ("");
3931 add_setshow_string_cmd ("default-collect", class_trace,
3932 &default_collect, _("\
3933 Set the list of expressions to collect by default"), _("\
3934 Show the list of expressions to collect by default"), NULL,
3936 &setlist, &showlist);
3938 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
3939 &disconnected_tracing, _("\
3940 Set whether tracing continues after GDB disconnects."), _("\
3941 Show whether tracing continues after GDB disconnects."), _("\
3942 Use this to continue a tracing run even if GDB disconnects\n\
3943 or detaches from the target. You can reconnect later and look at\n\
3944 trace data collected in the meantime."),
3945 set_disconnected_tracing,
3950 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
3951 &circular_trace_buffer, _("\
3952 Set target's use of circular trace buffer."), _("\
3953 Show target's use of circular trace buffer."), _("\
3954 Use this to make the trace buffer into a circular buffer,\n\
3955 which will discard traceframes (oldest first) instead of filling\n\
3956 up and stopping the trace run."),
3957 set_circular_trace_buffer,
3964 add_target (&tfile_ops);