1 /* Tracing functionality for remote targets in custom GDB protocol
3 Copyright (C) 1997-2013 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "arch-utils.h"
25 #include "expression.h"
30 #include "gdb_string.h"
32 #include "breakpoint.h"
33 #include "tracepoint.h"
36 #include "completer.h"
38 #include "dictionary.h"
40 #include "user-regs.h"
44 #include "filenames.h"
45 #include "gdbthread.h"
53 #include "exceptions.h"
54 #include "cli/cli-utils.h"
57 /* readline include files */
58 #include "readline/readline.h"
59 #include "readline/history.h"
61 /* readline defines this. */
72 /* Maximum length of an agent aexpression.
73 This accounts for the fact that packets are limited to 400 bytes
74 (which includes everything -- including the checksum), and assumes
75 the worst case of maximum length for each of the pieces of a
78 NOTE: expressions get mem2hex'ed otherwise this would be twice as
79 large. (400 - 31)/2 == 184 */
80 #define MAX_AGENT_EXPR_LEN 184
84 /* A hook used to notify the UI of tracepoint operations. */
86 void (*deprecated_trace_find_hook) (char *arg, int from_tty);
87 void (*deprecated_trace_start_stop_hook) (int start, int from_tty);
89 extern void (*deprecated_readline_begin_hook) (char *, ...);
90 extern char *(*deprecated_readline_hook) (char *);
91 extern void (*deprecated_readline_end_hook) (void);
96 This module defines the following debugger commands:
97 trace : set a tracepoint on a function, line, or address.
98 info trace : list all debugger-defined tracepoints.
99 delete trace : delete one or more tracepoints.
100 enable trace : enable one or more tracepoints.
101 disable trace : disable one or more tracepoints.
102 actions : specify actions to be taken at a tracepoint.
103 passcount : specify a pass count for a tracepoint.
104 tstart : start a trace experiment.
105 tstop : stop a trace experiment.
106 tstatus : query the status of a trace experiment.
107 tfind : find a trace frame in the trace buffer.
108 tdump : print everything collected at the current tracepoint.
109 save-tracepoints : write tracepoint setup into a file.
111 This module defines the following user-visible debugger variables:
112 $trace_frame : sequence number of trace frame currently being debugged.
113 $trace_line : source line of trace frame currently being debugged.
114 $trace_file : source file of trace frame currently being debugged.
115 $tracepoint : tracepoint number of trace frame currently being debugged.
119 /* ======= Important global variables: ======= */
121 /* The list of all trace state variables. We don't retain pointers to
122 any of these for any reason - API is by name or number only - so it
123 works to have a vector of objects. */
125 typedef struct trace_state_variable tsv_s;
128 /* An object describing the contents of a traceframe. */
130 struct traceframe_info
132 /* Collected memory. */
133 VEC(mem_range_s) *memory;
136 static VEC(tsv_s) *tvariables;
138 /* The next integer to assign to a variable. */
140 static int next_tsv_number = 1;
142 /* Number of last traceframe collected. */
143 static int traceframe_number;
145 /* Tracepoint for last traceframe collected. */
146 static int tracepoint_number;
148 /* Symbol for function for last traceframe collected. */
149 static struct symbol *traceframe_fun;
151 /* Symtab and line for last traceframe collected. */
152 static struct symtab_and_line traceframe_sal;
154 /* The traceframe info of the current traceframe. NULL if we haven't
155 yet attempted to fetch it, or if the target does not support
156 fetching this object, or if we're not inspecting a traceframe
158 static struct traceframe_info *traceframe_info;
160 /* Tracing command lists. */
161 static struct cmd_list_element *tfindlist;
163 /* List of expressions to collect by default at each tracepoint hit. */
164 char *default_collect = "";
166 static int disconnected_tracing;
168 /* This variable controls whether we ask the target for a linear or
169 circular trace buffer. */
171 static int circular_trace_buffer;
173 /* This variable is the requested trace buffer size, or -1 to indicate
174 that we don't care and leave it up to the target to set a size. */
176 static int trace_buffer_size = -1;
178 /* Textual notes applying to the current and/or future trace runs. */
180 char *trace_user = NULL;
182 /* Textual notes applying to the current and/or future trace runs. */
184 char *trace_notes = NULL;
186 /* Textual notes applying to the stopping of a trace. */
188 char *trace_stop_notes = NULL;
190 /* ======= Important command functions: ======= */
191 static void trace_actions_command (char *, int);
192 static void trace_start_command (char *, int);
193 static void trace_stop_command (char *, int);
194 static void trace_status_command (char *, int);
195 static void trace_find_command (char *, int);
196 static void trace_find_pc_command (char *, int);
197 static void trace_find_tracepoint_command (char *, int);
198 static void trace_find_line_command (char *, int);
199 static void trace_find_range_command (char *, int);
200 static void trace_find_outside_command (char *, int);
201 static void trace_dump_command (char *, int);
203 /* support routines */
205 struct collection_list;
206 static void add_aexpr (struct collection_list *, struct agent_expr *);
207 static char *mem2hex (gdb_byte *, char *, int);
208 static void add_register (struct collection_list *collection,
211 static void free_uploaded_tps (struct uploaded_tp **utpp);
212 static void free_uploaded_tsvs (struct uploaded_tsv **utsvp);
215 extern void _initialize_tracepoint (void);
217 static struct trace_status trace_status;
219 char *stop_reason_names[] = {
229 struct trace_status *
230 current_trace_status (void)
232 return &trace_status;
238 free_traceframe_info (struct traceframe_info *info)
242 VEC_free (mem_range_s, info->memory);
248 /* Free and clear the traceframe info cache of the current
252 clear_traceframe_info (void)
254 free_traceframe_info (traceframe_info);
255 traceframe_info = NULL;
258 /* Set traceframe number to NUM. */
260 set_traceframe_num (int num)
262 traceframe_number = num;
263 set_internalvar_integer (lookup_internalvar ("trace_frame"), num);
266 /* Set tracepoint number to NUM. */
268 set_tracepoint_num (int num)
270 tracepoint_number = num;
271 set_internalvar_integer (lookup_internalvar ("tracepoint"), num);
274 /* Set externally visible debug variables for querying/printing
275 the traceframe context (line, function, file). */
278 set_traceframe_context (struct frame_info *trace_frame)
282 /* Save as globals for internal use. */
283 if (trace_frame != NULL
284 && get_frame_pc_if_available (trace_frame, &trace_pc))
286 traceframe_sal = find_pc_line (trace_pc, 0);
287 traceframe_fun = find_pc_function (trace_pc);
289 /* Save linenumber as "$trace_line", a debugger variable visible to
291 set_internalvar_integer (lookup_internalvar ("trace_line"),
292 traceframe_sal.line);
296 init_sal (&traceframe_sal);
297 traceframe_fun = NULL;
298 set_internalvar_integer (lookup_internalvar ("trace_line"), -1);
301 /* Save func name as "$trace_func", a debugger variable visible to
303 if (traceframe_fun == NULL
304 || SYMBOL_LINKAGE_NAME (traceframe_fun) == NULL)
305 clear_internalvar (lookup_internalvar ("trace_func"));
307 set_internalvar_string (lookup_internalvar ("trace_func"),
308 SYMBOL_LINKAGE_NAME (traceframe_fun));
310 /* Save file name as "$trace_file", a debugger variable visible to
312 if (traceframe_sal.symtab == NULL)
313 clear_internalvar (lookup_internalvar ("trace_file"));
315 set_internalvar_string (lookup_internalvar ("trace_file"),
316 symtab_to_filename_for_display (traceframe_sal.symtab));
319 /* Create a new trace state variable with the given name. */
321 struct trace_state_variable *
322 create_trace_state_variable (const char *name)
324 struct trace_state_variable tsv;
326 memset (&tsv, 0, sizeof (tsv));
327 tsv.name = xstrdup (name);
328 tsv.number = next_tsv_number++;
329 return VEC_safe_push (tsv_s, tvariables, &tsv);
332 /* Look for a trace state variable of the given name. */
334 struct trace_state_variable *
335 find_trace_state_variable (const char *name)
337 struct trace_state_variable *tsv;
340 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
341 if (strcmp (name, tsv->name) == 0)
348 delete_trace_state_variable (const char *name)
350 struct trace_state_variable *tsv;
353 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
354 if (strcmp (name, tsv->name) == 0)
356 observer_notify_tsv_deleted (tsv);
358 xfree ((void *)tsv->name);
359 VEC_unordered_remove (tsv_s, tvariables, ix);
364 warning (_("No trace variable named \"$%s\", not deleting"), name);
367 /* Throws an error if NAME is not valid syntax for a trace state
371 validate_trace_state_variable_name (const char *name)
376 error (_("Must supply a non-empty variable name"));
378 /* All digits in the name is reserved for value history
380 for (p = name; isdigit (*p); p++)
383 error (_("$%s is not a valid trace state variable name"), name);
385 for (p = name; isalnum (*p) || *p == '_'; p++)
388 error (_("$%s is not a valid trace state variable name"), name);
391 /* The 'tvariable' command collects a name and optional expression to
392 evaluate into an initial value. */
395 trace_variable_command (char *args, int from_tty)
397 struct cleanup *old_chain;
399 struct trace_state_variable *tsv;
403 error_no_arg (_("Syntax is $NAME [ = EXPR ]"));
405 /* Only allow two syntaxes; "$name" and "$name=value". */
406 p = skip_spaces (args);
409 error (_("Name of trace variable should start with '$'"));
412 while (isalnum (*p) || *p == '_')
414 name = savestring (name, p - name);
415 old_chain = make_cleanup (xfree, name);
418 if (*p != '=' && *p != '\0')
419 error (_("Syntax must be $NAME [ = EXPR ]"));
421 validate_trace_state_variable_name (name);
424 initval = value_as_long (parse_and_eval (++p));
426 /* If the variable already exists, just change its initial value. */
427 tsv = find_trace_state_variable (name);
430 if (tsv->initial_value != initval)
432 tsv->initial_value = initval;
433 observer_notify_tsv_modified (tsv);
435 printf_filtered (_("Trace state variable $%s "
436 "now has initial value %s.\n"),
437 tsv->name, plongest (tsv->initial_value));
438 do_cleanups (old_chain);
442 /* Create a new variable. */
443 tsv = create_trace_state_variable (name);
444 tsv->initial_value = initval;
446 observer_notify_tsv_created (tsv);
448 printf_filtered (_("Trace state variable $%s "
449 "created, with initial value %s.\n"),
450 tsv->name, plongest (tsv->initial_value));
452 do_cleanups (old_chain);
456 delete_trace_variable_command (char *args, int from_tty)
460 struct cleanup *back_to;
464 if (query (_("Delete all trace state variables? ")))
465 VEC_free (tsv_s, tvariables);
467 observer_notify_tsv_deleted (NULL);
471 argv = gdb_buildargv (args);
472 back_to = make_cleanup_freeargv (argv);
474 for (ix = 0; argv[ix] != NULL; ix++)
476 if (*argv[ix] == '$')
477 delete_trace_state_variable (argv[ix] + 1);
479 warning (_("Name \"%s\" not prefixed with '$', ignoring"), argv[ix]);
482 do_cleanups (back_to);
488 tvariables_info_1 (void)
490 struct trace_state_variable *tsv;
493 struct cleanup *back_to;
494 struct ui_out *uiout = current_uiout;
496 if (VEC_length (tsv_s, tvariables) == 0 && !ui_out_is_mi_like_p (uiout))
498 printf_filtered (_("No trace state variables.\n"));
502 /* Try to acquire values from the target. */
503 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix, ++count)
504 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
507 back_to = make_cleanup_ui_out_table_begin_end (uiout, 3,
508 count, "trace-variables");
509 ui_out_table_header (uiout, 15, ui_left, "name", "Name");
510 ui_out_table_header (uiout, 11, ui_left, "initial", "Initial");
511 ui_out_table_header (uiout, 11, ui_left, "current", "Current");
513 ui_out_table_body (uiout);
515 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
517 struct cleanup *back_to2;
521 back_to2 = make_cleanup_ui_out_tuple_begin_end (uiout, "variable");
523 name = concat ("$", tsv->name, (char *) NULL);
524 make_cleanup (xfree, name);
525 ui_out_field_string (uiout, "name", name);
526 ui_out_field_string (uiout, "initial", plongest (tsv->initial_value));
528 if (tsv->value_known)
529 c = plongest (tsv->value);
530 else if (ui_out_is_mi_like_p (uiout))
531 /* For MI, we prefer not to use magic string constants, but rather
532 omit the field completely. The difference between unknown and
533 undefined does not seem important enough to represent. */
535 else if (current_trace_status ()->running || traceframe_number >= 0)
536 /* The value is/was defined, but we don't have it. */
539 /* It is not meaningful to ask about the value. */
542 ui_out_field_string (uiout, "current", c);
543 ui_out_text (uiout, "\n");
545 do_cleanups (back_to2);
548 do_cleanups (back_to);
551 /* List all the trace state variables. */
554 tvariables_info (char *args, int from_tty)
556 tvariables_info_1 ();
559 /* Stash definitions of tsvs into the given file. */
562 save_trace_state_variables (struct ui_file *fp)
564 struct trace_state_variable *tsv;
567 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
569 fprintf_unfiltered (fp, "tvariable $%s", tsv->name);
570 if (tsv->initial_value)
571 fprintf_unfiltered (fp, " = %s", plongest (tsv->initial_value));
572 fprintf_unfiltered (fp, "\n");
576 /* ACTIONS functions: */
578 /* The three functions:
579 collect_pseudocommand,
580 while_stepping_pseudocommand, and
581 end_actions_pseudocommand
582 are placeholders for "commands" that are actually ONLY to be used
583 within a tracepoint action list. If the actual function is ever called,
584 it means that somebody issued the "command" at the top level,
585 which is always an error. */
588 end_actions_pseudocommand (char *args, int from_tty)
590 error (_("This command cannot be used at the top level."));
594 while_stepping_pseudocommand (char *args, int from_tty)
596 error (_("This command can only be used in a tracepoint actions list."));
600 collect_pseudocommand (char *args, int from_tty)
602 error (_("This command can only be used in a tracepoint actions list."));
606 teval_pseudocommand (char *args, int from_tty)
608 error (_("This command can only be used in a tracepoint actions list."));
611 /* Parse any collection options, such as /s for strings. */
614 decode_agent_options (const char *exp)
616 struct value_print_options opts;
621 /* Call this to borrow the print elements default for collection
623 get_user_print_options (&opts);
628 if (target_supports_string_tracing ())
630 /* Allow an optional decimal number giving an explicit maximum
631 string length, defaulting it to the "print elements" value;
632 so "collect/s80 mystr" gets at most 80 bytes of string. */
633 trace_string_kludge = opts.print_max;
635 if (*exp >= '0' && *exp <= '9')
636 trace_string_kludge = atoi (exp);
637 while (*exp >= '0' && *exp <= '9')
641 error (_("Target does not support \"/s\" option for string tracing."));
644 error (_("Undefined collection format \"%c\"."), *exp);
646 exp = skip_spaces_const (exp);
651 /* Enter a list of actions for a tracepoint. */
653 trace_actions_command (char *args, int from_tty)
655 struct tracepoint *t;
656 struct command_line *l;
658 t = get_tracepoint_by_number (&args, NULL, 1);
662 xstrprintf ("Enter actions for tracepoint %d, one per line.",
664 struct cleanup *cleanups = make_cleanup (xfree, tmpbuf);
666 l = read_command_lines (tmpbuf, from_tty, 1,
667 check_tracepoint_command, t);
668 do_cleanups (cleanups);
669 breakpoint_set_commands (&t->base, l);
671 /* else just return */
674 /* Report the results of checking the agent expression, as errors or
678 report_agent_reqs_errors (struct agent_expr *aexpr)
680 /* All of the "flaws" are serious bytecode generation issues that
681 should never occur. */
682 if (aexpr->flaw != agent_flaw_none)
683 internal_error (__FILE__, __LINE__, _("expression is malformed"));
685 /* If analysis shows a stack underflow, GDB must have done something
686 badly wrong in its bytecode generation. */
687 if (aexpr->min_height < 0)
688 internal_error (__FILE__, __LINE__,
689 _("expression has min height < 0"));
691 /* Issue this error if the stack is predicted to get too deep. The
692 limit is rather arbitrary; a better scheme might be for the
693 target to report how much stack it will have available. The
694 depth roughly corresponds to parenthesization, so a limit of 20
695 amounts to 20 levels of expression nesting, which is actually
696 a pretty big hairy expression. */
697 if (aexpr->max_height > 20)
698 error (_("Expression is too complicated."));
701 /* worker function */
703 validate_actionline (const char *line, struct breakpoint *b)
705 struct cmd_list_element *c;
706 struct expression *exp = NULL;
707 struct cleanup *old_chain = NULL;
710 struct bp_location *loc;
711 struct agent_expr *aexpr;
712 struct tracepoint *t = (struct tracepoint *) b;
714 /* If EOF is typed, *line is NULL. */
718 p = skip_spaces_const (line);
720 /* Symbol lookup etc. */
721 if (*p == '\0') /* empty line: just prompt for another line. */
724 if (*p == '#') /* comment line */
727 c = lookup_cmd (&p, cmdlist, "", -1, 1);
729 error (_("`%s' is not a tracepoint action, or is ambiguous."), p);
731 if (cmd_cfunc_eq (c, collect_pseudocommand))
733 trace_string_kludge = 0;
735 p = decode_agent_options (p);
738 { /* Repeat over a comma-separated list. */
739 QUIT; /* Allow user to bail out with ^C. */
740 p = skip_spaces_const (p);
742 if (*p == '$') /* Look for special pseudo-symbols. */
744 if (0 == strncasecmp ("reg", p + 1, 3)
745 || 0 == strncasecmp ("arg", p + 1, 3)
746 || 0 == strncasecmp ("loc", p + 1, 3)
747 || 0 == strncasecmp ("_ret", p + 1, 4)
748 || 0 == strncasecmp ("_sdata", p + 1, 6))
753 /* else fall thru, treat p as an expression and parse it! */
756 for (loc = t->base.loc; loc; loc = loc->next)
759 exp = parse_exp_1 (&p, loc->address,
760 block_for_pc (loc->address), 1);
761 old_chain = make_cleanup (free_current_contents, &exp);
763 if (exp->elts[0].opcode == OP_VAR_VALUE)
765 if (SYMBOL_CLASS (exp->elts[2].symbol) == LOC_CONST)
767 error (_("constant `%s' (value %s) "
768 "will not be collected."),
769 SYMBOL_PRINT_NAME (exp->elts[2].symbol),
770 plongest (SYMBOL_VALUE (exp->elts[2].symbol)));
772 else if (SYMBOL_CLASS (exp->elts[2].symbol)
773 == LOC_OPTIMIZED_OUT)
775 error (_("`%s' is optimized away "
776 "and cannot be collected."),
777 SYMBOL_PRINT_NAME (exp->elts[2].symbol));
781 /* We have something to collect, make sure that the expr to
782 bytecode translator can handle it and that it's not too
784 aexpr = gen_trace_for_expr (loc->address, exp);
785 make_cleanup_free_agent_expr (aexpr);
787 if (aexpr->len > MAX_AGENT_EXPR_LEN)
788 error (_("Expression is too complicated."));
792 report_agent_reqs_errors (aexpr);
794 do_cleanups (old_chain);
797 while (p && *p++ == ',');
800 else if (cmd_cfunc_eq (c, teval_pseudocommand))
803 { /* Repeat over a comma-separated list. */
804 QUIT; /* Allow user to bail out with ^C. */
805 p = skip_spaces_const (p);
808 for (loc = t->base.loc; loc; loc = loc->next)
812 /* Only expressions are allowed for this action. */
813 exp = parse_exp_1 (&p, loc->address,
814 block_for_pc (loc->address), 1);
815 old_chain = make_cleanup (free_current_contents, &exp);
817 /* We have something to evaluate, make sure that the expr to
818 bytecode translator can handle it and that it's not too
820 aexpr = gen_eval_for_expr (loc->address, exp);
821 make_cleanup_free_agent_expr (aexpr);
823 if (aexpr->len > MAX_AGENT_EXPR_LEN)
824 error (_("Expression is too complicated."));
827 report_agent_reqs_errors (aexpr);
829 do_cleanups (old_chain);
832 while (p && *p++ == ',');
835 else if (cmd_cfunc_eq (c, while_stepping_pseudocommand))
839 p = skip_spaces_const (p);
840 t->step_count = strtol (p, &endp, 0);
841 if (endp == p || t->step_count == 0)
842 error (_("while-stepping step count `%s' is malformed."), line);
846 else if (cmd_cfunc_eq (c, end_actions_pseudocommand))
850 error (_("`%s' is not a supported tracepoint action."), line);
854 memrange_absolute = -1
859 int type; /* memrange_absolute for absolute memory range,
860 else basereg number. */
861 bfd_signed_vma start;
865 struct collection_list
867 unsigned char regs_mask[32]; /* room for up to 256 regs */
870 struct memrange *list;
871 long aexpr_listsize; /* size of array pointed to by expr_list elt */
873 struct agent_expr **aexpr_list;
875 /* True is the user requested a collection of "$_sdata", "static
879 tracepoint_list, stepping_list;
881 /* MEMRANGE functions: */
883 static int memrange_cmp (const void *, const void *);
885 /* Compare memranges for qsort. */
887 memrange_cmp (const void *va, const void *vb)
889 const struct memrange *a = va, *b = vb;
891 if (a->type < b->type)
893 if (a->type > b->type)
895 if (a->type == memrange_absolute)
897 if ((bfd_vma) a->start < (bfd_vma) b->start)
899 if ((bfd_vma) a->start > (bfd_vma) b->start)
904 if (a->start < b->start)
906 if (a->start > b->start)
912 /* Sort the memrange list using qsort, and merge adjacent memranges. */
914 memrange_sortmerge (struct collection_list *memranges)
918 qsort (memranges->list, memranges->next_memrange,
919 sizeof (struct memrange), memrange_cmp);
920 if (memranges->next_memrange > 0)
922 for (a = 0, b = 1; b < memranges->next_memrange; b++)
924 /* If memrange b overlaps or is adjacent to memrange a,
926 if (memranges->list[a].type == memranges->list[b].type
927 && memranges->list[b].start <= memranges->list[a].end)
929 if (memranges->list[b].end > memranges->list[a].end)
930 memranges->list[a].end = memranges->list[b].end;
931 continue; /* next b, same a */
935 memcpy (&memranges->list[a], &memranges->list[b],
936 sizeof (struct memrange));
938 memranges->next_memrange = a + 1;
942 /* Add a register to a collection list. */
944 add_register (struct collection_list *collection, unsigned int regno)
947 printf_filtered ("collect register %d\n", regno);
948 if (regno >= (8 * sizeof (collection->regs_mask)))
949 error (_("Internal: register number %d too large for tracepoint"),
951 collection->regs_mask[regno / 8] |= 1 << (regno % 8);
954 /* Add a memrange to a collection list. */
956 add_memrange (struct collection_list *memranges,
957 int type, bfd_signed_vma base,
962 printf_filtered ("(%d,", type);
964 printf_filtered (",%ld)\n", len);
967 /* type: memrange_absolute == memory, other n == basereg */
968 memranges->list[memranges->next_memrange].type = type;
969 /* base: addr if memory, offset if reg relative. */
970 memranges->list[memranges->next_memrange].start = base;
971 /* len: we actually save end (base + len) for convenience */
972 memranges->list[memranges->next_memrange].end = base + len;
973 memranges->next_memrange++;
974 if (memranges->next_memrange >= memranges->listsize)
976 memranges->listsize *= 2;
977 memranges->list = xrealloc (memranges->list,
978 memranges->listsize);
981 if (type != memrange_absolute) /* Better collect the base register! */
982 add_register (memranges, type);
985 /* Add a symbol to a collection list. */
987 collect_symbol (struct collection_list *collect,
989 struct gdbarch *gdbarch,
990 long frame_regno, long frame_offset,
995 bfd_signed_vma offset;
996 int treat_as_expr = 0;
998 len = TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym)));
999 switch (SYMBOL_CLASS (sym))
1002 printf_filtered ("%s: don't know symbol class %d\n",
1003 SYMBOL_PRINT_NAME (sym),
1004 SYMBOL_CLASS (sym));
1007 printf_filtered ("constant %s (value %s) will not be collected.\n",
1008 SYMBOL_PRINT_NAME (sym), plongest (SYMBOL_VALUE (sym)));
1011 offset = SYMBOL_VALUE_ADDRESS (sym);
1016 sprintf_vma (tmp, offset);
1017 printf_filtered ("LOC_STATIC %s: collect %ld bytes at %s.\n",
1018 SYMBOL_PRINT_NAME (sym), len,
1021 /* A struct may be a C++ class with static fields, go to general
1022 expression handling. */
1023 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT)
1026 add_memrange (collect, memrange_absolute, offset, len);
1029 reg = SYMBOL_REGISTER_OPS (sym)->register_number (sym, gdbarch);
1031 printf_filtered ("LOC_REG[parm] %s: ",
1032 SYMBOL_PRINT_NAME (sym));
1033 add_register (collect, reg);
1034 /* Check for doubles stored in two registers. */
1035 /* FIXME: how about larger types stored in 3 or more regs? */
1036 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FLT &&
1037 len > register_size (gdbarch, reg))
1038 add_register (collect, reg + 1);
1041 printf_filtered ("Sorry, don't know how to do LOC_REF_ARG yet.\n");
1042 printf_filtered (" (will not collect %s)\n",
1043 SYMBOL_PRINT_NAME (sym));
1047 offset = frame_offset + SYMBOL_VALUE (sym);
1050 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1051 SYMBOL_PRINT_NAME (sym), len);
1052 printf_vma (offset);
1053 printf_filtered (" from frame ptr reg %d\n", reg);
1055 add_memrange (collect, reg, offset, len);
1057 case LOC_REGPARM_ADDR:
1058 reg = SYMBOL_VALUE (sym);
1062 printf_filtered ("LOC_REGPARM_ADDR %s: Collect %ld bytes at offset ",
1063 SYMBOL_PRINT_NAME (sym), len);
1064 printf_vma (offset);
1065 printf_filtered (" from reg %d\n", reg);
1067 add_memrange (collect, reg, offset, len);
1071 offset = frame_offset + SYMBOL_VALUE (sym);
1074 printf_filtered ("LOC_LOCAL %s: Collect %ld bytes at offset ",
1075 SYMBOL_PRINT_NAME (sym), len);
1076 printf_vma (offset);
1077 printf_filtered (" from frame ptr reg %d\n", reg);
1079 add_memrange (collect, reg, offset, len);
1082 case LOC_UNRESOLVED:
1086 case LOC_OPTIMIZED_OUT:
1087 printf_filtered ("%s has been optimized out of existence.\n",
1088 SYMBOL_PRINT_NAME (sym));
1096 /* Expressions are the most general case. */
1099 struct agent_expr *aexpr;
1100 struct cleanup *old_chain1 = NULL;
1102 aexpr = gen_trace_for_var (scope, gdbarch, sym);
1104 /* It can happen that the symbol is recorded as a computed
1105 location, but it's been optimized away and doesn't actually
1106 have a location expression. */
1109 printf_filtered ("%s has been optimized out of existence.\n",
1110 SYMBOL_PRINT_NAME (sym));
1114 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1118 report_agent_reqs_errors (aexpr);
1120 discard_cleanups (old_chain1);
1121 add_aexpr (collect, aexpr);
1123 /* Take care of the registers. */
1124 if (aexpr->reg_mask_len > 0)
1128 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1130 QUIT; /* Allow user to bail out with ^C. */
1131 if (aexpr->reg_mask[ndx1] != 0)
1133 /* Assume chars have 8 bits. */
1134 for (ndx2 = 0; ndx2 < 8; ndx2++)
1135 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1136 /* It's used -- record it. */
1137 add_register (collect, ndx1 * 8 + ndx2);
1144 /* Data to be passed around in the calls to the locals and args
1147 struct add_local_symbols_data
1149 struct collection_list *collect;
1150 struct gdbarch *gdbarch;
1157 /* The callback for the locals and args iterators. */
1160 do_collect_symbol (const char *print_name,
1164 struct add_local_symbols_data *p = cb_data;
1166 collect_symbol (p->collect, sym, p->gdbarch, p->frame_regno,
1167 p->frame_offset, p->pc);
1171 /* Add all locals (or args) symbols to collection list. */
1173 add_local_symbols (struct collection_list *collect,
1174 struct gdbarch *gdbarch, CORE_ADDR pc,
1175 long frame_regno, long frame_offset, int type)
1177 struct block *block;
1178 struct add_local_symbols_data cb_data;
1180 cb_data.collect = collect;
1181 cb_data.gdbarch = gdbarch;
1183 cb_data.frame_regno = frame_regno;
1184 cb_data.frame_offset = frame_offset;
1189 block = block_for_pc (pc);
1192 warning (_("Can't collect locals; "
1193 "no symbol table info available.\n"));
1197 iterate_over_block_local_vars (block, do_collect_symbol, &cb_data);
1198 if (cb_data.count == 0)
1199 warning (_("No locals found in scope."));
1203 pc = get_pc_function_start (pc);
1204 block = block_for_pc (pc);
1207 warning (_("Can't collect args; no symbol table info available."));
1211 iterate_over_block_arg_vars (block, do_collect_symbol, &cb_data);
1212 if (cb_data.count == 0)
1213 warning (_("No args found in scope."));
1218 add_static_trace_data (struct collection_list *collection)
1221 printf_filtered ("collect static trace data\n");
1222 collection->strace_data = 1;
1225 /* worker function */
1227 clear_collection_list (struct collection_list *list)
1231 list->next_memrange = 0;
1232 for (ndx = 0; ndx < list->next_aexpr_elt; ndx++)
1234 free_agent_expr (list->aexpr_list[ndx]);
1235 list->aexpr_list[ndx] = NULL;
1237 list->next_aexpr_elt = 0;
1238 memset (list->regs_mask, 0, sizeof (list->regs_mask));
1239 list->strace_data = 0;
1242 /* Reduce a collection list to string form (for gdb protocol). */
1244 stringify_collection_list (struct collection_list *list, char *string)
1246 char temp_buf[2048];
1250 char *(*str_list)[];
1254 count = 1 + 1 + list->next_memrange + list->next_aexpr_elt + 1;
1255 str_list = (char *(*)[]) xmalloc (count * sizeof (char *));
1257 if (list->strace_data)
1260 printf_filtered ("\nCollecting static trace data\n");
1263 (*str_list)[ndx] = savestring (temp_buf, end - temp_buf);
1267 for (i = sizeof (list->regs_mask) - 1; i > 0; i--)
1268 if (list->regs_mask[i] != 0) /* Skip leading zeroes in regs_mask. */
1270 if (list->regs_mask[i] != 0) /* Prepare to send regs_mask to the stub. */
1273 printf_filtered ("\nCollecting registers (mask): 0x");
1278 QUIT; /* Allow user to bail out with ^C. */
1280 printf_filtered ("%02X", list->regs_mask[i]);
1281 sprintf (end, "%02X", list->regs_mask[i]);
1284 (*str_list)[ndx] = xstrdup (temp_buf);
1288 printf_filtered ("\n");
1289 if (list->next_memrange > 0 && info_verbose)
1290 printf_filtered ("Collecting memranges: \n");
1291 for (i = 0, count = 0, end = temp_buf; i < list->next_memrange; i++)
1293 QUIT; /* Allow user to bail out with ^C. */
1294 sprintf_vma (tmp2, list->list[i].start);
1297 printf_filtered ("(%d, %s, %ld)\n",
1300 (long) (list->list[i].end - list->list[i].start));
1302 if (count + 27 > MAX_AGENT_EXPR_LEN)
1304 (*str_list)[ndx] = savestring (temp_buf, count);
1311 bfd_signed_vma length = list->list[i].end - list->list[i].start;
1313 /* The "%X" conversion specifier expects an unsigned argument,
1314 so passing -1 (memrange_absolute) to it directly gives you
1315 "FFFFFFFF" (or more, depending on sizeof (unsigned)).
1317 if (list->list[i].type == memrange_absolute)
1318 sprintf (end, "M-1,%s,%lX", tmp2, (long) length);
1320 sprintf (end, "M%X,%s,%lX", list->list[i].type, tmp2, (long) length);
1323 count += strlen (end);
1324 end = temp_buf + count;
1327 for (i = 0; i < list->next_aexpr_elt; i++)
1329 QUIT; /* Allow user to bail out with ^C. */
1330 if ((count + 10 + 2 * list->aexpr_list[i]->len) > MAX_AGENT_EXPR_LEN)
1332 (*str_list)[ndx] = savestring (temp_buf, count);
1337 sprintf (end, "X%08X,", list->aexpr_list[i]->len);
1338 end += 10; /* 'X' + 8 hex digits + ',' */
1341 end = mem2hex (list->aexpr_list[i]->buf,
1342 end, list->aexpr_list[i]->len);
1343 count += 2 * list->aexpr_list[i]->len;
1348 (*str_list)[ndx] = savestring (temp_buf, count);
1353 (*str_list)[ndx] = NULL;
1366 encode_actions_1 (struct command_line *action,
1367 struct breakpoint *t,
1368 struct bp_location *tloc,
1370 LONGEST frame_offset,
1371 struct collection_list *collect,
1372 struct collection_list *stepping_list)
1374 const char *action_exp;
1375 struct expression *exp = NULL;
1377 struct value *tempval;
1378 struct cmd_list_element *cmd;
1379 struct agent_expr *aexpr;
1381 for (; action; action = action->next)
1383 QUIT; /* Allow user to bail out with ^C. */
1384 action_exp = action->line;
1385 action_exp = skip_spaces_const (action_exp);
1387 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
1389 error (_("Bad action list item: %s"), action_exp);
1391 if (cmd_cfunc_eq (cmd, collect_pseudocommand))
1393 trace_string_kludge = 0;
1394 if (*action_exp == '/')
1395 action_exp = decode_agent_options (action_exp);
1398 { /* Repeat over a comma-separated list. */
1399 QUIT; /* Allow user to bail out with ^C. */
1400 action_exp = skip_spaces_const (action_exp);
1402 if (0 == strncasecmp ("$reg", action_exp, 4))
1404 for (i = 0; i < gdbarch_num_regs (tloc->gdbarch); i++)
1405 add_register (collect, i);
1406 action_exp = strchr (action_exp, ','); /* more? */
1408 else if (0 == strncasecmp ("$arg", action_exp, 4))
1410 add_local_symbols (collect,
1416 action_exp = strchr (action_exp, ','); /* more? */
1418 else if (0 == strncasecmp ("$loc", action_exp, 4))
1420 add_local_symbols (collect,
1426 action_exp = strchr (action_exp, ','); /* more? */
1428 else if (0 == strncasecmp ("$_ret", action_exp, 5))
1430 struct cleanup *old_chain1 = NULL;
1432 aexpr = gen_trace_for_return_address (tloc->address,
1435 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1438 report_agent_reqs_errors (aexpr);
1440 discard_cleanups (old_chain1);
1441 add_aexpr (collect, aexpr);
1443 /* take care of the registers */
1444 if (aexpr->reg_mask_len > 0)
1448 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1450 QUIT; /* allow user to bail out with ^C */
1451 if (aexpr->reg_mask[ndx1] != 0)
1453 /* assume chars have 8 bits */
1454 for (ndx2 = 0; ndx2 < 8; ndx2++)
1455 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1456 /* it's used -- record it */
1457 add_register (collect,
1463 action_exp = strchr (action_exp, ','); /* more? */
1465 else if (0 == strncasecmp ("$_sdata", action_exp, 7))
1467 add_static_trace_data (collect);
1468 action_exp = strchr (action_exp, ','); /* more? */
1473 struct cleanup *old_chain = NULL;
1474 struct cleanup *old_chain1 = NULL;
1476 exp = parse_exp_1 (&action_exp, tloc->address,
1477 block_for_pc (tloc->address), 1);
1478 old_chain = make_cleanup (free_current_contents, &exp);
1480 switch (exp->elts[0].opcode)
1484 const char *name = &exp->elts[2].string;
1486 i = user_reg_map_name_to_regnum (tloc->gdbarch,
1487 name, strlen (name));
1489 internal_error (__FILE__, __LINE__,
1490 _("Register $%s not available"),
1493 printf_filtered ("OP_REGISTER: ");
1494 add_register (collect, i);
1499 /* Safe because we know it's a simple expression. */
1500 tempval = evaluate_expression (exp);
1501 addr = value_address (tempval);
1502 /* Initialize the TYPE_LENGTH if it is a typedef. */
1503 check_typedef (exp->elts[1].type);
1504 add_memrange (collect, memrange_absolute, addr,
1505 TYPE_LENGTH (exp->elts[1].type));
1509 collect_symbol (collect,
1510 exp->elts[2].symbol,
1517 default: /* Full-fledged expression. */
1518 aexpr = gen_trace_for_expr (tloc->address, exp);
1520 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1524 report_agent_reqs_errors (aexpr);
1526 discard_cleanups (old_chain1);
1527 add_aexpr (collect, aexpr);
1529 /* Take care of the registers. */
1530 if (aexpr->reg_mask_len > 0)
1535 for (ndx1 = 0; ndx1 < aexpr->reg_mask_len; ndx1++)
1537 QUIT; /* Allow user to bail out with ^C. */
1538 if (aexpr->reg_mask[ndx1] != 0)
1540 /* Assume chars have 8 bits. */
1541 for (ndx2 = 0; ndx2 < 8; ndx2++)
1542 if (aexpr->reg_mask[ndx1] & (1 << ndx2))
1543 /* It's used -- record it. */
1544 add_register (collect,
1551 do_cleanups (old_chain);
1554 while (action_exp && *action_exp++ == ',');
1556 else if (cmd_cfunc_eq (cmd, teval_pseudocommand))
1559 { /* Repeat over a comma-separated list. */
1560 QUIT; /* Allow user to bail out with ^C. */
1561 action_exp = skip_spaces_const (action_exp);
1564 struct cleanup *old_chain = NULL;
1565 struct cleanup *old_chain1 = NULL;
1567 exp = parse_exp_1 (&action_exp, tloc->address,
1568 block_for_pc (tloc->address), 1);
1569 old_chain = make_cleanup (free_current_contents, &exp);
1571 aexpr = gen_eval_for_expr (tloc->address, exp);
1572 old_chain1 = make_cleanup_free_agent_expr (aexpr);
1575 report_agent_reqs_errors (aexpr);
1577 discard_cleanups (old_chain1);
1578 /* Even though we're not officially collecting, add
1579 to the collect list anyway. */
1580 add_aexpr (collect, aexpr);
1582 do_cleanups (old_chain);
1585 while (action_exp && *action_exp++ == ',');
1587 else if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
1589 /* We check against nested while-stepping when setting
1590 breakpoint action, so no way to run into nested
1592 gdb_assert (stepping_list);
1594 encode_actions_1 (action->body_list[0], t, tloc, frame_reg,
1595 frame_offset, stepping_list, NULL);
1598 error (_("Invalid tracepoint command '%s'"), action->line);
1602 /* Render all actions into gdb protocol. */
1605 encode_actions (struct breakpoint *t, struct bp_location *tloc,
1606 char ***tdp_actions, char ***stepping_actions)
1608 static char tdp_buff[2048], step_buff[2048];
1609 char *default_collect_line = NULL;
1610 struct command_line *actions;
1611 struct command_line *default_collect_action = NULL;
1613 LONGEST frame_offset;
1614 struct cleanup *back_to;
1616 back_to = make_cleanup (null_cleanup, NULL);
1618 clear_collection_list (&tracepoint_list);
1619 clear_collection_list (&stepping_list);
1621 *tdp_actions = NULL;
1622 *stepping_actions = NULL;
1624 gdbarch_virtual_frame_pointer (tloc->gdbarch,
1625 tloc->address, &frame_reg, &frame_offset);
1627 actions = breakpoint_commands (t);
1629 /* If there are default expressions to collect, make up a collect
1630 action and prepend to the action list to encode. Note that since
1631 validation is per-tracepoint (local var "xyz" might be valid for
1632 one tracepoint and not another, etc), we make up the action on
1633 the fly, and don't cache it. */
1634 if (*default_collect)
1636 default_collect_line = xstrprintf ("collect %s", default_collect);
1637 make_cleanup (xfree, default_collect_line);
1639 validate_actionline (default_collect_line, t);
1641 default_collect_action = xmalloc (sizeof (struct command_line));
1642 make_cleanup (xfree, default_collect_action);
1643 default_collect_action->next = actions;
1644 default_collect_action->line = default_collect_line;
1645 actions = default_collect_action;
1647 encode_actions_1 (actions, t, tloc, frame_reg, frame_offset,
1648 &tracepoint_list, &stepping_list);
1650 memrange_sortmerge (&tracepoint_list);
1651 memrange_sortmerge (&stepping_list);
1653 *tdp_actions = stringify_collection_list (&tracepoint_list,
1655 *stepping_actions = stringify_collection_list (&stepping_list,
1658 do_cleanups (back_to);
1662 add_aexpr (struct collection_list *collect, struct agent_expr *aexpr)
1664 if (collect->next_aexpr_elt >= collect->aexpr_listsize)
1666 collect->aexpr_list =
1667 xrealloc (collect->aexpr_list,
1668 2 * collect->aexpr_listsize * sizeof (struct agent_expr *));
1669 collect->aexpr_listsize *= 2;
1671 collect->aexpr_list[collect->next_aexpr_elt] = aexpr;
1672 collect->next_aexpr_elt++;
1676 process_tracepoint_on_disconnect (void)
1678 VEC(breakpoint_p) *tp_vec = NULL;
1680 struct breakpoint *b;
1681 int has_pending_p = 0;
1683 /* Check whether we still have pending tracepoint. If we have, warn the
1684 user that pending tracepoint will no longer work. */
1685 tp_vec = all_tracepoints ();
1686 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1695 struct bp_location *loc1;
1697 for (loc1 = b->loc; loc1; loc1 = loc1->next)
1699 if (loc1->shlib_disabled)
1710 VEC_free (breakpoint_p, tp_vec);
1713 warning (_("Pending tracepoints will not be resolved while"
1714 " GDB is disconnected\n"));
1719 start_tracing (char *notes)
1721 VEC(breakpoint_p) *tp_vec = NULL;
1723 struct breakpoint *b;
1724 struct trace_state_variable *tsv;
1725 int any_enabled = 0, num_to_download = 0;
1728 tp_vec = all_tracepoints ();
1730 /* No point in tracing without any tracepoints... */
1731 if (VEC_length (breakpoint_p, tp_vec) == 0)
1733 VEC_free (breakpoint_p, tp_vec);
1734 error (_("No tracepoints defined, not starting trace"));
1737 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1739 struct tracepoint *t = (struct tracepoint *) b;
1740 struct bp_location *loc;
1742 if (b->enable_state == bp_enabled)
1745 if ((b->type == bp_fast_tracepoint
1746 ? may_insert_fast_tracepoints
1747 : may_insert_tracepoints))
1750 warning (_("May not insert %stracepoints, skipping tracepoint %d"),
1751 (b->type == bp_fast_tracepoint ? "fast " : ""), b->number);
1756 if (target_supports_enable_disable_tracepoint ())
1757 warning (_("No tracepoints enabled"));
1760 /* No point in tracing with only disabled tracepoints that
1761 cannot be re-enabled. */
1762 VEC_free (breakpoint_p, tp_vec);
1763 error (_("No tracepoints enabled, not starting trace"));
1767 if (num_to_download <= 0)
1769 VEC_free (breakpoint_p, tp_vec);
1770 error (_("No tracepoints that may be downloaded, not starting trace"));
1773 target_trace_init ();
1775 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
1777 struct tracepoint *t = (struct tracepoint *) b;
1778 struct bp_location *loc;
1779 int bp_location_downloaded = 0;
1781 /* Clear `inserted' flag. */
1782 for (loc = b->loc; loc; loc = loc->next)
1785 if ((b->type == bp_fast_tracepoint
1786 ? !may_insert_fast_tracepoints
1787 : !may_insert_tracepoints))
1790 t->number_on_target = 0;
1792 for (loc = b->loc; loc; loc = loc->next)
1794 /* Since tracepoint locations are never duplicated, `inserted'
1795 flag should be zero. */
1796 gdb_assert (!loc->inserted);
1798 target_download_tracepoint (loc);
1801 bp_location_downloaded = 1;
1804 t->number_on_target = b->number;
1806 for (loc = b->loc; loc; loc = loc->next)
1807 if (loc->probe != NULL)
1808 loc->probe->pops->set_semaphore (loc->probe, loc->gdbarch);
1810 if (bp_location_downloaded)
1811 observer_notify_breakpoint_modified (b);
1813 VEC_free (breakpoint_p, tp_vec);
1815 /* Send down all the trace state variables too. */
1816 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
1818 target_download_trace_state_variable (tsv);
1821 /* Tell target to treat text-like sections as transparent. */
1822 target_trace_set_readonly_regions ();
1823 /* Set some mode flags. */
1824 target_set_disconnected_tracing (disconnected_tracing);
1825 target_set_circular_trace_buffer (circular_trace_buffer);
1826 target_set_trace_buffer_size (trace_buffer_size);
1829 notes = trace_notes;
1830 ret = target_set_trace_notes (trace_user, notes, NULL);
1832 if (!ret && (trace_user || notes))
1833 warning (_("Target does not support trace user/notes, info ignored"));
1835 /* Now insert traps and begin collecting data. */
1836 target_trace_start ();
1838 /* Reset our local state. */
1839 set_traceframe_num (-1);
1840 set_tracepoint_num (-1);
1841 set_traceframe_context (NULL);
1842 current_trace_status()->running = 1;
1843 clear_traceframe_info ();
1846 /* The tstart command requests the target to start a new trace run.
1847 The command passes any arguments it has to the target verbatim, as
1848 an optional "trace note". This is useful as for instance a warning
1849 to other users if the trace runs disconnected, and you don't want
1850 anybody else messing with the target. */
1853 trace_start_command (char *args, int from_tty)
1855 dont_repeat (); /* Like "run", dangerous to repeat accidentally. */
1857 if (current_trace_status ()->running)
1860 && !query (_("A trace is running already. Start a new run? ")))
1861 error (_("New trace run not started."));
1864 start_tracing (args);
1867 /* The tstop command stops the tracing run. The command passes any
1868 supplied arguments to the target verbatim as a "stop note"; if the
1869 target supports trace notes, then it will be reported back as part
1870 of the trace run's status. */
1873 trace_stop_command (char *args, int from_tty)
1875 if (!current_trace_status ()->running)
1876 error (_("Trace is not running."));
1878 stop_tracing (args);
1882 stop_tracing (char *note)
1885 VEC(breakpoint_p) *tp_vec = NULL;
1887 struct breakpoint *t;
1889 target_trace_stop ();
1891 tp_vec = all_tracepoints ();
1892 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
1894 struct bp_location *loc;
1896 if ((t->type == bp_fast_tracepoint
1897 ? !may_insert_fast_tracepoints
1898 : !may_insert_tracepoints))
1901 for (loc = t->loc; loc; loc = loc->next)
1903 /* GDB can be totally absent in some disconnected trace scenarios,
1904 but we don't really care if this semaphore goes out of sync.
1905 That's why we are decrementing it here, but not taking care
1907 if (loc->probe != NULL)
1908 loc->probe->pops->clear_semaphore (loc->probe, loc->gdbarch);
1912 VEC_free (breakpoint_p, tp_vec);
1915 note = trace_stop_notes;
1916 ret = target_set_trace_notes (NULL, NULL, note);
1919 warning (_("Target does not support trace notes, note ignored"));
1921 /* Should change in response to reply? */
1922 current_trace_status ()->running = 0;
1925 /* tstatus command */
1927 trace_status_command (char *args, int from_tty)
1929 struct trace_status *ts = current_trace_status ();
1931 VEC(breakpoint_p) *tp_vec = NULL;
1932 struct breakpoint *t;
1934 status = target_get_trace_status (ts);
1938 if (ts->filename != NULL)
1939 printf_filtered (_("Using a trace file.\n"));
1942 printf_filtered (_("Trace can not be run on this target.\n"));
1947 if (!ts->running_known)
1949 printf_filtered (_("Run/stop status is unknown.\n"));
1951 else if (ts->running)
1953 printf_filtered (_("Trace is running on the target.\n"));
1957 switch (ts->stop_reason)
1959 case trace_never_run:
1960 printf_filtered (_("No trace has been run on the target.\n"));
1964 printf_filtered (_("Trace stopped by a tstop command (%s).\n"),
1967 printf_filtered (_("Trace stopped by a tstop command.\n"));
1969 case trace_buffer_full:
1970 printf_filtered (_("Trace stopped because the buffer was full.\n"));
1972 case trace_disconnected:
1973 printf_filtered (_("Trace stopped because of disconnection.\n"));
1975 case tracepoint_passcount:
1976 printf_filtered (_("Trace stopped by tracepoint %d.\n"),
1977 ts->stopping_tracepoint);
1979 case tracepoint_error:
1980 if (ts->stopping_tracepoint)
1981 printf_filtered (_("Trace stopped by an "
1982 "error (%s, tracepoint %d).\n"),
1983 ts->stop_desc, ts->stopping_tracepoint);
1985 printf_filtered (_("Trace stopped by an error (%s).\n"),
1988 case trace_stop_reason_unknown:
1989 printf_filtered (_("Trace stopped for an unknown reason.\n"));
1992 printf_filtered (_("Trace stopped for some other reason (%d).\n"),
1998 if (ts->traceframes_created >= 0
1999 && ts->traceframe_count != ts->traceframes_created)
2001 printf_filtered (_("Buffer contains %d trace "
2002 "frames (of %d created total).\n"),
2003 ts->traceframe_count, ts->traceframes_created);
2005 else if (ts->traceframe_count >= 0)
2007 printf_filtered (_("Collected %d trace frames.\n"),
2008 ts->traceframe_count);
2011 if (ts->buffer_free >= 0)
2013 if (ts->buffer_size >= 0)
2015 printf_filtered (_("Trace buffer has %d bytes of %d bytes free"),
2016 ts->buffer_free, ts->buffer_size);
2017 if (ts->buffer_size > 0)
2018 printf_filtered (_(" (%d%% full)"),
2019 ((int) ((((long long) (ts->buffer_size
2020 - ts->buffer_free)) * 100)
2021 / ts->buffer_size)));
2022 printf_filtered (_(".\n"));
2025 printf_filtered (_("Trace buffer has %d bytes free.\n"),
2029 if (ts->disconnected_tracing)
2030 printf_filtered (_("Trace will continue if GDB disconnects.\n"));
2032 printf_filtered (_("Trace will stop if GDB disconnects.\n"));
2034 if (ts->circular_buffer)
2035 printf_filtered (_("Trace buffer is circular.\n"));
2037 if (ts->user_name && strlen (ts->user_name) > 0)
2038 printf_filtered (_("Trace user is %s.\n"), ts->user_name);
2040 if (ts->notes && strlen (ts->notes) > 0)
2041 printf_filtered (_("Trace notes: %s.\n"), ts->notes);
2043 /* Now report on what we're doing with tfind. */
2044 if (traceframe_number >= 0)
2045 printf_filtered (_("Looking at trace frame %d, tracepoint %d.\n"),
2046 traceframe_number, tracepoint_number);
2048 printf_filtered (_("Not looking at any trace frame.\n"));
2050 /* Report start/stop times if supplied. */
2055 LONGEST run_time = ts->stop_time - ts->start_time;
2057 /* Reporting a run time is more readable than two long numbers. */
2058 printf_filtered (_("Trace started at %ld.%06ld secs, stopped %ld.%06ld secs later.\n"),
2059 (long int) ts->start_time / 1000000,
2060 (long int) ts->start_time % 1000000,
2061 (long int) run_time / 1000000,
2062 (long int) run_time % 1000000);
2065 printf_filtered (_("Trace started at %ld.%06ld secs.\n"),
2066 (long int) ts->start_time / 1000000,
2067 (long int) ts->start_time % 1000000);
2069 else if (ts->stop_time)
2070 printf_filtered (_("Trace stopped at %ld.%06ld secs.\n"),
2071 (long int) ts->stop_time / 1000000,
2072 (long int) ts->stop_time % 1000000);
2074 /* Now report any per-tracepoint status available. */
2075 tp_vec = all_tracepoints ();
2077 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, t); ix++)
2078 target_get_tracepoint_status (t, NULL);
2080 VEC_free (breakpoint_p, tp_vec);
2083 /* Report the trace status to uiout, in a way suitable for MI, and not
2084 suitable for CLI. If ON_STOP is true, suppress a few fields that
2085 are not meaningful in the -trace-stop response.
2087 The implementation is essentially parallel to trace_status_command, but
2088 merging them will result in unreadable code. */
2090 trace_status_mi (int on_stop)
2092 struct ui_out *uiout = current_uiout;
2093 struct trace_status *ts = current_trace_status ();
2096 status = target_get_trace_status (ts);
2098 if (status == -1 && ts->filename == NULL)
2100 ui_out_field_string (uiout, "supported", "0");
2104 if (ts->filename != NULL)
2105 ui_out_field_string (uiout, "supported", "file");
2107 ui_out_field_string (uiout, "supported", "1");
2109 if (ts->filename != NULL)
2110 ui_out_field_string (uiout, "trace-file", ts->filename);
2112 gdb_assert (ts->running_known);
2116 ui_out_field_string (uiout, "running", "1");
2118 /* Unlike CLI, do not show the state of 'disconnected-tracing' variable.
2119 Given that the frontend gets the status either on -trace-stop, or from
2120 -trace-status after re-connection, it does not seem like this
2121 information is necessary for anything. It is not necessary for either
2122 figuring the vital state of the target nor for navigation of trace
2123 frames. If the frontend wants to show the current state is some
2124 configure dialog, it can request the value when such dialog is
2125 invoked by the user. */
2129 char *stop_reason = NULL;
2130 int stopping_tracepoint = -1;
2133 ui_out_field_string (uiout, "running", "0");
2135 if (ts->stop_reason != trace_stop_reason_unknown)
2137 switch (ts->stop_reason)
2140 stop_reason = "request";
2142 case trace_buffer_full:
2143 stop_reason = "overflow";
2145 case trace_disconnected:
2146 stop_reason = "disconnection";
2148 case tracepoint_passcount:
2149 stop_reason = "passcount";
2150 stopping_tracepoint = ts->stopping_tracepoint;
2152 case tracepoint_error:
2153 stop_reason = "error";
2154 stopping_tracepoint = ts->stopping_tracepoint;
2160 ui_out_field_string (uiout, "stop-reason", stop_reason);
2161 if (stopping_tracepoint != -1)
2162 ui_out_field_int (uiout, "stopping-tracepoint",
2163 stopping_tracepoint);
2164 if (ts->stop_reason == tracepoint_error)
2165 ui_out_field_string (uiout, "error-description",
2171 if (ts->traceframe_count != -1)
2172 ui_out_field_int (uiout, "frames", ts->traceframe_count);
2173 if (ts->traceframes_created != -1)
2174 ui_out_field_int (uiout, "frames-created", ts->traceframes_created);
2175 if (ts->buffer_size != -1)
2176 ui_out_field_int (uiout, "buffer-size", ts->buffer_size);
2177 if (ts->buffer_free != -1)
2178 ui_out_field_int (uiout, "buffer-free", ts->buffer_free);
2180 ui_out_field_int (uiout, "disconnected", ts->disconnected_tracing);
2181 ui_out_field_int (uiout, "circular", ts->circular_buffer);
2183 ui_out_field_string (uiout, "user-name", ts->user_name);
2184 ui_out_field_string (uiout, "notes", ts->notes);
2189 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2190 (long int) ts->start_time / 1000000,
2191 (long int) ts->start_time % 1000000);
2192 ui_out_field_string (uiout, "start-time", buf);
2193 xsnprintf (buf, sizeof buf, "%ld.%06ld",
2194 (long int) ts->stop_time / 1000000,
2195 (long int) ts->stop_time % 1000000);
2196 ui_out_field_string (uiout, "stop-time", buf);
2200 /* This function handles the details of what to do about an ongoing
2201 tracing run if the user has asked to detach or otherwise disconnect
2204 disconnect_tracing (int from_tty)
2206 /* It can happen that the target that was tracing went away on its
2207 own, and we didn't notice. Get a status update, and if the
2208 current target doesn't even do tracing, then assume it's not
2210 if (target_get_trace_status (current_trace_status ()) < 0)
2211 current_trace_status ()->running = 0;
2213 /* If running interactively, give the user the option to cancel and
2214 then decide what to do differently with the run. Scripts are
2215 just going to disconnect and let the target deal with it,
2216 according to how it's been instructed previously via
2217 disconnected-tracing. */
2218 if (current_trace_status ()->running && from_tty)
2220 process_tracepoint_on_disconnect ();
2222 if (current_trace_status ()->disconnected_tracing)
2224 if (!query (_("Trace is running and will "
2225 "continue after detach; detach anyway? ")))
2226 error (_("Not confirmed."));
2230 if (!query (_("Trace is running but will "
2231 "stop on detach; detach anyway? ")))
2232 error (_("Not confirmed."));
2236 /* Also we want to be out of tfind mode, otherwise things can get
2237 confusing upon reconnection. Just use these calls instead of
2238 full tfind_1 behavior because we're in the middle of detaching,
2239 and there's no point to updating current stack frame etc. */
2240 set_current_traceframe (-1);
2241 set_tracepoint_num (-1);
2242 set_traceframe_context (NULL);
2245 /* Worker function for the various flavors of the tfind command. */
2247 tfind_1 (enum trace_find_type type, int num,
2248 ULONGEST addr1, ULONGEST addr2,
2251 int target_frameno = -1, target_tracept = -1;
2252 struct frame_id old_frame_id = null_frame_id;
2253 struct tracepoint *tp;
2254 struct ui_out *uiout = current_uiout;
2256 /* Only try to get the current stack frame if we have a chance of
2257 succeeding. In particular, if we're trying to get a first trace
2258 frame while all threads are running, it's not going to succeed,
2259 so leave it with a default value and let the frame comparison
2260 below (correctly) decide to print out the source location of the
2262 if (!(type == tfind_number && num == -1)
2263 && (has_stack_frames () || traceframe_number >= 0))
2264 old_frame_id = get_frame_id (get_current_frame ());
2266 target_frameno = target_trace_find (type, num, addr1, addr2,
2269 if (type == tfind_number
2271 && target_frameno == -1)
2273 /* We told the target to get out of tfind mode, and it did. */
2275 else if (target_frameno == -1)
2277 /* A request for a non-existent trace frame has failed.
2278 Our response will be different, depending on FROM_TTY:
2280 If FROM_TTY is true, meaning that this command was
2281 typed interactively by the user, then give an error
2282 and DO NOT change the state of traceframe_number etc.
2284 However if FROM_TTY is false, meaning that we're either
2285 in a script, a loop, or a user-defined command, then
2286 DON'T give an error, but DO change the state of
2287 traceframe_number etc. to invalid.
2289 The rationalle is that if you typed the command, you
2290 might just have committed a typo or something, and you'd
2291 like to NOT lose your current debugging state. However
2292 if you're in a user-defined command or especially in a
2293 loop, then you need a way to detect that the command
2294 failed WITHOUT aborting. This allows you to write
2295 scripts that search thru the trace buffer until the end,
2296 and then continue on to do something else. */
2299 error (_("Target failed to find requested trace frame."));
2303 printf_filtered ("End of trace buffer.\n");
2304 #if 0 /* dubious now? */
2305 /* The following will not recurse, since it's
2307 trace_find_command ("-1", from_tty);
2312 tp = get_tracepoint_by_number_on_target (target_tracept);
2314 reinit_frame_cache ();
2315 target_dcache_invalidate ();
2317 set_tracepoint_num (tp ? tp->base.number : target_tracept);
2319 if (target_frameno != get_traceframe_number ())
2320 observer_notify_traceframe_changed (target_frameno, tracepoint_number);
2322 set_current_traceframe (target_frameno);
2324 if (target_frameno == -1)
2325 set_traceframe_context (NULL);
2327 set_traceframe_context (get_current_frame ());
2329 if (traceframe_number >= 0)
2331 /* Use different branches for MI and CLI to make CLI messages
2333 if (ui_out_is_mi_like_p (uiout))
2335 ui_out_field_string (uiout, "found", "1");
2336 ui_out_field_int (uiout, "tracepoint", tracepoint_number);
2337 ui_out_field_int (uiout, "traceframe", traceframe_number);
2341 printf_unfiltered (_("Found trace frame %d, tracepoint %d\n"),
2342 traceframe_number, tracepoint_number);
2347 if (ui_out_is_mi_like_p (uiout))
2348 ui_out_field_string (uiout, "found", "0");
2349 else if (type == tfind_number && num == -1)
2350 printf_unfiltered (_("No longer looking at any trace frame\n"));
2351 else /* This case may never occur, check. */
2352 printf_unfiltered (_("No trace frame found\n"));
2355 /* If we're in nonstop mode and getting out of looking at trace
2356 frames, there won't be any current frame to go back to and
2359 && (has_stack_frames () || traceframe_number >= 0))
2361 enum print_what print_what;
2363 /* NOTE: in imitation of the step command, try to determine
2364 whether we have made a transition from one function to
2365 another. If so, we'll print the "stack frame" (ie. the new
2366 function and it's arguments) -- otherwise we'll just show the
2369 if (frame_id_eq (old_frame_id,
2370 get_frame_id (get_current_frame ())))
2371 print_what = SRC_LINE;
2373 print_what = SRC_AND_LOC;
2375 print_stack_frame (get_selected_frame (NULL), 1, print_what);
2380 /* trace_find_command takes a trace frame number n,
2381 sends "QTFrame:<n>" to the target,
2382 and accepts a reply that may contain several optional pieces
2383 of information: a frame number, a tracepoint number, and an
2384 indication of whether this is a trap frame or a stepping frame.
2386 The minimal response is just "OK" (which indicates that the
2387 target does not give us a frame number or a tracepoint number).
2388 Instead of that, the target may send us a string containing
2390 F<hexnum> (gives the selected frame number)
2391 T<hexnum> (gives the selected tracepoint number)
2396 trace_find_command (char *args, int from_tty)
2397 { /* This should only be called with a numeric argument. */
2400 if (current_trace_status ()->running
2401 && current_trace_status ()->filename == NULL)
2402 error (_("May not look at trace frames while trace is running."));
2404 if (args == 0 || *args == 0)
2405 { /* TFIND with no args means find NEXT trace frame. */
2406 if (traceframe_number == -1)
2407 frameno = 0; /* "next" is first one. */
2409 frameno = traceframe_number + 1;
2411 else if (0 == strcmp (args, "-"))
2413 if (traceframe_number == -1)
2414 error (_("not debugging trace buffer"));
2415 else if (from_tty && traceframe_number == 0)
2416 error (_("already at start of trace buffer"));
2418 frameno = traceframe_number - 1;
2420 /* A hack to work around eval's need for fp to have been collected. */
2421 else if (0 == strcmp (args, "-1"))
2424 frameno = parse_and_eval_long (args);
2427 error (_("invalid input (%d is less than zero)"), frameno);
2429 tfind_1 (tfind_number, frameno, 0, 0, from_tty);
2434 trace_find_end_command (char *args, int from_tty)
2436 trace_find_command ("-1", from_tty);
2441 trace_find_start_command (char *args, int from_tty)
2443 trace_find_command ("0", from_tty);
2446 /* tfind pc command */
2448 trace_find_pc_command (char *args, int from_tty)
2452 if (current_trace_status ()->running
2453 && current_trace_status ()->filename == NULL)
2454 error (_("May not look at trace frames while trace is running."));
2456 if (args == 0 || *args == 0)
2457 pc = regcache_read_pc (get_current_regcache ());
2459 pc = parse_and_eval_address (args);
2461 tfind_1 (tfind_pc, 0, pc, 0, from_tty);
2464 /* tfind tracepoint command */
2466 trace_find_tracepoint_command (char *args, int from_tty)
2469 struct tracepoint *tp;
2471 if (current_trace_status ()->running
2472 && current_trace_status ()->filename == NULL)
2473 error (_("May not look at trace frames while trace is running."));
2475 if (args == 0 || *args == 0)
2477 if (tracepoint_number == -1)
2478 error (_("No current tracepoint -- please supply an argument."));
2480 tdp = tracepoint_number; /* Default is current TDP. */
2483 tdp = parse_and_eval_long (args);
2485 /* If we have the tracepoint on hand, use the number that the
2486 target knows about (which may be different if we disconnected
2487 and reconnected). */
2488 tp = get_tracepoint (tdp);
2490 tdp = tp->number_on_target;
2492 tfind_1 (tfind_tp, tdp, 0, 0, from_tty);
2495 /* TFIND LINE command:
2497 This command will take a sourceline for argument, just like BREAK
2498 or TRACE (ie. anything that "decode_line_1" can handle).
2500 With no argument, this command will find the next trace frame
2501 corresponding to a source line OTHER THAN THE CURRENT ONE. */
2504 trace_find_line_command (char *args, int from_tty)
2506 static CORE_ADDR start_pc, end_pc;
2507 struct symtabs_and_lines sals;
2508 struct symtab_and_line sal;
2509 struct cleanup *old_chain;
2511 if (current_trace_status ()->running
2512 && current_trace_status ()->filename == NULL)
2513 error (_("May not look at trace frames while trace is running."));
2515 if (args == 0 || *args == 0)
2517 sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
2519 sals.sals = (struct symtab_and_line *)
2520 xmalloc (sizeof (struct symtab_and_line));
2525 sals = decode_line_with_current_source (args, DECODE_LINE_FUNFIRSTLINE);
2529 old_chain = make_cleanup (xfree, sals.sals);
2530 if (sal.symtab == 0)
2531 error (_("No line number information available."));
2533 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2535 if (start_pc == end_pc)
2537 printf_filtered ("Line %d of \"%s\"",
2539 symtab_to_filename_for_display (sal.symtab));
2541 printf_filtered (" is at address ");
2542 print_address (get_current_arch (), start_pc, gdb_stdout);
2544 printf_filtered (" but contains no code.\n");
2545 sal = find_pc_line (start_pc, 0);
2547 && find_line_pc_range (sal, &start_pc, &end_pc)
2548 && start_pc != end_pc)
2549 printf_filtered ("Attempting to find line %d instead.\n",
2552 error (_("Cannot find a good line."));
2556 /* Is there any case in which we get here, and have an address
2557 which the user would want to see? If we have debugging
2558 symbols and no line numbers? */
2559 error (_("Line number %d is out of range for \"%s\"."),
2560 sal.line, symtab_to_filename_for_display (sal.symtab));
2562 /* Find within range of stated line. */
2564 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, from_tty);
2566 tfind_1 (tfind_outside, 0, start_pc, end_pc - 1, from_tty);
2567 do_cleanups (old_chain);
2570 /* tfind range command */
2572 trace_find_range_command (char *args, int from_tty)
2574 static CORE_ADDR start, stop;
2577 if (current_trace_status ()->running
2578 && current_trace_status ()->filename == NULL)
2579 error (_("May not look at trace frames while trace is running."));
2581 if (args == 0 || *args == 0)
2582 { /* XXX FIXME: what should default behavior be? */
2583 printf_filtered ("Usage: tfind range <startaddr>,<endaddr>\n");
2587 if (0 != (tmp = strchr (args, ',')))
2589 *tmp++ = '\0'; /* Terminate start address. */
2590 tmp = skip_spaces (tmp);
2591 start = parse_and_eval_address (args);
2592 stop = parse_and_eval_address (tmp);
2595 { /* No explicit end address? */
2596 start = parse_and_eval_address (args);
2597 stop = start + 1; /* ??? */
2600 tfind_1 (tfind_range, 0, start, stop, from_tty);
2603 /* tfind outside command */
2605 trace_find_outside_command (char *args, int from_tty)
2607 CORE_ADDR start, stop;
2610 if (current_trace_status ()->running
2611 && current_trace_status ()->filename == NULL)
2612 error (_("May not look at trace frames while trace is running."));
2614 if (args == 0 || *args == 0)
2615 { /* XXX FIXME: what should default behavior be? */
2616 printf_filtered ("Usage: tfind outside <startaddr>,<endaddr>\n");
2620 if (0 != (tmp = strchr (args, ',')))
2622 *tmp++ = '\0'; /* Terminate start address. */
2623 tmp = skip_spaces (tmp);
2624 start = parse_and_eval_address (args);
2625 stop = parse_and_eval_address (tmp);
2628 { /* No explicit end address? */
2629 start = parse_and_eval_address (args);
2630 stop = start + 1; /* ??? */
2633 tfind_1 (tfind_outside, 0, start, stop, from_tty);
2636 /* info scope command: list the locals for a scope. */
2638 scope_info (char *args, int from_tty)
2640 struct symtabs_and_lines sals;
2642 struct minimal_symbol *msym;
2643 struct block *block;
2644 const char *symname;
2645 char *save_args = args;
2646 struct block_iterator iter;
2648 struct gdbarch *gdbarch;
2651 if (args == 0 || *args == 0)
2652 error (_("requires an argument (function, "
2653 "line or *addr) to define a scope"));
2655 sals = decode_line_1 (&args, DECODE_LINE_FUNFIRSTLINE, NULL, 0);
2656 if (sals.nelts == 0)
2657 return; /* Presumably decode_line_1 has already warned. */
2659 /* Resolve line numbers to PC. */
2660 resolve_sal_pc (&sals.sals[0]);
2661 block = block_for_pc (sals.sals[0].pc);
2665 QUIT; /* Allow user to bail out with ^C. */
2666 ALL_BLOCK_SYMBOLS (block, iter, sym)
2668 QUIT; /* Allow user to bail out with ^C. */
2670 printf_filtered ("Scope for %s:\n", save_args);
2673 symname = SYMBOL_PRINT_NAME (sym);
2674 if (symname == NULL || *symname == '\0')
2675 continue; /* Probably botched, certainly useless. */
2677 gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
2679 printf_filtered ("Symbol %s is ", symname);
2680 switch (SYMBOL_CLASS (sym))
2683 case LOC_UNDEF: /* Messed up symbol? */
2684 printf_filtered ("a bogus symbol, class %d.\n",
2685 SYMBOL_CLASS (sym));
2686 count--; /* Don't count this one. */
2689 printf_filtered ("a constant with value %s (%s)",
2690 plongest (SYMBOL_VALUE (sym)),
2691 hex_string (SYMBOL_VALUE (sym)));
2693 case LOC_CONST_BYTES:
2694 printf_filtered ("constant bytes: ");
2695 if (SYMBOL_TYPE (sym))
2696 for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
2697 fprintf_filtered (gdb_stdout, " %02x",
2698 (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
2701 printf_filtered ("in static storage at address ");
2702 printf_filtered ("%s", paddress (gdbarch,
2703 SYMBOL_VALUE_ADDRESS (sym)));
2706 /* GDBARCH is the architecture associated with the objfile
2707 the symbol is defined in; the target architecture may be
2708 different, and may provide additional registers. However,
2709 we do not know the target architecture at this point.
2710 We assume the objfile architecture will contain all the
2711 standard registers that occur in debug info in that
2713 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2716 if (SYMBOL_IS_ARGUMENT (sym))
2717 printf_filtered ("an argument in register $%s",
2718 gdbarch_register_name (gdbarch, regno));
2720 printf_filtered ("a local variable in register $%s",
2721 gdbarch_register_name (gdbarch, regno));
2724 printf_filtered ("an argument at stack/frame offset %s",
2725 plongest (SYMBOL_VALUE (sym)));
2728 printf_filtered ("a local variable at frame offset %s",
2729 plongest (SYMBOL_VALUE (sym)));
2732 printf_filtered ("a reference argument at offset %s",
2733 plongest (SYMBOL_VALUE (sym)));
2735 case LOC_REGPARM_ADDR:
2736 /* Note comment at LOC_REGISTER. */
2737 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
2739 printf_filtered ("the address of an argument, in register $%s",
2740 gdbarch_register_name (gdbarch, regno));
2743 printf_filtered ("a typedef.\n");
2746 printf_filtered ("a label at address ");
2747 printf_filtered ("%s", paddress (gdbarch,
2748 SYMBOL_VALUE_ADDRESS (sym)));
2751 printf_filtered ("a function at address ");
2752 printf_filtered ("%s",
2753 paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
2755 case LOC_UNRESOLVED:
2756 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
2759 printf_filtered ("Unresolved Static");
2762 printf_filtered ("static storage at address ");
2763 printf_filtered ("%s",
2764 paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msym)));
2767 case LOC_OPTIMIZED_OUT:
2768 printf_filtered ("optimized out.\n");
2771 SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
2772 BLOCK_START (block),
2776 if (SYMBOL_TYPE (sym))
2777 printf_filtered (", length %d.\n",
2778 TYPE_LENGTH (check_typedef (SYMBOL_TYPE (sym))));
2780 if (BLOCK_FUNCTION (block))
2783 block = BLOCK_SUPERBLOCK (block);
2786 printf_filtered ("Scope for %s contains no locals or arguments.\n",
2790 /* Helper for trace_dump_command. Dump the action list starting at
2791 ACTION. STEPPING_ACTIONS is true if we're iterating over the
2792 actions of the body of a while-stepping action. STEPPING_FRAME is
2793 set if the current traceframe was determined to be a while-stepping
2797 trace_dump_actions (struct command_line *action,
2798 int stepping_actions, int stepping_frame,
2801 const char *action_exp, *next_comma;
2803 for (; action != NULL; action = action->next)
2805 struct cmd_list_element *cmd;
2807 QUIT; /* Allow user to bail out with ^C. */
2808 action_exp = action->line;
2809 action_exp = skip_spaces_const (action_exp);
2811 /* The collection actions to be done while stepping are
2812 bracketed by the commands "while-stepping" and "end". */
2814 if (*action_exp == '#') /* comment line */
2817 cmd = lookup_cmd (&action_exp, cmdlist, "", -1, 1);
2819 error (_("Bad action list item: %s"), action_exp);
2821 if (cmd_cfunc_eq (cmd, while_stepping_pseudocommand))
2825 for (i = 0; i < action->body_count; ++i)
2826 trace_dump_actions (action->body_list[i],
2827 1, stepping_frame, from_tty);
2829 else if (cmd_cfunc_eq (cmd, collect_pseudocommand))
2831 /* Display the collected data.
2832 For the trap frame, display only what was collected at
2833 the trap. Likewise for stepping frames, display only
2834 what was collected while stepping. This means that the
2835 two boolean variables, STEPPING_FRAME and
2836 STEPPING_ACTIONS should be equal. */
2837 if (stepping_frame == stepping_actions)
2840 struct cleanup *old_chain
2841 = make_cleanup (free_current_contents, &cmd);
2843 if (*action_exp == '/')
2844 action_exp = decode_agent_options (action_exp);
2847 { /* Repeat over a comma-separated list. */
2848 QUIT; /* Allow user to bail out with ^C. */
2849 if (*action_exp == ',')
2851 action_exp = skip_spaces_const (action_exp);
2853 next_comma = strchr (action_exp, ',');
2855 if (0 == strncasecmp (action_exp, "$reg", 4))
2856 registers_info (NULL, from_tty);
2857 else if (0 == strncasecmp (action_exp, "$_ret", 5))
2859 else if (0 == strncasecmp (action_exp, "$loc", 4))
2860 locals_info (NULL, from_tty);
2861 else if (0 == strncasecmp (action_exp, "$arg", 4))
2862 args_info (NULL, from_tty);
2865 if (next_comma != NULL)
2867 size_t len = next_comma - action_exp;
2869 cmd = xrealloc (cmd, len + 1);
2870 memcpy (cmd, action_exp, len);
2875 size_t len = strlen (action_exp);
2877 cmd = xrealloc (cmd, len + 1);
2878 memcpy (cmd, action_exp, len + 1);
2881 printf_filtered ("%s = ", cmd);
2882 output_command_const (cmd, from_tty);
2883 printf_filtered ("\n");
2885 action_exp = next_comma;
2887 while (action_exp && *action_exp == ',');
2889 do_cleanups (old_chain);
2895 /* The tdump command. */
2898 trace_dump_command (char *args, int from_tty)
2900 struct regcache *regcache;
2901 struct tracepoint *t;
2902 int stepping_frame = 0;
2903 struct bp_location *loc;
2904 char *default_collect_line = NULL;
2905 struct command_line *actions, *default_collect_action = NULL;
2906 struct cleanup *old_chain = NULL;
2908 if (tracepoint_number == -1)
2910 warning (_("No current trace frame."));
2914 t = get_tracepoint (tracepoint_number);
2917 error (_("No known tracepoint matches 'current' tracepoint #%d."),
2920 printf_filtered ("Data collected at tracepoint %d, trace frame %d:\n",
2921 tracepoint_number, traceframe_number);
2923 /* The current frame is a trap frame if the frame PC is equal
2924 to the tracepoint PC. If not, then the current frame was
2925 collected during single-stepping. */
2927 regcache = get_current_regcache ();
2929 /* If the traceframe's address matches any of the tracepoint's
2930 locations, assume it is a direct hit rather than a while-stepping
2931 frame. (FIXME this is not reliable, should record each frame's
2934 for (loc = t->base.loc; loc; loc = loc->next)
2935 if (loc->address == regcache_read_pc (regcache))
2938 actions = breakpoint_commands (&t->base);
2940 /* If there is a default-collect list, make up a collect command,
2941 prepend to the tracepoint's commands, and pass the whole mess to
2942 the trace dump scanner. We need to validate because
2943 default-collect might have been junked since the trace run. */
2944 if (*default_collect)
2946 default_collect_line = xstrprintf ("collect %s", default_collect);
2947 old_chain = make_cleanup (xfree, default_collect_line);
2948 validate_actionline (default_collect_line, &t->base);
2949 default_collect_action = xmalloc (sizeof (struct command_line));
2950 make_cleanup (xfree, default_collect_action);
2951 default_collect_action->next = actions;
2952 default_collect_action->line = default_collect_line;
2953 actions = default_collect_action;
2956 trace_dump_actions (actions, 0, stepping_frame, from_tty);
2958 if (*default_collect)
2959 do_cleanups (old_chain);
2962 /* Encode a piece of a tracepoint's source-level definition in a form
2963 that is suitable for both protocol and saving in files. */
2964 /* This version does not do multiple encodes for long strings; it should
2965 return an offset to the next piece to encode. FIXME */
2968 encode_source_string (int tpnum, ULONGEST addr,
2969 char *srctype, char *src, char *buf, int buf_size)
2971 if (80 + strlen (srctype) > buf_size)
2972 error (_("Buffer too small for source encoding"));
2973 sprintf (buf, "%x:%s:%s:%x:%x:",
2974 tpnum, phex_nz (addr, sizeof (addr)),
2975 srctype, 0, (int) strlen (src));
2976 if (strlen (buf) + strlen (src) * 2 >= buf_size)
2977 error (_("Source string too long for buffer"));
2978 bin2hex (src, buf + strlen (buf), 0);
2982 /* Free trace file writer. */
2985 trace_file_writer_xfree (void *arg)
2987 struct trace_file_writer *writer = arg;
2989 writer->ops->dtor (writer);
2993 /* TFILE trace writer. */
2995 struct tfile_trace_file_writer
2997 struct trace_file_writer base;
2999 /* File pointer to tfile trace file. */
3001 /* Path name of the tfile trace file. */
3005 /* This is the implementation of trace_file_write_ops method
3006 target_save. We just call the generic target
3007 target_save_trace_data to do target-side saving. */
3010 tfile_target_save (struct trace_file_writer *self,
3011 const char *filename)
3013 int err = target_save_trace_data (filename);
3018 /* This is the implementation of trace_file_write_ops method
3022 tfile_dtor (struct trace_file_writer *self)
3024 struct tfile_trace_file_writer *writer
3025 = (struct tfile_trace_file_writer *) self;
3027 xfree (writer->pathname);
3029 if (writer->fp != NULL)
3030 fclose (writer->fp);
3033 /* This is the implementation of trace_file_write_ops method
3034 start. It creates the trace file FILENAME and registers some
3038 tfile_start (struct trace_file_writer *self, const char *filename)
3040 struct tfile_trace_file_writer *writer
3041 = (struct tfile_trace_file_writer *) self;
3043 writer->pathname = tilde_expand (filename);
3044 writer->fp = fopen (writer->pathname, "wb");
3045 if (writer->fp == NULL)
3046 error (_("Unable to open file '%s' for saving trace data (%s)"),
3047 filename, safe_strerror (errno));
3050 /* This is the implementation of trace_file_write_ops method
3051 write_header. Write the TFILE header. */
3054 tfile_write_header (struct trace_file_writer *self)
3056 struct tfile_trace_file_writer *writer
3057 = (struct tfile_trace_file_writer *) self;
3060 /* Write a file header, with a high-bit-set char to indicate a
3061 binary file, plus a hint as what this file is, and a version
3062 number in case of future needs. */
3063 written = fwrite ("\x7fTRACE0\n", 8, 1, writer->fp);
3065 perror_with_name (writer->pathname);
3068 /* This is the implementation of trace_file_write_ops method
3069 write_regblock_type. Write the size of register block. */
3072 tfile_write_regblock_type (struct trace_file_writer *self, int size)
3074 struct tfile_trace_file_writer *writer
3075 = (struct tfile_trace_file_writer *) self;
3077 fprintf (writer->fp, "R %x\n", size);
3080 /* This is the implementation of trace_file_write_ops method
3084 tfile_write_status (struct trace_file_writer *self,
3085 struct trace_status *ts)
3087 struct tfile_trace_file_writer *writer
3088 = (struct tfile_trace_file_writer *) self;
3090 fprintf (writer->fp, "status %c;%s",
3091 (ts->running ? '1' : '0'), stop_reason_names[ts->stop_reason]);
3092 if (ts->stop_reason == tracepoint_error)
3094 char *buf = (char *) alloca (strlen (ts->stop_desc) * 2 + 1);
3096 bin2hex ((gdb_byte *) ts->stop_desc, buf, 0);
3097 fprintf (writer->fp, ":%s", buf);
3099 fprintf (writer->fp, ":%x", ts->stopping_tracepoint);
3100 if (ts->traceframe_count >= 0)
3101 fprintf (writer->fp, ";tframes:%x", ts->traceframe_count);
3102 if (ts->traceframes_created >= 0)
3103 fprintf (writer->fp, ";tcreated:%x", ts->traceframes_created);
3104 if (ts->buffer_free >= 0)
3105 fprintf (writer->fp, ";tfree:%x", ts->buffer_free);
3106 if (ts->buffer_size >= 0)
3107 fprintf (writer->fp, ";tsize:%x", ts->buffer_size);
3108 if (ts->disconnected_tracing)
3109 fprintf (writer->fp, ";disconn:%x", ts->disconnected_tracing);
3110 if (ts->circular_buffer)
3111 fprintf (writer->fp, ";circular:%x", ts->circular_buffer);
3112 fprintf (writer->fp, "\n");
3115 /* This is the implementation of trace_file_write_ops method
3116 write_uploaded_tsv. */
3119 tfile_write_uploaded_tsv (struct trace_file_writer *self,
3120 struct uploaded_tsv *utsv)
3123 struct tfile_trace_file_writer *writer
3124 = (struct tfile_trace_file_writer *) self;
3128 buf = (char *) xmalloc (strlen (utsv->name) * 2 + 1);
3129 bin2hex ((gdb_byte *) (utsv->name), buf, 0);
3132 fprintf (writer->fp, "tsv %x:%s:%x:%s\n",
3133 utsv->number, phex_nz (utsv->initial_value, 8),
3134 utsv->builtin, buf);
3140 #define MAX_TRACE_UPLOAD 2000
3142 /* This is the implementation of trace_file_write_ops method
3143 write_uploaded_tp. */
3146 tfile_write_uploaded_tp (struct trace_file_writer *self,
3147 struct uploaded_tp *utp)
3149 struct tfile_trace_file_writer *writer
3150 = (struct tfile_trace_file_writer *) self;
3153 gdb_byte buf[MAX_TRACE_UPLOAD];
3155 fprintf (writer->fp, "tp T%x:%s:%c:%x:%x",
3156 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
3157 (utp->enabled ? 'E' : 'D'), utp->step, utp->pass);
3158 if (utp->type == bp_fast_tracepoint)
3159 fprintf (writer->fp, ":F%x", utp->orig_size);
3161 fprintf (writer->fp,
3162 ":X%x,%s", (unsigned int) strlen (utp->cond) / 2,
3164 fprintf (writer->fp, "\n");
3165 for (a = 0; VEC_iterate (char_ptr, utp->actions, a, act); ++a)
3166 fprintf (writer->fp, "tp A%x:%s:%s\n",
3167 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
3168 for (a = 0; VEC_iterate (char_ptr, utp->step_actions, a, act); ++a)
3169 fprintf (writer->fp, "tp S%x:%s:%s\n",
3170 utp->number, phex_nz (utp->addr, sizeof (utp->addr)), act);
3173 encode_source_string (utp->number, utp->addr,
3174 "at", utp->at_string, buf, MAX_TRACE_UPLOAD);
3175 fprintf (writer->fp, "tp Z%s\n", buf);
3177 if (utp->cond_string)
3179 encode_source_string (utp->number, utp->addr,
3180 "cond", utp->cond_string,
3181 buf, MAX_TRACE_UPLOAD);
3182 fprintf (writer->fp, "tp Z%s\n", buf);
3184 for (a = 0; VEC_iterate (char_ptr, utp->cmd_strings, a, act); ++a)
3186 encode_source_string (utp->number, utp->addr, "cmd", act,
3187 buf, MAX_TRACE_UPLOAD);
3188 fprintf (writer->fp, "tp Z%s\n", buf);
3190 fprintf (writer->fp, "tp V%x:%s:%x:%s\n",
3191 utp->number, phex_nz (utp->addr, sizeof (utp->addr)),
3193 phex_nz (utp->traceframe_usage,
3194 sizeof (utp->traceframe_usage)));
3197 /* This is the implementation of trace_file_write_ops method
3198 write_definition_end. */
3201 tfile_write_definition_end (struct trace_file_writer *self)
3203 struct tfile_trace_file_writer *writer
3204 = (struct tfile_trace_file_writer *) self;
3206 fprintf (writer->fp, "\n");
3209 /* This is the implementation of trace_file_write_ops method
3213 tfile_write_raw_data (struct trace_file_writer *self, gdb_byte *buf,
3216 struct tfile_trace_file_writer *writer
3217 = (struct tfile_trace_file_writer *) self;
3219 if (fwrite (buf, len, 1, writer->fp) < 1)
3220 perror_with_name (writer->pathname);
3223 /* This is the implementation of trace_file_write_ops method
3227 tfile_end (struct trace_file_writer *self)
3229 struct tfile_trace_file_writer *writer
3230 = (struct tfile_trace_file_writer *) self;
3231 uint32_t gotten = 0;
3233 /* Mark the end of trace data. */
3234 if (fwrite (&gotten, 4, 1, writer->fp) < 1)
3235 perror_with_name (writer->pathname);
3238 /* Operations to write trace buffers into TFILE format. */
3240 static const struct trace_file_write_ops tfile_write_ops =
3246 tfile_write_regblock_type,
3248 tfile_write_uploaded_tsv,
3249 tfile_write_uploaded_tp,
3250 tfile_write_definition_end,
3251 tfile_write_raw_data,
3256 /* Helper macros. */
3258 #define TRACE_WRITE_R_BLOCK(writer, buf, size) \
3259 writer->ops->frame_ops->write_r_block ((writer), (buf), (size))
3260 #define TRACE_WRITE_M_BLOCK_HEADER(writer, addr, size) \
3261 writer->ops->frame_ops->write_m_block_header ((writer), (addr), \
3263 #define TRACE_WRITE_M_BLOCK_MEMORY(writer, buf, size) \
3264 writer->ops->frame_ops->write_m_block_memory ((writer), (buf), \
3266 #define TRACE_WRITE_V_BLOCK(writer, num, val) \
3267 writer->ops->frame_ops->write_v_block ((writer), (num), (val))
3269 extern int trace_regblock_size;
3271 /* Save tracepoint data to file named FILENAME through WRITER. WRITER
3272 determines the trace file format. If TARGET_DOES_SAVE is non-zero,
3273 the save is performed on the target, otherwise GDB obtains all trace
3274 data and saves it locally. */
3277 trace_save (const char *filename, struct trace_file_writer *writer,
3278 int target_does_save)
3280 struct trace_status *ts = current_trace_status ();
3282 struct uploaded_tp *uploaded_tps = NULL, *utp;
3283 struct uploaded_tsv *uploaded_tsvs = NULL, *utsv;
3285 ULONGEST offset = 0;
3286 gdb_byte buf[MAX_TRACE_UPLOAD];
3288 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
3290 /* If the target is to save the data to a file on its own, then just
3291 send the command and be done with it. */
3292 if (target_does_save)
3294 if (!writer->ops->target_save (writer, filename))
3295 error (_("Target failed to save trace data to '%s'."),
3300 /* Get the trace status first before opening the file, so if the
3301 target is losing, we can get out without touching files. */
3302 status = target_get_trace_status (ts);
3304 writer->ops->start (writer, filename);
3306 writer->ops->write_header (writer);
3308 /* Write descriptive info. */
3310 /* Write out the size of a register block. */
3311 writer->ops->write_regblock_type (writer, trace_regblock_size);
3313 /* Write out status of the tracing run (aka "tstatus" info). */
3314 writer->ops->write_status (writer, ts);
3316 /* Note that we want to upload tracepoints and save those, rather
3317 than simply writing out the local ones, because the user may have
3318 changed tracepoints in GDB in preparation for a future tracing
3319 run, or maybe just mass-deleted all types of breakpoints as part
3320 of cleaning up. So as not to contaminate the session, leave the
3321 data in its uploaded form, don't make into real tracepoints. */
3323 /* Get trace state variables first, they may be checked when parsing
3324 uploaded commands. */
3326 target_upload_trace_state_variables (&uploaded_tsvs);
3328 for (utsv = uploaded_tsvs; utsv; utsv = utsv->next)
3329 writer->ops->write_uploaded_tsv (writer, utsv);
3331 free_uploaded_tsvs (&uploaded_tsvs);
3333 target_upload_tracepoints (&uploaded_tps);
3335 for (utp = uploaded_tps; utp; utp = utp->next)
3336 target_get_tracepoint_status (NULL, utp);
3338 for (utp = uploaded_tps; utp; utp = utp->next)
3339 writer->ops->write_uploaded_tp (writer, utp);
3341 free_uploaded_tps (&uploaded_tps);
3343 /* Mark the end of the definition section. */
3344 writer->ops->write_definition_end (writer);
3346 /* Get and write the trace data proper. */
3351 /* The writer supports writing the contents of trace buffer
3352 directly to trace file. Don't parse the contents of trace
3354 if (writer->ops->write_trace_buffer != NULL)
3356 /* We ask for big blocks, in the hopes of efficiency, but
3357 will take less if the target has packet size limitations
3359 gotten = target_get_raw_trace_data (buf, offset,
3362 error (_("Failure to get requested trace buffer data"));
3363 /* No more data is forthcoming, we're done. */
3367 writer->ops->write_trace_buffer (writer, buf, gotten);
3375 /* Parse the trace buffers according to how data are stored
3376 in trace buffer in GDBserver. */
3378 gotten = target_get_raw_trace_data (buf, offset, 6);
3383 /* Read the first six bytes in, which is the tracepoint
3384 number and trace frame size. */
3386 extract_unsigned_integer (&buf[0], 2, byte_order);
3388 tf_size = (uint32_t)
3389 extract_unsigned_integer (&buf[2], 4, byte_order);
3391 writer->ops->frame_ops->start (writer, tp_num);
3400 for (block = 0; block < tf_size; )
3402 gdb_byte block_type;
3404 /* We'll fetch one block each time, in order to
3405 handle the extremely large 'M' block. We first
3406 fetch one byte to get the type of the block. */
3407 gotten = target_get_raw_trace_data (buf, offset, 1);
3409 error (_("Failure to get requested trace buffer data"));
3415 block_type = buf[0];
3420 = target_get_raw_trace_data (buf, offset,
3421 trace_regblock_size);
3422 if (gotten < trace_regblock_size)
3423 error (_("Failure to get requested trace"
3426 TRACE_WRITE_R_BLOCK (writer, buf,
3427 trace_regblock_size);
3431 unsigned short mlen;
3436 t = target_get_raw_trace_data (buf,offset, 10);
3438 error (_("Failure to get requested trace"
3446 extract_unsigned_integer (buf, 8,
3448 mlen = (unsigned short)
3449 extract_unsigned_integer (&buf[8], 2,
3452 TRACE_WRITE_M_BLOCK_HEADER (writer, addr,
3455 /* The memory contents in 'M' block may be
3456 very large. Fetch the data from the target
3457 and write them into file one by one. */
3458 for (j = 0; j < mlen; )
3460 unsigned int read_length;
3462 if (mlen - j > MAX_TRACE_UPLOAD)
3463 read_length = MAX_TRACE_UPLOAD;
3465 read_length = mlen - j;
3467 t = target_get_raw_trace_data (buf,
3470 if (t < read_length)
3471 error (_("Failure to get requested"
3472 " trace buffer data"));
3474 TRACE_WRITE_M_BLOCK_MEMORY (writer, buf,
3478 gotten += read_length;
3489 = target_get_raw_trace_data (buf, offset,
3492 error (_("Failure to get requested"
3493 " trace buffer data"));
3495 vnum = (int) extract_signed_integer (buf,
3499 = extract_signed_integer (&buf[4], 8,
3502 TRACE_WRITE_V_BLOCK (writer, vnum, val);
3506 error (_("Unknown block type '%c' (0x%x) in"
3508 block_type, block_type);
3518 writer->ops->frame_ops->end (writer);
3522 writer->ops->end (writer);
3525 /* Return a trace writer for TFILE format. */
3527 static struct trace_file_writer *
3528 tfile_trace_file_writer_new (void)
3530 struct tfile_trace_file_writer *writer
3531 = xmalloc (sizeof (struct tfile_trace_file_writer));
3533 writer->base.ops = &tfile_write_ops;
3535 writer->pathname = NULL;
3537 return (struct trace_file_writer *) writer;
3541 trace_save_command (char *args, int from_tty)
3543 int target_does_save = 0;
3545 char *filename = NULL;
3546 struct cleanup *back_to;
3547 struct trace_file_writer *writer = NULL;
3550 error_no_arg (_("file in which to save trace data"));
3552 argv = gdb_buildargv (args);
3553 back_to = make_cleanup_freeargv (argv);
3555 for (; *argv; ++argv)
3557 if (strcmp (*argv, "-r") == 0)
3558 target_does_save = 1;
3559 else if (**argv == '-')
3560 error (_("unknown option `%s'"), *argv);
3566 error_no_arg (_("file in which to save trace data"));
3568 writer = tfile_trace_file_writer_new ();
3570 make_cleanup (trace_file_writer_xfree, writer);
3572 trace_save (filename, writer, target_does_save);
3575 printf_filtered (_("Trace data saved to file '%s'.\n"), filename);
3577 do_cleanups (back_to);
3580 /* Save the trace data to file FILENAME of tfile format. */
3583 trace_save_tfile (const char *filename, int target_does_save)
3585 struct trace_file_writer *writer;
3586 struct cleanup *back_to;
3588 writer = tfile_trace_file_writer_new ();
3589 back_to = make_cleanup (trace_file_writer_xfree, writer);
3590 trace_save (filename, writer, target_does_save);
3591 do_cleanups (back_to);
3594 /* Tell the target what to do with an ongoing tracing run if GDB
3595 disconnects for some reason. */
3598 set_disconnected_tracing (char *args, int from_tty,
3599 struct cmd_list_element *c)
3601 target_set_disconnected_tracing (disconnected_tracing);
3605 set_circular_trace_buffer (char *args, int from_tty,
3606 struct cmd_list_element *c)
3608 target_set_circular_trace_buffer (circular_trace_buffer);
3612 set_trace_buffer_size (char *args, int from_tty,
3613 struct cmd_list_element *c)
3615 target_set_trace_buffer_size (trace_buffer_size);
3619 set_trace_user (char *args, int from_tty,
3620 struct cmd_list_element *c)
3624 ret = target_set_trace_notes (trace_user, NULL, NULL);
3627 warning (_("Target does not support trace notes, user ignored"));
3631 set_trace_notes (char *args, int from_tty,
3632 struct cmd_list_element *c)
3636 ret = target_set_trace_notes (NULL, trace_notes, NULL);
3639 warning (_("Target does not support trace notes, note ignored"));
3643 set_trace_stop_notes (char *args, int from_tty,
3644 struct cmd_list_element *c)
3648 ret = target_set_trace_notes (NULL, NULL, trace_stop_notes);
3651 warning (_("Target does not support trace notes, stop note ignored"));
3654 /* Convert the memory pointed to by mem into hex, placing result in buf.
3655 * Return a pointer to the last char put in buf (null)
3656 * "stolen" from sparc-stub.c
3659 static const char hexchars[] = "0123456789abcdef";
3662 mem2hex (gdb_byte *mem, char *buf, int count)
3670 *buf++ = hexchars[ch >> 4];
3671 *buf++ = hexchars[ch & 0xf];
3680 get_traceframe_number (void)
3682 return traceframe_number;
3685 /* Make the traceframe NUM be the current trace frame. Does nothing
3686 if NUM is already current. */
3689 set_current_traceframe (int num)
3693 if (traceframe_number == num)
3695 /* Nothing to do. */
3699 newnum = target_trace_find (tfind_number, num, 0, 0, NULL);
3702 warning (_("could not change traceframe"));
3704 set_traceframe_num (newnum);
3706 /* Changing the traceframe changes our view of registers and of the
3708 registers_changed ();
3710 clear_traceframe_info ();
3713 /* Make the traceframe NUM be the current trace frame, and do nothing
3717 set_traceframe_number (int num)
3719 traceframe_number = num;
3722 /* A cleanup used when switching away and back from tfind mode. */
3724 struct current_traceframe_cleanup
3726 /* The traceframe we were inspecting. */
3727 int traceframe_number;
3731 do_restore_current_traceframe_cleanup (void *arg)
3733 struct current_traceframe_cleanup *old = arg;
3735 set_current_traceframe (old->traceframe_number);
3739 restore_current_traceframe_cleanup_dtor (void *arg)
3741 struct current_traceframe_cleanup *old = arg;
3747 make_cleanup_restore_current_traceframe (void)
3749 struct current_traceframe_cleanup *old;
3751 old = xmalloc (sizeof (struct current_traceframe_cleanup));
3752 old->traceframe_number = traceframe_number;
3754 return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
3755 restore_current_traceframe_cleanup_dtor);
3759 make_cleanup_restore_traceframe_number (void)
3761 return make_cleanup_restore_integer (&traceframe_number);
3764 /* Given a number and address, return an uploaded tracepoint with that
3765 number, creating if necessary. */
3767 struct uploaded_tp *
3768 get_uploaded_tp (int num, ULONGEST addr, struct uploaded_tp **utpp)
3770 struct uploaded_tp *utp;
3772 for (utp = *utpp; utp; utp = utp->next)
3773 if (utp->number == num && utp->addr == addr)
3775 utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
3776 memset (utp, 0, sizeof (struct uploaded_tp));
3779 utp->actions = NULL;
3780 utp->step_actions = NULL;
3781 utp->cmd_strings = NULL;
3788 free_uploaded_tps (struct uploaded_tp **utpp)
3790 struct uploaded_tp *next_one;
3794 next_one = (*utpp)->next;
3800 /* Given a number and address, return an uploaded tracepoint with that
3801 number, creating if necessary. */
3803 static struct uploaded_tsv *
3804 get_uploaded_tsv (int num, struct uploaded_tsv **utsvp)
3806 struct uploaded_tsv *utsv;
3808 for (utsv = *utsvp; utsv; utsv = utsv->next)
3809 if (utsv->number == num)
3811 utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
3812 memset (utsv, 0, sizeof (struct uploaded_tsv));
3814 utsv->next = *utsvp;
3820 free_uploaded_tsvs (struct uploaded_tsv **utsvp)
3822 struct uploaded_tsv *next_one;
3826 next_one = (*utsvp)->next;
3832 /* FIXME this function is heuristic and will miss the cases where the
3833 conditional is semantically identical but differs in whitespace,
3834 such as "x == 0" vs "x==0". */
3837 cond_string_is_same (char *str1, char *str2)
3839 if (str1 == NULL || str2 == NULL)
3840 return (str1 == str2);
3842 return (strcmp (str1, str2) == 0);
3845 /* Look for an existing tracepoint that seems similar enough to the
3846 uploaded one. Enablement isn't compared, because the user can
3847 toggle that freely, and may have done so in anticipation of the
3848 next trace run. Return the location of matched tracepoint. */
3850 static struct bp_location *
3851 find_matching_tracepoint_location (struct uploaded_tp *utp)
3853 VEC(breakpoint_p) *tp_vec = all_tracepoints ();
3855 struct breakpoint *b;
3856 struct bp_location *loc;
3858 for (ix = 0; VEC_iterate (breakpoint_p, tp_vec, ix, b); ix++)
3860 struct tracepoint *t = (struct tracepoint *) b;
3862 if (b->type == utp->type
3863 && t->step_count == utp->step
3864 && t->pass_count == utp->pass
3865 && cond_string_is_same (t->base.cond_string, utp->cond_string)
3866 /* FIXME also test actions. */
3869 /* Scan the locations for an address match. */
3870 for (loc = b->loc; loc; loc = loc->next)
3872 if (loc->address == utp->addr)
3880 /* Given a list of tracepoints uploaded from a target, attempt to
3881 match them up with existing tracepoints, and create new ones if not
3885 merge_uploaded_tracepoints (struct uploaded_tp **uploaded_tps)
3887 struct uploaded_tp *utp;
3888 /* A set of tracepoints which are modified. */
3889 VEC(breakpoint_p) *modified_tp = NULL;
3891 struct breakpoint *b;
3893 /* Look for GDB tracepoints that match up with our uploaded versions. */
3894 for (utp = *uploaded_tps; utp; utp = utp->next)
3896 struct bp_location *loc;
3897 struct tracepoint *t;
3899 loc = find_matching_tracepoint_location (utp);
3904 /* Mark this location as already inserted. */
3906 t = (struct tracepoint *) loc->owner;
3907 printf_filtered (_("Assuming tracepoint %d is same "
3908 "as target's tracepoint %d at %s.\n"),
3909 loc->owner->number, utp->number,
3910 paddress (loc->gdbarch, utp->addr));
3912 /* The tracepoint LOC->owner was modified (the location LOC
3913 was marked as inserted in the target). Save it in
3914 MODIFIED_TP if not there yet. The 'breakpoint-modified'
3915 observers will be notified later once for each tracepoint
3916 saved in MODIFIED_TP. */
3918 VEC_iterate (breakpoint_p, modified_tp, ix, b);
3920 if (b == loc->owner)
3926 VEC_safe_push (breakpoint_p, modified_tp, loc->owner);
3930 t = create_tracepoint_from_upload (utp);
3932 printf_filtered (_("Created tracepoint %d for "
3933 "target's tracepoint %d at %s.\n"),
3934 t->base.number, utp->number,
3935 paddress (get_current_arch (), utp->addr));
3937 printf_filtered (_("Failed to create tracepoint for target's "
3938 "tracepoint %d at %s, skipping it.\n"),
3940 paddress (get_current_arch (), utp->addr));
3942 /* Whether found or created, record the number used by the
3943 target, to help with mapping target tracepoints back to their
3944 counterparts here. */
3946 t->number_on_target = utp->number;
3949 /* Notify 'breakpoint-modified' observer that at least one of B's
3950 locations was changed. */
3951 for (ix = 0; VEC_iterate (breakpoint_p, modified_tp, ix, b); ix++)
3952 observer_notify_breakpoint_modified (b);
3954 VEC_free (breakpoint_p, modified_tp);
3955 free_uploaded_tps (uploaded_tps);
3958 /* Trace state variables don't have much to identify them beyond their
3959 name, so just use that to detect matches. */
3961 static struct trace_state_variable *
3962 find_matching_tsv (struct uploaded_tsv *utsv)
3967 return find_trace_state_variable (utsv->name);
3970 static struct trace_state_variable *
3971 create_tsv_from_upload (struct uploaded_tsv *utsv)
3973 const char *namebase;
3976 struct trace_state_variable *tsv;
3977 struct cleanup *old_chain;
3981 namebase = utsv->name;
3982 buf = xstrprintf ("%s", namebase);
3987 buf = xstrprintf ("%s_%d", namebase, try_num++);
3990 /* Fish for a name that is not in use. */
3991 /* (should check against all internal vars?) */
3992 while (find_trace_state_variable (buf))
3995 buf = xstrprintf ("%s_%d", namebase, try_num++);
3998 old_chain = make_cleanup (xfree, buf);
4000 /* We have an available name, create the variable. */
4001 tsv = create_trace_state_variable (buf);
4002 tsv->initial_value = utsv->initial_value;
4003 tsv->builtin = utsv->builtin;
4005 observer_notify_tsv_created (tsv);
4007 do_cleanups (old_chain);
4012 /* Given a list of uploaded trace state variables, try to match them
4013 up with existing variables, or create additional ones. */
4016 merge_uploaded_trace_state_variables (struct uploaded_tsv **uploaded_tsvs)
4019 struct uploaded_tsv *utsv;
4020 struct trace_state_variable *tsv;
4023 /* Most likely some numbers will have to be reassigned as part of
4024 the merge, so clear them all in anticipation. */
4025 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
4028 for (utsv = *uploaded_tsvs; utsv; utsv = utsv->next)
4030 tsv = find_matching_tsv (utsv);
4034 printf_filtered (_("Assuming trace state variable $%s "
4035 "is same as target's variable %d.\n"),
4036 tsv->name, utsv->number);
4040 tsv = create_tsv_from_upload (utsv);
4042 printf_filtered (_("Created trace state variable "
4043 "$%s for target's variable %d.\n"),
4044 tsv->name, utsv->number);
4046 /* Give precedence to numberings that come from the target. */
4048 tsv->number = utsv->number;
4051 /* Renumber everything that didn't get a target-assigned number. */
4053 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
4054 if (tsv->number > highest)
4055 highest = tsv->number;
4058 for (ix = 0; VEC_iterate (tsv_s, tvariables, ix, tsv); ++ix)
4059 if (tsv->number == 0)
4060 tsv->number = highest++;
4062 free_uploaded_tsvs (uploaded_tsvs);
4065 /* target tfile command */
4067 static struct target_ops tfile_ops;
4069 /* Fill in tfile_ops with its defined operations and properties. */
4071 #define TRACE_HEADER_SIZE 8
4073 static char *trace_filename;
4074 static int trace_fd = -1;
4075 static off_t trace_frames_offset;
4076 static off_t cur_offset;
4077 static int cur_data_size;
4078 int trace_regblock_size;
4080 static void tfile_interp_line (char *line,
4081 struct uploaded_tp **utpp,
4082 struct uploaded_tsv **utsvp);
4084 /* Read SIZE bytes into READBUF from the trace frame, starting at
4085 TRACE_FD's current position. Note that this call `read'
4086 underneath, hence it advances the file's seek position. Throws an
4087 error if the `read' syscall fails, or less than SIZE bytes are
4091 tfile_read (gdb_byte *readbuf, int size)
4095 gotten = read (trace_fd, readbuf, size);
4097 perror_with_name (trace_filename);
4098 else if (gotten < size)
4099 error (_("Premature end of file while reading trace file"));
4103 tfile_open (char *filename, int from_tty)
4105 volatile struct gdb_exception ex;
4107 struct cleanup *old_chain;
4110 char header[TRACE_HEADER_SIZE];
4111 char linebuf[1000]; /* Should be max remote packet size or so. */
4114 struct trace_status *ts;
4115 struct uploaded_tp *uploaded_tps = NULL;
4116 struct uploaded_tsv *uploaded_tsvs = NULL;
4118 target_preopen (from_tty);
4120 error (_("No trace file specified."));
4122 filename = tilde_expand (filename);
4123 if (!IS_ABSOLUTE_PATH(filename))
4125 temp = concat (current_directory, "/", filename, (char *) NULL);
4130 old_chain = make_cleanup (xfree, filename);
4132 flags = O_BINARY | O_LARGEFILE;
4134 scratch_chan = open (filename, flags, 0);
4135 if (scratch_chan < 0)
4136 perror_with_name (filename);
4138 /* Looks semi-reasonable. Toss the old trace file and work on the new. */
4140 discard_cleanups (old_chain); /* Don't free filename any more. */
4141 unpush_target (&tfile_ops);
4143 trace_filename = xstrdup (filename);
4144 trace_fd = scratch_chan;
4147 /* Read the file header and test for validity. */
4148 tfile_read ((gdb_byte *) &header, TRACE_HEADER_SIZE);
4150 bytes += TRACE_HEADER_SIZE;
4151 if (!(header[0] == 0x7f
4152 && (strncmp (header + 1, "TRACE0\n", 7) == 0)))
4153 error (_("File is not a valid trace file."));
4155 push_target (&tfile_ops);
4157 trace_regblock_size = 0;
4158 ts = current_trace_status ();
4159 /* We know we're working with a file. Record its name. */
4160 ts->filename = trace_filename;
4161 /* Set defaults in case there is no status line. */
4162 ts->running_known = 0;
4163 ts->stop_reason = trace_stop_reason_unknown;
4164 ts->traceframe_count = -1;
4165 ts->buffer_free = 0;
4166 ts->disconnected_tracing = 0;
4167 ts->circular_buffer = 0;
4169 TRY_CATCH (ex, RETURN_MASK_ALL)
4171 /* Read through a section of newline-terminated lines that
4172 define things like tracepoints. */
4176 tfile_read (&byte, 1);
4181 /* Empty line marks end of the definition section. */
4186 tfile_interp_line (linebuf, &uploaded_tps, &uploaded_tsvs);
4189 linebuf[i++] = byte;
4191 error (_("Excessively long lines in trace file"));
4194 /* Record the starting offset of the binary trace data. */
4195 trace_frames_offset = bytes;
4197 /* If we don't have a blocksize, we can't interpret the
4199 if (trace_regblock_size == 0)
4200 error (_("No register block size recorded in trace file"));
4204 /* Pop the partially set up target. */
4206 throw_exception (ex);
4209 inferior_appeared (current_inferior (), TFILE_PID);
4210 inferior_ptid = pid_to_ptid (TFILE_PID);
4211 add_thread_silent (inferior_ptid);
4213 if (ts->traceframe_count <= 0)
4214 warning (_("No traceframes present in this file."));
4216 /* Add the file's tracepoints and variables into the current mix. */
4218 /* Get trace state variables first, they may be checked when parsing
4219 uploaded commands. */
4220 merge_uploaded_trace_state_variables (&uploaded_tsvs);
4222 merge_uploaded_tracepoints (&uploaded_tps);
4224 post_create_inferior (&tfile_ops, from_tty);
4227 /* Interpret the given line from the definitions part of the trace
4231 tfile_interp_line (char *line,
4232 struct uploaded_tp **utpp, struct uploaded_tsv **utsvp)
4236 if (strncmp (p, "R ", strlen ("R ")) == 0)
4239 trace_regblock_size = strtol (p, &p, 16);
4241 else if (strncmp (p, "status ", strlen ("status ")) == 0)
4243 p += strlen ("status ");
4244 parse_trace_status (p, current_trace_status ());
4246 else if (strncmp (p, "tp ", strlen ("tp ")) == 0)
4248 p += strlen ("tp ");
4249 parse_tracepoint_definition (p, utpp);
4251 else if (strncmp (p, "tsv ", strlen ("tsv ")) == 0)
4253 p += strlen ("tsv ");
4254 parse_tsv_definition (p, utsvp);
4257 warning (_("Ignoring trace file definition \"%s\""), line);
4260 /* Parse the part of trace status syntax that is shared between
4261 the remote protocol and the trace file reader. */
4264 parse_trace_status (char *line, struct trace_status *ts)
4266 char *p = line, *p1, *p2, *p3, *p_temp;
4270 ts->running_known = 1;
4271 ts->running = (*p++ == '1');
4272 ts->stop_reason = trace_stop_reason_unknown;
4273 xfree (ts->stop_desc);
4274 ts->stop_desc = NULL;
4275 ts->traceframe_count = -1;
4276 ts->traceframes_created = -1;
4277 ts->buffer_free = -1;
4278 ts->buffer_size = -1;
4279 ts->disconnected_tracing = 0;
4280 ts->circular_buffer = 0;
4281 xfree (ts->user_name);
4282 ts->user_name = NULL;
4285 ts->start_time = ts->stop_time = 0;
4289 p1 = strchr (p, ':');
4291 error (_("Malformed trace status, at %s\n\
4292 Status line: '%s'\n"), p, line);
4293 p3 = strchr (p, ';');
4295 p3 = p + strlen (p);
4296 if (strncmp (p, stop_reason_names[trace_buffer_full], p1 - p) == 0)
4298 p = unpack_varlen_hex (++p1, &val);
4299 ts->stop_reason = trace_buffer_full;
4301 else if (strncmp (p, stop_reason_names[trace_never_run], p1 - p) == 0)
4303 p = unpack_varlen_hex (++p1, &val);
4304 ts->stop_reason = trace_never_run;
4306 else if (strncmp (p, stop_reason_names[tracepoint_passcount],
4309 p = unpack_varlen_hex (++p1, &val);
4310 ts->stop_reason = tracepoint_passcount;
4311 ts->stopping_tracepoint = val;
4313 else if (strncmp (p, stop_reason_names[tstop_command], p1 - p) == 0)
4315 p2 = strchr (++p1, ':');
4323 ts->stop_desc = xmalloc (strlen (line));
4324 end = hex2bin (p1, ts->stop_desc, (p2 - p1) / 2);
4325 ts->stop_desc[end] = '\0';
4328 ts->stop_desc = xstrdup ("");
4330 p = unpack_varlen_hex (++p2, &val);
4331 ts->stop_reason = tstop_command;
4333 else if (strncmp (p, stop_reason_names[trace_disconnected], p1 - p) == 0)
4335 p = unpack_varlen_hex (++p1, &val);
4336 ts->stop_reason = trace_disconnected;
4338 else if (strncmp (p, stop_reason_names[tracepoint_error], p1 - p) == 0)
4340 p2 = strchr (++p1, ':');
4343 ts->stop_desc = xmalloc ((p2 - p1) / 2 + 1);
4344 end = hex2bin (p1, ts->stop_desc, (p2 - p1) / 2);
4345 ts->stop_desc[end] = '\0';
4348 ts->stop_desc = xstrdup ("");
4350 p = unpack_varlen_hex (++p2, &val);
4351 ts->stopping_tracepoint = val;
4352 ts->stop_reason = tracepoint_error;
4354 else if (strncmp (p, "tframes", p1 - p) == 0)
4356 p = unpack_varlen_hex (++p1, &val);
4357 ts->traceframe_count = val;
4359 else if (strncmp (p, "tcreated", p1 - p) == 0)
4361 p = unpack_varlen_hex (++p1, &val);
4362 ts->traceframes_created = val;
4364 else if (strncmp (p, "tfree", p1 - p) == 0)
4366 p = unpack_varlen_hex (++p1, &val);
4367 ts->buffer_free = val;
4369 else if (strncmp (p, "tsize", p1 - p) == 0)
4371 p = unpack_varlen_hex (++p1, &val);
4372 ts->buffer_size = val;
4374 else if (strncmp (p, "disconn", p1 - p) == 0)
4376 p = unpack_varlen_hex (++p1, &val);
4377 ts->disconnected_tracing = val;
4379 else if (strncmp (p, "circular", p1 - p) == 0)
4381 p = unpack_varlen_hex (++p1, &val);
4382 ts->circular_buffer = val;
4384 else if (strncmp (p, "starttime", p1 - p) == 0)
4386 p = unpack_varlen_hex (++p1, &val);
4387 ts->start_time = val;
4389 else if (strncmp (p, "stoptime", p1 - p) == 0)
4391 p = unpack_varlen_hex (++p1, &val);
4392 ts->stop_time = val;
4394 else if (strncmp (p, "username", p1 - p) == 0)
4397 ts->user_name = xmalloc (strlen (p) / 2);
4398 end = hex2bin (p1, ts->user_name, (p3 - p1) / 2);
4399 ts->user_name[end] = '\0';
4402 else if (strncmp (p, "notes", p1 - p) == 0)
4405 ts->notes = xmalloc (strlen (p) / 2);
4406 end = hex2bin (p1, ts->notes, (p3 - p1) / 2);
4407 ts->notes[end] = '\0';
4412 /* Silently skip unknown optional info. */
4413 p_temp = strchr (p1 + 1, ';');
4417 /* Must be at the end. */
4424 parse_tracepoint_status (char *p, struct breakpoint *bp,
4425 struct uploaded_tp *utp)
4428 struct tracepoint *tp = (struct tracepoint *) bp;
4430 p = unpack_varlen_hex (p, &uval);
4432 tp->base.hit_count += uval;
4434 utp->hit_count += uval;
4435 p = unpack_varlen_hex (p + 1, &uval);
4437 tp->traceframe_usage += uval;
4439 utp->traceframe_usage += uval;
4440 /* Ignore any extra, allowing for future extensions. */
4443 /* Given a line of text defining a part of a tracepoint, parse it into
4444 an "uploaded tracepoint". */
4447 parse_tracepoint_definition (char *line, struct uploaded_tp **utpp)
4451 ULONGEST num, addr, step, pass, orig_size, xlen, start;
4454 char *cond, *srctype, *buf;
4455 struct uploaded_tp *utp = NULL;
4458 /* Both tracepoint and action definitions start with the same number
4459 and address sequence. */
4461 p = unpack_varlen_hex (p, &num);
4462 p++; /* skip a colon */
4463 p = unpack_varlen_hex (p, &addr);
4464 p++; /* skip a colon */
4467 enabled = (*p++ == 'E');
4468 p++; /* skip a colon */
4469 p = unpack_varlen_hex (p, &step);
4470 p++; /* skip a colon */
4471 p = unpack_varlen_hex (p, &pass);
4472 type = bp_tracepoint;
4474 /* Thumb through optional fields. */
4477 p++; /* skip a colon */
4480 type = bp_fast_tracepoint;
4482 p = unpack_varlen_hex (p, &orig_size);
4486 type = bp_static_tracepoint;
4492 p = unpack_varlen_hex (p, &xlen);
4493 p++; /* skip a comma */
4494 cond = (char *) xmalloc (2 * xlen + 1);
4495 strncpy (cond, p, 2 * xlen);
4496 cond[2 * xlen] = '\0';
4500 warning (_("Unrecognized char '%c' in tracepoint "
4501 "definition, skipping rest"), *p);
4503 utp = get_uploaded_tp (num, addr, utpp);
4505 utp->enabled = enabled;
4510 else if (piece == 'A')
4512 utp = get_uploaded_tp (num, addr, utpp);
4513 VEC_safe_push (char_ptr, utp->actions, xstrdup (p));
4515 else if (piece == 'S')
4517 utp = get_uploaded_tp (num, addr, utpp);
4518 VEC_safe_push (char_ptr, utp->step_actions, xstrdup (p));
4520 else if (piece == 'Z')
4522 /* Parse a chunk of source form definition. */
4523 utp = get_uploaded_tp (num, addr, utpp);
4525 p = strchr (p, ':');
4526 p++; /* skip a colon */
4527 p = unpack_varlen_hex (p, &start);
4528 p++; /* skip a colon */
4529 p = unpack_varlen_hex (p, &xlen);
4530 p++; /* skip a colon */
4532 buf = alloca (strlen (line));
4534 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
4537 if (strncmp (srctype, "at:", strlen ("at:")) == 0)
4538 utp->at_string = xstrdup (buf);
4539 else if (strncmp (srctype, "cond:", strlen ("cond:")) == 0)
4540 utp->cond_string = xstrdup (buf);
4541 else if (strncmp (srctype, "cmd:", strlen ("cmd:")) == 0)
4542 VEC_safe_push (char_ptr, utp->cmd_strings, xstrdup (buf));
4544 else if (piece == 'V')
4546 utp = get_uploaded_tp (num, addr, utpp);
4548 parse_tracepoint_status (p, NULL, utp);
4552 /* Don't error out, the target might be sending us optional
4553 info that we don't care about. */
4554 warning (_("Unrecognized tracepoint piece '%c', ignoring"), piece);
4558 /* Convert a textual description of a trace state variable into an
4562 parse_tsv_definition (char *line, struct uploaded_tsv **utsvp)
4565 ULONGEST num, initval, builtin;
4567 struct uploaded_tsv *utsv = NULL;
4569 buf = alloca (strlen (line));
4572 p = unpack_varlen_hex (p, &num);
4573 p++; /* skip a colon */
4574 p = unpack_varlen_hex (p, &initval);
4575 p++; /* skip a colon */
4576 p = unpack_varlen_hex (p, &builtin);
4577 p++; /* skip a colon */
4578 end = hex2bin (p, (gdb_byte *) buf, strlen (p) / 2);
4581 utsv = get_uploaded_tsv (num, utsvp);
4582 utsv->initial_value = initval;
4583 utsv->builtin = builtin;
4584 utsv->name = xstrdup (buf);
4587 /* Close the trace file and generally clean up. */
4590 tfile_close (int quitting)
4597 pid = ptid_get_pid (inferior_ptid);
4598 inferior_ptid = null_ptid; /* Avoid confusion from thread stuff. */
4599 exit_inferior_silent (pid);
4603 xfree (trace_filename);
4604 trace_filename = NULL;
4608 tfile_files_info (struct target_ops *t)
4610 printf_filtered ("\t`%s'\n", trace_filename);
4613 /* The trace status for a file is that tracing can never be run. */
4616 tfile_get_trace_status (struct trace_status *ts)
4618 /* Other bits of trace status were collected as part of opening the
4619 trace files, so nothing to do here. */
4625 tfile_get_tracepoint_status (struct breakpoint *tp, struct uploaded_tp *utp)
4627 /* Other bits of trace status were collected as part of opening the
4628 trace files, so nothing to do here. */
4631 /* Given the position of a traceframe in the file, figure out what
4632 address the frame was collected at. This would normally be the
4633 value of a collected PC register, but if not available, we
4637 tfile_get_traceframe_address (off_t tframe_offset)
4641 struct tracepoint *tp;
4642 off_t saved_offset = cur_offset;
4644 /* FIXME dig pc out of collected registers. */
4646 /* Fall back to using tracepoint address. */
4647 lseek (trace_fd, tframe_offset, SEEK_SET);
4648 tfile_read ((gdb_byte *) &tpnum, 2);
4649 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
4651 (target_gdbarch ()));
4653 tp = get_tracepoint_by_number_on_target (tpnum);
4654 /* FIXME this is a poor heuristic if multiple locations. */
4655 if (tp && tp->base.loc)
4656 addr = tp->base.loc->address;
4658 /* Restore our seek position. */
4659 cur_offset = saved_offset;
4660 lseek (trace_fd, cur_offset, SEEK_SET);
4664 /* Given a type of search and some parameters, scan the collection of
4665 traceframes in the file looking for a match. When found, return
4666 both the traceframe and tracepoint number, otherwise -1 for
4670 tfile_trace_find (enum trace_find_type type, int num,
4671 ULONGEST addr1, ULONGEST addr2, int *tpp)
4674 int tfnum = 0, found = 0;
4675 unsigned int data_size;
4676 struct tracepoint *tp;
4677 off_t offset, tframe_offset;
4687 lseek (trace_fd, trace_frames_offset, SEEK_SET);
4688 offset = trace_frames_offset;
4691 tframe_offset = offset;
4692 tfile_read ((gdb_byte *) &tpnum, 2);
4693 tpnum = (short) extract_signed_integer ((gdb_byte *) &tpnum, 2,
4695 (target_gdbarch ()));
4699 tfile_read ((gdb_byte *) &data_size, 4);
4700 data_size = (unsigned int) extract_unsigned_integer
4701 ((gdb_byte *) &data_size, 4,
4702 gdbarch_byte_order (target_gdbarch ()));
4705 if (type == tfind_number)
4707 /* Looking for a specific trace frame. */
4713 /* Start from the _next_ trace frame. */
4714 if (tfnum > traceframe_number)
4719 tfaddr = tfile_get_traceframe_address (tframe_offset);
4720 if (tfaddr == addr1)
4724 tp = get_tracepoint (num);
4725 if (tp && tpnum == tp->number_on_target)
4729 tfaddr = tfile_get_traceframe_address (tframe_offset);
4730 if (addr1 <= tfaddr && tfaddr <= addr2)
4734 tfaddr = tfile_get_traceframe_address (tframe_offset);
4735 if (!(addr1 <= tfaddr && tfaddr <= addr2))
4739 internal_error (__FILE__, __LINE__, _("unknown tfind type"));
4748 cur_offset = offset;
4749 cur_data_size = data_size;
4753 /* Skip past the traceframe's data. */
4754 lseek (trace_fd, data_size, SEEK_CUR);
4755 offset += data_size;
4756 /* Update our own count of traceframes. */
4759 /* Did not find what we were looking for. */
4765 /* Prototype of the callback passed to tframe_walk_blocks. */
4766 typedef int (*walk_blocks_callback_func) (char blocktype, void *data);
4768 /* Callback for traceframe_walk_blocks, used to find a given block
4769 type in a traceframe. */
4772 match_blocktype (char blocktype, void *data)
4774 char *wantedp = data;
4776 if (*wantedp == blocktype)
4782 /* Walk over all traceframe block starting at POS offset from
4783 CUR_OFFSET, and call CALLBACK for each block found, passing in DATA
4784 unmodified. If CALLBACK returns true, this returns the position in
4785 the traceframe where the block is found, relative to the start of
4786 the traceframe (cur_offset). Returns -1 if no callback call
4787 returned true, indicating that all blocks have been walked. */
4790 traceframe_walk_blocks (walk_blocks_callback_func callback,
4791 int pos, void *data)
4793 /* Iterate through a traceframe's blocks, looking for a block of the
4796 lseek (trace_fd, cur_offset + pos, SEEK_SET);
4797 while (pos < cur_data_size)
4799 unsigned short mlen;
4802 tfile_read (&block_type, 1);
4806 if ((*callback) (block_type, data))
4812 lseek (trace_fd, cur_offset + pos + trace_regblock_size, SEEK_SET);
4813 pos += trace_regblock_size;
4816 lseek (trace_fd, cur_offset + pos + 8, SEEK_SET);
4817 tfile_read ((gdb_byte *) &mlen, 2);
4818 mlen = (unsigned short)
4819 extract_unsigned_integer ((gdb_byte *) &mlen, 2,
4821 (target_gdbarch ()));
4822 lseek (trace_fd, mlen, SEEK_CUR);
4823 pos += (8 + 2 + mlen);
4826 lseek (trace_fd, cur_offset + pos + 4 + 8, SEEK_SET);
4830 error (_("Unknown block type '%c' (0x%x) in trace frame"),
4831 block_type, block_type);
4839 /* Convenience wrapper around traceframe_walk_blocks. Looks for the
4840 position offset of a block of type TYPE_WANTED in the current trace
4841 frame, starting at POS. Returns -1 if no such block was found. */
4844 traceframe_find_block_type (char type_wanted, int pos)
4846 return traceframe_walk_blocks (match_blocktype, pos, &type_wanted);
4849 /* Look for a block of saved registers in the traceframe, and get the
4850 requested register from it. */
4853 tfile_fetch_registers (struct target_ops *ops,
4854 struct regcache *regcache, int regno)
4856 struct gdbarch *gdbarch = get_regcache_arch (regcache);
4857 int offset, regn, regsize, pc_regno;
4860 /* An uninitialized reg size says we're not going to be
4861 successful at getting register blocks. */
4862 if (!trace_regblock_size)
4865 regs = alloca (trace_regblock_size);
4867 if (traceframe_find_block_type ('R', 0) >= 0)
4869 tfile_read (regs, trace_regblock_size);
4871 /* Assume the block is laid out in GDB register number order,
4872 each register with the size that it has in GDB. */
4874 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4876 regsize = register_size (gdbarch, regn);
4877 /* Make sure we stay within block bounds. */
4878 if (offset + regsize >= trace_regblock_size)
4880 if (regcache_register_status (regcache, regn) == REG_UNKNOWN)
4884 regcache_raw_supply (regcache, regno, regs + offset);
4887 else if (regno == -1)
4889 regcache_raw_supply (regcache, regn, regs + offset);
4897 /* We get here if no register data has been found. Mark registers
4899 for (regn = 0; regn < gdbarch_num_regs (gdbarch); regn++)
4900 regcache_raw_supply (regcache, regn, NULL);
4902 /* We can often usefully guess that the PC is going to be the same
4903 as the address of the tracepoint. */
4904 pc_regno = gdbarch_pc_regnum (gdbarch);
4905 if (pc_regno >= 0 && (regno == -1 || regno == pc_regno))
4907 struct tracepoint *tp = get_tracepoint (tracepoint_number);
4909 if (tp && tp->base.loc)
4911 /* But don't try to guess if tracepoint is multi-location... */
4912 if (tp->base.loc->next)
4914 warning (_("Tracepoint %d has multiple "
4915 "locations, cannot infer $pc"),
4919 /* ... or does while-stepping. */
4920 if (tp->step_count > 0)
4922 warning (_("Tracepoint %d does while-stepping, "
4923 "cannot infer $pc"),
4928 store_unsigned_integer (regs, register_size (gdbarch, pc_regno),
4929 gdbarch_byte_order (gdbarch),
4930 tp->base.loc->address);
4931 regcache_raw_supply (regcache, pc_regno, regs);
4937 tfile_xfer_partial (struct target_ops *ops, enum target_object object,
4938 const char *annex, gdb_byte *readbuf,
4939 const gdb_byte *writebuf, ULONGEST offset, LONGEST len)
4941 /* We're only doing regular memory for now. */
4942 if (object != TARGET_OBJECT_MEMORY)
4945 if (readbuf == NULL)
4946 error (_("tfile_xfer_partial: trace file is read-only"));
4948 if (traceframe_number != -1)
4952 /* Iterate through the traceframe's blocks, looking for
4954 while ((pos = traceframe_find_block_type ('M', pos)) >= 0)
4956 ULONGEST maddr, amt;
4957 unsigned short mlen;
4958 enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
4960 tfile_read ((gdb_byte *) &maddr, 8);
4961 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
4963 tfile_read ((gdb_byte *) &mlen, 2);
4964 mlen = (unsigned short)
4965 extract_unsigned_integer ((gdb_byte *) &mlen, 2, byte_order);
4967 /* If the block includes the first part of the desired
4968 range, return as much it has; GDB will re-request the
4969 remainder, which might be in a different block of this
4971 if (maddr <= offset && offset < (maddr + mlen))
4973 amt = (maddr + mlen) - offset;
4977 if (maddr != offset)
4978 lseek (trace_fd, offset - maddr, SEEK_CUR);
4979 tfile_read (readbuf, amt);
4983 /* Skip over this block. */
4984 pos += (8 + 2 + mlen);
4988 /* It's unduly pedantic to refuse to look at the executable for
4989 read-only pieces; so do the equivalent of readonly regions aka
4991 /* FIXME account for relocation at some point. */
4998 for (s = exec_bfd->sections; s; s = s->next)
5000 if ((s->flags & SEC_LOAD) == 0
5001 || (s->flags & SEC_READONLY) == 0)
5005 size = bfd_get_section_size (s);
5006 if (vma <= offset && offset < (vma + size))
5010 amt = (vma + size) - offset;
5014 amt = bfd_get_section_contents (exec_bfd, s,
5015 readbuf, offset - vma, amt);
5021 /* Indicate failure to find the requested memory block. */
5025 /* Iterate through the blocks of a trace frame, looking for a 'V'
5026 block with a matching tsv number. */
5029 tfile_get_trace_state_variable_value (int tsvnum, LONGEST *val)
5034 /* Iterate over blocks in current frame and find the last 'V'
5035 block in which tsv number is TSVNUM. In one trace frame, there
5036 may be multiple 'V' blocks created for a given trace variable,
5037 and the last matched 'V' block contains the updated value. */
5039 while ((pos = traceframe_find_block_type ('V', pos)) >= 0)
5043 tfile_read ((gdb_byte *) &vnum, 4);
5044 vnum = (int) extract_signed_integer ((gdb_byte *) &vnum, 4,
5046 (target_gdbarch ()));
5049 tfile_read ((gdb_byte *) val, 8);
5050 *val = extract_signed_integer ((gdb_byte *) val, 8,
5052 (target_gdbarch ()));
5062 tfile_has_all_memory (struct target_ops *ops)
5068 tfile_has_memory (struct target_ops *ops)
5074 tfile_has_stack (struct target_ops *ops)
5076 return traceframe_number != -1;
5080 tfile_has_registers (struct target_ops *ops)
5082 return traceframe_number != -1;
5086 tfile_thread_alive (struct target_ops *ops, ptid_t ptid)
5091 /* Callback for traceframe_walk_blocks. Builds a traceframe_info
5092 object for the tfile target's current traceframe. */
5095 build_traceframe_info (char blocktype, void *data)
5097 struct traceframe_info *info = data;
5103 struct mem_range *r;
5105 unsigned short mlen;
5107 tfile_read ((gdb_byte *) &maddr, 8);
5108 maddr = extract_unsigned_integer ((gdb_byte *) &maddr, 8,
5110 (target_gdbarch ()));
5111 tfile_read ((gdb_byte *) &mlen, 2);
5112 mlen = (unsigned short)
5113 extract_unsigned_integer ((gdb_byte *) &mlen,
5114 2, gdbarch_byte_order
5115 (target_gdbarch ()));
5117 r = VEC_safe_push (mem_range_s, info->memory, NULL);
5130 warning (_("Unhandled trace block type (%d) '%c ' "
5131 "while building trace frame info."),
5132 blocktype, blocktype);
5139 static struct traceframe_info *
5140 tfile_traceframe_info (void)
5142 struct traceframe_info *info = XCNEW (struct traceframe_info);
5144 traceframe_walk_blocks (build_traceframe_info, 0, info);
5149 init_tfile_ops (void)
5151 tfile_ops.to_shortname = "tfile";
5152 tfile_ops.to_longname = "Local trace dump file";
5154 = "Use a trace file as a target. Specify the filename of the trace file.";
5155 tfile_ops.to_open = tfile_open;
5156 tfile_ops.to_close = tfile_close;
5157 tfile_ops.to_fetch_registers = tfile_fetch_registers;
5158 tfile_ops.to_xfer_partial = tfile_xfer_partial;
5159 tfile_ops.to_files_info = tfile_files_info;
5160 tfile_ops.to_get_trace_status = tfile_get_trace_status;
5161 tfile_ops.to_get_tracepoint_status = tfile_get_tracepoint_status;
5162 tfile_ops.to_trace_find = tfile_trace_find;
5163 tfile_ops.to_get_trace_state_variable_value
5164 = tfile_get_trace_state_variable_value;
5165 tfile_ops.to_stratum = process_stratum;
5166 tfile_ops.to_has_all_memory = tfile_has_all_memory;
5167 tfile_ops.to_has_memory = tfile_has_memory;
5168 tfile_ops.to_has_stack = tfile_has_stack;
5169 tfile_ops.to_has_registers = tfile_has_registers;
5170 tfile_ops.to_traceframe_info = tfile_traceframe_info;
5171 tfile_ops.to_thread_alive = tfile_thread_alive;
5172 tfile_ops.to_magic = OPS_MAGIC;
5176 free_current_marker (void *arg)
5178 struct static_tracepoint_marker **marker_p = arg;
5180 if (*marker_p != NULL)
5182 release_static_tracepoint_marker (*marker_p);
5189 /* Given a line of text defining a static tracepoint marker, parse it
5190 into a "static tracepoint marker" object. Throws an error is
5191 parsing fails. If PP is non-null, it points to one past the end of
5192 the parsed marker definition. */
5195 parse_static_tracepoint_marker_definition (char *line, char **pp,
5196 struct static_tracepoint_marker *marker)
5203 p = unpack_varlen_hex (p, &addr);
5204 p++; /* skip a colon */
5206 marker->gdbarch = target_gdbarch ();
5207 marker->address = (CORE_ADDR) addr;
5209 endp = strchr (p, ':');
5211 error (_("bad marker definition: %s"), line);
5213 marker->str_id = xmalloc (endp - p + 1);
5214 end = hex2bin (p, (gdb_byte *) marker->str_id, (endp - p + 1) / 2);
5215 marker->str_id[end] = '\0';
5218 p++; /* skip a colon */
5220 marker->extra = xmalloc (strlen (p) + 1);
5221 end = hex2bin (p, (gdb_byte *) marker->extra, strlen (p) / 2);
5222 marker->extra[end] = '\0';
5228 /* Release a static tracepoint marker's contents. Note that the
5229 object itself isn't released here. There objects are usually on
5233 release_static_tracepoint_marker (struct static_tracepoint_marker *marker)
5235 xfree (marker->str_id);
5236 marker->str_id = NULL;
5239 /* Print MARKER to gdb_stdout. */
5242 print_one_static_tracepoint_marker (int count,
5243 struct static_tracepoint_marker *marker)
5245 struct command_line *l;
5248 char wrap_indent[80];
5249 char extra_field_indent[80];
5250 struct ui_out *uiout = current_uiout;
5251 struct cleanup *bkpt_chain;
5252 VEC(breakpoint_p) *tracepoints;
5254 struct symtab_and_line sal;
5258 sal.pc = marker->address;
5260 tracepoints = static_tracepoints_here (marker->address);
5262 bkpt_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "marker");
5264 /* A counter field to help readability. This is not a stable
5266 ui_out_field_int (uiout, "count", count);
5268 ui_out_field_string (uiout, "marker-id", marker->str_id);
5270 ui_out_field_fmt (uiout, "enabled", "%c",
5271 !VEC_empty (breakpoint_p, tracepoints) ? 'y' : 'n');
5272 ui_out_spaces (uiout, 2);
5274 strcpy (wrap_indent, " ");
5276 if (gdbarch_addr_bit (marker->gdbarch) <= 32)
5277 strcat (wrap_indent, " ");
5279 strcat (wrap_indent, " ");
5281 strcpy (extra_field_indent, " ");
5283 ui_out_field_core_addr (uiout, "addr", marker->gdbarch, marker->address);
5285 sal = find_pc_line (marker->address, 0);
5286 sym = find_pc_sect_function (marker->address, NULL);
5289 ui_out_text (uiout, "in ");
5290 ui_out_field_string (uiout, "func",
5291 SYMBOL_PRINT_NAME (sym));
5292 ui_out_wrap_hint (uiout, wrap_indent);
5293 ui_out_text (uiout, " at ");
5296 ui_out_field_skip (uiout, "func");
5298 if (sal.symtab != NULL)
5300 ui_out_field_string (uiout, "file",
5301 symtab_to_filename_for_display (sal.symtab));
5302 ui_out_text (uiout, ":");
5304 if (ui_out_is_mi_like_p (uiout))
5306 const char *fullname = symtab_to_fullname (sal.symtab);
5308 ui_out_field_string (uiout, "fullname", fullname);
5311 ui_out_field_skip (uiout, "fullname");
5313 ui_out_field_int (uiout, "line", sal.line);
5317 ui_out_field_skip (uiout, "fullname");
5318 ui_out_field_skip (uiout, "line");
5321 ui_out_text (uiout, "\n");
5322 ui_out_text (uiout, extra_field_indent);
5323 ui_out_text (uiout, _("Data: \""));
5324 ui_out_field_string (uiout, "extra-data", marker->extra);
5325 ui_out_text (uiout, "\"\n");
5327 if (!VEC_empty (breakpoint_p, tracepoints))
5329 struct cleanup *cleanup_chain;
5331 struct breakpoint *b;
5333 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout,
5336 ui_out_text (uiout, extra_field_indent);
5337 ui_out_text (uiout, _("Probed by static tracepoints: "));
5338 for (ix = 0; VEC_iterate(breakpoint_p, tracepoints, ix, b); ix++)
5341 ui_out_text (uiout, ", ");
5342 ui_out_text (uiout, "#");
5343 ui_out_field_int (uiout, "tracepoint-id", b->number);
5346 do_cleanups (cleanup_chain);
5348 if (ui_out_is_mi_like_p (uiout))
5349 ui_out_field_int (uiout, "number-of-tracepoints",
5350 VEC_length(breakpoint_p, tracepoints));
5352 ui_out_text (uiout, "\n");
5354 VEC_free (breakpoint_p, tracepoints);
5356 do_cleanups (bkpt_chain);
5360 info_static_tracepoint_markers_command (char *arg, int from_tty)
5362 VEC(static_tracepoint_marker_p) *markers;
5363 struct cleanup *old_chain;
5364 struct static_tracepoint_marker *marker;
5365 struct ui_out *uiout = current_uiout;
5368 /* We don't have to check target_can_use_agent and agent's capability on
5369 static tracepoint here, in order to be compatible with older GDBserver.
5370 We don't check USE_AGENT is true or not, because static tracepoints
5371 don't work without in-process agent, so we don't bother users to type
5372 `set agent on' when to use static tracepoint. */
5375 = make_cleanup_ui_out_table_begin_end (uiout, 5, -1,
5376 "StaticTracepointMarkersTable");
5378 ui_out_table_header (uiout, 7, ui_left, "counter", "Cnt");
5380 ui_out_table_header (uiout, 40, ui_left, "marker-id", "ID");
5382 ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");
5383 if (gdbarch_addr_bit (target_gdbarch ()) <= 32)
5384 ui_out_table_header (uiout, 10, ui_left, "addr", "Address");
5386 ui_out_table_header (uiout, 18, ui_left, "addr", "Address");
5387 ui_out_table_header (uiout, 40, ui_noalign, "what", "What");
5389 ui_out_table_body (uiout);
5391 markers = target_static_tracepoint_markers_by_strid (NULL);
5392 make_cleanup (VEC_cleanup (static_tracepoint_marker_p), &markers);
5395 VEC_iterate (static_tracepoint_marker_p,
5396 markers, i, marker);
5399 print_one_static_tracepoint_marker (i + 1, marker);
5400 release_static_tracepoint_marker (marker);
5403 do_cleanups (old_chain);
5406 /* The $_sdata convenience variable is a bit special. We don't know
5407 for sure type of the value until we actually have a chance to fetch
5408 the data --- the size of the object depends on what has been
5409 collected. We solve this by making $_sdata be an internalvar that
5410 creates a new value on access. */
5412 /* Return a new value with the correct type for the sdata object of
5413 the current trace frame. Return a void value if there's no object
5416 static struct value *
5417 sdata_make_value (struct gdbarch *gdbarch, struct internalvar *var,
5423 /* We need to read the whole object before we know its size. */
5424 size = target_read_alloc (¤t_target,
5425 TARGET_OBJECT_STATIC_TRACE_DATA,
5432 type = init_vector_type (builtin_type (gdbarch)->builtin_true_char,
5434 v = allocate_value (type);
5435 memcpy (value_contents_raw (v), buf, size);
5440 return allocate_value (builtin_type (gdbarch)->builtin_void);
5443 #if !defined(HAVE_LIBEXPAT)
5445 struct traceframe_info *
5446 parse_traceframe_info (const char *tframe_info)
5448 static int have_warned;
5453 warning (_("Can not parse XML trace frame info; XML support "
5454 "was disabled at compile time"));
5460 #else /* HAVE_LIBEXPAT */
5462 #include "xml-support.h"
5464 /* Handle the start of a <memory> element. */
5467 traceframe_info_start_memory (struct gdb_xml_parser *parser,
5468 const struct gdb_xml_element *element,
5469 void *user_data, VEC(gdb_xml_value_s) *attributes)
5471 struct traceframe_info *info = user_data;
5472 struct mem_range *r = VEC_safe_push (mem_range_s, info->memory, NULL);
5473 ULONGEST *start_p, *length_p;
5475 start_p = xml_find_attribute (attributes, "start")->value;
5476 length_p = xml_find_attribute (attributes, "length")->value;
5478 r->start = *start_p;
5479 r->length = *length_p;
5482 /* Discard the constructed trace frame info (if an error occurs). */
5485 free_result (void *p)
5487 struct traceframe_info *result = p;
5489 free_traceframe_info (result);
5492 /* The allowed elements and attributes for an XML memory map. */
5494 static const struct gdb_xml_attribute memory_attributes[] = {
5495 { "start", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
5496 { "length", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
5497 { NULL, GDB_XML_AF_NONE, NULL, NULL }
5500 static const struct gdb_xml_element traceframe_info_children[] = {
5501 { "memory", memory_attributes, NULL,
5502 GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
5503 traceframe_info_start_memory, NULL },
5504 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
5507 static const struct gdb_xml_element traceframe_info_elements[] = {
5508 { "traceframe-info", NULL, traceframe_info_children, GDB_XML_EF_NONE,
5510 { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
5513 /* Parse a traceframe-info XML document. */
5515 struct traceframe_info *
5516 parse_traceframe_info (const char *tframe_info)
5518 struct traceframe_info *result;
5519 struct cleanup *back_to;
5521 result = XCNEW (struct traceframe_info);
5522 back_to = make_cleanup (free_result, result);
5524 if (gdb_xml_parse_quick (_("trace frame info"),
5525 "traceframe-info.dtd", traceframe_info_elements,
5526 tframe_info, result) == 0)
5528 /* Parsed successfully, keep the result. */
5529 discard_cleanups (back_to);
5534 do_cleanups (back_to);
5538 #endif /* HAVE_LIBEXPAT */
5540 /* Returns the traceframe_info object for the current traceframe.
5541 This is where we avoid re-fetching the object from the target if we
5542 already have it cached. */
5544 static struct traceframe_info *
5545 get_traceframe_info (void)
5547 if (traceframe_info == NULL)
5548 traceframe_info = target_traceframe_info ();
5550 return traceframe_info;
5553 /* If the target supports the query, return in RESULT the set of
5554 collected memory in the current traceframe, found within the LEN
5555 bytes range starting at MEMADDR. Returns true if the target
5556 supports the query, otherwise returns false, and RESULT is left
5560 traceframe_available_memory (VEC(mem_range_s) **result,
5561 CORE_ADDR memaddr, ULONGEST len)
5563 struct traceframe_info *info = get_traceframe_info ();
5567 struct mem_range *r;
5572 for (i = 0; VEC_iterate (mem_range_s, info->memory, i, r); i++)
5573 if (mem_ranges_overlap (r->start, r->length, memaddr, len))
5575 ULONGEST lo1, hi1, lo2, hi2;
5576 struct mem_range *nr;
5579 hi1 = memaddr + len;
5582 hi2 = r->start + r->length;
5584 nr = VEC_safe_push (mem_range_s, *result, NULL);
5586 nr->start = max (lo1, lo2);
5587 nr->length = min (hi1, hi2) - nr->start;
5590 normalize_mem_ranges (*result);
5597 /* Implementation of `sdata' variable. */
5599 static const struct internalvar_funcs sdata_funcs =
5606 /* module initialization */
5608 _initialize_tracepoint (void)
5610 struct cmd_list_element *c;
5612 /* Explicitly create without lookup, since that tries to create a
5613 value with a void typed value, and when we get here, gdbarch
5614 isn't initialized yet. At this point, we're quite sure there
5615 isn't another convenience variable of the same name. */
5616 create_internalvar_type_lazy ("_sdata", &sdata_funcs, NULL);
5618 traceframe_number = -1;
5619 tracepoint_number = -1;
5621 if (tracepoint_list.list == NULL)
5623 tracepoint_list.listsize = 128;
5624 tracepoint_list.list = xmalloc
5625 (tracepoint_list.listsize * sizeof (struct memrange));
5627 if (tracepoint_list.aexpr_list == NULL)
5629 tracepoint_list.aexpr_listsize = 128;
5630 tracepoint_list.aexpr_list = xmalloc
5631 (tracepoint_list.aexpr_listsize * sizeof (struct agent_expr *));
5634 if (stepping_list.list == NULL)
5636 stepping_list.listsize = 128;
5637 stepping_list.list = xmalloc
5638 (stepping_list.listsize * sizeof (struct memrange));
5641 if (stepping_list.aexpr_list == NULL)
5643 stepping_list.aexpr_listsize = 128;
5644 stepping_list.aexpr_list = xmalloc
5645 (stepping_list.aexpr_listsize * sizeof (struct agent_expr *));
5648 add_info ("scope", scope_info,
5649 _("List the variables local to a scope"));
5651 add_cmd ("tracepoints", class_trace, NULL,
5652 _("Tracing of program execution without stopping the program."),
5655 add_com ("tdump", class_trace, trace_dump_command,
5656 _("Print everything collected at the current tracepoint."));
5658 add_com ("tsave", class_trace, trace_save_command, _("\
5659 Save the trace data to a file.\n\
5660 Use the '-r' option to direct the target to save directly to the file,\n\
5661 using its own filesystem."));
5663 c = add_com ("tvariable", class_trace, trace_variable_command,_("\
5664 Define a trace state variable.\n\
5665 Argument is a $-prefixed name, optionally followed\n\
5666 by '=' and an expression that sets the initial value\n\
5667 at the start of tracing."));
5668 set_cmd_completer (c, expression_completer);
5670 add_cmd ("tvariable", class_trace, delete_trace_variable_command, _("\
5671 Delete one or more trace state variables.\n\
5672 Arguments are the names of the variables to delete.\n\
5673 If no arguments are supplied, delete all variables."), &deletelist);
5674 /* FIXME add a trace variable completer. */
5676 add_info ("tvariables", tvariables_info, _("\
5677 Status of trace state variables and their values.\n\
5680 add_info ("static-tracepoint-markers",
5681 info_static_tracepoint_markers_command, _("\
5682 List target static tracepoints markers.\n\
5685 add_prefix_cmd ("tfind", class_trace, trace_find_command, _("\
5686 Select a trace frame;\n\
5687 No argument means forward by one frame; '-' means backward by one frame."),
5688 &tfindlist, "tfind ", 1, &cmdlist);
5690 add_cmd ("outside", class_trace, trace_find_outside_command, _("\
5691 Select a trace frame whose PC is outside the given range (exclusive).\n\
5692 Usage: tfind outside addr1, addr2"),
5695 add_cmd ("range", class_trace, trace_find_range_command, _("\
5696 Select a trace frame whose PC is in the given range (inclusive).\n\
5697 Usage: tfind range addr1,addr2"),
5700 add_cmd ("line", class_trace, trace_find_line_command, _("\
5701 Select a trace frame by source line.\n\
5702 Argument can be a line number (with optional source file),\n\
5703 a function name, or '*' followed by an address.\n\
5704 Default argument is 'the next source line that was traced'."),
5707 add_cmd ("tracepoint", class_trace, trace_find_tracepoint_command, _("\
5708 Select a trace frame by tracepoint number.\n\
5709 Default is the tracepoint for the current trace frame."),
5712 add_cmd ("pc", class_trace, trace_find_pc_command, _("\
5713 Select a trace frame by PC.\n\
5714 Default is the current PC, or the PC of the current trace frame."),
5717 add_cmd ("end", class_trace, trace_find_end_command, _("\
5718 De-select any trace frame and resume 'live' debugging."),
5721 add_alias_cmd ("none", "end", class_trace, 0, &tfindlist);
5723 add_cmd ("start", class_trace, trace_find_start_command,
5724 _("Select the first trace frame in the trace buffer."),
5727 add_com ("tstatus", class_trace, trace_status_command,
5728 _("Display the status of the current trace data collection."));
5730 add_com ("tstop", class_trace, trace_stop_command, _("\
5731 Stop trace data collection.\n\
5732 Usage: tstop [ <notes> ... ]\n\
5733 Any arguments supplied are recorded with the trace as a stop reason and\n\
5734 reported by tstatus (if the target supports trace notes)."));
5736 add_com ("tstart", class_trace, trace_start_command, _("\
5737 Start trace data collection.\n\
5738 Usage: tstart [ <notes> ... ]\n\
5739 Any arguments supplied are recorded with the trace as a note and\n\
5740 reported by tstatus (if the target supports trace notes)."));
5742 add_com ("end", class_trace, end_actions_pseudocommand, _("\
5743 Ends a list of commands or actions.\n\
5744 Several GDB commands allow you to enter a list of commands or actions.\n\
5745 Entering \"end\" on a line by itself is the normal way to terminate\n\
5747 Note: the \"end\" command cannot be used at the gdb prompt."));
5749 add_com ("while-stepping", class_trace, while_stepping_pseudocommand, _("\
5750 Specify single-stepping behavior at a tracepoint.\n\
5751 Argument is number of instructions to trace in single-step mode\n\
5752 following the tracepoint. This command is normally followed by\n\
5753 one or more \"collect\" commands, to specify what to collect\n\
5754 while single-stepping.\n\n\
5755 Note: this command can only be used in a tracepoint \"actions\" list."));
5757 add_com_alias ("ws", "while-stepping", class_alias, 0);
5758 add_com_alias ("stepping", "while-stepping", class_alias, 0);
5760 add_com ("collect", class_trace, collect_pseudocommand, _("\
5761 Specify one or more data items to be collected at a tracepoint.\n\
5762 Accepts a comma-separated list of (one or more) expressions. GDB will\n\
5763 collect all data (variables, registers) referenced by that expression.\n\
5764 Also accepts the following special arguments:\n\
5765 $regs -- all registers.\n\
5766 $args -- all function arguments.\n\
5767 $locals -- all variables local to the block/function scope.\n\
5768 $_sdata -- static tracepoint data (ignored for non-static tracepoints).\n\
5769 Note: this command can only be used in a tracepoint \"actions\" list."));
5771 add_com ("teval", class_trace, teval_pseudocommand, _("\
5772 Specify one or more expressions to be evaluated at a tracepoint.\n\
5773 Accepts a comma-separated list of (one or more) expressions.\n\
5774 The result of each evaluation will be discarded.\n\
5775 Note: this command can only be used in a tracepoint \"actions\" list."));
5777 add_com ("actions", class_trace, trace_actions_command, _("\
5778 Specify the actions to be taken at a tracepoint.\n\
5779 Tracepoint actions may include collecting of specified data,\n\
5780 single-stepping, or enabling/disabling other tracepoints,\n\
5781 depending on target's capabilities."));
5783 default_collect = xstrdup ("");
5784 add_setshow_string_cmd ("default-collect", class_trace,
5785 &default_collect, _("\
5786 Set the list of expressions to collect by default"), _("\
5787 Show the list of expressions to collect by default"), NULL,
5789 &setlist, &showlist);
5791 add_setshow_boolean_cmd ("disconnected-tracing", no_class,
5792 &disconnected_tracing, _("\
5793 Set whether tracing continues after GDB disconnects."), _("\
5794 Show whether tracing continues after GDB disconnects."), _("\
5795 Use this to continue a tracing run even if GDB disconnects\n\
5796 or detaches from the target. You can reconnect later and look at\n\
5797 trace data collected in the meantime."),
5798 set_disconnected_tracing,
5803 add_setshow_boolean_cmd ("circular-trace-buffer", no_class,
5804 &circular_trace_buffer, _("\
5805 Set target's use of circular trace buffer."), _("\
5806 Show target's use of circular trace buffer."), _("\
5807 Use this to make the trace buffer into a circular buffer,\n\
5808 which will discard traceframes (oldest first) instead of filling\n\
5809 up and stopping the trace run."),
5810 set_circular_trace_buffer,
5815 add_setshow_zuinteger_unlimited_cmd ("trace-buffer-size", no_class,
5816 &trace_buffer_size, _("\
5817 Set requested size of trace buffer."), _("\
5818 Show requested size of trace buffer."), _("\
5819 Use this to choose a size for the trace buffer. Some targets\n\
5820 may have fixed or limited buffer sizes. A value of -1 disables\n\
5821 any attempt to set the buffer size and lets the target choose."),
5822 set_trace_buffer_size, NULL,
5823 &setlist, &showlist);
5825 add_setshow_string_cmd ("trace-user", class_trace,
5827 Set the user name to use for current and future trace runs"), _("\
5828 Show the user name to use for current and future trace runs"), NULL,
5829 set_trace_user, NULL,
5830 &setlist, &showlist);
5832 add_setshow_string_cmd ("trace-notes", class_trace,
5834 Set notes string to use for current and future trace runs"), _("\
5835 Show the notes string to use for current and future trace runs"), NULL,
5836 set_trace_notes, NULL,
5837 &setlist, &showlist);
5839 add_setshow_string_cmd ("trace-stop-notes", class_trace,
5840 &trace_stop_notes, _("\
5841 Set notes string to use for future tstop commands"), _("\
5842 Show the notes string to use for future tstop commands"), NULL,
5843 set_trace_stop_notes, NULL,
5844 &setlist, &showlist);
5848 add_target (&tfile_ops);